Does Claude Code's thinking mode actually cost more tokens?

Thinking tokens show up in Claude Code's bill exactly where Anthropic's docs say they will: as output tokens, billed at your model's full output rate whether or not you ever see them rendered. There's no separate "thinking budget" line item and no discount for reasoning Claude decided to do on its own - the effort setting only changes how often and how deeply Claude reaches for it, and on some models a prior turn's thinking sticks around in context and gets billed again, as input, on every turn after that.

How Claude Code decides whether to think at all

On every model that supports it, thinking is adaptive: Claude looks at each request and decides for itself whether reasoning first will improve the answer, and the decision resets on every turn. A one-line factual question can get a direct response with no thinking block at all; a multi-file refactor or a bug that doesn't reproduce on the first read triggers deeper reasoning automatically. Anthropic's own docs are explicit that this isn't optional to disable per turn from your side - "the same conversation can contain turns with and without thinking, and a turn where Claude chose not to think contains no thinking block."

The primary control over how often that happens is effort, not a token budget you set directly. Claude Code exposes it as a session-wide setting, confirmed against v2.1.222's own --help output and its model-configuration docs rather than assumed from an older release:

| Effort level | What it changes | | --- | --- | | max | Claude always thinks, no constraint on depth | | xhigh | Claude always thinks deeply, with extended exploration | | high (Claude Code's default on every model that supports effort, except Opus 4.7, which defaults to xhigh) | Claude almost always thinks; deep reasoning on complex tasks | | medium | Moderate thinking; may skip it on simple queries | | low | Minimizes thinking; skips it on simple tasks where speed matters most |

That "default high" line is worth sitting with: unless you've touched /effort before, every session you run is already reasoning almost every turn, on every model that supports it - not a rare mode you opt into for hard problems.

Where thinking tokens actually land on your bill

Two separate charges follow from a turn where Claude thinks, and Anthropic's pricing docs list both explicitly:

1. The tokens Claude spends thinking, billed as output tokens - at the model's full output rate, the same rate as the answer text itself.
2. Thinking blocks from prior turns that stay in context, billed as input tokens (cache-read, if caching is intact) on every later turn - but only on models that keep them. Per Anthropic's per-model preservation rule, Opus 4.5 and models numbered 4.6 and higher keep every prior turn's thinking blocks in context by default; Sonnet 4.5, Haiku 4.5, and earlier models strip them instead.

That second point is the same mechanic this site's plan-mode guide already covers for a different lever: whatever plan mode reads gets re-billed as cache-read on every turn until you clear it. Kept-all thinking blocks work the same way - the reasoning that produced turn 3's answer can still be sitting in your context, and getting re-billed, at turn 40.

There's a wrinkle Anthropic flags directly and page 1's pricing roundups never mention: the billed count and the visible count are different numbers. Claude Code collapses thinking output by default (Ctrl+O expands it), and on the Anthropic API interactive sessions receive redacted thinking summaries unless showThinkingSummaries: true is set. Anthropic's own warning is blunt about what that means for your bill: "You are billed for the full thinking process, not the thinking content visible in the response." The exact split is readable in the API response as usage.output_tokens_details.thinking_tokens - a real field, not a modeled estimate, but one that only API integrators watching raw usage payloads ever see; /usage in Claude Code shows the combined output total, not the reasoning/text split within it.

What the effort levels change, level by level

effort is set per session, not per request, which is why Anthropic's caching docs warn that changing it mid-conversation invalidates your prompt cache - the resolved effort value gets rendered into the prompt itself, so a changed value is a changed prompt as far as the cache is concerned. Claude Code gives you several ways to set it, each with different persistence:

• /effort in an interactive session opens a slider, or takes a level name directly; /effort auto resets to the model default.
• --effort <level> at launch sets it for that session only.
• CLAUDE_CODE_EFFORT_LEVEL (env var) overrides everything else, including a saved default.
• effortLevel in settings.json sets a persistent default; max and the ultracode workflow setting are session-only and can't be saved this way.
• Skill and subagent frontmatter can set effort for just that skill or subagent's run, without touching the session level.

Two model-specific gotchas worth knowing before you assume a setting stuck: asking for a level a model doesn't support falls back to the highest one it does (xhigh runs as high on Opus 4.6), and the first time you run Fable 5, Opus 4.8, or Opus 4.7, Claude Code applies that model's own default effort and holds it across sessions - even over a level you'd previously set for a different model - until you explicitly change it again. Opus 5 doesn't have that hold; a level you set for it carries over normally.

Separately from the session-wide setting, typing ultrathink anywhere in a single prompt asks for deeper reasoning on that one turn - Claude Code recognizes it as a keyword and adds an in-context instruction, but "the effort level sent to the API is unchanged," so it doesn't touch your cache the way an /effort change does. Other phrases people use out of habit - "think", "think hard", "think more" - are passed through as ordinary prompt text; Claude Code doesn't treat them as keywords at all, even though Anthropic's model-layer docs describe similar phrasing as a legitimate way to nudge thinking frequency at the API level.

The dollar math: what a thinking-heavy turn costs across models

Thinking tokens are billed at the plain output rate, so the fastest way to see what effort actually costs is Anthropic's own current per-model output pricing, fetched directly from platform.claude.com rather than pulled from memory (checked 2026-08-16 - Sonnet 5's introductory rate became the standard rate on 2026-09-01, per the same page):

| Model | Output rate | Cost per 10,000 thinking tokens | Cost per 30,000 thinking tokens | | --- | --- | --- | --- | | Claude Opus 5 | $25 / MTok | $0.25 | $0.75 | | Claude Sonnet 5 | $10 / MTok | $0.10 | $0.30 | | Claude Haiku 4.5 | $5 / MTok | $0.05 | $0.15 |

That's straight arithmetic on official list rates, not a measured session - flagged ESTIMATED-by-construction, and the columns exist to show scale, not to claim your actual sessions land on exactly 10,000 or 30,000 thinking tokens. Claude Code's own cost-management docs only go as far as "the default budget can be tens of thousands of tokens per request depending on the model," without a fixed number - which is honestly the more useful fact, because it means a single hard debugging turn on high effort can plausibly land anywhere in that range, and the difference between the Opus and Haiku columns above is a 5x swing for the exact same reasoning depth.

What this project's own sessions say about output-token cost

Two numbers from UsageCut's own measured session history are directly relevant here, because thinking tokens inherit whatever's true of output tokens generally:

• MEASURED, from 1,037 of this project's own real sessions (20,722 deduped assistant messages): output tokens are only 0.7% of total billed tokens, but account for 15.9% of total dollar cost. Output is billed at the full per-token rate with no cache discount, so a small share of tokens still carries an outsized share of the bill - and thinking tokens sit inside that same 0.7%/15.9% split, not off to the side of it.
• ESTIMATED, from the same measurement pass, and labeled lossy on purpose: shaping output length and thinking budget down (lower effort, terser responses) tracks to roughly 20-40% of output tokens, self-reported. It's real, but it trades reasoning depth for the saving, which is exactly why this project's own build notes say never to make that lever default-aggressive on coding work specifically.

Neither number is thinking-specific by itself - nobody's shipped a public breakdown of thinking tokens as their own bucket yet, which is a real gap page 1 doesn't fill either. But the direction both numbers point is the same: output-side tokens (thinking included) are disproportionately expensive per token, and the lever to spend fewer of them is real but genuinely lossy, not a free cut.

Turning thinking down without losing the reasoning you need

The tools Claude Code gives you here work at different scopes, and mixing them up costs you either cache or reasoning quality:

• One task, deeper reasoning, cache preserved: add ultrathink to that one prompt. It doesn't change the effort value sent to the API, so it doesn't invalidate your cache the way a session-level /effort change would.
• A whole session of routine edits: drop to /effort low or medium before you start, not mid-session - switching later still works, it just eats the one-time cache-miss cost of the switch itself.
• Every session, globally: set effortLevel in settings.json, or CLAUDE_CODE_EFFORT_LEVEL if you want an override nothing else can beat.
• Turn thinking off outright: Option+T (macOS) / Alt+T (Windows/Linux) toggles it for the current session; /config toggles the persistent default (alwaysThinkingEnabled in ~/.claude/settings.json); MAX_THINKING_TOKENS=0 disables it regardless of effort, on every model except Fable 5, which can't turn thinking off at all - the toggle, the settings flag, and the zero budget all have no effect there.
• Legacy fixed-budget models only: Opus 4.6 and Sonnet 4.6 can revert to the old fixed-budget mode with CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1, and only then does a nonzero MAX_THINKING_TOKENS value do anything. Fable 5, Sonnet 5, and Opus 4.7 and later are adaptive-only - that variable's nonzero values don't apply to them at all.

When the extra reasoning is worth the spend, and when it isn't

None of this has a fixed right answer - it depends on what the thinking replaces, the same shape of question plan mode's cost tradeoff resolves to for its own lever:

• Worth it: a bug that doesn't reproduce on the first read, a change that touches several files with a non-obvious interaction between them, anything where a wrong first attempt means re-sent, re-billed turns undoing it. high effort's default posture exists because most agentic coding work looks more like this than not.
• Not worth it: a one-line fix you could name the file and line for before you asked, a rename, a config toggle. Reasoning through something you already know costs real output tokens for a conclusion you'd already have reached.
• The middle case - use ultrathink, not a session-wide change: you're mostly doing routine work but this one turn is harder than the rest. Keep the session at its normal effort and reach for the keyword instead of ratcheting the whole session up and eating a cache miss for it.

When this doesn't apply

This is a token-cost read specifically, not a verdict on whether to think - on a flat-rate Pro or Max plan, where usage draws from a shared seat allowance rather than a per-token bill, the token count itself doesn't touch what you pay directly, even though it still shapes how fast you hit that plan's usage window. Everything here is checked against Claude Code v2.1.222 and Anthropic's current docs as of 2026-08-16; effort defaults, which models get adaptive reasoning by default, and the exact settings names have all changed across versions before, and Anthropic's deprecation notice on manual budget_tokens thinking says plainly that Claude 4.7 and later reject it outright - so anything here scoped to "legacy fixed-budget models" narrows further with every model release.

FAQ

• Is thinking mode a separate, more expensive mode from normal Claude Code usage? No. It runs on the same model, in the same context window, as the rest of your session. What changes is whether that turn includes a reasoning pass before the answer, billed as output tokens like any other output.
• Does lowering effort guarantee lower token usage? No - effort is soft guidance on how much of Claude's output budget goes to thinking, not a hard cap. Anthropic's own docs describe it as shaping behavior, not guaranteeing a token count.
• What's the fastest way to see how many thinking tokens a single API response used? Read usage.output_tokens_details.thinking_tokens in the response - it's always less than or equal to output_tokens and reflects the raw reasoning generated, not the summarized text you're shown. Claude Code's own /usage only reports the combined output total.
• Can I turn thinking off completely? Yes, on every model except Fable 5: Option+T/Alt+T for the current session, /config for the persistent default, or MAX_THINKING_TOKENS=0 to disable it regardless of effort.
• Does the ultrathink keyword cost more than raising effort for the whole session? For that one turn, it asks for similar depth - but because it leaves the effort value sent to the API unchanged, it avoids the cache-invalidation cost that an actual /effort change carries for every turn after it.
• Is there a documented average thinking-token cost per session? Not one Anthropic or Claude Code publishes as its own bucket. The closest official numbers are the per-model output rates and the "tens of thousands of tokens per request" range in Claude Code's cost-management docs - both used in the dollar-math table above, not a specific measured average.

Reading your own sessions' actual thinking-token share isn't something /usage breaks out today, which is exactly the gap the free scan is built to close - it reads your real session history directly rather than asking you to guess from the combined output total. The cost calculator is a quicker way to see what a given token count actually costs across models before you decide an effort change is worth making, and how Claude Code's caching and compaction actually work covers the re-billing mechanic this whole piece leans on for kept-all thinking blocks.

Made by Neo

UsageCut by ClockedCode - not affiliated with Anthropic. The figures on this page are measured on real Claude Code sessions and labeled measured or estimated where it matters.