OpenRouter Pricing 2026: Complete Model Cost Guide & Hidden Markup Breakdown

TL;DR — OpenRouter’s “no markup on inference” claim is technically true in May 2026: the per-token catalog rates match each provider’s published rates, including Claude Opus 4.7 at $5/$25. The real money lives in two places most teams miss — a 5.5% credit-card platform fee ($0.80 minimum, so small top-ups effectively pay 10-20%) and a 5% BYOK fee on every request above 1M per month. Budget for 5-7% overhead on top of whatever the model itself costs, and treat the calculator-quoted token rate as the floor, not the ceiling.

OpenRouter has spent the last year arguing it doesn’t mark up model prices. That’s mostly correct, mostly defensible, and almost beside the point. The fees you actually pay never show up on a per-token basis. They get pulled out of your wallet at top-up time, or at the request-count tail end of BYOK, or in the fine print of a Stripe transaction that converts your EUR to USD before OpenRouter ever sees it.

This guide runs the breakdown the marketing page doesn’t: every fee verified against openrouter.ai/pricing as of May 2026, plus the scenarios where the published rates lie to you by omission.

What OpenRouter actually charges (the real fee stack)

OpenRouter’s billing has three distinct layers stacked on every dollar you spend. Most users only see the top one.

The inference passthrough is the one OpenRouter defends loudest, and it’s the one they actually deliver. The two platform fees are where they make money. They’re transparent about that, but transparent in the way utility companies are transparent: documented, just buried.

The $0.80 minimum is the fee that hurts indie devs

Here’s what nobody tells you about the platform fee: it has a $0.80 floor. So if you top up $5 to test a project, you pay $0.80 in fees — that’s 16%, not 5.5%. Top up $10? Still $0.80, so 8%. The fee doesn’t normalize to 5.5% until you’re loading roughly $15+ at a time.

If your workflow is “deposit a fiver, see how far it goes,” OpenRouter is charging you a lot more than the marketing page implies. The fix is boring: load $50 or $100 at a time and stop thinking about it.

The “Claude has 100% markup” claim is no longer true

If you’ve Googled OpenRouter pricing in the last twelve months you’ve probably hit a forum post or blog claiming Claude carries a 100% markup on OpenRouter — $6/$30 versus $3/$15 direct. That number was real once. It isn’t anymore.

I verified Claude Opus 4.7 on openrouter.ai/anthropic/claude-opus-4.7 at time of writing: $5 per million input tokens, $25 per million output. That’s the exact rate Anthropic publishes directly. Same for Sonnet 4.6 ($3/$15) and Haiku 4.5 ($1/$5). Passthrough holds.

The “100% markup” lore comes from an earlier era when OpenRouter’s Anthropic provider didn’t pass through the full enterprise rate. It got fixed quietly. Treat any pricing analysis written before late 2025 as archaeologically interesting, not actionable.

There’s an asterisk worth knowing about. OpenRouter routes between multiple providers per model. If a provider raises their rate, OpenRouter’s listed rate moves too. The promise is “no markup,” not “lowest possible price.” You’re getting the published rate, not necessarily the best available rate.

BYOK: free until you forget about it

In October 2025 OpenRouter announced 1 million free BYOK requests per month. Above that ceiling, you pay 5% of what the equivalent OpenRouter call would have cost, even though you’re billed directly by Anthropic/OpenAI/etc. for the tokens.

This is a real trap for teams scaling agent workloads. A million requests sounds like a lot until you do the math on a coding agent that fires three tool calls and a summary per task:

• 1,000 active developers
• 20 agent runs per developer per day
• 4 LLM round-trips per run (plan, edit, verify, summary)
• = 80,000 requests/day per company
• = 2.4M requests/month

That puts you at 1.4M requests over the free tier. The fee scales with your usage (1.4M × average cost per request × 5%), not a flat rate, so heavy users pay proportionally more. There’s no overage cap.

The way around it: stay under 1M requests if you can (cache aggressively, batch where possible), or accept the fee and treat it as the cost of unified routing. There’s no third option short of leaving the platform.

Hidden costs you won’t see in the calculator

The platform fee and BYOK fee are documented. These are the ones that aren’t.

Stripe FX conversion (non-USD cards)

If you top up from a non-USD card, your bank’s Stripe conversion adds 1-3% on top of the 5.5% platform fee. OpenRouter doesn’t quote prices in any currency other than USD, and the conversion happens before the platform fee, so you’re paying ~7-8% all-in to load credits from a EUR or JPY card.

This isn’t OpenRouter’s fault, it’s how Stripe works, but the marketing page won’t show it to you. Watch your statement, not the OpenRouter dashboard.

Failed routing retries (rare but real)

OpenRouter’s failover routes between providers when one returns an error. If the first provider charged you partial tokens before failing (some do), you’re billed for both attempts. The retry behavior is documented in the OpenRouter FAQ, but the bill aggregation isn’t obvious. You see one combined charge.

In practice this costs less than 0.5% over a month of normal traffic. Not a scam, just not zero, and it doesn’t show on the per-token quoted rate.

Free models that route to paid providers

OpenRouter lists “free” variants of some open-source models (Llama 4 Scout, DeepSeek V4 Flash, Qwen3 Coder, Gemma 3 — the current 2026 free roster). These actually call a sponsored provider with strict rate limits (typically 20 req/min, 200 req/day per the OpenRouter free-models docs). When limits get hit, calls may queue, drop, or (if you’ve configured fallback) silently re-route to a paid provider at full rate.

If you build production traffic on free-tier routes, monitor the actual provider returned in the response headers. The cost difference between “free” and “fallback paid” can be 100x.

Concrete cost scenarios (the bills that matter)

Let’s run real numbers. All prices verified May 2026; assumes Claude Opus 4.7 at $5/M input + $25/M output, GPT-5.4 Pro at OpenAI’s listed rate, Gemini 3.1 Pro at Google’s listed rate.

Scenario 1: Solo dev, $50/month Claude Code usage

• Token cost: $50.00
• Platform fee on $50 top-up (5.5%): $2.75
• Total: $52.75
• Effective overhead: 5.5%

This is the case OpenRouter’s marketing is built around, and it’s honest. You pay roughly what you’d pay direct, plus convenience tax.

Scenario 2: Indie hacker testing 5 models, $5 top-ups each

• 5 separate $5 top-ups, $0.80 minimum each: $4.00 in fees
• Token usage: $25.00
• Total: $29.00 for $25 of compute
• Effective overhead: 16%

The lesson: don’t top up small. Consolidate to one $25+ load.

Scenario 3: Startup with 50 devs running agents, BYOK with Anthropic

• Total requests/month: ~600,000 (under the 1M free tier)
• BYOK fee: $0
• Anthropic charges you directly for tokens
• Token cost (paid to Anthropic): $4,200/month
• OpenRouter cost: $0/month
• Total: $4,200/month

This is where OpenRouter is genuinely free. You’re paying Anthropic for compute and using OpenRouter for routing/observability at no marginal cost.

Scenario 4: Same startup at 3x growth

• Total requests/month: 1.8M (800K over the 1M free tier)
• Average equivalent OpenRouter price per request: ~$0.008
• BYOK fee: 800,000 × $0.008 × 5% = $320/month
• Anthropic still charges you directly for tokens
• Total: $12,600 (Anthropic) + $320 (OpenRouter BYOK fee) = $12,920

Worth it if you value unified routing, less worth it if you only call one provider anyway.

When OpenRouter pricing wins, and when it loses

OpenRouter wins when you genuinely want multi-model access from one API key, your top-up volume is large enough to amortize the $0.80 minimum, and your BYOK request count stays under 1M/month. For a typical mid-sized team running Claude + GPT + Gemini in parallel for different tasks, the 5.5% is a reasonable price for not maintaining three vendor relationships.

OpenRouter loses when you’ve already standardized on one provider with a negotiated rate (you’re paying their list price + 5.5%), when your top-ups are small (the $0.80 floor eats you), when you’re scaling BYOK past 1M/month without realizing it, or when you need the absolute lowest per-token price and would rather route through a discount aggregator. OpenRouter optimizes for breadth and convenience. If you’re optimizing for cost-per-token at scale, the answer is usually a different aggregator or going direct.

Alternatives worth pricing against OpenRouter

Three aggregators commonly compared head-to-head on cost in 2026:

• ofox.ai — Single-Key, OpenAI-compatible aggregator. Pricing is published per model with automatic volume-tier savings (Bronze/Silver/Gold/Platinum, 3–7% off once monthly spend crosses $1K / $5K / $10K / $20K). No 5.5% credit-purchase fee; you pay for actual usage. Catalog covers Claude Opus 4.7 / Opus 4.6 / Sonnet 4.6, the GPT-5.5 and GPT-5.4 families, Gemini 3.5 / 3.1 families, DeepSeek V4 Pro and V4 Flash, Grok 4.20, Qwen 3.7 Max, and Kimi K2.6 (no Llama variants listed at time of writing).
• Direct provider accounts — Cheapest on a per-token basis if you’re using one provider, zero overhead. Cost is the engineering time to maintain N billing relationships.
• Cloud-vendor inference (AWS Bedrock, GCP Vertex) — Includes Claude/Llama/etc., with cloud-vendor billing and quota mechanics. Usually 10-20% more expensive per token but folds into existing cloud spend.

For a deeper comparison see our OpenRouter alternatives guide and is OpenRouter reliable for production? — both look at non-pricing axes that matter when the difference between aggregators isn’t dollars.

How to verify these numbers yourself

I lean toward making readers do their own math because pricing changes:

1. Pull the current rate for any model from openrouter.ai/pricing (catalog) and confirm against the provider’s published price.
2. Run a $10 test top-up and check the actual credit balance you receive. The difference is your real platform fee.
3. Make 10 real calls and inspect the response headers. They show which underlying provider was hit. Calculate effective cost from your billing dashboard and compare to the quoted rate.
4. If using BYOK, hit the /api/v1/usage endpoint to track request count toward the 1M/month free tier. Set an alert at 800K.

That’s the work. There’s no shortcut, no spreadsheet that survives a model-version bump, and no “true” overhead percentage that applies to every team.

Bottom line for 2026

OpenRouter’s pricing is honest, layered, and easy to misread. The marketing emphasizes the inference passthrough (which is real) and de-emphasizes the platform fee (which is also real, just non-zero). Budget 5-7% overhead on credit-card spend, watch the BYOK tail at 1M requests, never top up under $20 if you can help it, and stop treating the “no markup” claim as a synonym for “no cost.” It’s just the cost showing up in a different column than you expected.

For broader cost framing across providers, see how to reduce AI API costs in 2026, the LLM API selection decision matrix, and the $30/month AI coding stack guide. All of which assume you’ve already done the homework this post laid out.

Sources

• OpenRouter Pricing page (official rate card and platform fee)
• OpenRouter: Simplifying Our Platform Fee announcement
• OpenRouter: 1 million free BYOK requests per month announcement
• OpenRouter FAQ — failover and routing behavior
• Claude Opus 4.7 on OpenRouter (catalog price verified May 2026)
• Anthropic Claude API pricing (direct rate for comparison)
• BYOK guide — OpenRouter docs