Claude Opus 5.5 vs Claude Sonnet 5.5: what does Opus add for the money?
By TechCompare · Updated · How we check
Sonnet is cheaper for the same uncached input and output. Cache reads cost $0.20 on Opus and $0.10 on Sonnet, so check the cached totals too.
Anthropic: Claude Opus 5.5
Anthropic's own price
- Input
- $4
- Output
- $20
- Cached
- $0.20
per 1M tokens
Price checked 2026-11-19
Anthropic: Claude Sonnet 5.5
Anthropic's own price
- Input
- $2
- Output
- $10
- Cached
- $0.10
per 1M tokens
Price checked 2026-11-19
Cost Comparison
Based on 100,000 input tokens (50% cached), 5,000 output tokens, and 100 requests.Prices come live from OpenRouter at each maker's own price where it's listed. Temporary deals are left out.
Claude Opus 5.5 charges about 2 times Claude Sonnet 5.5's base input rate and 2 times its output rate. Cache reads cost $0.20 per million tokens on Opus and $0.10 on Sonnet, so a shared-context workflow has its own gap. The right question is how much uncached input and output your application pays for, and whether using Opus improves the completed result enough to cover those higher rates.
Compare base rates and cache read costs against what each tier delivers.
Side-by-side specs
| Spec | Claude Opus 5.5 | Claude Sonnet 5.5 |
|---|---|---|
| Rates | ||
| Standard input per 1M tokens | $4.00 | $2.00 (better on this spec) |
| Standard output per 1M tokens | $20.00 | $10.00 (better on this spec) |
| Cache reads per 1M tokensCached input is text the provider has already processed. It costs less than fresh input. | $0.20 | $0.10 (better on this spec) |
| Example costs | ||
| 100K input + 5K output, no cache hits | $0.50 | $0.25 (better on this spec) |
| 100K input + 5K output, 50% cached input | $0.31 | $0.155 (better on this spec) |
| 100K input + 5K output, all input cached | $0.12 | $0.06 (better on this spec) |
| Limits and extras | ||
| 5-minute cache writes per 1M tokensA cache write stores a prompt prefix so later calls can read it at the cached price. | $5 | $2.50 (better on this spec) |
| 1-hour cache writes per 1M tokens | $8 | $4 (better on this spec) |
| Context window | 1,000,000 tokens | 1,000,000 tokens |
| Batch API input / output per 1MBatch jobs return results later, at a lower price than live calls. | $2.00 / $10.00 | $1.00 / $5.00 |
How they differ
Opus costs $4 input and $20 output per million tokens, compared with Sonnet's $2 and $10. A 100,000-input, 5,000-output request without cache hits costs $0.50 on Opus and $0.25 on Sonnet. With half the input read from cache, the estimates become $0.31 and $0.155.
If all 100,000 input tokens are eligible cache reads, they become $0.12 and $0.06. Cached input costs about 2 times as much on Opus. Output stays about 2 times as expensive on Opus.
Five-minute cache writes cost $5 per million on Opus and $2.50 on Sonnet, with one-hour writes at $8 and $4. Both support a 1M context window at standard rates. Both have a 50% provider Batch API discount.
These worked estimates exclude writes and tool fees. The embedded chart uses live OpenRouter prices and can differ with provider routing.
Verdict
Use Sonnet as a candidate for tasks it completes to your required standard, then evaluate Opus on the work that remains difficult. Cache hits can change the per-call gap, but that doesn't make either model better value on its own. Track the number of attempts, output tokens, and human corrections per successful task. Route using those measurements rather than treating the Opus name as evidence of a benefit on every workload.
Which should you pick?
Choose Claude Opus 5.5
Use Opus when your evaluation shows a worthwhile improvement on longer agent workflows, coding tasks, or document analysis. A reused cache can reduce the cost of repeated context, but creating and refreshing that cache still costs money. Set budgets for reasoning and tool turns so a small quality gain doesn't arrive with an unexpectedly large output bill.
Choose Claude Sonnet 5.5
Use Sonnet when it reaches the same success criteria with acceptable response times and review effort. Its lower uncached-input, output, and write rates matter for one-off requests, growing conversations, and output-heavy applications. Keep an escalation path for tasks that need another attempt on Opus instead of paying the higher rate for every routine request.