Do I get charged for reasoning tokens I never see?

Yes. Reasoning or thinking tokens are billed at the model's standard output rate even though most APIs don't return the reasoning content in a form you'd display to a user.

Can I turn off reasoning to save money?

Often, yes, through an effort or reasoning-mode setting, though disabling or minimizing reasoning can reduce accuracy on harder tasks, so it's a real quality tradeoff, not a free cost cut.

Why does the same prompt sometimes cost more on a reasoning model than a non-reasoning one?

Because the reasoning model may generate thousands of hidden tokens working through the problem before answering, all billed as output, while a non-reasoning model goes straight to a final response with no hidden token cost.

How do I estimate reasoning token cost before running a request?

You generally can't estimate it precisely in advance, since the volume depends on what the model decides the problem needs. The reliable approach is measuring actual usage from real requests and budgeting from that data rather than a prediction.

What Are Reasoning Tokens, and Why Do They Bill as Output?

If a reasoning-capable model's bill looks higher than the visible response justifies, this is usually why — and it's the single most common source of "why is my bill higher than I calculated" support questions.

Models like Claude's extended thinking, OpenAI's reasoning models, Gemini's thinking mode, and DeepSeek's thinking mode generate an internal chain of reasoning before producing the final answer you see. That internal reasoning is billed as output tokens, at the model's output rate, even though it never appears in your response.

01What's Actually Happening

When you send a prompt to a reasoning-capable model, the model doesn't jump straight to a final answer. It generates intermediate reasoning steps first, working through the problem before committing to a response. Providers frame this differently (extended thinking, reasoning tokens, thinking mode) but the billing mechanic is consistent across the major labs: the reasoning content counts as output tokens, and you're charged the model's output rate for every one of them.

Two things make this easy to miss:

You usually don't see the reasoning content. Most APIs either omit it from the response or return it in a separate field you're not rendering, so the token count feels disconnected from what you can visually verify.
It scales with problem difficulty, not prompt length. A short prompt asking a hard question can generate far more reasoning tokens than a long prompt asking a simple one, which breaks the mental shortcut of "longer input means higher cost."

02Why It's Billed as Output at All

Reasoning tokens are output from the model's perspective: the model generated them, token by token, the same way it generates the visible answer. The compute cost is identical whether a token ends up in the reasoning trace or the final response, so providers bill it at the same output rate rather than creating a separate, usually cheaper, tier for it. There's no discount for reasoning you don't get to read.

Estimate your real reasoning-token overhead

Model the hidden cost on top of your visible output

Open the calculator →

03What Controls the Reasoning Token Volume

Most providers expose some form of effort or thinking-budget control that trades reasoning depth for cost:

Effort or reasoning-effort settings (low, medium, high, or similar) that cap how much internal reasoning the model does before answering
Explicit thinking budgets on some platforms, where you set a token ceiling for the reasoning phase directly
Task-dependent defaults, where the model decides how much reasoning a given prompt needs, which is convenient but harder to predict cost-wise without testing

Lowering the effort setting is usually the single biggest lever for controlling reasoning-token cost on a given task, often more impactful than switching to a smaller model tier, since a lower-effort setting on a strong model can cost less than full-effort reasoning on the same model while a smaller model without reasoning may not solve the task at all.

04Where to Actually Find the Number

Most providers report reasoning-token counts separately in their API's usage metadata, even though the reasoning content itself usually isn't returned. Field names vary by provider and API version, so check your specific provider's current docs, but two consistently-named examples worth knowing: OpenAI returns it under output_tokens_details.reasoning_tokens in the response usage object, and Google's Gemini API returns thoughts_token_count alongside the standard token counts. Anthropic and DeepSeek both surface reasoning content in a separate field as well — exact naming depends on which SDK or gateway you're using, so treat the usage object on your specific request as the source of truth over any generic name printed in a guide like this one.

Key takeaway
Pull the real number from your own usage metadata before you trust any estimate, including the illustrative 500/3,000/400 example above. That ratio isn't fixed — it swings hard by task, from almost no overhead on a quick factual lookup to thousands of reasoning tokens on a multi-step planning task with a short final answer.

05What to Do About It

Pull actual token usage from a sample of your real production requests rather than estimating from prompt and response length. That real reasoning-token count, once you have it from a handful of representative requests, is what you should plug into a cost model — not a guess based on the visible answer alone.

Model your actual monthly cost with real numbers

Use the Reasoning Token Overhead estimator once you have real usage data

Run the numbers →

This piece describes reasoning-token billing mechanics that are broadly consistent across OpenAI, Anthropic, Google, and DeepSeek as of August 14, 2026, and is intentionally illustrative rather than tied to any one provider's current dollar rates — those change often enough that this article deliberately doesn't quote them. The worked example (500/3,000/400 tokens) is illustrative, not a typical or guaranteed ratio for any specific model or task. See the live calculator's Reasoning Token Overhead estimator to model your own costs, and verify field names and effort-setting terminology against your specific provider's current documentation before building automation around them.