There’s a number on the pricing page, and then there’s what you actually pay.
The token price is straightforward: $4 per million input tokens, $20 per million output tokens, $0.20 per million cache reads on Claude Opus 5.5. Easy enough to read, harder to apply to a real session. Because you don’t buy tokens. You run tasks. And the task that takes 25 turns costs less than the task that takes 40, even if they end up in the same place, because every turn resends everything that came before it.
That’s the gap most developers hit when they first look at their bill. Same model. Same problem. Wildly different costs. This post, based on Anthropic’s official breakdown written by Addy Osmani, explains what drives that gap and which levers actually move it.
A Claude Code session is a loop. The model reads the conversation, calls a tool, reads the result, and goes around again until the task is done. Each trip around that loop is one request. And every request resends the entire conversation so far, not just what’s new.
That’s the thing people don’t immediately clock. You’re not paying per new token. You’re paying per total token on every turn. A conversation that grows from 20K tokens to 120K over 40 turns isn’t billing you for 120K tokens. It’s billing you for the cumulative total of what was sent on each of those 40 turns, which works out to around 2.8 million input tokens even though the conversation never exceeded 120K.
Four things decide what that loop costs:
Turns. The single biggest lever. Fewer turns means fewer resends. A task in 25 turns processes roughly 1.75 million tokens. The same task in 40 turns processes around 2.8 million. Same work, 60% more input tokens, just from taking more trips around the loop.
Cache reads. This is where the Opus 5.5 price change matters most. On Opus 5, cache reads cost a tenth of the input price. On Opus 5.5, they cost a twentieth, dropping from $0.50 to $0.20 per million. Most of what a turn resends is content the model already saw on the previous turn, billed at the cache rate. At 90% cache hit rate on that 2.8M token session, input costs around $1.62. At 0% cache, the same tokens cost $11.20. Per Anthropic’s breakdown: “No other setting moves input cost this much.”
Output tokens. The most expensive per token, at five times the input price. They’re also where thinking shows up on the bill. Thinking is billed as output, even when Claude Code shows you only a summary of the reasoning. So effort level (which largely controls how much the model thinks) moves the bill significantly.
Model choice. The price of every token in every turn. And it cascades: subagents that inherit the main model’s setting inherit its price too.
The examples Anthropic uses are illustrative: $4 per million input, $20 per million output, $0.20 per million cache reads at list prices. Cache writes are separate, covered below.
Two things shifted: the price, and the work the model does per task.
The price. Every line dropped. Input and output tokens are 20% cheaper than Opus 5. Cache reads are 60% cheaper. That’s the number that hits hardest for Claude Code users, because agentic coding sessions are predominantly cache reads. In Anthropic’s example session, the cache line on the receipt falls from $1.00 to $0.40 when you move from Opus 5 to Opus 5.5, the largest drop on the whole bill.
On Pro, Max, and Team plans, the lower Opus 5.5 prices mean your usage limits go about 25% further than on Opus 5. The extra cut on cache reads is an API price change specifically.
How much you save depends on what your work looks like. A session that is mostly cache reads can save up to 60% on input. A short, cache-cold question with a long answer saves closer to 20%, because output dominates it. Most Claude Code tasks sit between those two poles.
The work per task. Opus 5.5 completes tasks in fewer turns and with fewer retries than Opus 5 on well-scoped work. On open-ended tasks where a model can spend many turns on the wrong approach, the gap should be largest. On tasks with a clear scope and a clear check (a test suite, a build that has to pass), both models tend to finish in about the same turns, and the savings is purely the price drop.
Opus 5.5 always thinks before it replies. You pay for that thinking as output. Anthropic notes that people generally get more done per session, but the per-task token count varies by task. Measure it on your own work.
One behavior worth knowing: Opus 5.5 closes long runs with a report of what it changed, what it found, and what it needs from you. That can save money on its own, because you rerun a session less often when you can see what happened.
Effort controls the model’s general disposition for how many tokens it spends per turn: thinking depth, text length, tool call breadth. Four levels on Opus 5.5 (low, medium, high, xhigh) plus max for a single session.
Medium is the right default for well-scoped daily work. Feature work across a few files, debugging with some context, code review with follow-up edits. Start here.
High is the move when medium keeps producing fixes that address one layer but miss another. The classic pattern: a field renamed in an API handler, tests pass, the client still sends the old field name. Medium read the handler. High would have gone wider before writing. But before you raise to high, check whether the model has a way to verify its own work. A test that runs through the client catches the missing layer in one turn at medium effort, without paying for higher thinking on every turn.
The rough cost math, using Anthropic’s illustrative example: high effort might add roughly 20,000 thinking tokens across a task. On Opus 5.5, that’s about $0.40. A retry loop of 10 turns at 100K of cached context with 10K output tokens costs about the same. The actual token count varies by task, but the principle holds: high effort pays for itself when it prevents one retry of comparable cost. On a task medium would have finished cleanly, it’s wasted.
Low is for mechanical work: renames, applying a known pattern across files, formatting changes. Don’t use it for anything requiring judgment.
Changing effort or thinking settings mid-session clears the cached conversation, because those settings are part of what the cache matches. The next request pays the cache write price on the whole conversation. Change effort settings at a natural break, not mid-task.
/effort status shows your current level. /effort high sets it. The change applies to the next request.
Model choice has the biggest cost impact of any single decision. It sets the price of every token in a session and cascades to every subagent.
Opus 5.5 as the daily driver. Feature work across a few files, debugging, code review with follow-up edits. Work you’re supervising and can redirect when it drifts. Lower latency than Fable 5.1, lower cost, appropriate for the wide middle of a developer’s day.
Move up to Fable 5.1 when:
A practical rule of thumb based on that guidance: when Opus 5.5 on high fails at the same point twice, it’s usually worth switching to Fable 5.1 rather than retrying. Switch back once the hard part is solved.
Fable 5.1 is priced at $10 per million input tokens and $50 per million output, roughly 2.5x the Opus 5.5 rates. Its cache reads cost $0.25 per million, only 1.25x the Opus 5.5 rate, because they bill at 0.025x its input price. The gap between the two models is smallest on long, cache-heavy runs and largest on tasks that write a lot of output.
Switch at a natural break. The cache belongs to the previous model, so the first turn on the new model pays the write price on the whole conversation. Run /compact first, or start fresh with a short written plan, to make that turn smaller. /model with an alias or model name switches models and optionally saves the choice as the default for new sessions.
Move down to Sonnet or Haiku for:
Keep code edits on Opus 5.5, even for mechanical work across many files. Use low effort there instead. The tradeoff on smaller models for search: if Haiku misreads a search result, the main model follows it to the wrong file and pays for the detour. Keep smaller models on work where a mistake is cheap to spot.
To assign a specific model to a subagent: set model: haiku or model: sonnet in its definition. To set a default for all subagents: set the CLAUDE_CODE_SUBAGENT_MODEL environment variable. A subagent with no model setting runs on your main model unless the variable overrides it.
Each subagent runs in its own context window and hands back a summary, so its file reads stay out of your main conversation. It still pays for its own tokens.
Claude Code handles caching automatically. Your session habits determine how much it saves.
The cache stores a prefix: the parts of a request that repeat from turn to turn, specifically the system prompt, tool definitions, and conversation history. On Opus 5.5:
On a Pro, Max, or Team plan, the cache lifetime is one hour. On an API key or cloud provider, it’s five minutes by default. That gap matters in practice: on an API key, a six-minute break turns what would be a $0.02 cache read into a $0.60 cache write for a 120K-token conversation. A one-hour write at that size costs about $0.96 upfront, but covers the gaps in your workday.
The cache stores a prefix, so anything that changes earlier parts of the request resets it from that point on.
Expect a cache write (not a read) when:
Set these up at the start of the session. Leave them alone while it runs.
Every turn resends the full context, so a turn costs more as the conversation grows, even with a high cache hit rate. At 20K tokens of context, a turn’s cache read costs about $0.004 on Opus 5.5. At 150K tokens, the same turn costs about $0.03. Thirty turns at 150K spend $0.90 on reads alone. Thirty turns at 20K cost about $0.12 total.
Much of that growing context is residue from earlier in the session: a stack trace from an hour ago, a file you’ve finished with, a test run you’ve since fixed. It’s all still sent on every turn.
/compact and /clearWhen a session nears its context limit, Claude Code automatically summarizes older history so later turns send less. /autocompact with a token count changes the threshold for when this triggers.
Two manual controls:
/clear empties the conversation entirely, costs nothing, and is the right move when you’re switching to unrelated work.
/compact keeps continuity at the cost of one request. It reads the conversation it summarizes. You can specify what to keep: /compact keep the failing test names and the schema change. At 150K tokens of context, a compaction costs roughly $0.25, covering the read, a summary of a few thousand output tokens, and a new cache write on the shorter context. Each subsequent turn saves about $0.025 in reads. The compaction pays for itself within roughly ten turns.
Compact at a natural break. A compaction mid-debugging session can drop the one specific log line that mattered. And a compaction just before you’re done costs more than it saves.
Your CLAUDE.md file loads into context at the start of every session. Every line in it is part of what every turn resends. Anthropic’s costs documentation suggests keeping it under 200 lines.
MCP tool definitions are deferred: only tool names and server instructions load at the start; full definitions load when a specific tool is called. /mcp shows which servers are connected. Disconnect the ones you aren’t using.
When migrating from Opus 4.8 or Opus 5 to Opus 5.5, instructions written for older models can make Opus 5.5 write more and repeat tool calls, consuming more tokens than the model actually needs.
Run /claude-api prompt-audit in Claude Code to check your CLAUDE.md file, skills, and the code of any Claude Platform app for these anti-patterns.
In Anthropic’s internal test on a 44-ticket customer support benchmark, the move to Opus 5.5 at low effort cut costs about 18% versus Opus 4.8. Running prompt-audit cut a further 9%, reaching about 25% below the Opus 4.8 starting point. The audit flagged and removed a mandatory six-step procedure, a scratchpad rule, a verify-twice rule, and instructions that contradicted each other. All of them were making the model write more and repeat tool calls.
That result is from one benchmark. Treat it as an example, not a universal number. Run the audit, then compare /usage before and after on a real task.
The numbers in this post are illustrations. Your codebase, prompts, and habits are different. Here’s how to get your actual numbers.
Run /usage at the end of any task. /cost does the same thing. The Session block shows token use and an estimated dollar cost at list price. A prompt-cache line shows what fraction of input came from cache. On subscription plans, the same screen shows your usage bars. The dollar figure is computed locally at list price, so on a subscription it’s a guide to how much work you did, not your actual bill.
Run the same task on both models. Pick something real from your backlog, not a toy. Use /model to switch between Opus 5 and Opus 5.5. Note turns, output tokens, and cost for each. Do three or four tasks before drawing a conclusion.
For teams, use the Analytics and Cost APIs. The Claude Code Analytics API gives estimated cost per user. The Usage and Cost API breaks spend down by model and by cached versus uncached tokens.
Try the effort ladder. Run one hard task at medium, then at high. Run one mechanical task at low. Compare /usage after each.
/usage outputCache share. For a long session it should be high. If it’s low, look for a long pause, a mid-session change of effort or model, or an MCP server connected partway through.
Output against input. A lot of output on a small change usually means effort is too high for the task, or the model is retrying rather than finishing.
Total input against conversation size. If total input is many times the conversation size, the session had many turns, and the transcript is worth reading to find where the loop repeated.
For a baseline: Anthropic’s Claude Code cost docs report an average across enterprise deployments of about $13 per developer per active day, with 90% of users under $30 per active day. A session that sits well above your normal is worth reviewing.
All figures per Anthropic’s official pricing, included here for reference:
| Token type | Opus 5.5 | Opus 5 |
|---|---|---|
| Input tokens | $4.00/M | $5.00/M |
| Output tokens | $20.00/M | $25.00/M |
| Cache reads | $0.20/M | $0.50/M |
| Cache writes (5 min) | ~$5.00/M | ~$6.25/M |
Fast mode (Claude Code and Claude Platform): $8 per million input tokens, $40 per million output tokens. Up to 2.5x speed.
| Decision | What it changes | When to use it |
|---|---|---|
| Effort: low | Fewer tool calls, less thinking | Mechanical work: renames, pattern application |
| Effort: medium | Default | Well-scoped feature work, debugging, code review |
| Effort: high | More reading before writing, less retry | When medium fails at the same layer twice |
/compact | Shorter context for future turns | At a natural break during a long session |
/clear | Empty conversation | Between unrelated tasks |
| Subagent on Haiku/Sonnet | Cheaper search and lookup | Log reading, file finding, test output parsing |
| Switch to Fable 5.1 | Higher capability ceiling | When high effort hits the same problem twice |
| Prompt audit | Removes token-wasting anti-patterns | When migrating from Opus 4.8 or Opus 5 |
Because every turn resends the full conversation, and the number of turns varies. A task that completes in 25 turns processes far fewer total tokens than the same task taking 40 turns, even if the conversation ends up the same size. Retries, false starts, and extra tool calls all add turns.
Cache reads. The difference between a 0% and 90% cache hit rate on a 2.8M token session is roughly $1.62 versus $11.20 in input costs. Keep sessions moving to maintain a warm cache, and avoid mid-session changes to effort settings, model, or MCP servers, which reset the cache.
Claude Code handles caching automatically. Cached input costs $0.20 per million tokens (5% of the $4 input rate). Cache writes cost approximately $5 per million for a five-minute lifetime or $8 per million for one hour, per Anthropic’s current pricing. Each cache hit resets the lifetime at no charge. On subscription plans, the cache lifetime is one hour; on API keys and cloud providers, it’s five minutes by default.
Fast mode in Claude Code and the Claude Platform offers up to 2.5x output speed at $8 per million input tokens and $40 per million output tokens. Use it when latency matters more than cost per token, for example interactive debugging sessions where you’re waiting on each turn. For unattended overnight runs, standard mode is more economical.
Effort primarily controls how much the model thinks per turn. Thinking is billed as output tokens at the $20/M rate. Adding roughly 20,000 thinking tokens across a task at high effort costs about $0.40. That pays for itself if it prevents even one retry loop of similar cost. On tasks medium effort would have finished cleanly, the thinking spend is wasted.
Run /usage or /cost at the end of any session. The Session block shows token use and estimated cost at list prices. On subscription plans, it also shows your usage bars. The dollar figure is calculated locally at list price, so on a subscription it reflects how much work you did rather than an exact bill.
Per Anthropic’s guidance, when upgrading effort and adding checks no longer improves results. A practical rule of thumb: if Opus 5.5 at high effort fails at the same point twice, switching to Fable 5.1 is usually the right call. Switch at a natural break, and switch back to Opus 5.5 once the hard part is done.
/compact do and when should I use it?/compact summarizes older conversation history into a shorter context, reducing the tokens sent on future turns. At 150K tokens, a compaction costs roughly $0.25 and pays for itself within about 10 subsequent turns. Use it at natural breaks in long sessions. Avoid it mid-debugging (you can lose key context) and at the very end of a session (it costs more than it saves).
Per Anthropic’s cost documentation, the average across enterprise deployments is about $13 per developer per active day, with 90% of users under $30 per active day. Sessions well above your personal baseline are worth reviewing in /usage.
Token pricing is the starting point, not the destination. What a Claude Code task actually costs on Opus 5.5 depends on how many turns it takes, how warm the cache stays, how much thinking the effort level demands, and which model you’ve chosen for each part of the work.
The good news is that most of these levers are accessible in a running session with a single command. The better news is that Opus 5.5’s 60% cheaper cache reads mean the levers move a larger total number. A warm cache that used to save you $0.60 now saves $1.00. A compaction that used to pay for itself in 15 turns now pays for itself in 10.
Run /usage after your next real task. Not a toy example, a real one from your backlog. Compare it to the same task on Opus 5. That’s the only number that actually matters for your specific workflow.
Most pricing figures, session examples, and core recommendations in this article are based on Anthropic’s official blog post “What a task costs on Opus 5.5” by Addy Osmani, published September 22, 2026, at claude.com/blog/what-a-task-costs-on-opus-5-5. Some additional context (Fable 5.1 pricing, subagent configuration details, CLAUDE.md guidance, the $13/day enterprise figure) is drawn from related Anthropic documentation. Some structural framing and organization is the author’s own. Prices are API list prices and may differ from effective rates on subscription plans. Cache write pricing varies by lifetime tier. Verify current rates at claude.com/pricing.
Curated by Lorphic
Digital intelligence. Clarity. Truth.
We have sent a 6-digit verification code to your email. Please enter it below to continue.
We have sent a 6-digit verification code to your email. Please enter it below to continue.
