Claude Opus 5.5 API pricing is $4 per million input tokens and $20 per million output tokens through Anthropic’s Standard API. Cache reads cost $0.20 per million tokens. These headline rates tell you the price of each token category; your actual bill depends on how much of each category a task consumes.
That distinction matters for coding agents and long conversations. Repeated context, cache creation, billed thinking tokens and retries can make two seemingly similar requests cost very different amounts. A useful estimate should show the calculation behind the cost per completed task, including unsuccessful attempts.
LinkModel offers Claude Opus 5.5 with 15% lower Standard input, output and cache token rates, including $3.40/M input and $17/M output. Billing is pay-as-you-go, with no minimum spend and no monthly platform fee. Teams can also access supported models through a unified API, while checking the model-specific features their applications require.
Claude Opus 5.5 API Pricing at a Glance
LinkModel’s five listed Standard token categories are each 15% below Anthropic’s corresponding rates. All prices below are in USD per one million tokens.
| Token category | Anthropic Standard | LinkModel | Savings |
|---|---|---|---|
| Fresh input | $4.00 | $3.40 | 15% |
| Cache read | $0.20 | $0.17 | 15% |
| Cache write: 5 minutes | $5.00 | $4.25 | 15% |
| Cache write: 1 hour | $8.00 | $6.80 | 15% |
| Output | $20.00 | $17.00 | 15% |
The comparison uses Anthropic’s official pricing and the Claude Opus 5.5 entry on LinkModel’s pricing page, checked on October 22, 2026. Worked examples are calculations from listed rates.
Anthropic also offers separate Batch and Fast pricing:
| Anthropic mode | Input / 1M tokens | Output / 1M tokens | Main consideration |
|---|---|---|---|
| Standard | $4.00 | $20.00 | Interactive requests |
| Batch | $2.00 | $10.00 | Asynchronous processing |
| Fast | $8.00 | $40.00 | Higher output throughput |
These Batch and Fast prices describe Anthropic’s offerings.
Anthropic prices shown in the chart. LinkModel’s corresponding Standard rates appear in the comparison table above.
How Much Does a Claude Opus 5.5 Request Cost?
Multiply the actual billed tokens in each category by that category’s price. Input and output are charged separately, so “one million tokens” is not a complete cost estimate unless you specify the mix.
Fresh Input and Output Examples
For requests without caching, the calculation is:
Request cost = input tokens ÷ 1,000,000 × input rate + output tokens ÷ 1,000,000 × output rate
| Fresh input | Billed output | Anthropic Standard | LinkModel | Savings per request |
|---|---|---|---|---|
| 10,000 tokens | 2,000 tokens | $0.080 | $0.068 | $0.012 |
| 100,000 tokens | 10,000 tokens | $0.600 | $0.510 | $0.090 |
| 1,000,000 tokens | 100,000 tokens | $6.000 | $5.100 | $0.900 |
For example, 100,000 fresh input tokens and 10,000 output tokens cost $0.60 through Anthropic Standard or $0.51 through LinkModel, assuming identical usage and no additional charges.
At 1,000 such requests, the calculated token charges become $600 versus $510, saving $90. This is a volume illustration, not a prediction of how many tokens your application will use.
Why a Short Answer Can Still Have a Larger Bill
Visible answer length is not the same as total billed output. Reasoning can contribute output tokens even when the final response is brief.
For agent workflows, also count subsequent calls. A retry or another planning step can process context again and generate additional output. When optimizing AI API costs, examine the complete run rather than only its first prompt.
Claude Opus 5.5 Cache Pricing: Reads, Writes and Break-Even
Caching makes repeated input cheaper, but creating the cache has its own price. A cache hit should be charged at the read rate, while newly stored content uses the applicable write rate.
What Each Cache Rate Means
| Operation | Anthropic | LinkModel | When it applies |
|---|---|---|---|
| Five-minute cache write | $5.00/M | $4.25/M | Creating a prefix with the shorter cache duration |
| One-hour cache write | $8.00/M | $6.80/M | Creating a prefix with the longer cache duration |
| Cache read | $0.20/M | $0.17/M | Reusing eligible cached content |
A read costs 95% less than fresh input at either provider’s listed rates. That percentage compares read prices only; it does not include the initial write.
Caching also requires eligible, matching content. It is not a discount automatically applied to every repeated-looking prompt. Follow Anthropic’s prompt caching documentation for implementation requirements, and use our Prompt Caching Guide to plan stable system instructions, tool definitions and reusable context.
When Does Caching Pay for Itself?
Consider the same 100,000-token prefix processed twice.
| Two uses of the same prefix | Anthropic | LinkModel |
|---|---|---|
| Fresh input both times | $0.80 | $0.68 |
| One five-minute write + one read | $0.52 | $0.442 |
| One one-hour write + one read | $0.82 | $0.697 |
The five-minute cache is already cheaper after one successful reuse. The one-hour cache needs another read to beat three fresh-input uses: $0.84 versus $1.20 through Anthropic, or $0.714 versus $1.02 through LinkModel.
These calculations assume the entire prefix remains reusable within the selected duration. They exclude output and unrelated input.
Why Cache Hit Rate Changes Agent Costs
As a transparent illustration, assume a run processes 2.8 million cumulative input tokens, split between fresh input and cache reads.
| Cache-read share | Fresh input | Cache reads | Anthropic input subtotal | LinkModel input subtotal |
|---|---|---|---|---|
| 0% | 2.8M | 0 | $11.20 | $9.52 |
| 90% | 0.28M | 2.52M | $1.624 | $1.3804 |
| 96% | 0.112M | 2.688M | $0.9856 | $0.83776 |
These subtotals exclude cache creation charges and output. They illustrate the effect of reads replacing fresh input, rather than a complete agent invoice.
The chart rounds Anthropic’s input subtotals. Add cache writes, output and other applicable charges when budgeting a complete run.
Anthropic Batch vs Standard vs Fast: Which Costs Less?
Batch has the lowest listed input and output rates of these three Anthropic modes. Fast carries a premium for throughput. Choose according to whether the work can wait and which features the endpoint supports.
Batch: Lower Rates for Asynchronous Work
Anthropic’s Batch API halves Standard input and output rates. A workload containing 1M fresh input tokens and 100,000 output tokens therefore costs $3 through Batch versus $6 through Standard, before other applicable charges.
Batch fits offline evaluation, classification, extraction and similar jobs that do not require an immediate response. It can also be combined with prompt caching under Anthropic’s applicable billing rules.
Fast: Higher Rates for Higher Throughput
Anthropic lists Fast input at $8/M and output at $40/M, twice the Standard rates. Its Opus 5.5 announcement reports up to 2.5× speed.
Fast supports caching but cannot be combined with Batch. Evaluate end-to-end latency on your workload: faster output generation does not guarantee the same improvement in retrieval, tool execution or total task duration.
For LinkModel requests, check the supported endpoint and billing before assuming either mode is available.
How to Calculate the Full Claude Opus 5.5 Token Bill
Separate fresh input, both cache-write durations, cache reads and output. Do not charge the same input tokens twice by treating a total-input counter and its cache breakdown as independent usage.
For token quantities expressed in millions:
Anthropic Standard cost = 4 × fresh input + 5 × five-minute writes + 8 × one-hour writes + 0.20 × cache reads + 20 × output
LinkModel cost = 3.40 × fresh input + 4.25 × five-minute writes + 6.80 × one-hour writes + 0.17 × cache reads + 17 × output
Worked Example with Caching
| Usage category | Tokens | Anthropic Standard | LinkModel |
|---|---|---|---|
| Fresh input | 100,000 | $0.40 | $0.34 |
| Five-minute cache writes | 200,000 | $1.00 | $0.85 |
| Cache reads | 2,000,000 | $0.40 | $0.34 |
| Output | 50,000 | $1.00 | $0.85 |
| Total | — | $2.80 | $2.38 |
The calculated saving is $0.42, or 15%, at identical token usage. Because all five compared rates share the same discount, changing the mix between those categories does not change that percentage.
Why Opus 5.5 Savings Can Be 15%, 20% or About 40%
These percentages use different baselines. They should not be presented as interchangeable discounts.
| Figure | Comparison | Meaning |
|---|---|---|
| 15% | LinkModel vs Anthropic Standard for Opus 5.5 | Lower listed rates across the five compared token categories |
| 20% | Opus 5.5 vs Opus 5 official Standard input/output | Lower input and output unit prices |
| About 40% | Anthropic’s reported typical workloads at default settings | A workload-level result rather than a guaranteed rate reduction |
Compared with Opus 5, the official rates change as follows:
| Token category | Opus 5 | Opus 5.5 | Reduction |
|---|---|---|---|
| Fresh input | $5.00/M | $4.00/M | 20% |
| Output | $25.00/M | $20.00/M | 20% |
| Cache read | $0.50/M | $0.20/M | 60% |
In its official release analysis, Anthropic reports approximately 40% lower costs on typical workloads at default settings. This combines workload behavior with pricing; it does not mean every customer receives a 40% reduction.
Vendor-reported results depend on workload and settings.
When comparing providers, hold usage constant. When comparing models, measure whether usage and success rates change. That is the difference between cost per token and cost per completed task.
What Published Coding Examples Actually Tell Us
Published examples can reveal cost drivers, but they are not predictions of your bill. Our research separates official evaluations, community usage reports and calculations from listed rates.
Eight Weeks of Claude Code: A Repricing Example with a Discrepancy
In a published transcript analysis, the author reported that approximately 97% of recorded tokens were cache reads. This is a useful example of why cached-input pricing can dominate a long-running workflow.
| Reported token category | Volume | Calculated at Opus 5 rates | Calculated at Opus 5.5 rates |
|---|---|---|---|
| Cache reads | 6,039M | $3,019.50 | $1,207.80 |
| One-hour cache writes | 133M | $1,330.00 | $1,064.00 |
| Five-minute cache writes | 53M | $331.25 | $265.00 |
| Output | 15.5M | $387.50 | $310.00 |
| Fresh input | 0.2M | $1.00 | $0.80 |
| Calculated total | — | $5,569.25 | $2,847.60 |
The original post reported $5,071 and $2,849. Its Opus 5 total differs materially from the calculation using the published quantities and rates, so we do not treat the reported 44% saving as independently verified.
Original reported figures, retained for context. The table above shows the discrepancy. This is a retrospective repricing exercise, not a comparison of actual subscription invoices or a LinkModel test.
The source also describes transcript-accounting pitfalls, including duplicated request records and separate subagent logs. When reconstructing agent costs, deduplicate requests and account for the whole run.
Official Coding Evaluations
Anthropic reports a tester completing a 200,000-line codebase audit in under three hours, compared with more than 20 hours using Opus 5. It also reports a C-to-Rust HAProxy migration taking 9.5 hours with Opus 5.5 versus 12 hours with Fable 5.1, at 51% lower cost.
Other customer examples in the same announcement discuss reduced prompts, turns or output.
Reported examples use different tasks and evaluation conditions. They should not be combined into a universal savings claim.
Small Benchmarks: Estimated Cost Is Not an Invoice
Our review of a published community benchmark found a useful methodological distinction: the author ran Claude Code on a Max subscription, then estimated API-equivalent costs from token usage and list prices.
The reported approximately $0.09 per passed task was therefore an estimate, not an API charge. The post’s headline refers to 25 tasks, while its main summary covers 23 tasks before two additional tests. Its results are specific to that small task set, harness and settings.
Use such reports to design your own evaluation. Do not turn them into a guaranteed cost, speed or accuracy claim.
How Thinking, Turns and Retries Affect Your Budget
Effort controls how much work the model spends on a response; it does not change the listed price of each token.
The official model documentation identifies the API model as claude-opus-5-5, with a 1M-token context window and 128K standard maximum output. Adaptive thinking is always enabled, and the default effort is Medium.
Evaluate Effort Instead of Assuming Higher Is Better
Start with the default and compare lower or higher settings against your acceptance criteria. A lower setting is useful only if the result remains acceptable; a higher setting is worthwhile when the additional reasoning prevents more expensive failures.
Anthropic’s effort documentation explains that the control affects thinking, response text and tool-call output. Set an appropriate output limit with room for reasoning and the final answer.
Count Every Attempt Needed to Finish
For production comparisons, use:
Cost per successful task = total spend across all attempts ÷ successfully completed tasks
Include retries, extra turns and any separately billed tools. Track function calls and tool use alongside model tokens so that missing requirements or repeated searches do not disappear from the estimate.
A cheaper request is valuable when the whole workflow still meets your quality and latency requirements.
What Should You Check Before Choosing an Opus 5.5 API Provider?
Compare price, feature support and actual billed usage together. A lower published rate is easier to evaluate when you can trace the request through to its charge.
| Check | What to verify |
|---|---|
| Model and endpoint | The intended model is selected, with the required request format |
| Cache behavior | Cache controls are supported and reads/writes appear in usage accounting |
| Application features | Streaming, tool calling and reasoning controls work for your workflow |
| Usage and billing | Reported quantities can be reconciled with the applicable rates |
| Operational requirements | Rate limits, latency, error handling and support fit your deployment |
| Service terms | Privacy, payment and refund terms meet your requirements |
LinkModel’s API documentation is the starting point for integration details. A unified interface can reduce provider-management work, but model-specific parameters still need validation.
For a practical comparison, run representative tasks with fixed settings and success criteria. Review output quality, elapsed time, retries, token categories and the final charge before moving more traffic.
Frequently Asked Questions
How much does Claude Opus 5.5 API access cost?
Anthropic Standard rates are $4/M fresh input and $20/M output. LinkModel lists $3.40/M input and $17/M output, with corresponding Standard cache rates also 15% lower. Input and output quantities are billed separately.
What are the Claude Opus 5.5 cache prices?
Anthropic charges $5/M for five-minute writes, $8/M for one-hour writes and $0.20/M for reads. LinkModel lists $4.25/M, $6.80/M and $0.17/M, respectively. Include both creation and reuse when estimating prompt caching costs.
Is API usage included in a Claude subscription?
Do not treat a Claude subscription as an included API token balance. Subscription usage limits and API token billing are different systems. A token-based estimate of subscription activity is not the same as an invoice, and API access requires the applicable provider’s billing arrangement.
Are longer prompts charged at a higher token rate?
Opus 5.5 has no separate long-context Standard token-price multiplier across its 1M-token context window. More tokens still increase the total charge. Anthropic’s US-only inference option adds a 1.1× multiplier, while Fast, caching and tools can change other parts of the bill.
Does LinkModel’s 15% discount guarantee 15% lower total operating costs?
It provides 15% lower listed rates for the five compared Standard token categories. At identical usage, those token charges are 15% lower. Total operating savings may differ when retries, tool fees, infrastructure or workload behavior change.
Estimate Your Cost, Then Test the Workflow
Begin with your actual mix of fresh input, cache writes, cache reads and output. Keep provider discounts separate from model-generation savings, and compare completed tasks rather than isolated requests.
With 15% lower Standard token rates, LinkModel offers a clear starting point for reducing Claude Opus 5.5 token charges. Review the current pricing, explore Claude Opus 5.5, and run a representative task in the Playground to evaluate the result and usage before scaling.
