⚡ Reasoning Token Cost

Every reasoning model has two output prices: the one on the pricing page and the one on your invoice. The gap is the thinking multiplier — internal chain-of-thought tokens that are billed at the full output rate and then discarded before the response reaches you. A 400-token answer that looks like $0.003 can settle at $0.019. This calculator takes your own rates as inputs, because the multiplier is a property of your workload, not of the model.

📐 Workload

Enter the rates from your own contract, not list prices, if they differ. The three fields that move the result most are the thinking multiplier, the per-task output length, and the monthly task count.

Reasoning model
Cheaper standard model with retries

Retries are modelled as full re-sends, so each attempt pays for the input again. That matches how most retry loops are actually written — they resend the prompt rather than resuming a conversation.

Why the Visible Answer Is Not What You Pay For

Reasoning models spend tokens before they speak. The model writes an internal chain of thought, discards it, then produces the answer you see. Providers meter that internal work at the output rate, because it is generated output — it just never reaches your response body. The response object reports the visible text; the usage object reports the total. Those two numbers are the whole story of this page.

The practical shape of the trap is that cost scales with difficulty, not with length. A one-sentence question about a hard invariant can trigger thousands of thinking tokens. A long but routine summarisation task can trigger almost none. That is why per-token list prices tell you very little about which model is cheaper for your workload: the multiplier is doing more work than the rate card.

There is a second-order effect that catches teams by surprise. Because input tokens are cheap and output tokens are not, a workload that looks input-heavy is barely affected by reasoning. A workload that looks output-heavy is affected several times over. The same model, the same token counts, two different bills — decided entirely by which side of the ledger the multiplier lands on.

Measuring Your Multiplier Instead of Guessing It

Published multipliers are averages over benchmark suites weighted toward math and competitive programming. Your production traffic is not that. The only number that matters is the ratio on your own requests, and it takes about twenty minutes to obtain.

multiplier = billed_output_tokens / visible_output_tokens billed_output_tokens = usage.output_tokens (provider reports this) visible_output_tokens = tokens in the response body Run 50 real tasks. Log both numbers. Take the median, not the mean — a handful of hard requests can drag a mean far above what you actually pay on a typical day.

Two measurement mistakes are common enough to name. The first is using the mean: reasoning token counts are heavy-tailed, so a few pathological requests inflate the average and make every projection pessimistic. The second is measuring on curated examples. Benchmarks and demos are exactly the tasks where reasoning models are worth their price; your routine traffic is where the multiplier quietly eats the budget.

If you cannot instrument the workload yet, a useful fallback is to divide the monthly bill by the price you expected to pay. A workload projected at $400 that invoices at $2,100 has a blended multiplier near 5, whatever the individual requests looked like.

The Retry Trade: Cheap Model Wrong Twice vs Expensive Model Right Once

The usual argument for a cheap model is per-token price. The usual counter-argument is that a cheap model needs retries, so the real cost is the price divided by the success rate. Both are half right, and the half that matters is how retries compound.

If a task succeeds with probability p on each attempt and you allow up to n attempts, the expected number of attempts is:

E[attempts] = (1 − pⁿ) / (1 − p) p = 0.55, n = 3 → E = 1.83 attempts p = 0.30, n = 3 → E = 2.19 attempts p = 0.90, n = 3 → E = 1.11 attempts

Expected cost is that multiplier times the per-attempt cost. Compare it against the reasoning model's per-attempt cost divided by its own success rate, and you have a like-for-like number. The breakeven is where the two meet, and it is usually far lower than intuition suggests.

Work an example. The reasoning model costs five times as much per attempt and succeeds 95% of the time, so its effective cost is 1.05× one attempt. The standard model must therefore average no more than 1.05 attempts, which needs a first-attempt accuracy around 90% with three retries allowed. At 55% accuracy the standard model averages 1.83 attempts — roughly 0.37 of the reasoning model's cost, so it wins on money and loses on latency and on developer time spent handling failures.

That last clause is why the arithmetic alone rarely settles the decision. Retry loops also carry engineering cost: idempotency, partial-failure handling, evaluation harnesses, and the on-call burden of a pipeline that fails a third of the time. Those costs do not appear in a token bill, which is exactly why they get ignored in one and matter in the other.

Where the Multiplier Stops Being Worth It

Reasoning earns its price on tasks with a checkable answer: proofs, multi-constraint refactors, schema design, anything where a wrong answer costs more than a slow one. It earns nothing on tasks where a standard model already clears your quality bar — classification, extraction, summarisation, routine support replies. In those cases the multiplier is pure overhead, often a 5× overhead on a workload that had no accuracy problem to begin with.

The useful diagnostic is not "is this a hard task" but "does this task have a failure mode I can detect". If you can score the output automatically, a cheap model plus retries plus a scorer is usually the better architecture. If a wrong answer is silent — a subtly incorrect proof, a plausible but broken refactor — retries do not help, because you never learn that a retry was needed.

The single cheapest lever is effort control, where the provider exposes it. Lowering reasoning effort reduces the multiplier roughly proportionally, and on tasks the model already solves reliably it changes nothing about answer quality. Teams routinely pay a 5× multiplier on traffic that would pass at 1.5×. That is a configuration difference, not a model difference.

Reading the Result

Invisible share is the fraction of all billed tokens that never appeared in a response. Above 70% is normal for reasoning-heavy traffic, and it is the number to put in front of anyone who budgets from visible output length.

Per visible 1M output restates the output price in the only unit that matches what reviewers actually see. If the pricing page says $8 per million and this field says $40, the multiplier is 5 and every output-length estimate in your planning is off by the same factor.

Breakeven accuracy is the first-attempt success rate the standard model would need to match the reasoning model's cost, given the retry cap. If it reports "not reachable", no success rate can close the gap at that retry count — the cost ratio exceeds the maximum attempt multiplier, and the cheap model loses on arithmetic regardless of quality.

What This Model Leaves Out

Cached input. Providers discount repeated input substantially, and cached reads change the input side of the bill without touching the output side. If your prompts share a large prefix, set the input price to your effective cached rate rather than the list rate.

Batch discounts. Batch APIs commonly halve both input and output rates. They apply uniformly to visible and hidden tokens, so a batch workload scales the whole result rather than changing the shape of it.

Failed requests. A request that errors before producing output may bill input tokens without billing output tokens. That makes failures cheaper than the model here assumes, and a retry loop with a high failure rate will over-perform this projection slightly.

Tool calls and multi-turn agent loops. Each tool call is a separate request with its own input bill, and each may carry its own thinking tokens. An agentic workflow is a chain of these calculations, not one, and the multiplier applies per hop rather than once.

Pricing Basis, Sources & Assumptions

This page does not assert vendor prices. Every rate is an input you control, pre-filled only as a starting point. That is a deliberate choice: 2026 list prices for the same model differ between the vendor's own pricing page, resellers, and third-party trackers, and a hardcoded rate would be wrong within weeks. Enter the rate on your invoice.

Pricing inputBasis used on this page
SourceAll per-token rates are user-supplied and every result depends on what you enter. The billing rule — that hidden reasoning tokens are metered at the output rate — follows the OpenAI API pricing documentation and the Anthropic pricing page, both re-read on . Preset values in the model selector are illustrative starting points, not a price claim, and are not used in any calculation until you select one.
RegionNot applicable — API pricing is global per provider, with regional differences limited to data-residency products that are out of scope here.
CurrencyUSD, as entered by the user
Last checked — the billing rule that reasoning tokens are metered at output rates was re-confirmed against provider documentation on this date. No rate is asserted.

Modelling assumptions