How Reasoning Token Pricing Works

The chain of thought you never see still shows up on the bill

Reasoning models — OpenAI's o1 and o3, the thinking tier of GPT-5, DeepSeek's R1, Gemini's thinking variants — don't jump straight from your prompt to an answer. Internally they generate a chain of intermediate steps, working through the problem the way a person might scribble on a notepad before writing a clean final answer. OpenAI calls these reasoning tokens. They are generated, and they are billed, exactly like the visible answer: at the model's saída price per token. The difference is that OpenAI strips them out of the response before you see it — you're charged for a notepad you're never shown.

DeepSeek R1 is the exception worth knowing: it emits its chain of thought in plain <think> tags inside the actual response, so you can read — and count — exactly what you paid for. Every other major reasoning API redacts it, which is precisely why so many teams are surprised by the bill: there's no field in the response that tells you "this call spent 4,000 tokens thinking before it wrote 80 words."

The arithmetic: output price × (visible + hidden)

A normal model's output cost is just visible tokens × output price. A reasoning model's output cost is (visible tokens + reasoning tokens) × output price — the reasoning tokens are added to the same output bucket, at the same rate, before the price is applied. If a call writes a 300-token answer but spent 2,400 tokens reasoning first, you're billed for 2,700 output tokens, not 300. The ratio of reasoning tokens to visible tokens isn't fixed by the model — it's set by the problem: easy lookups might add nothing, a hard multi-step proof or an agentic planning turn can run 10-15× the visible length or more.

Worked example, in real dollars

10,000 requests/month, each producing a 300-token visible answer. The only thing that changes across rows is how many hidden reasoning tokens that same 300-token answer took to produce — the visible result to the end user is identical in every row.

Two multipliers stack here, and it's easy to only see one of them. The per-token price already spans 27× between o1 and DeepSeek R1 before reasoning enters the picture. Then the reasoning ratio adds its own multiplier on top — on o1 alone, moving from a task that needs no extra thought to one that needs 15× as much thought turns an $180/month line item into $2,880/month, a 16× swing, without a single extra visible word reaching the user. Budgeting off the visible answer length tells you almost nothing about either axis.

Effort levels: the one control you actually have per-call

Most reasoning APIs expose an effort or thinking-budget setting (commonly low / medium / high, or a numeric token cap). It doesn't change the price per token — it changes how many reasoning tokens the model is allowed to spend before answering. Dropping a workload from high to medium effort on prompts that don't need deep multi-step thought routinely cuts the reasoning ratio by half or more with no visible change in answer quality, because the model simply wasn't using most of that budget productively on an easy question in the first place.

The catch is that effort level is a ceiling, not a guarantee — a genuinely hard prompt at "low" effort can still underperform, and the fix there is routing it to a higher tier rather than force-capping every request. Tail cases (the occasional request that reasons far longer than the median) are exactly what blow past a budget built on an average, which is why the token distribution matters more than the mean.

Three levers, besides the effort slider

• Route by difficulty, not by default. Reasoning is worth paying for on genuinely hard tasks and pure waste on easy ones. Classify or route cheap, high-confidence requests to a non-reasoning model and reserve the reasoning tier for the hard tail — size the split with the calculadora de economia de roteamento de modelo.
• Tighten the prompt. A vague, open-ended prompt gives the model more to explore before it commits to an answer, which shows up directly as more reasoning tokens. A clearer, more constrained prompt is a rare case where better prompt engineering is also cheaper prompt engineering.
• Watch the tail, not the average. Reasoning token counts are data-dependent and can vary by an order of magnitude between an easy and a hard call in the same workload. A budget sized on the median case will blow up the moment volume includes enough tail cases — size for the p90 or p99, not p50.

Erros comuns

• Pricing from the visible answer length alone. Two calls that return the same 300-token answer can cost wildly different amounts depending on reasoning effort spent to get there — the response you see tells you almost nothing about what you were billed.
• Assuming the reasoning ratio is a model constant. It's set by the specific prompt and task difficulty, not by the model. The same model can run near-zero reasoning on a lookup and 15× on a proof.
• Forgetting reasoning and agent-loop costs stack. A reasoning model inside an agent loop pays the hidden-thinking tax on every call e o quadratic context-accumulation tax across calls — they come from different places and both apply at once.
• Treating effort level as free quality. Higher effort costs more output tokens even when it doesn't change the final answer — it's a ceiling worth tuning down wherever quality doesn't actually depend on it.

Continuar aprendendo

Perguntas frequentes

What are reasoning tokens and why am I billed for them?

Reasoning models (OpenAI o1/o3/GPT-5, DeepSeek R1, and similar) generate an internal chain of thought before writing the answer you see. That chain of thought is billed as output tokens at the model's full output rate, even though OpenAI redacts it from the response and only DeepSeek R1 shows it to you directly. You pay for tokens that never appear in your terminal or UI.

How much more does reasoning actually cost compared to the visible answer?

It depends on task difficulty, not a fixed rate. A simple classification might add 0-3x the visible answer in thinking tokens; a hard multi-step problem can add 8-15x or more. On o1 ($60/1M output), 10,000 requests/month with a 300-token visible answer costs $180/month with zero reasoning, but $2,880/month at a 15x reasoning ratio — the visible output never changed, only the hidden chain of thought did.

Does every reasoning model bill the same way?

No. OpenAI's o1, o3 and GPT-5 reasoning tiers bill hidden, redacted thinking tokens at the output rate and let you set an effort level (low/medium/high) that roughly trades quality for token count. DeepSeek R1 exposes its chain of thought in visible <think> tags, so those tokens count toward output length you can actually inspect per-call, not just estimate from the bill. Both charge the output rate for them either way.

How do I control reasoning token cost without giving up quality?

Three levers matter most: lower the effort/budget setting for tasks that don't need deep multi-step thought (often halves the bill with no visible quality drop), route easy requests to a cheaper non-reasoning model and reserve reasoning for the genuinely hard tail, and tighten prompts — a more constrained question gives the model less to explore, which means fewer reasoning tokens for the same answer quality.