OpenRouter API pricing comparison isn't about "how much is the plan" — it's about how one key billing 400+ models charges per model, whether the platform marks up prices, and how much free access you get. It uses an OpenAI-compatible endpoint with model-id pass-through token rates and no markup, but top-ups carry a 5.5% fee ($0.80 minimum). Free models default to 50 requests/day and rise to 1000/day after $10 in credits. This article tallies per-model API rates, router costs, and the direct-API math. Prices below are as of 2026-08-13; check OpenRouter for live rates.
API billing model: one key, one endpoint, billed by model id
OpenRouter API has a single billing thread: one OpenAI-compatible endpoint (/api/v1/chat/completions) where you name a model id and get charged that model's official token rate from openrouter.ai/models, deducted from Credits with no markup (source). There's no monthly fee and no per-key charge — real cost is entirely a function of which model you call and how many tokens you use. Keys are issued in settings/keys and Credits are topped up in settings/credits, with a platform fee on purchase.
| Billing item | Rule | Notes |
|---|---|---|
| Inference token rate | Matches provider list price | No markup |
| Top-up fee | 5.5% ($0.80 minimum) | 5% for crypto |
| Free-model quota | 50/day by default | 1000/day after $10 in credits |
| BYOK service fee | $25,000 list-price inference/month free ($200,000 Enterprise) | 5% beyond that |
| Router fee | auto/free: no extra fee | Billed at routed model's token rate |
For top-up, refund, and free-quota details, see the OpenRouter Credits page on this site.
API price comparison: budget tiers from $0.03, flagship output up to $30
The cheapest paid model on the OpenRouter API is Qwen 3.7 Flash at $0.03/1M input and $0.13/1M output; the priciest is GPT-5.6 Sol at $30/1M output — nearly a 50x gap on one platform. Each provider uses a distinct model-id prefix, but every token rate passes through to the official price (source). The table below lists core providers by entry and flagship tier, priced per 1M tokens (input/output):
| Provider | Model-id prefix | Entry tier (input/output) | Flagship tier (input/output) |
|---|---|---|---|
| OpenAI | openai/* | Luna $0.10/$0.60 | Sol $5/$30 |
| Anthropic | anthropic/* | Haiku 4.5 $1/$5 | Opus 5 $5/$25 |
| google/* | Flash Lite $0.30/$2.50 | 3.6 Flash $1.5/$7.5 | |
| DeepSeek | deepseek/* | Flash 0731 $0.08/$0.18 | Pro 0813 $0.435/$0.87 |
| xAI | x-ai/* | Build $1/$2 | Grok 4.6 $2/$6 |
| Qwen | qwen/* | 3.7 Flash $0.03/$0.13 | 3.8 Max $2/$6 |
| Z.ai | z-ai/* | 4.7 Flash $0.06/$0.40 | 5.2 $0.49/$1.54 |
| Kimi | moonshotai/* | K2.5 $0.57/$2.85 | K3 $3/$15 |
| Xiaomi | xiaomi/* | MiMo V2.5 $0.14/$0.28 | V2.5-Pro $0.435/$0.87 |
| Tencent | tencent/* | Hy3 preview $0.06/$0.21 | Hy3 $0.132/$0.528 |
The pattern is clear: Chinese providers keep entry prices very low, making them the volume picks. DeepSeek's Flash tier runs $0.08/M input, Qwen 3.7 Flash just $0.03/M, Z.ai GLM 4.7 Flash $0.06/M, and MiMo V2.5 $0.14/M — these tiers rank among the most-used on OpenRouter for high-throughput batch work. Flagships get expensive fast: Claude API Opus 5 costs $5/$25 and Kimi K3 $3/$15, aimed at quality-sensitive coding and agent workloads.
How routers are priced: auto/free/fusion and the other six
Most of OpenRouter's six first-party routers add no extra fee: auto and free bill at $0 or the routed model's token rate, and only multi-model tools like fusion sum up participating model costs. Every router uses an openrouter/ model-id prefix, and response metadata returns the actual underlying model that was used (source).
| Router | Model id | Cost | Purpose |
|---|---|---|---|
| Auto Beta | openrouter/auto (also auto-beta) | No extra fee; billed at selected model rate | 7-day community spend-share routing |
| Free Router | openrouter/free | $0 (daily caps apply) | Random pick from free pool |
| Fusion Router | openrouter/fusion | Sum of participating model token costs | Parallel panel + judge synthesis |
| Pareto Code | openrouter/pareto-code | Billed at routed coding model rate | Benchmark-driven coding model pick |
| Body Builder | openrouter/bodybuilder | Beta | Natural language to structured request |
| Owl Alpha | openrouter/owl-alpha | $0 | Agent foundation: tool use + long context |
The trick with routers is knowing where the money goes. auto looks like "pick a model for me," but its cost equals the token rate of the model it selects — sometimes cheaper than what you'd pick, sometimes pricier. fusion runs multiple models and synthesizes, so it bills the sum of every participating model's tokens: a high-fidelity, high-cost option. To spend nothing, use openrouter/free or append :free to any model id — $0 tokens, just capped by the 50/1000 per-day limit.
Direct vendor API vs OpenRouter API: what the 5.5% fee buys
OpenRouter API doesn't profit from token spread — it only charges the 5.5% top-up fee. If you call GPT, Claude, and DeepSeek together, that fee beats opening, funding, and managing separate accounts; if you stick to one model, going direct is cheaper. Here's the comparison (source):
| Dimension | Direct vendor API | OpenRouter API |
|---|---|---|
| Token rate | Official price | Same as official, no markup |
| Extra fee | None | 5.5% top-up fee ($0.80 min) |
| Model coverage | Single vendor | 400+ models, one endpoint |
| Switching cost | Separate account, top-up, key per vendor | One key, swap model id |
| Failover | None | Provider fallback |
| Routing | None | auto/fusion/pareto-code/:nitro/:floor |
The takeaway: multi-model users should treat OpenRouter as a unified gateway; single-model heavy users should go direct. Two more variables matter: provider fallback automatically switches providers on errors with no code changes, and BYOK lets you bring your own provider keys with a monthly no-fee allowance measured by list-price inference cost ($25,000/month on pay-as-you-go, $200,000/month on Enterprise) before a 5% service fee kicks in — a real cost lever at high volume.
Picking model ids and controlling cost
Controlling OpenRouter API cost comes down to three habits: name your model id explicitly, lean on the free tier, and watch what routers actually route to. Concretely:
- Specify model ids (e.g. openai/gpt-5.6-luna, deepseek/deepseek-v4-flash-0731) so billing stays predictable; leave auto selection for when you're unsure.
- Use the free tier for prototypes and demos: openrouter/free or the :free suffix costs $0; the daily cap rises from 50 to 1000 after $10 in credits.
- Constrain auto with session_id sticky routing and an allowed_models allowlist so it can't silently land on a flagship.
- Add provider fallback and variants in production: :nitro for latency, :floor for the cheapest provider, and watch Activity to keep the balance in check.
- For Claude Code, Cursor, and similar tools, point them at OpenRouter by swapping base_url, Authorization, and the model name — usually a few minutes of setup.
Caveats
- Credits expire: unused Credits may expire one year after purchase — don't top up too much at once.
- Refunds are limited: refunds within 24 hours on the Credits page, but platform fees are non-refundable and crypto is never refundable.
- Free models are capped: 50/day by default, 1000/day after $10 in credits — fine for testing, not production.
- Routers bill at the routed model: auto/pareto-code charge the selected model's rate and fusion sums participants, so bills can exceed a single fixed model.
- Rates change: all prices pass through openrouter.ai/models, so actual billing follows the live rate.