OpenRouter is free to sign up and has no subscription. You pay each model's own price plus a 5.5% fee when you buy credits, or no OpenRouter fee on your own provider keys for the first $25,000 of list-price inference a month. Some models are free with rate limits. Here is what that costs at your volume, and to run the fee math on your own numbers, use our OpenRouter fee calculator.
Updated November 10, 2026. Fees re-checked against OpenRouter's pricing page, FAQ, BYOK and rate limits docs; model prices against OpenRouter's model list.
Is OpenRouter free?
Yes and no. Signing up and calling the API cost nothing, and models whose IDs end in :free cost $0 per token, capped at 20 requests a minute and 50 a day (1,000 a day once you have bought at least $10 of credits). Paid models cost the provider's list price, paid through credits with a 5.5% card fee, or through your own keys, free up to $25,000 of inference a month.
OpenRouter pricing at a glance
| What you pay for | OpenRouter cost |
|---|---|
| Buying credits | 5.5% fee by card ($0.80 minimum), 5% with crypto, 8% on Business |
| BYOK (your own provider keys) | No fee on the first $25,000 of list-price inference a month, then 5% |
| Subscription | None. No monthly plan, no seat price, no minimum spend |
| Free models | $0 per token, 20 requests a minute and 50 a day (1,000 a day after $10 of credit purchases) |
Per-token prices are the provider's list price on every plan. OpenRouter's pricing FAQ says the fee is charged when you buy credits, never on individual requests.

OpenRouter also has four plans, and the fee depends on which one you're on:
| Plan | Fee on credit purchases | BYOK allowance | What's different |
|---|---|---|---|
| Free | None (free models only) | None | Free models from 4 free providers, 50 requests a day |
| Standard (pay-as-you-go) | 5.5% | $25,000/month, then 5% | Most users. Email support |
| Business (pay-as-you-go) | 8% | $25,000/month, then 5% | EU and US in-region routing, up to 1,000 workspaces, signed DPA on request |
| Enterprise | Contract (fee discounts available) | Custom | SSO/SAML, contractual SLAs, invoicing, dedicated support |
If your team is on Business, every "credits" figure in this article is 8% over list, not 5.5%. The $1,800 Opus 5.5 example below becomes $1,944 through Business credits (+$144).
Two details matter for the numbers. The BYOK allowance is measured in dollars of list-price inference, not requests. OpenRouter used to offer 1 million free BYOK requests a month, and a lot of older guides still quote that. And the 5% BYOK fee, once you pass the allowance, is deducted from your OpenRouter credits, so you still keep a small credit balance.
OpenRouter vs direct API: the cost at three volumes
Here is the same monthly list-price inference bill paid three ways. The direct API is the provider's own price with no middleman.
| Monthly inference at list price | Direct API | OpenRouter credits, card (+5.5%) | OpenRouter credits, Business (+8%) | OpenRouter BYOK |
|---|---|---|---|---|
| $500 | $500 | $527.50 (+$27.50) | $540 (+$40) | $500 |
| $5,000 | $5,000 | $5,275 (+$275) | $5,400 (+$400) | $5,000 |
| $30,000 | $30,000 | $31,650 (+$1,650) | $32,400 (+$2,400) | $30,250 (+$250) |
Credits always cost more than going direct. BYOK costs the same as direct until you pass $25,000 a month, then adds 5% on the excess only. The per-model breakdown is in the OpenRouter cost comparison below.
OpenRouter vs Ollama
Ollama runs open-weight models on your own machine, so there is no per-token bill at all. The cost moves to hardware and electricity, and the model has to fit in your RAM or VRAM. Proprietary models such as Claude and GPT are not available locally.
| OpenRouter | Direct API | Ollama (local) | |
|---|---|---|---|
| Per-token price | Provider list price | Provider list price | $0 |
| Extra fees | 5.5% on credits, or BYOK free to $25,000/month | None | None. You pay for hardware and power |
| Models | Proprietary and open-weight, one key | One provider's models per key | Open-weight only |
| Speed | One extra network hop through OpenRouter's edge | Provider speed | Limited by your hardware |
| Privacy | Requests pass through OpenRouter | Requests go to the provider | Data stays on your machine |
| Uptime | Automatic fallback across providers | Single provider | Your machine. Sleep or a full RAM stops the agent |
Pick Ollama when the data must stay on your machine, when you are testing and want zero token cost, or when you work offline. Pick OpenRouter or a direct key when you need frontier proprietary models or 24/7 uptime. Many teams develop on Ollama and run production on a cloud API. If Ollama refuses connections from your agent, see our Ollama connection refused fix, and to choose a local runner, our Ollama vs LM Studio comparison.
Does OpenRouter have a subscription?
No. There's no monthly plan, no seat price and no minimum spend beyond the $0.80 minimum fee on a card purchase. Business is also pay-as-you-go, with an 8% fee instead of 5.5%; Enterprise is a negotiated contract. If you're really choosing between OpenRouter and a $20 Claude Pro or ChatGPT Plus plan, see "OpenRouter vs a $20 AI subscription" below.
OpenRouter fees, refunds and credit expiry
- Card purchases: 5.5% of the order, minimum $0.80. On $10 that's $0.80, on $100 it's $5.50, on $2,000 it's $110.
- Crypto purchases: 5% flat, no minimum. Crypto payments are never refundable.
- Refunds: unused credits can be refunded within 24 hours of purchase, to the original payment method. The platform fee is never refunded.
- Expiry: OpenRouter reserves the right to expire unused credits one year after purchase, so don't buy a year's worth up front.
- BYOK past the allowance: 5% of what the same model and provider would normally cost on OpenRouter.
OpenRouter pricing per model
OpenRouter doesn't set its own token prices. Each model is listed at the provider's rate, with no markup. Here is what popular models cost per million tokens before the credit fee:
| Model | OpenRouter model ID | Input (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|---|
| Claude Opus 5.5 | anthropic/claude-opus-5.5 | $4.00 | $20.00 |
| Claude Sonnet 5.5 | anthropic/claude-sonnet-5.5 | $2.00 | $10.00 |
| Claude Haiku 5.5 | anthropic/claude-haiku-5.5 | $0.10 | $0.50 |
| GPT-6 Astra | openai/gpt-6-astra | $10.00 | $50.00 |
| GPT-6.1 Sol | openai/gpt-6.1-sol | $2.00 | $10.00 |
| Gemini 4 Argon | google/gemini-4-argon | $2.00 | $10.00 |
| DeepSeek V4 Pro 0813 | deepseek/deepseek-v4-pro-0813 | $1.32 | $3.96 |
| Qwen3.8 Max (0902) | qwen/qwen3.8-max-0902 | $2.00 | $6.00 |
| GLM 5.3 | z-ai/glm-5.3 | $0.079 | $1.40 |
| Llama 4 Maverick | meta-llama/llama-4-maverick | $0.1875 | $0.6525 |
| Gemma 4 31B (free) | google/gemma-4-31b-it:free | $0 | $0 |
| Nemotron 3 Ultra (free) | nvidia/nemotron-3-ultra-550b-a55b:free | $0 | $0 |
Prices from OpenRouter's model list, checked November 2, 2026. OpenRouter passes these provider rates through with no markup, so add 5.5% if you pay with credits by card, or nothing under the BYOK allowance. Open-weight models are served by many hosts at different prices, and the list shows just one of them. GLM 5.3's $0.079/$1.40 is the cheapest host (an fp4 quantization), while Z.ai's own endpoint charges $1.40/$4.40. DeepSeek V4 Pro's $1.32/$3.96 is DeepSeek's peak rate, and going direct off-peak halves it (details below). The :free models cost nothing but share the 50 requests/day limit.
What OpenRouter actually is (30-second version)
OpenRouter is an API aggregator. Instead of managing separate API keys for OpenAI, Anthropic, Google, DeepSeek, Mistral, and dozens of others, you get one API key that routes to hundreds of models from 80+ providers.
You add credits to your OpenRouter account. You make API calls. Credits are deducted per-token at the model's published rate. The 5.5% fee happens at the credit purchase step, not per-call.
The value proposition is: one API key, unified billing, automatic failover (if Claude goes down, route to GPT automatically), and access to models you might not have individual API keys for.
For someone making one-off API calls, this is a nice convenience. For someone running AI agents that consume millions of tokens per day across multiple models, the cost and operational implications are different.
The OpenRouter cost comparison most guides skip
Current models at their list prices, monthly cost (30 days) for a typical agent workload: 5 million input tokens plus 2 million output tokens a day, no caching, so these are worst-case numbers.
Claude Opus 5.5
Direct from Anthropic: $4/MTok input, $20/MTok output. Daily cost: (5 x $4) + (2 x $20) = $20 + $40 = $60/day = $1,800/month.
Through OpenRouter credits: Per-token rates match the provider's published rate (OpenRouter lists Opus 5.5 at the same $4/$20), but you need $1,800 in credits. At a 5.5% fee, you pay $1,899 for them. Effective monthly cost: $1,899 (extra $99).
Through OpenRouter BYOK: $1,800 is well under the $25,000 allowance. Effective monthly cost: $1,800 (extra $0).
Claude Sonnet 5
Direct from Anthropic: $2/MTok input, $10/MTok output. Daily cost: (5 x $2) + (2 x $10) = $10 + $20 = $30/day = $900/month.
Through OpenRouter credits: $949.50 (extra $49.50). Through BYOK: $900.
DeepSeek direct vs OpenRouter
DeepSeek is the model people ask about most when comparing OpenRouter to going direct, because the per-token price is so low that the 5.5% fee looks like nothing. It is small in dollars. It is not zero, and there is one detail that matters more than the fee.
Direct from DeepSeek at off-peak rates: $0.66/MTok input (cache miss), $1.98/MTok output. Daily cost: (5 x $0.66) + (2 x $1.98) = $3.30 + $3.96 = $7.26/day = $217.80/month. DeepSeek now charges double during weekday peak hours (01:00-04:00 and 06:00-10:00 UTC), so an all-peak workload would be $435.60/month.
Through OpenRouter credits: You pay $229.78 to get $217.80 in purchasing power. Effective monthly cost: $229.78 (extra $11.98).
The detail: OpenRouter routes DeepSeek requests to whichever provider is serving the model, and that is not always DeepSeek itself. Third-party hosts of DeepSeek weights set their own prices and do not follow DeepSeek's off-peak discount. The DeepSeek section below shows what that costs and how to avoid it.
GPT-6 Astra and GPT-6 Sol
Direct from OpenAI, GPT-6 Astra (the flagship): $10/MTok input, $50/MTok output. Daily cost: (5 x $10) + (2 x $50) = $50 + $100 = $150/day = $4,500/month.
Through OpenRouter credits: You pay $4,747.50 to get $4,500. Effective monthly cost: $4,747.50 (extra $247.50).
GPT-6 Sol, the mid tier, costs exactly what Sonnet 5 does: $2/$10, so $900/month direct and $949.50 through credits. One OpenAI-specific catch: any GPT-6 prompt over 272K input tokens is billed at 2x input and 1.5x output for the whole request. Claude has no long-context surcharge, on OpenRouter or direct.
All five side by side
| Model (5M in + 2M out/day) | Direct API | OpenRouter credits (+5.5%) | OpenRouter BYOK |
|---|---|---|---|
| GPT-6 Astra ($10/$50) | $4,500.00 | $4,747.50 (+$247.50) | $4,500.00 |
| Claude Opus 5.5 ($4/$20) | $1,800.00 | $1,899.00 (+$99.00) | $1,800.00 |
| Claude Sonnet 5 ($2/$10) | $900.00 | $949.50 (+$49.50) | $900.00 |
| GPT-6 Sol ($2/$10) | $900.00 | $949.50 (+$49.50) | $900.00 |
| DeepSeek V4 Pro, off-peak ($0.66/$1.98) | $217.80 | $229.78 (+$11.98) | $217.80 |
Prices checked November 2, 2026 against the Anthropic, OpenAI and DeepSeek pricing pages and OpenRouter's pricing page, FAQ and model list.
The 5.5% fee scales with your spend. On cheap models (DeepSeek), the extra cost is small. On mid-tier models (Sonnet 5, GPT-6 Sol) it's about $50/month at this volume. On the expensive ones (Opus 5.5, GPT-6 Astra), it's $99-248/month. The same question applies to whatever AI agent builder you run on top: ask what it adds to your inference bill before you connect a key.
For the full picture of what these models cost across different agent workload scenarios, we published a detailed breakdown with five real use cases.
The 5.5% fee is invisible at low volume. At $2,000+/month in LLM spend, it starts to matter. At $10,000+/month, it's a line item worth eliminating, and BYOK is how you eliminate it without leaving OpenRouter.
The BYOK escape hatch (and why it changes everything)
Here's the part most people miss.
OpenRouter supports BYOK (Bring Your Own Key). You add your own Anthropic, OpenAI, or DeepSeek API keys in OpenRouter's settings. The provider bills you directly for the inference, and OpenRouter acts purely as a routing layer, which sidesteps the 5.5% credit purchase fee on that traffic.
The pricing is set in dollars, not requests. On pay-as-you-go, the first $25,000 of list-price inference per month through your own keys carries no OpenRouter fee. Past that, OpenRouter charges 5% of what the same model and provider would normally cost on OpenRouter, deducted from your credits. (Older guides, including an earlier version of this one, quoted "1 million free BYOK requests a month." That's no longer how it works.)
What that means in practice:
- $1,800/month of Opus 5.5 via BYOK: $0 in OpenRouter fees. Same cost as going direct.
- $25,000/month via BYOK: still $0 in fees.
- $30,000/month via BYOK: 5% on the $5,000 above the allowance = $250/month. Through credits, the same $30,000 would cost $1,650 in fees.
For almost every agent team, that's the best of both worlds. You get OpenRouter's unified API, automatic failover, and model switching at the same price as going direct.
The catch: you need to manage those API keys. If you have keys for three providers, you're back to managing three billing relationships. OpenRouter handles the routing, but the payment goes direct.
This is similar to the model we use at BetterClaw, though we take it a step further. BYOK with zero inference markup across 28+ model providers. You connect your own API keys. We route your requests. You pay providers directly. We charge a flat platform fee ($49/month on Pro for 5 agents) and never touch your inference costs, with no usage fee on top at any volume. For a detailed comparison of how different platforms handle LLM pricing, the differences between BYOK, markup, and bundled credits are significant.
OpenRouter vs DeepSeek pricing: direct API vs OpenRouter (the off-peak catch)
DeepSeek is the one provider where going direct can beat OpenRouter by much more than the 5.5% fee. DeepSeek's own API charges half price off-peak. Peak hours are 01:00-04:00 and 06:00-10:00 UTC, Monday to Friday. Everything else is off-peak, including weekends.
Most OpenRouter hosts of DeepSeek's weights don't do that. They charge one price around the clock, and for most of them that price is DeepSeek's peak rate. Here is DeepSeek V4 Pro, per million tokens, checked on OpenRouter's live endpoints on 22 September 2026:
| Route | Input | Output | Notes |
|---|---|---|---|
| DeepSeek direct, off-peak | $0.66 | $1.98 | Nights, weekends and most of the working day in the Americas |
| DeepSeek direct, peak | $1.32 | $3.96 | Weekday 01:00-04:00 and 06:00-10:00 UTC |
| OpenRouter, DeepSeek's own endpoint | $0.66 | $1.98 | Listed at the off-peak rate when we checked (an off-peak hour), plus 5.5% on credits |
| OpenRouter, most third-party hosts | $1.32 | $3.96 | Together, Fireworks, Parasail and others. Peak rate all day, plus 5.5% |
For the 5M-input, 2M-output workload above, run entirely off-peak, that's $217.80/month direct against $459.56/month on a typical third-party host through OpenRouter credits. Default routing gives most traffic to the cheapest hosts, so you won't always pay the worst case, but you can't count on the off-peak rate either.
The fix: pin DeepSeek's own endpoint. Use the current model ID (deepseek/deepseek-v4-pro-0813, which is what DeepSeek's API serves today). The older deepseek/deepseek-v4-pro listing on OpenRouter isn't served by DeepSeek at all. Then pin the provider so OpenRouter can't fall back to another host:
{
"model": "deepseek/deepseek-v4-pro-0813",
"provider": {
"order": ["deepseek"],
"allow_fallbacks": false
},
"messages": [{"role": "user", "content": "..."}]
}
You still pay the 5.5% credit fee, or nothing extra through BYOK with your own DeepSeek key. V4.1 Flash (deepseek-flash on DeepSeek's API, deepseek/deepseek-v4.1-flash on OpenRouter) is different. DeepSeek charges $0.15/$0.60 off-peak and $0.30/$1.20 peak, but OpenRouter's Flash hosts range widely: on 28 September, Together charged $0.30/$1.20, Fireworks $0.22/$0.66 and DeepInfra $0.14/$0.42 (an fp8 quantization). For Flash, a third-party host can undercut DeepSeek's own peak price. Check the quantization before you pin it.
How OpenRouter provider routing works (cheapest vs fastest)
By default OpenRouter load-balances each request across the providers serving that model. It first drops any provider that has had a significant outage in the last 30 seconds. Among the rest, it picks by price, weighted by the inverse square of the price. A $1 provider is 9 times more likely to get the request than a $3 one. The others become fallbacks. So the default leans cheap, but it does not always pick the cheapest provider.
To choose the trade-off yourself:
| You want | Set | What it does |
|---|---|---|
| Cheapest | "provider": {"sort": "price"}, or add :floor to the model ID | Tries providers from lowest price up. :floor also unlocks flex-tier endpoints |
| Fastest output | "provider": {"sort": "throughput"}, or add :nitro to the model ID | Tries the highest tokens-per-second providers first. :nitro also unlocks priority-tier endpoints |
| Lowest latency | "provider": {"sort": "latency"} | Tries the fastest time-to-first-token providers first |
| One specific provider | "provider": {"order": ["deepseek"], "allow_fallbacks": false} | Pins the provider, as in the DeepSeek example above |
Setting sort or order turns off the default load balancing, so providers are tried strictly in that sequence. Every option is in OpenRouter's provider routing docs.
OpenRouter vs direct API: latency
Every OpenRouter request makes one extra hop before it reaches the model provider. OpenRouter doesn't publish a fixed millisecond figure for that hop. Its latency docs say the gateway runs on Cloudflare Workers at the edge and caches key and account data, so the overhead is small next to the model's own time to first token. Three situations make it slower:
- Cold edge caches. The first minute or two of traffic in a new region can be slightly slower while caches warm up.
- Low credit balance. When your balance drops to single-digit dollars, or a key nears its credit limit, OpenRouter runs extra billing checks on each request. Latency stays higher until you top up.
- Fallbacks. If the first model or provider fails and routing tries the next one, that request takes as long as both attempts combined.
For agents, the gap rarely decides anything. A tool-calling loop spends seconds waiting on the model, not milliseconds on the gateway. If latency matters, compare time to first token and throughput per provider on each model's OpenRouter page, sort routing by latency as shown above, or append :nitro to the model ID to route to the fastest provider. A direct API key removes the hop entirely, but it also removes the fallback.
Is OpenRouter worth it?
Yes, if you use several models or want automatic failover and spend under about $2,000 a month. No, if you run one model at scale. Credits cost 5.5% more than going direct at every spend level. BYOK removes the fee for the first $25,000 of inference a month. The crossover is around $2,000 a month through credits, where the fee passes $110 a month and BYOK or a direct key wins.
"Is it cheaper?" and "is it worth it?" are different questions. It's never cheaper than going direct on credits, but it's often worth the 5.5%. The short version:
Worth it if you:
- switch between models often (hundreds of models behind one API key)
- want automatic fallback when a provider goes down
- are prototyping and testing providers before you commit
- spend under about $500 a month, where the fee is under $27.50
Not worth it if you:
- use one model almost exclusively (direct saves 5.5% on every dollar, 8% on Business)
- need guaranteed rate limits and SLAs from the model provider
- spend $2,000+ a month through credits (the fee passes $110 a month; switch to BYOK or go direct)
- care a lot about vendor support (see the note below)
A note on support. OpenRouter's Trustpilot score sits below 2 out of 5, from a small number of reviews. Most complaints are about support response times, account issues and credit refunds. Unused credits can only be refunded within 24 hours of purchase, and the platform fee is never refunded. The complaints are rarely about routing or model quality.
When OpenRouter is worth it
Let me be fair. OpenRouter isn't a bad deal for everyone. There are specific scenarios where it's clearly the better choice:
You're testing multiple models. If you're evaluating 10 different models for your agent workflow, setting up 10 different API accounts with 10 different billing setups is a waste of time. OpenRouter lets you test all of them with one key. The 5.5% fee on a $50 testing budget is $2.75. That's nothing compared to the hours you'd spend managing accounts.
You need failover. If your production agent can't tolerate downtime when Claude's API has an outage (and they do happen), OpenRouter's automatic failover routes to a backup model. Building this yourself requires a routing layer, health checks, and fallback logic. OpenRouter gives it to you for the 5.5%, or for free under the BYOK allowance.
You want access to niche models. OpenRouter hosts models you can't easily access through direct APIs. Smaller open-weight models, regional providers, and experimental models that don't have their own API infrastructure. If your agent needs one of these, OpenRouter might be the only option. (If self-hosting is on the table too, the OpenRouter vs Ollama section above adds the third path.)
Your spend is under $500/month. At $500/month, the 5.5% fee is $27.50. That's less than the cost of one hour of engineering time spent managing multiple API integrations. The convenience is worth it.

When direct API is the better deal
Your spend exceeds $1,000/month on a single provider and you'd pay by credits. If 80% of your inference goes through Anthropic, the numbers are simple. The 5.5% on $1,000 is $55/month. Over a year, that's $660. You could use that to pay for an agent platform subscription and still come out ahead. (Or keep OpenRouter and switch that provider to BYOK. Under $25,000/month, it costs the same as direct.)
Your BYOK traffic is above $25,000/month. Past the allowance, BYOK adds 5% on the excess. At that scale, going direct (or negotiating OpenRouter Enterprise, which has a Custom BYOK allowance) is the cheaper route.
You need guaranteed rate limits and SLAs. Direct API accounts with providers like Anthropic and OpenAI come with documented rate limits, priority tiers, and support. OpenRouter routes through providers but doesn't guarantee their rate limits apply to your traffic specifically. (For raw inference speed specifically, our Groq vs OpenAI API comparison covers the fastest direct route.) For production agents where throughput predictability matters, direct relationships give you more control.
You're already managing the keys anyway. If your agent platform handles multi-provider routing for you (connecting your own keys and routing between them based on task type), you don't need OpenRouter as a middleware layer. You already have the routing. Adding OpenRouter credits would just add the 5.5% for no benefit.
Data sensitivity. Every API call through OpenRouter passes through their infrastructure. For regulated industries (healthcare, finance, government), adding a third-party intermediary in the data flow creates compliance questions. Direct API calls go from your system to the provider. One hop instead of two.
OpenRouter vs a $20 AI subscription: when each makes sense
A lot of people comparing OpenRouter prices are really asking something else. Should I pay $20 a month for Claude Pro or ChatGPT Plus, or pay per token through OpenRouter?
| Claude Pro | ChatGPT Plus | OpenRouter (pay per token) | |
|---|---|---|---|
| Price | $20/month ($17/month billed annually) | $20/month | No fee, pay for tokens plus 5.5% on credits |
| What you get | Claude apps, Claude Code and Cowork | ChatGPT's paid tier, including Codex | Hundreds of models through one API |
| Usage limit | Usage limits apply, with weekly caps | Usage limits apply | None beyond provider rate limits. You pay for what you use |
| Light use: 50 messages/day on Claude Sonnet 5 | $20 flat | $20 flat (OpenAI models) | About $14/month |
| Heavy use: 500 messages/day on Claude Sonnet 5 | $20 flat, if you stay under the limits | $20 flat, if you stay under the limits | About $142/month |
| API access for your own app or agent | Not included. The API is billed separately ($2/$10 per 1M tokens for Sonnet 5) | Not included. The API is billed separately | Included. That's what it is |
The OpenRouter figures assume 2,000 input and 500 output tokens per message at Sonnet 5's $2/$10 rate, bought through credits. Longer conversations resend more context each turn, so treat them as a floor.
The rule of thumb: for chatting with one assistant every day, a subscription wins, because $20 buys far more usage than $20 of tokens. A subscription can't power your own app or agent, though. Once you're calling a model from code, OpenRouter (or a direct API key) is the only option of the three, and at light volume it costs less than $20 a month.
The free model tier is useful, within limits
Here's the part of OpenRouter that doesn't get enough attention.
OpenRouter lists a set of free models (IDs ending in :free) with zero per-token cost. No credit card required. They are capped at 20 requests a minute and 50 a day, rising to 1,000 a day once your account has bought at least $10 of credits. Failed attempts count toward the daily cap, and a negative credit balance blocks free models until you top up. The list changes often, so check it before you build on one.
For testing agent workflows, prototyping new skills, or running low-volume internal agents, free models on OpenRouter are a real option. You won't get Claude or GPT-6 quality, but for tasks like simple classification, text formatting, or basic summarization, free models from Google, Meta, Mistral, and others can handle the workload.
This is particularly valuable if you're building on BetterClaw with BYOK. Use your paid API keys for production agents. Use an OpenRouter free-tier key for development and testing. Zero cost for prototyping. Full quality for production. The platform handles both.
The hidden cost most people forget: platform markup
Here's where this comparison gets relevant for anyone building AI agents (not just making API calls).
OpenRouter's 5.5% credit fee is one type of markup. But many AI agent platforms add their own markup on top of whatever you're paying for inference. Some charge 20-40% on top of the model's published rate. Some bundle LLM costs into their subscription and don't tell you what you're actually paying per token.
The question isn't just "OpenRouter vs direct API." It's "what's the total cost stack between my request and the model?"
Stack A: Your agent -> Platform (20% markup) -> OpenRouter credits (5.5% fee) -> Provider = 26.6% above published rate.
Stack B: Your agent -> Platform (BYOK, zero markup) -> Provider = 0% above published rate.
That 26.6% difference on a $2,000/month LLM bill is $532/month. $6,384/year. That's real money.
The cheapest API route in the world doesn't help if your agent platform adds 20% on top. Check the full stack, not just the token price.

The actual decision framework
Here's how I'd decide (or plug your own token volumes into the OpenRouter fee calculator):
Monthly LLM spend under $500, testing multiple models: Use OpenRouter credits. The convenience and model variety are worth the 5.5%.
Monthly LLM spend $500-25,000, settling on 2-3 models: Use OpenRouter with BYOK for your primary models. Under the $25,000/month allowance, that traffic costs exactly what direct would. Use a small credit balance for niche models and testing.
Monthly LLM spend over $25,000, production agents: Go direct for your primary providers, or talk to OpenRouter about Enterprise (Custom BYOK allowance). Past the allowance, BYOK adds 5% on the excess, and credits add 5.5% on everything. Use a BYOK agent platform that handles multi-provider routing natively.
Running AI agents specifically: Use a platform that supports BYOK across multiple providers and handles the routing for you. Whether you feed it an OpenRouter key or direct provider keys is your choice. The platform shouldn't care and shouldn't charge you for the privilege.
For a broader look at how to choose the right LLM for each agent task, the routing strategy matters as much as the pricing strategy.
If OpenRouter isn't the right fit, we compared nine OpenRouter alternatives on real fees, verified on each gateway's own pricing page. For the lowest-cost models to run through any of these routes, see our list of the cheapest AI models for agents.
Want the exact fee on your own usage? Run your model and daily tokens through the OpenRouter fee calculator. If a key stops working mid-setup, our OpenRouter error guide covers the common production failures.
Frequently Asked Questions
Is OpenRouter free?
Partly. Signing up and calling the API cost nothing, and models with IDs ending in
Does OpenRouter have a subscription?
No. OpenRouter has no monthly plan, no seat price and no minimum spend. You buy credits as you need them or connect your own provider keys. The Business plan is also pay-as-you-go, with an 8% credit fee instead of 5.5%, and Enterprise is a negotiated contract. For daily chatting, a $20 Claude Pro or ChatGPT Plus plan is better value.
What is the OpenRouter fee?
OpenRouter charges a fee when you buy credits: 5.5% by card with a $0.80 minimum per purchase, 5% with crypto, and 8% on the Business plan. On $100 of credits by card the fee is $5.50. BYOK traffic carries no fee up to $25,000 of list-price inference a month, then 5% on the excess. The fee is never refunded.
Is OpenRouter cheaper than the direct API?
No, not on credits. Per-token prices match the provider, so buying credits makes OpenRouter 5.5% dearer than going direct, or 8% on Business. With BYOK it costs the same as direct up to $25,000 of list-price inference a month, then 5% applies to the excess. OpenRouter wins on convenience and failover, not on price.
Is OpenRouter or Ollama cheaper?
Ollama is cheaper per token, because it runs open-weight models on your own machine at $0 a token. You pay for the hardware and electricity instead, and you cannot run proprietary models such as Claude or GPT. OpenRouter charges the provider's list price plus a 5.5% credit fee, but needs no hardware and gives you hundreds of models through one key.
What is OpenRouter BYOK?
BYOK means bring your own key. You add your own Anthropic, OpenAI, DeepSeek or other provider keys in OpenRouter's settings, the provider bills you directly, and OpenRouter only routes the requests. The first $25,000 of list-price inference a month carries no OpenRouter fee. Above that, OpenRouter deducts 5% of the list-price cost from your credits.
Does OpenRouter mark up tokens?
No. OpenRouter's pricing page says inference is billed at the provider's list price on every plan, so a model costs the same per token on OpenRouter as it does direct. OpenRouter makes its money from the fee on credit purchases, 5.5% on Standard and 8% on Business, plus the 5% BYOK fee above the monthly allowance.




