What Claude Code Actually Costs — and Which Dials Move It

The sentence the pricing pages leave out

You ask one short question in a session you've had open since 9am. It gets billed like you asked it to re-read your entire morning, because that's exactly what happened.

The model remembers nothing between turns. So every request re-sends the entire conversation — the system prompt (the instructions loaded before your first message), your instruction file, every message, every tool result. And every tool call inside a turn is another request.

Which means a one-line question, asked in a session you have had open all day, is billed against the whole day.

That single fact reorganises everything else. Cost scales with the context you are carrying, not the work you are asking for — and every intuition you imported from human labour, where a small question costs a small amount, is wrong here.

The dial nobody mentions: cache hygiene

A warm session is affordable only because almost all of its input arrives as cache reads rather than fresh tokens. A cache read bills at roughly a tenth of a normal input token, per Anthropic's prompt-caching documentation (code.claude.com/docs/en/prompt-caching, re-check date in the rot register below). In a worked example from that same documentation, a session costing well under a dollar moved nearly a million cached tokens against about a thousand fresh ones.

So the expensive actions are the ones that feel free.

The doctrine that follows: pick your model and effort at the top of a session, and treat a mid-task switch as a deliberate, priced decision rather than a shrug.

And watch cache creation. cache_creation_input_tokens is a field in the API's usage telemetry — the count of tokens written fresh into the cache on a given request, as opposed to read cheaply from it. If that number stays high turn after turn, something is churning your prefix. Anthropic's own engineering writing on prompt caching treats that as an incident to investigate, not a mood to tolerate.

The clock is a cost dial

The cache dies of inactivity. Roughly an hour on subscription plans; about five minutes on API keys — and five minutes for subscribers once they are on usage credits, and always for subagents.

So stepping away and coming back to a large session costs a cold re-read of the entire thing.

Nobody writes this down. Every operator discovers it as "why was that first message back so slow, and why did my usage jump?"

Your lunch break has a token price. Knowing that changes when you /clear before walking away.

Where you are sitting is part of the cache key

The cache is effectively scoped to machine and working directory. Git worktrees of the same repository miss each other's cache. Sequential sessions share a prefix only when the startup snapshot matches.

Which has a consequence for the parallelism everyone is excited about: multi-stream work multiplies cold starts, and agent teams multiply whole contexts — per the same costs documentation (code.claude.com/docs/en/costs), about seven times a standard session's tokens when teammates run in plan mode.

Parallelism is bought with tokens, and the purchase is superlinear in how heavy your context is.

Thinking bills as output

Extended thinking is charged at the output rate — the expensive class, several times the input rate — and it is on by default with budgets that can run to tens of thousands of tokens per request. You are charged for it even when it displays collapsed.

So effort is a spend dial wearing a quality costume.

The honest setting: effort down for scoped mechanical work, effort up when the failure mode is under-investigation. And the vendor flags maximum effort as prone to overthinking with diminishing returns — worth reaching for on a specific hard problem, not worth parking there.

A subscription is not unlimited. It is a different meter.

Plan allowances are opaque — a rolling multi-hour window plus weekly windows, sizes unpublished, shared across every Claude surface, enforced with reset timers instead of invoices.

That is why third-party tools exist to guess your limits from your own history. The meter is hidden, so people built instruments to infer it.

The operator consequence is behavioural:

Choosing a regime is choosing which failure mode you would rather manage. And past the allowance, usage credits bill at standard API rates and shorten your cache lifetime — the marginal token gets dearer twice over.

What smart people get wrong

The habit that makes all of this worth knowing

One ledger line per work product. Written when you read /usage, before you clear.

Here's an illustrative one, the shape a real line takes once you've been keeping the habit for a week (the numbers are a representative example, not a specific session's actual receipt):

The line that would actually surprise you, and the reason this habit earns its keep: the same task run again after a /clear and a model switch, cold, comes in at 3,000 fresh input tokens instead of 82,000 cached — a small dollar difference on this one task, but the same pattern compounding across a week of switched-model sessions is where the "why did my usage jump" surprise actually comes from. That is it. And it is the point of the whole exercise.

The minimum worth keeping:

Beyond those four, cost telemetry is a hobby rather than accounting.

Rot register

Verified 2026-08-05. This is the fastest-rotting material in the harness series — it is made of perishable numbers. The mechanics above are durable. Re-check every figure before relying on it.

Any page quoting AI tooling prices without a date is telling you what was true on a day it will not name.