Reasoning Token Costs: What You're Actually Paying For

Reasoning models write an invisible draft before they answer. That draft — the "thinking" or "reasoning" tokens OpenAI's o-series and GPT-5.x line, Google's Gemini Thinking models, and Claude's extended thinking generate before producing a visible response — is billed at the same rate as ordinary output tokens. Most of it never appears in your application. A short, clean answer can be sitting on top of a reasoning-token bill several times its size, and unless you're reading the right field in the API response, you won't see it coming.

LeanLM (not affiliated with Google's LearnLM educational AI) is an LLM cost optimization platform — this post covers how reasoning-token billing works and how to control it, as one piece of the broader enterprise LLM cost optimization picture.

Are Reasoning Tokens Billed?

Yes, on every major provider that offers extended reasoning. The mechanism is consistent even though the parameter names differ:

• OpenAI — reasoning tokens from o-series and GPT-5.x reasoning calls are billed at the standard output-token rate. They're generated before the visible answer and are not returned in full; a request can generate several times more reasoning tokens than the length of the answer it produces.
• Google Gemini — "thinking tokens are billed at the same rate as output tokens." Billing is based on the full raw thought tokens the model generates, even when the API only surfaces a summary (or nothing) of that reasoning to you.
• Anthropic Claude — extended-thinking tokens are billed at the output-token rate. Anthropic is explicit that "the billed output token count will not match the visible token count in the response" — you pay for the full internal reasoning process, not the summary text shown.

The common thread: reasoning tokens are real, metered output. None of the three providers discounts them, and none of them shows you the full trace by default.

Reasoning Tokens vs. Output Tokens vs. Input Tokens

Input tokens are what you send — the prompt, system instructions, and any prior conversation. Output tokens, in the traditional sense, are the visible text the model returns. Reasoning tokens are a distinct sub-category of output: generated by the model as part of the same response, billed at the output rate, but functionally separate from — and usually much larger than — the text you actually see.

This is why reasoning-enabled requests break the usual mental model of "short answer, cheap answer." A one-paragraph response from a reasoning model can carry thousands of billed tokens that never rendered anywhere. Neither caching nor batch discounts apply to reasoning tokens the way they do to repeated input — reasoning is generated fresh on every call, so the only lever that reduces its cost is generating less of it.

How Much Do Reasoning Tokens Actually Cost?

Reasoning tokens bill at plain list output pricing — no cache discount, no batch discount, since they're generated fresh and (for now) can't be processed asynchronously the way batch-eligible output can. Using the verified list output prices from our LLM effective cost table, here's what 10,000 reasoning tokens costs on each tier:

Per-request cost looks trivial in isolation. The problem is volume: a complex request can generate 3–10× the reasoning tokens of its visible answer, and every request on a reasoning-enabled endpoint pays this tax — not just the hard ones, unless you explicitly gate which requests get reasoning mode at all.

Run the same math at scale: 100,000 reasoning-enabled requests a month, each generating a conservative 3,000 reasoning tokens, on gpt-5.5 ($30/MTok output) works out to roughly $9,000/month in reasoning tokens alone — before counting a single visible output token or input token. That's the number that shows up on the invoice with no corresponding line in your product's response logs.

How to Reduce Reasoning-Token Spend

Reasoning tokens don't benefit from caching or batching, so the available levers are different from the rest of the cost stack:

1. Set an explicit reasoning budget instead of the default. Use OpenAI's reasoning_effort (minimal/low/medium/high), Gemini's thinkingBudget, or Claude's budget_tokens explicitly per request type — don't let the model decide how much to think on every call.
2. Route simple subtasks away from reasoning mode entirely. Classification, extraction, formatting, and short factual lookups rarely need extended thinking. Reserve it for the steps that are genuinely hard — this is the same model routing principle applied inside a single model's reasoning setting, not just across models.
3. Cap the budget instead of leaving it dynamic. Gemini's dynamic mode (thinkingBudget: -1) and unconstrained high-effort settings can spend far more than a task needs. Set a hard per-request ceiling sized to actual task complexity.
4. Monitor billed reasoning tokens directly from usage fields — OpenAI's completion_tokens_details.reasoning_tokens, Claude's output_tokens_details.thinking_tokens — rather than assuming the visible response length reflects the real cost. This is the only reliable way to catch a runaway reasoning budget before the invoice does.
5. Tighten prompts and force constrained output formats. A model given a narrow, well-specified task deliberates less than one given an open-ended prompt. This won't eliminate reasoning-token cost on genuinely hard problems, but it trims the tax on everything else.

Provider Specifics

OpenAI

Source: OpenAI reasoning guide. OpenAI's o-series and GPT-5.x reasoning models expose a reasoning_effort parameter (minimal, low, medium, high) that controls how much a request is allowed to think before answering. Reasoning tokens are billed at the model's standard output rate and are not fully returned in the response — you can inspect the count via completion_tokens_details.reasoning_tokens in the usage object. Lower-effort settings and routing simple calls to non-reasoning models are the two most direct levers.

Google Gemini

Source: Gemini thinking docs. Gemini's "Thinking" models use a thinkingBudget parameter, an integer token ceiling the model can spend on internal reasoning. Setting it to 0 disables thinking outright; -1 enables dynamic mode, where the model decides its own reasoning depth per prompt (left unset, it defaults to a self-managed budget up to a per-model cap). Newer Gemini 3 models simplify this into a thinking_level parameter (e.g. low/high) instead of a raw token count. Either way, you're billed for the full raw thought tokens generated, even when the API only returns a summary.

Anthropic Claude

Source: Claude extended thinking docs. Claude's extended thinking is enabled via a thinking object with type: "enabled" and a budget_tokens value (minimum 1,024 tokens), which must be set below max_tokens. Anthropic's own guidance: start at the minimum budget and increase incrementally rather than defaulting to a large ceiling. The billed output count reflects the full reasoning process, not the summarized trace shown in the response — check usage.output_tokens_details.thinking_tokens to see the real number. Anthropic frames the break-even rule directly: use extended thinking when the cost of a wrong answer exceeds roughly 5× the call cost — multi-step reasoning, adversarial debugging, formal logic, and nontrivial code review qualify; routine lookups and formatting generally don't.

A Quick Token-Counting Anchor

If you're translating reasoning-token counts into intuition: roughly 750 words of English text is about 1,000 tokens, so 10,000 reasoning tokens is the rough token-equivalent of a 7,500-word internal monologue you never see — for a task that might return a two-sentence answer. For the base list, cached, and batch prices those tokens are measured against, see the LLM effective cost table; reasoning tokens use the plain list output column there, since neither caching nor batch discounts apply to them.

Frequently Asked Questions

Are reasoning tokens billed?

Yes. Reasoning (or "thinking") tokens are billed at the model's standard output-token rate across OpenAI, Google Gemini, and Anthropic Claude. They're also typically invisible in the response you see — the model may return a short summary or nothing at all of its internal reasoning, but you're charged for the full token count it generated.

What is the difference between reasoning tokens and output tokens?

Output tokens are the visible text in the model's response. Reasoning tokens are the model's internal step-by-step deliberation before it writes that response — generated and billed as part of the same output-token pool, but usually hidden or only partially summarized in what you see. A response with a short visible answer can still carry a large, mostly invisible reasoning-token cost.

How much do reasoning tokens actually cost?

At the output-token rate. On the effective-cost table's list prices, 10,000 reasoning tokens cost roughly $0.09–$0.12 on workhorse-tier models (gemini-3.5-flash, gpt-5.4) and $0.25–$0.30 on flagship-tier models (Claude Opus 4.8, gpt-5.5) — before any caching or batch discount, since reasoning tokens are freshly generated output and don't benefit from either. A single complex request can generate 3–10× the reasoning tokens of its visible answer.

How can I reduce reasoning-token spend?

Set an explicit reasoning-effort or thinking-budget parameter instead of letting the model decide (OpenAI's reasoning_effort, Gemini's thinkingBudget, Claude's budget_tokens). Route subtasks that don't need deep reasoning — classification, extraction, formatting — to a non-reasoning or low-effort model. Cap the budget per request rather than using unconstrained dynamic thinking. And monitor billed reasoning-token counts directly from the API usage fields rather than assuming the visible answer reflects the real cost.

Do all AI models generate reasoning tokens?

No — only models built for extended reasoning: OpenAI's o-series and GPT-5.x line with reasoning_effort set above minimal, Google's Gemini "Thinking" models via thinkingBudget or thinking_level, and Claude models with the thinking parameter enabled and a budget_tokens value. Standard (non-reasoning) calls on the same model families skip this step entirely and bill only ordinary input/output tokens.

Can you turn off reasoning tokens?

It depends on the provider. Claude and OpenAI's reasoning models are opt-in — you only generate (and pay for) reasoning tokens if you explicitly enable Claude's thinking parameter or call a reasoning-capable OpenAI model; OpenAI's reasoning_effort can be set to minimal to reduce volume, but there's no hard off-switch once a reasoning model is selected. Gemini is the one provider with an explicit disable: setting thinkingBudget to 0 turns thinking off entirely.