Claude Opus 5.5 API pricing is $4/M input and $20/M output, which is 20% lower than Opus 5. Cache reads cost just $0.20/M, while Batch reduces pricing to $2/M input and $10/M output.
The 20% figure refers to Standard input and output token-rate reductions; Anthropic’s ~40% figure refers to reported total cost on typical workloads at default settings. Cache-hit rate, thinking and output tokens, agent turns, retries and tool calls can all change the final cost per completed task.
LinkModel offers Claude Opus 5.5 at 85% of Anthropic’s corresponding official listed rates—$3.40/M input and $17/M output versus Anthropic’s $4/M and $20/M. Teams also get one OpenAI-compatible API, one API key and unified billing, with the ability to switch supported models by price, quality, speed or availability without rebuilding integrations.
Claude Opus 5.5 API Pricing at a Glance
Claude Opus 5.5 Standard API pricing is $4/M input and $20/M output. Cache reads cost $0.20/M, Batch reduces input/output to $2/M and $10/M, and Fast costs $8/M and $40/M.
| Pricing Type | Cost per 1M Tokens |
| Standard input | $4.00 |
| Standard output | $20.00 |
| 5m cache write | $5.00 |
| 1h cache write | $8.00 |
| Cache read | $0.20 |
| Batch input | $2.00 |
| Batch output | $10.00 |
| Fast input | $8.00 |
| Fast output | $40.00 |
Claude Opus 5.5 was released on September 22, 2026. Its API model ID is claude-opus-5-5, with a 1M-token context window and up to 128K output tokens.
There is no long-context token-price multiplier: Standard rates remain $4/M input and $20/M output across the full 1M-token context window. Prompt caching and Batch discounts remain available, and Batch and caching can be combined.
US-only inference applies a 1.1× multiplier to input, output, cache-write and cache-read pricing. The largest unit-cost gap is between output tokens at $20/M and cache reads at $0.20/M—a 100× difference.
Claude Opus 5.5 Input and Output Pricing
How Much Does Claude Opus 5.5 Input Cost?
Standard uncached input costs $4/M tokens.
| Input Tokens | Cost |
| 10K | $0.04 |
| 100K | $0.40 |
| 500K | $2.00 |
| 1M | $4.00 |
A request with 100K fresh input + 10K output costs $0.60: $0.40 for input and $0.20 for output.
That estimate works well for a simple request. It becomes less representative in agent workflows because later turns can repeatedly process system instructions, tools, repository files and conversation history.
How Much Does Claude Opus 5.5 Output Cost?
Output costs $20/M tokens, five times the Standard input rate. 10K output tokens cost $0.20, while 100K cost $2.
The key detail is that thinking is included in billed output. Anthropic illustrates this with a 60K-output-token task costing $1.20, equal to the cost of reading about 6M tokens from cache.
For reasoning-heavy workloads, optimizing AI API costs only around the initial prompt can therefore miss one of the largest cost drivers.
Claude Opus 5.5 Cache Pricing and Agent Costs
Claude Opus 5.5 Cache Read and Write Pricing
Prompt caching uses three distinct prices:
| Cache Type | Price |
| 5m cache write | $5/M |
| 1h cache write | $8/M |
| Cache read | $0.20/M |
A cache read costs only 5% of Standard input. The 5-minute write is 1.25× Standard input, while the 1-hour write is 2×.
For the same token volume, one 5m cache write costs as much as 25 cache reads. This is why repeated context can become dramatically cheaper after the initial write.
For implementation strategies, our Prompt Caching Guide explains how stable system prompts, tool definitions and repeated context can be structured for better reuse.
Why Cache Hit Rate Can Matter More Than $4/M Input
Anthropic models a 40-turn agent task processing approximately 2.8M cumulative input tokens. Without caching, that input costs $11.20. At a 90% cache-hit rate, it falls to roughly $1.62; at 96%, about $0.99.
That leads to a practical pricing rule: for long-running agents, track cache-hit rate rather than total input tokens alone.
The Claude Code workloads reviewed in our research showed the same pattern, with cached context accounting for the overwhelming majority of token volume in one long-running dataset.
Claude Opus 5.5 Batch API and Fast Mode Pricing
Claude Opus 5.5 Batch Pricing
Batch reduces Standard input and output rates by 50%:
| Mode | Input | Output |
| Standard | $4/M | $20/M |
| Batch | $2/M | $10/M |
Batch reduces Standard input and output rates by 50% and supports up to 300K output tokens in beta.
A workload with 1M input + 100K output costs $6 with Standard and $3 with Batch, before cache or other modifiers.
Batch is especially useful for offline evaluation, extraction, classification and document processing where immediate responses are unnecessary. Because Batch and prompt caching can be combined, cache-heavy asynchronous workloads can benefit from both discounts.
Claude Opus 5.5 Fast Mode Pricing
Fast Mode costs $8/M input and $40/M output, exactly 2× Standard pricing. Anthropic reports up to 2.5× higher output tokens per second, so the main trade-off is higher output throughput at a higher token price.
Fast can use prompt caching, but Fast and Batch cannot be combined.
In practical terms, Batch prioritizes lower cost, Standard balances cost and responsiveness, and Fast prioritizes output throughput.
Claude Opus 5.5 API Pricing: Anthropic vs LinkModel
LinkModel prices Claude Opus 5.5 at 85% of Anthropic’s corresponding official listed Standard token rates. That reduces input from $4/M to $3.40/M and output from $20/M to $17/M.
| Provider | Input | Output |
| Anthropic Standard | $4/M | $20/M |
| LinkModel | $3.40/M | $17/M |
A workload using 1M input tokens and 100K output tokens would cost $6 at Anthropic’s Standard listed rates versus $5.10 at LinkModel, assuming the same token usage.
LinkModel also provides one OpenAI-compatible API, one API key and unified billing, allowing teams to switch supported models by price, quality, speed or availability without rebuilding integrations.
Claude Opus 5.5 vs Opus 5 Pricing: 20% vs 40% Explained
Claude Opus 5.5 is 20% cheaper than Opus 5 for Standard input and output tokens, while Anthropic’s ~40% figure refers to reported total workload cost at default settings. Cache reads are also 60% cheaper, falling from $0.50/M to $0.20/M, and lower token usage per completed task can further reduce total cost.
| Price | Opus 5 | Opus 5.5 | Reduction |
| Input | $5/M | $4/M | 20% |
| Output | $25/M | $20/M | 20% |
| Cache read | $0.50/M | $0.20/M | 60% |
Why can a 20% token-price cut produce roughly 40% lower workload cost? Because the two figures measure different things. Opus 5.5 cuts Standard input and output prices by 20%, while cache reads are 60% cheaper. Total workload cost can fall further when a task also requires fewer output tokens, agent turns or retries. Cost per token and cost per completed task are therefore different metrics.
Claude Opus 5.5 Cost in Real Coding and Agent Workloads
Reported coding and agent workloads suggest two ways Claude Opus 5.5 can reduce task cost: lower token prices and fewer tokens, turns or retries required to finish the same work. These are reported evaluations rather than universal benchmarks, so results will vary by workload.
Case Study: Eight Weeks of Claude Code Usage
A historical Claude Code workload reviewed in our research contained 6,039M cache-read tokens, 133M 1h cache writes, 53M 5m cache writes, 15.5M output tokens and only 0.2M plain input tokens.
About 97% of the tokens were cache reads. Repricing the same historical token mix produced an estimated $5,071 under Opus 5 pricing versus $2,849 under Opus 5.5, or approximately 44% less.
This does not imply every Claude Code workload saves 44%. The important finding is structural: when cache reads dominate token volume, the 60% cache-read price cut can matter more than the 20% Standard input reduction.
The same workload review also exposed cost-accounting risks. Direct transcript summation reportedly overstated output by around 3.4×, while omitting subagent transcripts could miss approximately 25% of spend. For a broader framework, our AI Agent Cost Guide explains why agent steps and repeated context can dominate production bills.
Case Study: 200K-Line Codebase Audit
Anthropic reports an early tester auditing and fixing a 200,000-line codebase in under three hours with Opus 5.5. The comparable Opus 5 run took more than 20 hours and used about 2.5× as many tokens.
The pricing lesson is important: a model can reduce total cost through both lower token prices and fewer tokens or turns required to finish the job.
Case Study: Reported Production Coding Efficiency
In Anthropic's C-to-Rust HAProxy migration, Opus 5.5 finished in 9.5 hours versus 12 hours for Fable 5.1 and was reported to cost 51% less.
Early-access evaluations showed the same efficiency pattern. Quantium reported a coding workflow falling from 38 prompts over four days to 11 prompts over three hours. Optiver reported comparable agentic tasks completing in about half the turns, time and output tokens, reducing workload cost by 40–50%. Factory reported Opus 5.5 at Medium matching Opus 5 at High while using 20–25% fewer output tokens.
These are official or company-reported evaluations rather than universal benchmarks, but they illustrate why task efficiency can amplify headline price reductions.
Claude Opus 5.5 Cost per Task vs Cost per Token
What a 25-Task Benchmark Shows
Our research reviewed a 25-task graded benchmark designed around successful-task economics.
Within that sample, Opus 5.5 averaged approximately $0.09 per passed task and 27 seconds per completion. Low effort was reported to be around 20% cheaper and 30% faster than High, with no observed accuracy loss across those 25 tasks.
Because the sample contains only 25 tasks, these results should be treated as directional rather than universal. The more useful lesson is methodological: measure total cost per successful task, not just cost per request or per million tokens.
A cheaper API call can still produce a higher total task cost if it fails and requires retries, additional turns or more tool calls.
How Effort, Turns and Retries Change Claude Opus 5.5 Cost
Higher effort can increase billed reasoning output, additional agent turns can resend accumulated context, and retries can repeat both input and output costs. For production workloads, optimize cost per successful task rather than cost per request.
Adaptive Thinking and Effort
Claude Opus 5.5 uses adaptive thinking that cannot be disabled, with Medium as the default effort level.
Higher effort can consume more billed output through additional reasoning. That may increase request cost, but it can still lower task cost if deeper reasoning avoids retries or incomplete fixes.
This is why cost benchmarks should hold task set, effort level, success criteria and retry policy constant. Otherwise, two apparently comparable API costs may represent very different amounts of work.
Why Fewer Agent Turns Can Save More Than Prompt Trimming
Every additional agent turn can resend accumulated context.
Anthropic's cost analysis uses a 40-turn example with about 2.8M cumulative input tokens. Cutting unnecessary turns reduces both repeated context and the opportunity for further output and tool calls.
In our review of user questions, recurring cost concerns involved unnecessary tool calls, repeated context, retries, failed approaches and excessive reasoning. Optimizing the first prompt alone does not address those multipliers.
How to Calculate and Reduce Claude Opus 5.5 API Cost
For Standard workloads, separate every billable token category:
Total cost = fresh input + 5m cache writes + 1h cache writes + cache reads + output
For a workload using 100K fresh input, 200K 5m writes, 2M cache reads and 50K output, the calculation is:
| Usage | Cost |
| 100K fresh input | $0.40 |
| 200K 5m writes | $1.00 |
| 2M cache reads | $0.40 |
| 50K output | $1.00 |
| Total | $2.80 |
The revealing number is 2M cache-read tokens costing only $0.40. Treating them as $4/M fresh input would substantially overestimate the workload.
For production optimization, track cache-hit ratio, turns per successful task, output tokens, retries, effort and success rate. Use Batch where latency is unimportant, preserve reusable prompt prefixes and compare models using completed-task economics. Our AI API Pricing Comparison 2026 provides the wider provider-level comparison.
Frequently Asked Questions
How much is Claude Opus 5.5 API per 1M tokens?
Standard pricing is $4/M input and $20/M output. Batch costs $2/M input and $10/M output, while Fast costs $8/M and $40/M.
How much is Claude Opus 5.5 cache pricing?
5m cache writes cost $5/M, 1h writes cost $8/M and cache reads cost $0.20/M. Cache reads therefore cost only 5% of Standard fresh input.
Is Claude Opus 5.5 Batch 50% cheaper?
Yes for input and output rates. Batch reduces $4/M input to $2/M and $20/M output to $10/M. Prompt caching can also be combined with Batch, so actual savings depend on token mix and cache reuse.
Is Claude Opus 5.5 20% or 40% cheaper than Opus 5?
Both figures are correct, but they measure different things. Claude Opus 5.5 Standard input and output token prices are 20% lower than Opus 5, while Anthropic reports roughly 40% lower total cost on typical workloads at default settings. The larger workload-level difference can reflect 60% cheaper cache reads and fewer tokens or turns required to complete a task.
Does Claude Opus 5.5 charge more for long-context requests?
No. Claude Opus 5.5 keeps the same Standard per-token rates across its full 1M-token context window. A 900K-token request uses the same per-token rate as a 9K-token request, although its total cost is higher because it contains more tokens. Separate modifiers such as US-only inference, Fast mode, cache operations and tool usage can still affect the final bill.
Conclusion
Claude Opus 5.5 costs $4/M input and $20/M output, but workload shape determines what teams actually pay. Cache-heavy agents can behave very differently from short uncached API calls because cache-hit rate, output usage, effort, agent turns and retries all affect cost per completed task.
The key distinction is cost per token versus cost per successful task. Opus 5.5 cuts Standard input and output rates by 20%, while Anthropic reports roughly 40% lower typical workload cost at default settings. For production workloads, track cache-hit ratio, turns, retries, output tokens and task success rate rather than relying on headline token prices alone.
