AI model gateways and routers: one key for every model, and who now owns it

On August 19, 2026, a payments company bought the switchboard. Stripe agreed to acquire OpenRouter, the service that lets one API key reach more than 400 AI models from over 80 providers. Bloomberg put the price above $7 billion, about five times the $1.3 billion valuation OpenRouter raised at in May. For a company that, by its own pricing FAQ, adds no markup to a single token, that is a lot of money for a switchboard.

If you have ever seen “via OpenRouter” under a chatbot and wondered what that means, this post is the answer. If you are deciding how your app should reach ten different models without ten accounts, it is also a field guide: what a gateway does, what it quietly costs, who owns each one now, and when you are better off with your own keys, your own proxy, or no cloud at all.

A gateway is one key that opens every model

Every AI vendor has its own API, its own key, its own invoice, and its own slightly different request format. An app that wants to use OpenAI for one task, Anthropic for another, and an open model from a cheap host for a third has to maintain three integrations and three billing relationships. Multiply that by the pace of model releases and the upkeep becomes a job.

A gateway (or router, or aggregator; the words blur) sits between your app and all of those vendors. You send every request to one address in one format, almost always the OpenAI chat-completions shape that the industry settled on, and name the model you want. The gateway holds the vendor keys, translates the request, forwards it, and sends back the answer. One key, one invoice, one format, every model.

That is why the business is so big and so thin at the same time. OpenRouter’s own announcement says it now moves more than 10 trillion tokens a day for over 10 million developers and companies. Sacra’s estimate puts its annualized revenue near $140 million as of July 2026, up from about $50 million at the end of 2025, almost all of it a roughly 5% cut on the inference spend flowing through it. The gateway earns pennies per request on a river of requests.

It does four jobs, and only one is routing

People say “router” as if picking a model were the whole point. In practice a gateway earns its place with four separate jobs, and most teams only need one or two of them.

Unify. The job above: one endpoint, one key, one invoice. This is the reason most people sign up, and on its own it is worth a lot of removed friction.

Fall back. When a vendor returns an error or times out, the gateway retries somewhere else without your code noticing. OpenRouter’s routing docs describe the default: skip any provider that has had a significant outage in the last 30 seconds, then spread traffic across the rest.

Route. The same open model, say a Llama or Qwen or DeepSeek release, is often served by a dozen hosts at different prices and speeds. OpenRouter’s default picks among stable providers “weighted by inverse square of the price,” so the cheapest host gets most of the traffic. Suffixes like :nitro sort by throughput instead and :floor by lowest price. This only matters for open-weight models; a closed model has exactly one host.

Observe. Spend broken down by key, team, or user; response caching; request logs; budgets that cut a key off at a limit. This is the part enterprises pay for, and the part the self-hosted proxies compete on.

The bill is small; the other three costs are not

Start with the one everybody asks about. The headline fee is modest, and every vendor is careful to say it is not a markup on tokens. OpenRouter charges 5.5% (minimum $0.80) when you buy credits by card and passes the provider’s per-token price through untouched; bring your own vendor keys and the first $25,000 a month is free, with 5% above that. Cloudflare takes 5% on credits bought through its unified billing and nothing if you plug in your own keys. Vercel charges the provider’s list price with no platform fee, and then bills add-ons separately: $0.10 per 1,000 requests for team-wide zero data retention, $5 per 1,000 queries against its reporting endpoint.

Five percent on a $200 monthly bill is $10. If you are optimizing that, you are optimizing the wrong thing; we made the same argument about per-token obsession in Cost-per-task, not cost-per-token. The three costs that matter do not show up on any invoice.

A second company in the data path. Every prompt and every answer transits the gateway. OpenRouter says it does not log prompts or completions by default and offers a 1% discount if you opt in to logging, which is a fair deal, clearly stated. The subtler issue is downstream. Its routing parameter data_collection defaults to allow, which its docs define as permitting providers that “store user data non-transiently and may train on it.” You can set it to deny, but you have to know to. A convenience layer that picks the cheapest host can pick one whose retention terms you never read. We walked through what each vendor keeps in What happens to your AI chats; a gateway adds one more party to that list.

One more thing that can go down. A gateway sells you resilience against any single vendor failing. It also becomes a single point through which all of them pass. When the gateway has an incident, every model is unavailable at once, and the fallback logic you were counting on is inside the thing that failed.

Your routing logic lives in their config. This is the lock-in nobody puts on a comparison chart. After six months on a gateway, your fallback chains, model aliases, per-team budgets, and cached prompts are all expressed in that vendor’s dashboard or its request parameters. The API format is portable; the operational knowledge is not. Leaving means rebuilding it, which is exactly why these companies are worth billions to an acquirer.

Every big hosted router now has a corporate owner

The hero strip at the top of this post is the argument in three rows. Between March and August 2026, three of the best-known hosted gateways were bought, each by a company whose core business is something other than AI models.

Stripe’s framing of the OpenRouter deal is explicit. Patrick Collison’s quote in the press release calls tokens “the central currency for companies building with AI.” Routing, in that view, is a metering and payments problem, and the company that already meters card payments for the internet wants to meter tokens too. OpenRouter’s side of the announcement promises the same name, product, and roadmap, and that routing stays driven by “what’s best for you, the user.” Worth holding them to.

Palo Alto Networks closed its purchase of Portkey on May 29, 2026 and folded it into Prisma AIRS, its AI security suite. Its release calls the gateway “the central nervous system for all AI traffic.” Same box, different owner, different purpose: here the switchboard is an inspection point, where prompts get scanned and agent behavior gets policed.

Helicone, the open-source observability proxy, joined docs company Mintlify on March 3, 2026. Its farewell post says the product enters maintenance mode: security fixes and new models, no new features. 16,000 organizations had routed 14.2 trillion tokens through it. That is the quieter failure mode of building on a gateway: not that it gets expensive, but that it stops moving.

Put the three together and a pattern appears. The “neutral layer” that every gateway pitches is, in 2026, owned by a payments company, a security company, and a documentation company. Each has a reason to sit in your data path that has nothing to do with picking the best model. The independents left standing are the self-hosted proxies, which are independent because there is nothing to buy: you run them.

Four kinds of gateway, and they are not the same thing

“Gateway” gets used for at least four different products, plus a fifth category that people mistake for one. The table sorts them by where the software runs and who you pay, because those two facts predict every tradeoff above.

Hosted routers are the OpenRouter shape: a marketplace with its own credits, its own routing, and the full convenience package. Platform gateways from Vercel and Cloudflare bolt the same features onto a hosting product you may already use; both let you bring your own vendor keys and skip the fee entirely. Cloud gateways like AWS Bedrock are a single API over many vendors inside one cloud’s billing, which is convenient until you want a model that cloud does not carry.

Self-hosted proxies are the same idea as a container you run. LiteLLM is the default here: a Python library and proxy server covering 100+ providers in the OpenAI format, with virtual keys, per-team budgets, retries, fallbacks, and caching. Its core is MIT licensed (an enterprise/ directory carries separate terms), and the repository sits above 56,000 GitHub stars as of August 2026. Your keys stay on your box, your logs stay in your database, and no acquirer can change the roadmap under you. The price is that you are now running a service.

Inference hosts get lumped in because they also give you one key to many models, but they are a different animal. Together, Fireworks, Groq, and DeepInfra run open-weight models on their own GPUs and charge per token; Together lists Llama 3.3 70B at $1.04 per million tokens and DeepSeek V4 Flash at $0.14 in, $0.28 out. They are vendors, not switchboards, and a router will happily route to them. The same is true for media: Replicate, Runware, and fal host image, video, and audio models behind one key each, which is the role csuite’s cloud providers play when you are not running a model locally.

Pick by the tradeoff you can live with

There is no universally right answer, but there is a right answer for each situation, and it follows from which of the four costs you can tolerate.

If you use one or two vendors, go direct. A gateway solves a problem you do not have and adds a hop you do not need. Keep the keys in your own secrets store and write the five-line fallback yourself.

If you are a small team trying a new model every week, a hosted router is the right tool, and the Stripe deal does not change that today. Set data_collection to deny, pin providers with the order parameter where it matters, and keep your fallback chains in your own code rather than the dashboard so they move with you. Treat the gateway as a convenience, not as architecture.

If you have budgets to enforce, auditors to satisfy, or documents that cannot leave your network, run a proxy. LiteLLM or one of its peers gives you the unify, fall-back, and observe jobs with the config in your repository and the logs in your database. The routing job matters less here, because regulated teams usually pin vendors anyway.

And if the work is repetitive, private, or offline, skip the cloud. We ran the numbers on when that flips in Cloud API vs local runtime; a gateway does not change them, it just adds a fee to the cloud side of the ledger.

A gateway is still someone else’s key

The pitch for a gateway is independence: no lock-in to any one model vendor. The pitch is true, and it hides a swap. You trade dependence on five vendors for dependence on one middleman, and this year the middlemen got owners. A gateway is still someone else’s key on someone else’s server, with someone else’s reasons for wanting to be there.

That is the same argument we made in BYOK vs SaaS AI: the closer the key and the data sit to you, the fewer parties can change the terms. A hosted router is a fine tool for exploring. For anything you depend on, keep the routing logic in your code, keep the vendor keys in your vault, and for the tasks that never needed a network at all, keep the model on your machine. Then the switchboard can be sold to whoever wants it, and your app will not notice.

That is also the shape we built CSuite around. The app is a router in the sense that matters to a person rather than a platform: one model picker over OpenAI, Anthropic, Google, Replicate, Runware, and the rest, each called with your own key, plus local runtimes (Ollama and Hugging Face) for the models that never need to leave your machine. The difference from a hosted gateway is where the switchboard lives. It runs on your desktop, so there is no middle server for your prompts to transit, no one taking a cut of the tokens, and no routing config held by a company that could be acquired next week. Your conversations and generations land in ordinary files on your disk. Same convenience, minus the second company in the data path.