This review is built from OpenRouter’s published pricing and documentation plus third-party analyses rather than a formal test of our own. Fees and limits are attributed with their dates; OpenRouter has changed its terms several times, so check its pricing page.
OpenRouter is a gateway that puts hundreds of AI models from dozens of providers behind one API key and one OpenAI-compatible endpoint. Instead of signing up with Anthropic, OpenAI, Google and a handful of open-model hosts separately, you buy credits once and call any model by name. It has become the default way many developers try new models, and it raised a $113 million Series B at about a $1.3 billion valuation in May 2026, according to UsagePricing.
The honest verdict: OpenRouter is excellent for experimenting, comparing models and building apps that need many models, and it is cheap at small scale. Token prices are passed through without markup. The cost sits in a 5.5% fee on credit purchases and, above a generous allowance, a fee on bring-your-own-key traffic. At large, steady volume on one or two models, going direct to the provider is cheaper and gives you contractual guarantees OpenRouter does not publish. Use it for breadth and flexibility; go direct for scale.
Table of Contents
- What OpenRouter Does
- OpenRouter Models and Providers
- How OpenRouter Pricing Works
- OpenRouter BYOK Explained
- The OpenRouter Free Tier
- Routing, Fallbacks and Uptime
- A Worked Cost Example
- OpenRouter Privacy and Data Policies
- Rate Limits and SLAs
- Developer Experience
- Using It Alongside Local Models
- Choosing Models for an App
- Watching for Hidden Costs
- OpenRouter vs Going Direct and Other Gateways
- Enterprise and Team Use
- Who Should Use What
- FAQ
- Getting Started With OpenRouter
- Verdict
- Sources and Further Reading

What OpenRouter Does
Capital and Compute described the product simply: a gateway that puts hundreds of AI models behind one API key and one OpenAI-compatible endpoint. Your code sends a request in the familiar OpenAI format with a model name, and the gateway forwards it to a provider that serves that model, then returns the response.
That solves three practical problems. You manage one account and one bill instead of many. You can switch models by changing a string, which makes testing new releases trivial. And when one provider is down or slow, requests can fall back to another provider serving the same model.
FutureAGI’s explainer summed up the billing model: one bill, one balance, with inference passed through and a fee on credit purchases.
OpenRouter Models and Providers
The catalogue is the main attraction. Capital and Compute counted more than 400 paid models across more than 70 providers on the July 2026 pricing page. By October, Developers Digest recorded the vendor stating more than 500 models from more than 80 providers.
That includes frontier proprietary models from the major labs and open-weight models served by specialist inference companies. Popular open models are often available from several providers at different prices and speeds, and the gateway can choose among them for you.
For developers comparing models for a product, this is the fastest way to run the same prompts across a dozen options in an afternoon. Our AI inference API providers review covers the hosts behind many of these endpoints.
How OpenRouter Pricing Works
There are no subscriptions. UsagePricing summarised the model as no subscription plans and no markup on models. Token prices match what the underlying provider charges. FutureAGI cited the FAQ: inference pricing is passed through with no per-call markup, and credit purchases incur a 5.5% fee.
In practice, that means every dollar of model usage costs about $1.055 when bought through credits. For a developer spending $50 a month, the fee is under $3, a small price for convenience. For a company spending $50,000 a month, it is more than $2,700, which is a real line item.
Dupple’s breakdown, read from the pricing page in late October 2026, listed three paths: a Free tier, pay-as-you-go, and Enterprise contracts with fee discounts, invoicing and purchase orders.
OpenRouter BYOK Explained
Bring your own key lets you attach your existing provider API keys while keeping the gateway’s routing, analytics and single endpoint. Requests that use your key are billed by the provider directly, not from your credits.
The fee rules have changed over time, which causes confusion. An earlier version allowed the first million BYOK requests a month free. Dupple and UsagePricing both reported the current rule as the first $25,000 of list-price usage each month carrying no fee, with a 5% fee on the equivalent price above that. Capital and Compute flagged that OpenRouter’s public pages did not state one consistent allowance in July, so check the live pricing page before relying on a number.
One subtlety matters. AIReiter explained that if your own key fails, through a rate limit, an empty balance or a provider outage, and fallback is enabled, the request may be served by another provider and billed to your OpenRouter credits. BYOK does not guarantee that every request uses your key.
The OpenRouter Free Tier
The free tier is genuinely useful for learning and prototypes. Dupple reported more than 25 free models capped at 50 requests a day. UsagePricing added that the cap rises to 1,000 requests a day once you have bought at least $10 of credits.
Free models are usually smaller open models or promotional endpoints, and they can be slower or less reliable than paid versions. They are perfect for testing an integration or building a hobby project, and not something to put a product on.
Routing, Fallbacks and Uptime
Routing is the feature that makes a gateway more than a billing convenience. When several providers serve the same model, OpenRouter can pick based on price, speed or availability, and fall back automatically if one fails.
For an application, that can mean fewer failed requests during provider outages, without writing your own failover logic. You can also restrict which providers handle your requests, for example to exclude ones with data policies you do not accept, or to prefer the fastest host for a latency-sensitive feature.
The trade-off is less control over exactly which infrastructure served a request unless you pin it. For most applications that is fine. For regulated workloads, pin providers explicitly.
A Worked Cost Example
Take a startup spending $3,000 a month on model usage across three models. Through credits, the 5.5% fee adds about $165 a month. Through BYOK under the current allowance, that usage falls well inside the fee-free $25,000, so the fee is zero, though the team must manage accounts with each provider.
Now take a larger company spending $60,000 a month, mostly on one frontier model. Through credits, the fee is about $3,300 a month. Through BYOK, the first $25,000 is free and the remaining $35,000 attracts a 5% fee, about $1,750. Going direct to the provider costs nothing extra and may unlock volume discounts and a contractual SLA.
The pattern is clear. The gateway’s fees are small at small scale and grow with volume. Past a certain size, the convenience has to justify a meaningful monthly cost.
OpenRouter Privacy and Data Policies
Every request passes through the gateway and then to a provider, so two sets of data policies apply. OpenRouter offers settings to control which providers you allow, including excluding providers that may log or train on prompts.
Capital and Compute’s guide discusses privacy controls alongside fees. For sensitive data, the safest approach is to restrict providers to those with zero-retention policies, or to keep that data on local models entirely. Our LM Studio vs Ollama comparison covers local options.
Rate Limits and SLAs
TrueFoundry’s analysis made the point that real costs become clear at scale, when credit purchase fees, BYOK charges, rate limits, missing public SLA terms and governance gaps start to affect production decisions. It noted that any contractual uptime guarantee must come through enterprise negotiation.
For a hobby project or internal tool, that is acceptable. For a customer-facing product, either negotiate an enterprise contract or keep a direct provider relationship as your primary path, with the gateway as a fallback or experimentation layer.
Developer Experience
This is where the gateway shines. Because it speaks the OpenAI API format, most SDKs, agent frameworks and coding tools work by changing the base URL and key. Model names follow a provider/model pattern that is easy to read.
The dashboard shows usage by model, key and provider, which helps when tracking down where money goes. Separate keys per project or environment make cost attribution straightforward.
Using It Alongside Local Models
For readers running local models, the gateway is a natural complement. Many self-hosted interfaces, including Open WebUI and LibreChat, can add it as one provider next to Ollama. You keep sensitive or routine work local and send hard problems to a frontier model through one key.
That hybrid pattern often gives the best of both: privacy and zero marginal cost for most queries, and top-tier capability when you need it.
Choosing Models for an App
Access to hundreds of models is only useful if you have a way to pick between them. A simple process works well. Write twenty to fifty real prompts from your application, with notes on what a good answer looks like. Run them through five or six candidate models, from a cheap small model to a frontier model. Score the outputs, note the cost per request and the response time, and pick the cheapest model that meets your quality bar.
Often the answer is two models: a cheap, fast one for routine requests and a strong one for hard cases, with simple rules or a classifier deciding which to call. That pattern can cut costs by half or more compared with sending everything to a frontier model, and a single gateway makes it easy to implement.
Repeat the evaluation every few months. New open models arrive constantly, and a model that was the best value in spring may be beaten on both price and quality by autumn. Keeping your prompt set and scoring notes makes each round quick. Our LLM evaluation tools guide covers software that automates this.
Watching for Hidden Costs
The headline token prices are only part of the bill. Several smaller items add up. The credit purchase fee applies to every top-up. Reasoning models generate long hidden chains of thought that are billed as output tokens, which can multiply the cost of a single answer. Long system prompts and conversation histories are re-sent with every request, so a chat that grows to thousands of tokens costs more with each turn.
Prompt caching, where providers support it, reduces the cost of repeated context, and it is worth enabling for agents and chat apps. Trimming conversation history, summarising older turns and keeping system prompts lean all help too.
Finally, watch automated workloads. An agent stuck in a retry loop, or a batch job that reprocesses the same documents, can spend more in an hour than a team spends in a week. Per-key spending limits are the simplest safeguard, and they are worth setting before the first incident rather than after it.
OpenRouter vs Going Direct and Other Gateways
| Option | Strength | Weakness |
|---|---|---|
| OpenRouter credits | Every model, one key, no setup | 5.5% fee on every credit purchase |
| OpenRouter BYOK | Routing and analytics with your own keys | Fee above the allowance, fallback billing quirks |
| Direct provider accounts | No gateway fee, SLAs, volume discounts | Many accounts and integrations |
| Self-hosted gateway | Full control and governance | You run and maintain it |
Self-hosted and enterprise gateways from companies such as TrueFoundry position themselves on governance, which is the area TrueFoundry says the hosted router leaves gaps. For a large organisation with compliance needs, that comparison is worth making.
One more practical tip: name your API keys after the project and environment they serve, such as production chat or staging agent. When a bill spikes, the dashboard then tells you immediately which system is responsible, instead of leaving you to guess.
Enterprise and Team Use
Enterprise contracts offer fee discounts, invoicing and purchase orders, according to Dupple. TrueFoundry reported that Enterprise also raises BYOK thresholds before the 5% fee applies.
For teams, the practical features are separate API keys with spending limits, per-key analytics and the ability to restrict providers centrally. Set limits on every key you hand out, especially to automated agents, which can run up bills quickly in loops.
Who Should Use What
| If you are | Start with | Why | Link |
|---|---|---|---|
| Testing and comparing many models | OpenRouter with credits | Every model through one key | Try it |
| Already holding provider keys and wanting routing | OpenRouter BYOK | Fee-free up to a large monthly allowance | Try it |
| Spending heavily on one or two models | Direct provider accounts | No gateway fee, contractual SLAs | Compare |
| Wanting fast, cheap open-model inference | Groq or Together AI | Direct, often cheaper at scale | Check price |
Frequently Asked Questions About OpenRouter
Does OpenRouter mark up model prices?
No. Token prices are passed through. The cost is a 5.5% fee on credit purchases.
What is BYOK?
Using your own provider API keys through the gateway. Under current terms, the first $25,000 of list-price usage a month carries no fee, then 5%.
Is there a free tier?
Yes, with more than 25 free models capped at 50 requests a day, rising to 1,000 after buying $10 of credits.
How many models does it offer?
More than 500 models from more than 80 providers, as stated in October 2026.
Does it have an SLA?
Not publicly. Uptime commitments require an enterprise contract.
When should I go direct?
When you spend heavily on one or two models and need guaranteed uptime or volume discounts.
Getting Started With OpenRouter
Create an account, generate an API key and set a spending limit on it. Point your OpenAI-compatible client at the gateway’s base URL and call a free model to confirm the integration.
Add a small amount of credit, test the models you care about with real prompts, and compare quality, speed and cost in the dashboard. If you already have provider keys, add them for BYOK and check the live allowance on the pricing page.
Before production, decide which providers you allow for data reasons and pin them in your settings.
Verdict
Use OpenRouter if you want access to hundreds of models through one key, fast experimentation, automatic fallbacks and a single bill. For prototypes, multi-model apps and small to medium spending, it is the most convenient option available, and the fees are modest.
The honest caveat is scale and guarantees. The 5.5% credit fee and the BYOK fee above the allowance grow with volume, BYOK can still bill credits on fallback, and there is no public SLA.
Next step: route your next model evaluation through OpenRouter, then, once one or two models carry most of your traffic, compare the monthly fee against going direct.
Sources and Further Reading
- Dupple: OpenRouter pricing 2026, for plans, the free tier and BYOK allowance.
- Capital and Compute: OpenRouter explained, for model counts, fees and privacy.
- UsagePricing: OpenRouter blueprint, for pricing history and funding.
- TrueFoundry: hidden fees at scale, for SLA and governance considerations.
- AIReiter: BYOK fees and fallback, for how fallback billing works.
On this site: compare hosts in our AI inference API providers review, see fast inference in our Groq and Cerebras reviews, and cut costs with LLM API cost optimisation.




