How do you spend less on OpenRouter? Token prices, context length, and what coding actually costs

The cheapest way to use OpenRouter is not to fill the context window, and it is not to switch models the moment an input price looks small. On the model list pulled on 16 October 2026, the same development request changes by an order of magnitude when you change the model or the prompt length.

The figures below are US dollars per million tokens. Inference is deducted from credits at the provider’s list price. The pricing page says no plan adds a fee on the request itself. Card purchases of credits are 5.5 percent, with a $0.80 minimum. The FAQ lists Coinbase at 5 percent. If the unit price moves, recompute. This piece does not invent a payback month.

List prices come from that day’s models endpoint. How a later call sticks to the provider that holds the cache is in the prompt-caching guide. If Activity shows a different unit price, Activity is the bill.

Where do these list prices actually differ?

In a coding loop, output often costs several times the input, sometimes dozens of times. A single request still carries far more input tokens than output tokens. Comparing only “dollars per million input tokens” makes a model look cheap when its output is expensive, or when it surcharges past a prompt length.

The table is the text-token list price from the models endpoint on 2026-10-16, in dollars per million tokens. The model id sits under the name so you can match Activity.

Gemini 4 Argon and Sonnet 5.5 share the $2 / $10 sticker. Argon’s entry also has internal_reasoning at the output rate, $10 per million. The words you can see are not the billed length.

Web search is 0.014 on the Argon entry and 0.01 on these OpenAI entries, charged per call, outside the token formula below. Kimi K3 (moonshotai/kimi-k3) is $0.405 per million input and $15.45 per million output. The input looks middling. An agent loop that writes a lot costs more than Sonnet.

Where does the price jump as context grows?

Context length is the most a request can carry. It is not a target to fill. Haiku 5.5 and Luna both sit near a million tokens, and both start at $0.10 input. The surcharge line is the difference.

Haiku’s min_prompt_tokens is 100,000. Past that line, input goes from $0.10 to $0.50 and output from $0.50 to $2.50. Both are five times the base rate. Luna waits until 272,000, then input becomes $0.20 and output $0.75. The step is smaller.

Qwen3.7 Flash leaves the cheap tier sooner. The base is $0.03 / $0.13. Past 32,000 tokens it becomes $0.10 / $0.40. Past 256,000 it becomes $0.20 / $0.80. A repo note plus a test log is enough to cross the first line.

Sonnet 5.5, Opus 5.5, and Gemini 4 Argon had no length surcharge in that day’s entry. They are expensive on every token. Shorten a prompt from 40,000 to 4,000 and the unit price stays put. The amount still falls with the token count.

Where do cache, the free tier, and the purchase fee land?

Cache-read multiples belong to the model, not to a slogan. Haiku 5.5 and Luna read cache at $0.01 per million, exactly 0.1 times base input. Sonnet 5.5 and Opus 5.5 read at 0.05 times input: $0.10 and $0.20. Argon’s cache read is also $0.10.

Writes are a separate line. On this Claude set, a cache write is 1.25 times input, and the one-hour TTL is 2 times. Haiku 5.5 writes the base tier at $0.125 per million. Sonnet 5.5 writes at $2.50. A prefix used once costs more than not caching. The saving starts when later requests send that prefix unchanged.

The caching guide says that when a cache read is cheaper, later requests stick to the provider that served the cached call. Set provider.order and your order wins over that stickiness. If you want the cache saving, do not pin the provider at the same time.

Free-model limits are a different counter. The FAQ says that without at least $10 of purchased credits, free models are capped at 50 requests a day. After at least $10, the cap is 1,000 a day. The pricing page marks prompt caching as absent on the free plan. Paid plans have it. openrouter/free has a 200,000 context and a $0 input and output price. It is for trying a call. An afternoon of agent turns, with no credits purchased, hits 50 first, and there is no cache read to deduct.

openrouter/auto has no fixed unit price in the list. The pricing page says auto routing adds no fee. You pay the model it picked. To keep the bill down, name the model id. Auto removes the choice, not the price.

$0.80 divided by 0.055 is about $14.55. A card top-up under that amount pays $0.80, not 5.5 percent. If a personal month of tokens is $0.90 and auto top-up buys $5 at a time, the fee outweighs the tokens. Stretch the purchase and the percent covers the minimum. The months below are multiplied by 1.055 only when the top-up is already large enough that the minimum does not apply.

What do a light day and a heavy day cost on the same rates?

The formula counts three things: fresh input, cache reads, and output. Cache writes, reasoning tokens, web search, and failed retries are extra. On the batch endpoints, Haiku 5.5, Luna, and Sonnet 5.5 are about half the live input and output rates, but only if the work can wait. That is not the default price for coding while you watch.

month ≈ calls per day × 30 × (fresh input × input rate + cache read × cache-read rate + output × output rate) ÷ 1,000,000

Rates are dollars per million tokens, so divide by 1,000,000. On a Standard card purchase that has already cleared the minimum fee, multiply by 1.055.

Thirty calls a day, still under the surcharge line

Assume 4,000 fresh input, 20,000 cache read, and 800 output. The prompt totals 24,000, under Haiku’s 100,000, Luna’s 272,000, and Qwen’s 32,000. That is 900 calls a month. The line counts cache reads, not writes.

Sonnet 5.5: 4,000×2 + 20,000×0.10 + 800×10, divided by one million, is $0.018 a call. Times 900 is $16.20 a month. Spread at 5.5 percent, the purchase is $17.09.

Luna and Haiku 5.5 share the base rate: $0.001 a call, $0.90 a month, $0.95 after 5.5 percent. Against Sonnet’s $16.20, that is 18 times. The 18 times holds only for this token mix.

DeepSeek V4.1 Flash is about $0.000713 a call, about $0.64 a month. Output alone is 800 × 0.684 / 1,000,000 ≈ $0.000547, about 77 percent of the call. The next saving is shorter answers, not a still-lower input name.

If every call also rewrites a 20,000-token prefix at Sonnet’s write rate, each call adds $0.05, and 900 calls add $45. The cache saves repeated reads. It does not save money because the switch is on.

One hundred fifty calls a day, fresh input past the line

Assume 120,000 fresh input, no cache, and 2,000 output. That is the shape of sending the repo and the log whole. It is not the recommended shape. A month is 4,500 calls. The whole prompt is fresh input, so Haiku’s 100,000 line has no cache-counting ambiguity.

Haiku 5.5 at 120,000 input uses $0.50 / $2.50. A call is $0.065. A month is $292.50, or $308.59 after 5.5 percent. Cut the same call to 40,000 fresh input and 2,000 output, and Haiku returns to the base rate: $0.005 a call, $22.50 a month. The extra 80,000 tokens move the month from $22.50 to $292.50 because the rate changes on both sides of the line. It is not a linear rise with token count.

Luna at 120,000 is still under 272,000, so it stays at $0.10 / $0.50. A call is $0.013. A month is $58.50. That is cheaper than Haiku after the surcharge, and more expensive than Haiku after you shorten the prompt. Leave the surcharge tier first, then compare models.

The same 120,000 input and 2,000 output on Sonnet 5.5 has no length surcharge. The rate is still $2 / $10. A call is $0.26. A month is $1,170, or $1,234.35 after 5.5 percent. Against Luna’s $58.50, that is 20 times. It is not the same 18 times as the light mix, because this mix has no cheap cache read and a different output share.

Push Luna to 300,000 tokens and it enters $0.20 / $0.75. A call is $0.0615. A month is $276.75. The window still fits. The bill has left the base tier.

Every month in the table can be rebuilt from the formula. The 5.5 percent applies to card purchases once a top-up is already above about $14.55. The FAQ’s 5 percent crypto rate does not inherit the minimum-fee sentence.

What does one feature cost across twelve turns?

This is an estimate, not a trace exported from a real session. Assume a small feature takes 12 turns, averaging 25,000 input and 800 output, with no cache hit. History is sent again, so the input figure is an average, not the first turn.

Sonnet 5.5 is $0.058 a turn, $0.696 for 12. Luna or base-tier Haiku is $0.0029 a turn, $0.0348 for 12. And $0.0348 × 20 = $0.696. The cheaper model has to do about 20 times the calls of that session before the fee matches one Sonnet pass.

A work month of 22 days and 20 such features a day is 440 sessions. Sonnet is about $306.24, about $323.08 after 5.5 percent. Luna is about $15.31, about $16.15 after 5.5 percent. Two or three failures do not close that gap. The gap closes when the cheap model cannot finish and you run the same context again on Sonnet or Opus. Then you pay both.

Twenty features times 12 turns is 240 requests. That is above the 50-a-day free-model cap before you have bought $10 of credits, and below the 1,000-a-day cap after that purchase. Once the cap steps aside, the wall is whether you can accept the model the free router assigns, and that each turn is resent at the full input price when there is no cache.

If the usage record bills reasoning tokens separately, the 800 visible output tokens are not the whole charge. Argon’s internal_reasoning matches the output rate. Use the Activity split, not the length of the chat bubble.

When tool logs come back whole on later turns, send fewer of those words before you change models. How to judge that layer is in Why Is Claude Code Using More Tokens? Can Context-Mode Lower Its Cost?

A multi-year bill for your own hardware against the vendor API, rather than this one OpenRouter request, is a different ledger: Run Open-Source LLMs Locally or Use Claude and GPT? How to Calculate Hardware Requirements and Long-Term Costs.

When does a cheap model stop being cheap?

A higher unit price is the cheaper path only when the cheap model cannot finish, and retries or hand repair cost more than the rate gap. On the 12-turn estimate, that crossing is about 20 times the calls. Short of that, do not replace the bill with “better quality.”

A cheap model stops being cheap in three cases:

• The prompt crosses its own surcharge line. Past 100,000, Haiku’s input and output both become five times. Past 32,000, Qwen3.7 Flash leaves $0.03 / $0.13. Luna waits until 272,000.
• Output is longer than you thought. DeepSeek V4.1 Flash has a very low input price, and 800 output tokens already dominate the call. Kimi K3 output is $15.45 per million, above Sonnet’s $10.
• The prefix is not stable. Cache writes are paid at 1.25 times for nothing. The free plan does not have that discount at all.

Calling the provider directly avoids the 5.5 percent on credit purchases. The pricing page and the FAQ both say inference is not marked up, so the token rate itself is usually not higher because the call went through OpenRouter. What you add is the fee on buying credits. What you get is one key, and a fallback route after a failure. That 5.5 percent does not erase an 18-times or 20-times gap between Luna and Sonnet. It multiplies both sides.

BYOK is a different path. The pricing page says Standard and Business include $25,000 a month of list-price usage without this OpenRouter fee. Above that, 5 percent of list price comes out of credits, and the provider bills inference directly. Under that allowance, BYOK does not remove the 5.5 percent, because you still pay the provider the token price.

The decision

To spend less, pin the model id, keep the prompt under that model’s surcharge line, and make sure a repeated prefix is actually read from cache. On the 2026-10-16 list, a personal mix of 30 calls a day and a 24,000-token prompt is about $0.90 a month on Luna or Haiku 5.5, and about $16.20 on Sonnet 5.5, before the purchase fee.

At 150 calls a day and 120,000 fresh input tokens, pull Haiku back under 100,000 first. The month moves from $292.50 back to the $22.50 range. Leave it at 120,000 and stop treating it as a $0.10 model. Sonnet on that volume is about $1,170. The cheap model’s failures meet one expensive pass on the bill only at about 20 times the calls.

Before you have bought $10 of credits, free models are 50 requests a day. Keep that for a trial call. Once a coding agent’s turns pass that number, use Standard credits and the formula above. Do not card-top-up so little that the $0.80 minimum fee outweighs the tokens.