The invoice arrives and the per-task cost is four times what the math on the pricing page predicted. Nothing broke. The model did exactly what it was asked. You are simply paying premium output rates for text you will never read.
Reasoning model thinking tokens bill at the output rate and never appear in the response you get back. They are output tokens with the receipt torn off. That one fact reshapes the math: the sticker price per token can look cheap while the per-task bill runs high, because most of what you fund is hidden reasoning you cannot edit or reuse. This post explains where those tokens come from, why they bypass your cache discount, why you re-pay for them on every turn, and how to cap the spend without giving up reasoning quality.
The verdict: reasoning models bill invisible thinking tokens at output rates
OpenAI's reasoning guide is direct about it. While reasoning tokens are not visible via the API, they still occupy space in the model's context window and are billed as output tokens. You get a count back, never the content. The usage object reports the number under output_tokens_details.reasoning_tokens, so you can measure the spend after the fact, but you cannot inspect the text that generated it.
Output tokens are the expensive side of every model's price card, usually several times the input rate. When the bulk of a request is reasoning, you pay the premium rate for tokens you will never see.
What are reasoning tokens (and why you are billed for them)
Reasoning tokens, also called thinking tokens, are the model's private scratchpad. Before a reasoning model commits to a final answer, it generates an internal chain of intermediate steps: it breaks the problem down, tries approaches, checks itself, and discards dead ends. That work is real computation, and the model charges for it.
The provider keeps the raw chain hidden by design and returns only the polished answer plus a token count. The reason for hiding it is partly product and partly safety, but the billing consequence is the same either way: you fund a large block of generation that gets stripped out before delivery.
This is why reasoning models win on hard tasks. The internal deliberation is the feature. Multi-step math, tricky debugging, and planning all improve when the model thinks longer. The catch is that thinking longer is exactly what runs up the bill, and an easy question does not need any of it.
Reasoning tokens are output tokens with the receipt torn off. You pay the output rate, you see a count, you never see the text.
Why reasoning tokens cost more: billed at output, hidden, and not cached
Reasoning tokens cost more for three reasons: they bill at the output rate, you cannot see or trim them, and prompt caching does not discount them.
They bill as output tokens
Reasoning tokens count as output, the most expensive token class on any price card. A model whose output rate looks modest can still run costly per task once the hidden reasoning is added in.
They are hidden from the response
You cannot trim, compress, or summarize tokens you never receive. With a normal completion you can shorten a verbose answer and cut output cost. With reasoning tokens that lever does not exist. The only control you get is how much thinking you permit up front.
They miss the prompt-cache discount
Prompt caching cuts cost only on repeated input tokens, never on generated ones. Anthropic is explicit: prompt caching has no effect on output token generation, and the response you receive is identical to what you would get without caching. Its cache-read rate of 0.1 times the base input price covers input only. OpenAI discounts cached input the same way, and reasoning tokens, being output, sit outside that discount entirely.
So even a heavily cached prompt does nothing for the reasoning burst. Cache the system prompt and the shared context all you want; every reasoning token in every call bills fresh at the full output rate. Caching shrinks the cheap part of the bill and leaves the expensive part untouched.
Here is what the pricing pages do not show you: you re-pay every turn
A normal output token, once generated, is yours. You can store the answer and feed it back as cheap input on the next turn, and with caching it gets cheaper still. Reasoning tokens do not work that way, and this is the part the rate cards never spell out.
OpenAI's own cookbook states that in a multistep conversation the reasoning tokens are discarded after each turn, while input and output tokens from each step are fed into the next. In turn two, any reasoning items from turn one are ignored and removed, because the model does not reuse reasoning items from previous turns. The deliberation you paid for on turn one is gone. If turn two needs to reason again, the model generates a fresh burst and bills it again at the output rate.
This compounds in agent loops. A ten-turn tool-using agent does not pay for reasoning once; it pays for ten independent reasoning bursts, none of which carries forward as a discount on the next. The Responses API does let you pass prior reasoning items back into a call (via previous_response_id) so the model can see its earlier work, which OpenAI reports lifting tool-use scores by roughly 3 percent on SWE-bench. That preserves quality across tool calls, but it does not refund the tokens. You still buy the reasoning fresh each time it runs.
Worked example: visible output vs total billed tokens
Numbers make the gap concrete. The table below uses round, illustrative figures, not live prices, to show how reasoning effort changes the bill on one task that returns the same 500-token answer. The only variable is how much the model thinks before it answers.
| Per task (same 500-token answer) | Low effort | Medium effort | High effort |
|---|---|---|---|
| Visible output tokens (what you read) | 500 | 500 | 500 |
| Hidden reasoning tokens (billed, unseen) | 1,000 | 4,000 | 12,000 |
| Total output-rated tokens billed | 1,500 | 4,500 | 12,500 |
| Hidden share of the output bill | 67% | 89% | 96% |
| Cost vs the visible answer alone | 3x | 9x | 25x |
At high effort, you can pay 25x for the answer, and 24 of those parts are invisible.
Read the last row. At high effort, the task can cost roughly twenty-five times the price of the answer you receive, because reasoning dwarfs the visible output. The exact multiple depends on the model and the problem, and OpenAI notes the models reason adaptively, using fewer tokens for simpler tasks and thinking harder for complex ones. The shape holds: the more you ask it to think, the larger the invisible part of the bill. Now multiply that single-task figure across every turn of an agent loop, since none of it carries over, and the per-run total climbs fast.
Pull reasoning_tokens vs output_tokens on yesterday's traffic. If the ratio is north of 3:1, you are paying a reasoning model to overthink tasks that may not need it.
Can a cheaper reasoning model cost more per task? Yes
A reasoning model with a lower output rate can bill more per task than a pricier non-reasoning model. Per-token price is only one factor. Tokens per task is the other, and reasoning models can spend many multiples of their visible output on hidden thinking.
Picture two models on a simple classification call. Model A is a direct, non-reasoning model at a higher output rate that answers in 200 tokens with no hidden reasoning. Model B is a cheaper-per-token reasoning model that emits 4,000 hidden reasoning tokens before its 200-token answer. Model B's lower rate cannot offset twenty times the billed tokens. The cheaper sticker loses the per-task comparison outright.
Cost per token is a vanity metric. Cost per finished task is the bill.
The failure mode is routing every request to a reasoning model because the rate card looks attractive. On hard, multi-step work the spend earns its keep. On extraction, formatting, short classification, and routine lookups, the reasoning burst is pure waste billed at the output rate.
How to reduce reasoning token costs
You control reasoning cost with three levers: size the reasoning effort, route by task difficulty, and cache the stable input. Used together they cut the bill without dropping quality where it counts.
Size the reasoning effort
OpenAI exposes a reasoning.effort parameter whose supported values are model-dependent and can include none, low, medium, high, and xhigh. Lower efforts prioritize speed and cost; higher efforts enable deeper analysis. Set it per task type instead of defaulting to the maximum. Most production calls do not need the deepest setting, and dropping a tier can cut hidden tokens sharply.
Route by task difficulty
Send simple, deterministic tasks to a non-reasoning model and reserve reasoning models for genuinely hard, multi-step work. A cheap classifier or a small non-reasoning model can triage incoming requests and escalate only the ones that warrant deliberation. This is the single biggest saver, because it removes the reasoning burst entirely for the easy majority. In an agent loop, where every turn would otherwise reason from scratch, cutting reasoning out of the routine turns saves you repeatedly rather than once.
Cache the stable input
Caching does not touch reasoning tokens, but it still cuts the input side of every call. Anthropic prices cache reads at 0.1 times the base input rate, and OpenAI discounts cached input as well, so a large reusable system prompt or shared context gets much cheaper on repeat calls. Put your stable, repeated content at the front of the prompt so the cache prefix stays intact.
The max-output trap: you can pay for thinking and get no answer
Capping max output too low is its own failure. If the limit sits below what the task needs, OpenAI's guide warns this might occur before any visible output tokens are produced, the response comes back incomplete with reason max_output_tokens, and you still incur costs for the reasoning tokens already generated. You pay for the thinking and receive nothing to show for it. Size the output budget to cover the reasoning the task will actually use, and reserve generous headroom for it.
- Default to a lower reasoning effort and raise it only where quality measurably improves.
- Route easy tasks to a non-reasoning model; escalate only the hard ones.
- Cache long, stable prompt prefixes to cut input cost, while accepting it does nothing for reasoning tokens.
- Remember reasoning does not carry across turns, so trim the turn count in agent loops to avoid re-paying for it.
- Monitor reasoning_tokens in the usage object so over-thinking shows up in your dashboards, not just your invoice.
- Reserve enough max output so a long reasoning burst does not stop mid-stream and bill you for an incomplete response.
Where MemX fits: stop re-sending context every call
Two invisible bills hit you at once: hidden thinking on the output side, and re-sent context on the input side. Many agents paste the full history, prior facts, and user preferences into every call, and that input grows with the conversation. Caching softens the repeat cost but still leaves you shipping a large prompt each turn, and a bigger prompt can nudge the model to reason longer too.
MemX (memx.app) is an external memory layer that stores durable facts about a user or task outside the prompt and returns only the relevant slice when a call needs it. Instead of re-sending the entire history every turn, you fetch the handful of facts that matter. Fewer input tokens per call, a tighter prompt, and less raw material for the model to chew on.
To be precise about scope: MemX trims the input tokens you re-send. It does not discount reasoning tokens, since nothing can, and it does not carry reasoning across turns either, because the model discards that itself. Pair persistent memory with right-sized reasoning effort and difficulty-based routing. Memory keeps the prompt lean, effort and routing keep the hidden thinking in check, and together they attack both halves of the bill.
01Do reasoning model thinking tokens cost more?
Yes. Reasoning tokens bill at the output rate, the most expensive token class, and they do not appear in the response. A task can bill several times its visible answer, so per-task cost runs higher than the per-token price implies.
02Are reasoning tokens billed as input or output?
As output. OpenAI's reasoning guide states reasoning tokens are billed as output tokens even though they are not returned in the response. You see only a count in output_tokens_details.reasoning_tokens, never the text itself.
03Does prompt caching reduce reasoning token cost?
No. Caching applies only to input tokens. Anthropic states caching has no effect on output token generation, and reasoning tokens are output. You can cache a repeated prompt prefix, but every reasoning burst bills fresh at the full output rate.
04Are reasoning tokens reused across conversation turns?
No. OpenAI's cookbook says reasoning tokens are discarded after each turn and the model does not reuse reasoning items from previous turns. In an agent loop the model reasons fresh every turn, so you re-pay for the thinking each time it runs.
05How do I lower reasoning token costs?
Size the reasoning effort down to what each task needs, route simple tasks to a non-reasoning model, cut turn count in agent loops, and cache stable input. Monitor the reasoning_tokens field so over-thinking shows up before it hits your invoice.
