How much does Claude Opus 5.5 cost per million tokens?

Base pricing is $4 per million input tokens and $20 per million output tokens on the Claude API. A cache hit costs $0.20 per million, a 5-minute cache write costs $5, and a 1-hour cache write costs $8. Batch requests are half price at $2 and $10.

Is Claude Opus 5.5 cheaper than Claude Opus 5?

Yes. Opus 5 lists at $5 input and $25 output, so Opus 5.5 is 20% cheaper per token. Anthropic claims 40% less on typical workloads, which folds in token efficiency on top of the rate cut. On sticker rates alone a cache-heavy agent loop lands closer to 30%.

Why are Claude Opus 5.5 cache reads so cheap?

Cache hits on Opus 5.5 are priced at 0.05x the base input rate instead of the usual 0.1x, which works out to $0.20 per million tokens against $0.50 on Opus 5. In an agent loop that re-reads the same repository context every turn, that single multiplier moves the bill more than the headline rate does.

What is the context window on Claude Opus 5.5?

One million input tokens, with up to 128,000 output tokens on the synchronous Messages API. Anthropic bills the full window at standard rates, so a 900,000-token request costs the same per token as a 9,000-token one. There is no long-context surcharge to plan around.

Should I use Claude Opus 5.5 or Claude Fable 5.1?

Opus 5.5 is the cheaper default at $4 and $20 against Fable 5.1 at $10 and $50, and Anthropic says it performs at Fable 5.1's level on most work. Keep Fable 5.1 for demanding reasoning and long-horizon agentic runs, or when your own evals on Opus 5.5 at higher effort still fall short.

Does cheaper agentic coding change how technical interviews work?

It changes what is worth testing. When a model can run a long refactor for a couple of dollars, typing out a known algorithm proves less than reading a diff, spotting the wrong abstraction, or explaining why a fix is safe. Expect more debugging and design judgement, less recall.

Claude Opus 5.5 Pricing: What It Really Costs to Run

Claude Opus 5.5 pricing is the part of this release worth reading twice. Anthropic shipped the model on 22 September 2026 at $4 per million input tokens and $20 per million output, and claimed it performs at the level of Claude Fable 5.1 on most work while costing 40% less to run than Opus 5. The rate card only explains part of that 40%, and the part it does not explain is the part that decides your bill.

So this is not a benchmark recap. It is an attempt to work out what a real agent loop costs on the new rates, and what that means if you write code for a living or you are preparing for interviews.

What Anthropic shipped on 22 September

Opus 5.5 is the first model in the 5.5 family, aimed at long-running agentic coding and knowledge work. The API ID is claude-opus-5-5. It carries a 1M-token context window, up to 128K output tokens on the synchronous Messages API, adaptive thinking that is always on, and a reliable knowledge cutoff of June 2026. Anthropic commits to keeping it available until at least 22 September 2027, per the published model overview. It is available on the Claude API, AWS, Google Cloud, Microsoft Azure, Claude Code and the Claude desktop apps.

The benchmark spread against Opus 5

Anthropic's own reported numbers, Opus 5.5 against Opus 5:

Terminal-Bench 4.0 — 66.4% against 52.3%
CursorBench 4.0 — 57.8% against 46.6%
FrontierCode v1.1 — 54.4% against 48.0%
OSWorld 2.0 — 81.8% partial against 74.0%
GDPval-AA v2.1 — 1846 Elo against 1708

Anthropic also says output generation is more than 30% faster than Opus 5, and reports one tester completing a 680,000-line code migration in under a day. Treat that last one as what it is: a single anecdote from a vendor blog post, not a benchmark.

Claude Opus 5.5 pricing, line by line

Here is the full rate card against the model it replaces, taken from Anthropic's pricing documentation. All figures are per million tokens.

                      Opus 5.5    Opus 5
Base input            $4.00       $5.00
Output                $20.00      $25.00
5m cache write        $5.00       $6.25
1h cache write        $8.00       $10.00
Cache hit             $0.20       $0.50
Batch input           $2.00       $2.50
Batch output          $10.00      $12.50
Fast mode input       $8.00       $10.00
Fast mode output      $40.00      $50.00

On base rates that is a flat 20% cut. Anthropic's 40% claim is about typical workloads, which means it also folds in the model needing fewer tokens to finish a task. Those are two different levers and it is worth keeping them apart when you model your own spend.

Where the cache discount does the work

The line that matters most is the cache hit. Most Claude models price a cache read at 0.1x the base input rate. Claude Opus 5.5 prices it at 0.05x — $0.20 per million against Opus 5's $0.50. That is a 60% cut on the single token category an agent loop consumes most of, because every turn re-reads the same system prompt, the same repository map, the same conversation so far.

5-minute cache writes

A 5-minute write costs 1.25x base input, so $5 per million on Opus 5.5. Against a $0.20 read, the write pays for itself after a single hit. For an interactive session where turns arrive seconds apart, this is the default worth reaching for.

1-hour cache writes

A 1-hour write costs 2x base input, so $8 per million. It needs two reads to break even, which it will comfortably get if you are holding a long-running agent open across a build, a test run and a review pass. Pick this when the gaps between turns are minutes rather than seconds.

Batch mode and fast mode

The Batch API takes 50% off both input and output, putting Opus 5.5 at $2 and $10. Anything that does not need an answer this second belongs there — nightly evals, bulk classification, regenerating a corpus. The discount also stacks with caching multipliers. If you have ever batched work to an execution service, the shape will be familiar; we wrote about the same trade-off in how we batch code submissions and stream results back.

Fast mode runs the other direction: double the price, at $8 and $40, in exchange for significantly faster output. It is a research preview, first-party API only, and it does not combine with the Batch API.

Sticker price is not cost per task

Two details will quietly break any comparison you build from the rate card alone.

Effort defaults make naive comparisons wrong

Opus 5.5 defaults to medium effort. Fable 5.1 defaults to high. If you run the same prompt against both and compare invoices, you are not comparing models — you are comparing one model thinking hard against another thinking moderately. Anthropic's own guidance is to start with Opus 5.5 and move to Fable 5.1 when your evals on Opus 5.5 at higher effort still fall short. Set effort explicitly before you conclude anything.

Tool overhead and the tokenizer caveat

Two smaller things that add up:

Tool-use overhead shrank. Declaring tools adds a system prompt whose cost is per-model. Opus 5.5 spends 286 tokens on it. Opus 4.7 spent 675. On a loop with thousands of turns that difference is real money.
Per-token prices are not comparable across generations. Claude 4.7 and later use a newer tokenizer that produces roughly 30% more tokens for the same text. So a dollars-per-token comparison against Sonnet 4.6 or anything older flatters the newer model. Between Opus 5 and Opus 5.5 the tokenizer is the same, so that comparison is clean.

A worked example: 20 turns of an agent loop

Take a plausible coding agent: a 60,000-token cached prefix of system prompt and repository context, 20 turns, 4,000 fresh input tokens and 2,000 output tokens per turn, one 5-minute cache write at the start.

Opus 5.5
  cache write   60,000 x $5.00 /1M  = $0.30
  cache reads 1,200,000 x $0.20 /1M = $0.24
  fresh input    80,000 x $4.00 /1M = $0.32
  output         40,000 x $20.00/1M = $0.80
  total                              = $1.66

Opus 5
  cache write   60,000 x $6.25 /1M  = $0.375
  cache reads 1,200,000 x $0.50 /1M = $0.60
  fresh input    80,000 x $5.00 /1M = $0.40
  output         40,000 x $25.00/1M = $1.00
  total                              = $2.375

That is a 30% saving on rates alone, and the cache read line by itself falls 60%. The gap widens as the cached prefix grows and narrows as output dominates. Anthropic's 40% figure is reachable, but you get there through token efficiency, not arithmetic on the rate card — which is exactly why you should run the numbers on your own traces rather than trusting a launch-post percentage.

The one thing to take away: on Claude Opus 5.5 the cheapest token is a cache hit at $0.20 per million, a twentieth of the base input rate. Before you optimise prompts or swap models, make sure your prefix is stable enough to actually cache. That single change usually beats both.

What this changes for a working developer

Concretely:

Long-horizon runs stop being a budget decision. A twenty-turn refactor at under two dollars is cheap enough to attempt speculatively and throw away.
The full 1M context is billed at standard rates. There is no long-context surcharge, so a 900,000-token request costs the same per token as a 9,000-token one. You can stop shipping clever chunking to dodge a price tier that does not exist.
Cache-stability becomes an architectural concern. Anything that mutates the head of your prompt — a timestamp, a shuffled tool list — invalidates the prefix and quietly moves you from $0.20 to $4.00 per million.
Cheap does not mean free at scale. Server-side tools bill separately. Web search is $10 per 1,000 searches on top of tokens. Web fetch adds no charge beyond the tokens it pulls in.

If you are wiring this into a product rather than a terminal, the latency work matters as much as the token maths. We went through that in detail while building voice agents over WebRTC, and the lesson transfers: the model is rarely the slow part.

What it changes for interview preparation

This is the part most launch coverage skips. When a competent agentic coder costs a couple of dollars a run, the market value of reciting a known algorithm from memory keeps falling. What holds value is everything the model cannot be trusted to do alone: deciding whether the change is correct, noticing that the abstraction is wrong, and being able to explain a trade-off out loud to someone who will have to maintain it.

Interview formats follow that. The questions worth practising now look less like "implement a trie" and more like "here is a diff, tell me what breaks", "this query got slow after we added a million rows, walk me through it", or "defend this schema". Our take on preparing for interviews using AI tools goes further on drilling that specific muscle, and the Taqari mock interview is built around being asked to justify an answer rather than just produce one.

One caution worth stating plainly: benchmark numbers like 66.4% on Terminal-Bench are a vendor's report of a vendor's harness. They are useful for direction, useless as a substitute for running the model on your own problems. The same scepticism you would apply to a candidate's self-assessment applies here.

How we would pick a model this week

A short decision list, for what it is worth:

Start on Claude Opus 5.5. It is Anthropic's recommended default for most workloads, and at $4 and $20 the cost of being wrong is small.
Turn caching on before you tune anything else. The 0.05x multiplier is the largest single discount available on this model.
Raise effort before you change model. Opus 5.5 at high effort is a different data point from Opus 5.5 at its medium default, and it is cheaper than moving to Fable 5.1 at $10 and $50.
Batch what is not interactive. Half price, stacks with caching, costs you nothing but latency.
Only then reach for Fable 5.1 — for demanding reasoning and long-horizon agentic work where your evals say the premium earns itself.

The wider pattern is the interesting one. Frontier-level coding capability is drifting from a thing you rationed toward a thing you leave running, and the skill that appreciates is knowing which of its outputs to trust.