In 2009 I joined AT&T to work on API strategy. Carriers were opening their networks to outside developers, and the plan was to charge per call for things only a carrier could do, like sending an SMS, locating a device or billing a purchase to a phone account.
The APIs shipped quickly. Turning a developer's first call into revenue that finance could book took years, because nobody had settled whether a failed call counted, what happened when usage crossed a tier in the middle of the month, or whose number won when the gateway and the invoice disagreed.
Telecom has run usage billing at scale for longer than almost anyone. Carriers have turned call detail records into bills for decades, with entire organizations devoted to mediation, rating and charging. But that machinery was built for subscribers and phone numbers. Developer accounts and API keys didn't fit it, so API programs ended up billing on the side. Most of the API businesses I've seen since still do, from a monthly export of gateway logs that someone in finance cleans up by hand.
Years later I was a product manager on Apigee at Google, working with Fortune 500 companies on how to monetize the APIs they ran through it. I saw the same gap there, from the gateway's side. A gateway knows the developer, the app, the API product and the call count, and Apigee can attach a rate plan and cut off a developer whose prepaid balance runs out. Charging the card, sending the invoice, collecting tax and recognizing revenue all happen in other systems. That's a sensible place for a gateway to stop. In practice it means the rate plan lives in Apigee, the invoice lives in the billing system, and the PM who owns the API files tickets with two teams to change a price.
I left Google in June 2024 to build the layer in between, for APIs first and for the AI agents and MCP servers that are now sold the same way, by the call. Today the live demo is open, and we're taking our first design partners.
Prices Move Every Quarter Now
For most of the time I've worked on APIs, a price changed about once a year, usually at renewal. If you sell on top of a frontier model, you reprice every few months whether you planned to or not. Your cost per request depends on input tokens, output tokens and cache hits, and those rates change every time your provider ships a new model. When your provider's price drops, your customers expect yours to follow. When a heavy customer finds an expensive way to use a cheap plan, you want to know that week, not when the inference bill arrives.
Agents make it worse, because the caller is now a program that can burn through a month's allowance in an afternoon. In Postman's 2025 State of the API report, a survey of more than 5,700 developers and API professionals, nearly one in four said they already design APIs with AI agents in mind, and half named unauthorized or excessive calls from agents as their top concern. In December 2025, MCP, the protocol many agents use to find and call tools, moved to the Linux Foundation's new Agentic AI Foundation, a sign the industry expects it to last.
A lot of people call this the agentic economy. Seen from the billing side, it means more software sold by the call, in units that keep changing. My bet is that companies that can reprice in a week will take business from the ones that need a quarter.
One MCP Server, End to End
Aforo is the API and agentic monetization platform. Meter, price, sell, bill and recognize revenue end to end, on the gateway you already run.
Take an MCP server with two tools. One runs a search that costs you almost nothing to serve. The other calls a frontier model and costs real money every time.
You install Aforo's plugin on the gateway in front of the server, or its shared flow if that gateway is Apigee. No traffic moves, and the server's code doesn't change. MCP servers are already in Aforo's catalog, so tool calls show up as billable units without anyone designing an event schema.
Then you set the price. Say searches are free up to a monthly allowance, generations cost a few cents each, and bigger customers commit to a monthly minimum. You build that as a rate plan and watch the bill simulator produce the invoice a real customer would receive. If you'd rather describe the plan in a sentence, Pricing Architect turns the sentence into a draft that you edit before anything is created.
You publish it as a new version. New customers get the new plan, and existing customers stay on the version they signed until you move them. In most companies, that step is the one that needs an engineer and a migration script.
Customers can buy through a storefront on your own domain, through widgets embedded in your site, or through a quote your sales team sends from CPQ. Aforo collects payment through Stripe, Adyen, Razorpay or Worldpay, calculates tax with Avalara, syncs to NetSuite, QuickBooks or Xero, and generates the ASC 606 schedules and journal entries from the same usage records that produced the invoice.
After that, you watch margin. Aforo splits the cost of each call into AI, infrastructure and fees, so you can see which customers make money at the price you chose. When one doesn't, Margin Guard warns you, and if you've turned it on, it slows that customer down or stops them at the gateway. Throttling and blocking are opt-in, because slowing down a paying customer should be a decision somebody makes deliberately.
In the product, those steps map to the Define, Sell, Bill and Analyse sections.
What Ships Today
- Eight product types with prebuilt billable units: five protocols (REST, GraphQL, gRPC, WebSocket and MQTT) and three kinds of AI product (agentic APIs, AI agents and MCP servers).
- Seven pricing models, versioned rate plans, the bill simulator, and compound meters, such as input and output tokens with cache reads and writes, from a single event.
- Adapters for Kong, AWS API Gateway, Azure API Management and MuleSoft, a shared flow for Apigee, SDKs in Node, Python, Java and Go, an MCP metering proxy, and webhook-to-ingest for everything else.
- A white-label storefront, eight embeddable widgets, a headless API and CPQ.
- Subscriptions, invoices, dunning, prepaid wallets, four payment providers, Avalara tax, ERP sync and ASC 606 revenue recognition.
- Cost and margin per call, Margin Guard, and usage and billing exports to your own S3 bucket as Parquet.
Choices Your VP of Engineering Will Ask About
Aforo is never a hard dependency of your request path. Metering is asynchronous, and the optional margin and quota checks are cached and fail open. If Aforo can't be reached, your API keeps serving.
A billing period can't be invoiced twice. Each bill run writes a watermark in the same transaction that completes it, and a nightly job compares the revenue estimated at ingest with what was invoiced, subscription by subscription. If the two drift apart, you hear about it the next morning instead of at quarter close.
Usage is attributed from validated JWT claims, not from headers a client can set. Tenants are isolated in the database, and SSO, SCIM and an audit log are there for the security review.
You can also leave. Aforo runs on your gateway and your payment provider, and your usage data lands in your own bucket.
What's Missing
We're early, so here's what isn't there yet. Three more product types are in progress: flat files and ETL, SaaS functions, and embedded analytics, each marked "coming soon" in the product. Exports land in S3 as Parquet today. Native Snowflake, BigQuery and Redshift connectors come later, and until then you load the files with your warehouse's own COPY or LOAD command. If your gateway isn't one of the five above, the SDKs and webhook-to-ingest cover it until a native adapter ships, and we've added adapters before.
We don't have customer logos yet either. Anything we show you is the product itself, running live.
How to Try It
The live demo gives you a workspace full of sample products, pricing, customers and usage. It needs a work email and no credit card, and it deletes itself when it expires. The docs cover the quickstart, the gateway adapters and the SDKs. You can request access on our site; tell us what you sell and which gateway sits in front of it.
We're also taking a small number of design partners. Each one meters a real product on Aforo, names an owner on their side, meets with us regularly, and agrees on a conversion date and price at the start, so nobody ends up in a pilot that never ends. If we do a demo together, we'll start in your gateway rather than in our product.
A small team built this with me, and most of what works in it is theirs.
Later this week I'll publish a longer piece on why so many companies can't change their prices when their costs move. The short version is that if you sell anything by the call, your price will change more often than your billing system expects, and we built Aforo so that each of those changes is configuration instead of a project.
If that's where you are, write to me at jay@aforo.ai.
— Jay