Reasoning models cost more because they generate a large batch of hidden “thinking” tokens before the visible answer, and those tokens are billed at the output rate. On a hard prompt this internal work can dwarf the reply you actually read, so the real bill often lands 5–10× above a naive estimate that only counts the words you see. The reasoning token cost calculator shows the gap for your own numbers.
What a reasoning token actually is
A standard model reads your prompt (input tokens) and writes a reply (output tokens). You pay for both, and you can see both. A reasoning model — the o-series style or any “extended thinking” mode — adds a middle step: it writes out a long internal chain of working before it commits to an answer.
Those internal tokens are real generated output. The provider charges for them at the output token price. The catch is that the API usually does not return their content to you, so nothing in the visible response tells you how many there were. You find out from the usage numbers on the bill, where they show up as output or in a dedicated reasoning-tokens field.
So the naive estimate — “the answer was 400 tokens, so I pay for 400 output tokens” — quietly ignores the 2,000 or 4,000 tokens of thinking that produced it.
Why the multiple is so large
Output tokens are the expensive side of most price sheets, often several times the input rate. Reasoning stacks more spending onto exactly that expensive side. Two things drive the size of the jump:
- Task difficulty. Easy questions get short reasoning. A tricky maths, planning, or debugging prompt can trigger thousands of thinking tokens as the model explores dead ends.
- Effort setting. Most reasoning models expose an effort or thinking-budget control (low / medium / high, or a token cap). High effort tells the model to think longer, which spends more hidden tokens per call.
Put those together and a single hard call on high effort can generate far more reasoning than answer. That is where the 5–10× figure comes from. Treat it as a rough band, not a fixed law — the exact multiple shifts with the model, the prompt, and the effort setting, and provider pricing changes over time.
Worked example: naive vs true cost
Say a model charges roughly $2.50 per million input tokens and $10 per million output tokens (illustrative round numbers — check live pricing). You send a 1,000-token prompt and get a 500-token visible answer. On high effort it also burns 5,000 hidden reasoning tokens.
| Line item | Tokens | Rate (per 1M) | Cost |
|---|---|---|---|
| Input | 1,000 | $2.50 | $0.0025 |
| Visible output | 500 | $10 | $0.0050 |
| Hidden reasoning | 5,000 | $10 | $0.0500 |
| True total | $0.0575 | ||
| Naive estimate (no reasoning) | $0.0075 |
The naive estimate said $0.0075. The real cost is $0.0575 — about 7.7× higher — and the reasoning tokens alone are the biggest single line. Multiply that across thousands of calls and the difference stops being rounding error.
When the extra cost is worth it
Hidden tokens are not waste. On problems where a wrong answer is expensive — a bad migration plan, a subtle logic bug, a legal or financial judgement — paying for deeper reasoning can be cheaper than shipping the mistake. The question is fit, not fear.
A simple way to decide:
- Use high reasoning for genuinely hard, low-volume, high-stakes calls where correctness dominates cost.
- Use low or no reasoning for high-volume, low-difficulty work — classification, formatting, extraction, short lookups — where a plain model is faster and far cheaper.
- Tune the effort per route, not per app. Most systems have a few hard prompts and many easy ones; sending everything to high effort is how bills balloon.
Before you commit, model both sides. Plug your token counts and effort level into the reasoning token cost calculator to see the true per-call cost, then compare a cheaper model on the same task with the model switch savings calculator. If reasoning calls run inside a multi-turn loop, they compound fast — the AI agent conversation cost calculator shows how that history stacks up.
The takeaway: reasoning models are not “a bit pricier.” They add a whole hidden output stream at the output rate, so estimate them on true tokens, not visible ones, and spend the effort only where it earns its keep.
