LLM cost calculator

Counted

• Input and output tokens at each provider's published list price, priced separately rather than blended.
• Cached input at the provider's own published cached rate. Models without one bill cached tokens at the full input price and are flagged, rather than silently inheriting another provider's discount.
• Reasoning output — as whatever you put in the output field. Reasoning tokens bill as output, so a reasoning model needs a much larger number there than its visible answers suggest.

Not counted, and why

• Cache writes. A write happens once per distinct prompt prefix, not once per request. Turning a per-request token count into a write volume needs an assumption about prefix reuse that nobody has, and charging it per request would overstate caching enough to invert the ranking.
• Batch discounts. Providers publish them; this catalogue does not carry them. Hardcoding “50% off” would be a guess dressed up as a number.
• Image, audio and tool fees. Priced separately by most providers and highly workload-specific.
• Negotiated rates. Everything here is list price. Committed-use and enterprise agreements move it.

So the figure is a floor: what the tokens you described would list for.

How do I calculate the cost of an LLM API call?

Multiply input tokens by the model’s input price per million and divide by a million, do the same for output tokens at the output price, and add them. Output is typically three to six times more expensive than input, so an output-heavy workload costs far more than the headline input price suggests. Reasoning models complicate this further: reasoning tokens bill as output even though you never see them, which can multiply the output side several times over. This calculator does that arithmetic across every priced model in the catalogue at once.

Why is my LLM bill higher than the price per million tokens suggests?

Three usual reasons. First, the quoted price is often the input price, and output costs several times more. Second, reasoning tokens count as output and are invisible in your prompt and response, so a "500 token answer" can bill as several thousand. Third, in a multi-turn conversation or an agent loop, the whole history is resent on every call — a ten-turn conversation is not ten short requests, it is ten increasingly long ones. Count requests as model calls, not user messages.

How much does prompt caching actually save?

It depends entirely on how much of your prompt is a stable, reusable prefix. Providers that publish a cached-input rate typically charge around a tenth of the full input price for a cache hit, so a workload that is 70% stable prefix — a long system prompt, a fixed tool schema, a retrieved corpus reused across a session — can cut the input side of the bill substantially. It does nothing for output tokens. This calculator uses each provider’s own published cached rate rather than assuming a fixed discount, and flags models that publish no cached rate instead of quietly discounting them.

Is the cheapest model the cheapest option?

Not always. A cheaper model that needs two attempts, a longer prompt, or a larger retrieval set to reach the same answer can cost more per unit of useful work than a stronger model that gets it right the first time. That is why cost per benchmark point exists — the measured dollars a model spends earning a point of capability. Use this calculator for the bill and the model comparison pages for whether the cheaper model can actually do the job.

How current is this pricing?

List prices come from OpenRouter and refresh every 15 minutes, so price cuts and new model launches appear without a redeploy. These are list prices — committed-use discounts, enterprise agreements and batch tiers are negotiated per customer and are not reflected here.

What does this calculator not include?

Cache write costs, batch-API discounts, image and audio tokens, web-search tool fees, and fine-tuning or hosting charges. Cache writes are excluded deliberately: a write happens once per distinct prompt prefix rather than once per request, so charging it per request would overstate caching enough to change the ranking. Treat the figure as a floor — what the tokens you described would list for.