What Claude Code actually costs: measured, not listed

The short answer, in numbers

There are two answers because there are two billing systems, and confusing them is why every thread about this contradicts itself.

Set that against the plans and the arithmetic decides itself. $150 to $250 a month of metered spend is one to two and a half times the price of Max 5x. If your usage looks like the average developer in that dataset and your work is interactive, the subscription wins and it is not close.

The two cost models, and why answers differ so much

• Subscription. You pay $20, $100, or $200 a month and run until you hit a usage window. Marginal cost per session is zero. Your risk is interruption, not a bill.
• API. You pay per token with no windows and no ceiling. Marginal cost per session is real. Your risk is a bill, not interruption.

Someone says a session cost them eleven dollars. Someone else says their whole month was twenty. Both are telling the truth and they are on different systems.

The third case: usage credits

Since usage credits shipped, the wall at the end of a subscription is optional. On Pro and Max you can turn on credits and keep working past your included limit; that overage is billed at standard API rates, with a monthly spending cap, optional auto-reload, and a $2,000 daily redemption limit (as of August 2026). Run /usage-credits in Claude Code to manage them. This makes a hybrid the common shape now: a flat subscription for the bulk of the work, metered spend for the tail.

Measured cost by task type

The figures below are API-rate equivalents for common task shapes at Sonnet 5 standard rates ($3 input, $15 output per million). They are what you would pay on a key, or the notional value of what you consumed on a subscription.

Why the range is so wide

Three variables, in order of how much they move the number:

1. Model. Opus 5 output is $25 per million against Sonnet 5 at $15 and Haiku 4.5 at $5. Same task, three prices, and for a large class of work the cheaper models finish it correctly. Anthropic's own guidance is to reserve Opus for complex architectural decisions and multi-step reasoning.
2. Context re-sent per turn. An agent loop sends the accumulated conversation again on every turn, and every tool result triggers another request carrying that whole batch. A 30-turn session does not send context once, it sends a growing prefix thirty times. This is the term people forget, and it is why cost grows roughly with the square of turn count.
3. Turn count, which is driven by how well specified the task was. A vague prompt that sends the agent exploring costs multiples of a precise one that names the files.

The arithmetic that decides your plan

Take your realistic weekly pattern, price it at API rates, and compare against the flat fee. The crossover points are unambiguous.

The pattern is that subscriptions win decisively for anyone who codes with an agent most days, and the API wins for everyone whose usage is spiky, low, or programmatic. The middle is thin.

Where the money actually goes

When people finally look at a breakdown, the same four surprises come up.

Reading costs more than writing

Output tokens are priced five times higher than input, so intuition says output dominates. It does not. A coding agent reads far more than it writes: file contents, command output, test logs, search results. A typical session is 90 to 97 percent input tokens. Even at a fifth of the price, that wins.

The consequence is that anything reducing what the agent reads is worth more than anything reducing what it writes. A precise prompt naming three files beats a vague one that greps the repo.

A few sessions dominate the month

Spend is not evenly distributed. In most months a small number of long, exploratory, Opus-driven sessions account for the majority of the total. To cut a bill, find those sessions rather than trimming everything uniformly.

Cache misses are a real line item

Anthropic documents the mechanism directly: your first message after a break longer than the cache lifetime misses the cache and reprocesses your full context at full input price. The lifetime is an hour on a subscription and five minutes by default on an API key or a cloud provider. Leaving a large session open over lunch and then asking one more question is a genuinely expensive habit on a key.

Tool output is a cost you control

Every command the agent runs returns output that becomes input tokens on the next turn. An agent that runs a full test suite and reads 4,000 lines of output has paid for 4,000 lines of output. Scoping test runs to the relevant file is a direct, measurable saving, and a PreToolUse hook that filters test output to failures only turns tens of thousands of tokens into hundreds.

Seeing your own number

Do not budget off this page. Measure a week of your own work, then decide.

Total cost:            $0.55
Total duration (API):  6m 20s
Total duration (wall): 6h 33m 10s
Total code changes:    0 lines added, 0 lines removed
Usage by model:
   claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)

echo "$ANTHROPIC_API_KEY"   # empty means subscription billing
unset ANTHROPIC_API_KEY    # for shells where you want the subscription

Cutting the number without cutting the work

1. Default to Sonnet, escalate deliberately. The single biggest lever. Use /model to switch mid-session when a task turns out to be hard, and model: haiku for simple subagents.
2. Name the files. Every turn the agent spends locating something is a turn you pay for. "Fix the retry logic in client/http.ts" is measurably cheaper than "fix the retry bug".
3. Run /clear between unrelated tasks. Context carries forward. Asking a new question in a session with 200k tokens of unrelated history pays for that history on every subsequent turn, and makes the answer worse.
4. Scope what commands return. Run the one test file, not the suite. A PreToolUse hook that greps test output for failures cuts a 10,000-line log to a handful of lines before the model ever sees it.
5. Move instructions out of CLAUDE.md into skills. CLAUDE.md loads at session start and is present even for unrelated work; skills load on demand. Anthropic's guidance is to keep CLAUDE.md under 200 lines.
6. Turn extended thinking down for simple work. Thinking tokens bill as output. Lower the effort level with /effort, or set MAX_THINKING_TOKENS on models with a fixed budget.
7. Delegate verbose reads to subagents. The log stays in the subagent context; only the summary comes back into yours.
8. Use plan mode for anything large. Agreeing the approach before edits prevents the expensive failure: a long confident run in the wrong direction that you then pay to undo.

Applied together these routinely halve a bill without changing what gets built. The first three are worth more than the rest combined.

Questions people ask

Keep reading