Journal Pricing
Claude Opus 5.5 cost: what a real Claude Code session costs
Claude Opus 5.5 pricing per million tokens, and what 194 real Claude Code sessions cost at those rates — with the cache-read share that drives most of the bill.
6 min read
Claude Opus 5.5 is cheaper per token than the Opus it replaced. That’s the headline. The question teams actually ask is different: what does a day of Claude Code on Opus 5.5 cost? The per-token price only answers half of it, because in Claude Code most of what you pay for isn’t the text you type or the code you get back.
Below are the official rates, then the numbers from 194 of our own Claude Code sessions priced at those rates.
Claude Opus 5.5 pricing per million tokens
These are Anthropic’s first-party API rates (USD per million tokens), from the official pricing page as of 8 November 2026:
| Model | Input | Cache write (1h) | Cache read | Output |
|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $8 | $0.20 | $20 |
| Claude Opus 5 | $5 | $10 | $0.50 | $25 |
| Claude Sonnet 5.5 | $2 | $4 | $0.10 | $10 |
| Claude Fable 5.1 | $10 | $20 | $0.25 | $50 |
Five-minute cache writes are cheaper ($5 on Opus 5.5), but Claude Code’s long sessions mostly write one-hour cache entries. Fast mode on Opus 5.5 costs $8 input / $40 output — double the standard rate.
Compared with Opus 5, input and output are 20% cheaper. Cache reads are 60% cheaper ($0.50 → $0.20). For Claude Code, that last line matters more than the other two combined.
Case study: 194 real Claude Code sessions
We took every Opus 5.5 session from our own team’s Claude Code logs over 14 days: 194 sessions, 46,036 model calls. We counted each API response once (Claude Code logs one response across several lines, so naive sums double-count), then priced the tokens at the rates above.
Total at Opus 5.5 rates: about $5,550. The same tokens at Opus 5 rates would be about $11,480.
Where the money went:
| Token type | Tokens | Cost at Opus 5.5 | Share of cost |
|---|---|---|---|
| Cache reads | 18.19 B | $3,637 | 66% |
| Cache writes | 0.15 B | $1,173 | 21% |
| Output | 0.04 B | $737 | 13% |
| Uncached input | 0.0001 B | ~$0 | 0% |
Two things stand out:
- Two-thirds of the bill is cache reads. Every call re-reads the conversation and files already in context — on average about 395,000 cached tokens per call in our sessions. Each read is cheap, but there are a lot of them.
- Output is only 13%. The code Claude writes is the smallest line item. Long sessions with big context are what you pay for.
That’s why the 60% cut in cache-read price nearly halves the bill, while the 20% cut in output price barely registers.
What one session costs
Sessions vary enormously. Across sessions with at least 20 model calls:
| Cost per session (Opus 5.5) | |
|---|---|
| 25th percentile | $3.15 |
| Median | $8.02 |
| 75th percentile | $38.22 |
| 90th percentile | $109.50 |
| Most expensive | $875.44 |
The median session made 101 model calls, wrote 122,000 output tokens and re-read 17.8 million cached tokens. Nothing unusual — a few hours of normal work on one task.
The spread is the useful part. A quarter of the sessions cost more than $38, and one in ten cost over $100. On a team, those outliers decide the monthly number, and they rarely show up in a plan-level total.
Does this apply if you pay for a subscription?
On a Claude subscription (Pro, Max, Ultra or Team seats) you don’t pay per token, so these figures aren’t cash out of pocket. They’re the API-equivalent value of the work, which is still the right number for two decisions:
- Is a seat worth it for this developer? If someone regularly uses $1,000+ of API-equivalent usage a month, the $200 Ultra plan is good value. If it’s $40, Pro may be enough.
- Which project is eating capacity? Plan limits are shared across everything a developer does. Knowing which repo burns the most tokens tells you where limits will bite first.
How to keep Opus 5.5 costs down
- Start fresh sessions per task. Cache reads scale with context size. A session that drags three finished tasks behind it pays to re-read all of them on every call.
- Keep
CLAUDE.mdand always-loaded files lean. They’re read on every call. A 20,000-token context file in a 100-call session is 2 million cache-read tokens before any work happens. - Watch the outliers, not the average. In our data, the top 10% of sessions made up 59% of the cost; the bottom 75% made up 15%. Find out what those expensive sessions were doing.
- Use fast mode deliberately. It doubles the per-token price. Worth it for interactive debugging, wasteful for long background tasks.
Measure it on your own team
Claude Code already reports claude_code.cost.usage and token counts per session through OpenTelemetry. SpendByTeam collects only those numbers — never prompts or code — and splits them by repository, project, team and client, so you can see your own median session and the outliers above it. It’s free for up to 3 developers.
Method note: costs are list-price estimates from token counts in local Claude Code logs, deduplicated by response ID. Your invoice may differ slightly because of rounding, discounts and plan terms.
