Claude Sonnet 5.5 API Pricing: Input, Output, Cache & Real Costs

Claude Sonnet 5.5 API pricing starts at $2 per million input tokens and $10 per million output tokens through Anthropic, with cached input reads at $0.10/M. LinkModel lists the same model at $1.70/M input, $8.50/M output, and $0.085/M cached reads—15% below the corresponding standard rates. A request using 100K fresh input tokens and 20K output tokens therefore costs $0.40 through Anthropic versus $0.34 through LinkModel, before additional charges.

But the lowest price per token does not always mean the lowest bill. Cache misses, reasoning tokens, repeated agent calls, failed attempts, and tool usage can make an apparently inexpensive request costly. Developers need to know not only what Sonnet 5.5 charges, but how much a successful task will consume.

LinkModel gives you a direct opportunity to reduce Sonnet 5.5 token costs without changing your model choice. Its published 15% discount covers fresh input, output, and both cache-write durations as well as cache reads. For 100M input tokens and 20M output tokens, that means $340 instead of $400 on identical standard-token usage. Explore LinkModel's Sonnet 5.5 pricing and estimate the savings against your own workload before scaling.

Claude Sonnet 5.5 API Pricing: Official Rates vs LinkModel

Anthropic's standard Claude Sonnet 5.5 API rates are $2/M input and $10/M output. LinkModel lists $1.70/M input and $8.50/M output, a 15% reduction. Both pricing schedules distinguish fresh input, cached reads, and cache creation.

Claude Sonnet 5.5 Input, Output, and Cache Pricing

Prices are in USD per million tokens. The comparison uses the published standard rates for each billing category.

The most important detail is that output costs five times as much as fresh input. An application generating extensive reasoning or lengthy responses can accumulate output charges quickly, even when its original prompt is relatively small.

Cache reads are also much cheaper than fresh input. A successful cached read costs just 5% of the fresh-input rate under either schedule. That creates substantial savings opportunities for repeated context, but only when the application actually achieves cache hits.

What Counts Toward a Sonnet 5.5 API Bill?

Sonnet 5.5 usage can include system instructions, user prompts, conversation history, reference documents, retrieved content, and tool responses.

Generated responses and applicable thinking tokens contribute to output usage. A short visible answer does not necessarily imply low output-token consumption when the model performs substantial internal reasoning.

For a cached request, billing may include several categories simultaneously:

- Fresh input: New tokens that are not served from cache.

- Cache creation: Eligible content written to a five-minute or one-hour cache.

- Cache reads: Previously stored content successfully reused.

- Output: Generated tokens, including applicable thinking usage.

Tool-specific fees or deployment conditions may introduce additional charges. A reliable API cost estimate therefore separates token categories instead of treating every token as ordinary input.

Is There a Sonnet 5.5 Long-Context Surcharge?

Sonnet 5.5 retains its standard per-token rates across its documented 1M context window. A request containing 900K input tokens is not assigned a higher base input rate merely because it is large.

The request is still expensive in absolute terms: 900K fresh input tokens cost $1.80 through Anthropic or $1.53 through LinkModel, before output and other charges.

For long-document applications, the question is not only whether the model accepts the context, but whether every included token contributes to the result.

How Much Does Claude Sonnet 5.5 Cost per Request?

A Sonnet 5.5 request with 15K fresh input tokens and 1K output tokens costs $0.040 at Anthropic's standard rates or $0.034 at LinkModel's published rates.

The calculation is straightforward for uncached requests, but real applications should account for cached tokens, retries, and tools.

Claude Sonnet 5.5 API Cost Formula

For an ordinary uncached request:

Total cost = (Input tokens × Input rate + Output tokens × Output rate) ÷ 1,000,000

For Anthropic:

Cost = (Input tokens × $2 + Output tokens × $10) ÷ 1,000,000

For LinkModel:

Cost = (Input tokens × $1.70 + Output tokens × $8.50) ÷ 1,000,000

When caching is involved, calculate fresh input, cache writes, cache reads, and output separately, then add applicable tool and deployment charges.

This distinction matters because a request containing 100K tokens of previously cached reference material may cost much less than one processing the same 100K tokens as fresh input.

Claude Sonnet 5.5 Cost Examples by Workload

The following examples are calculated from defined token quantities. They illustrate potential usage patterns rather than claiming that every task in a category requires the same number of tokens.

All examples assume standard uncached input and output rates, without additional fees.

The table reveals an important cost pattern: input-heavy tasks benefit from reducing unnecessary context, while output-heavy tasks benefit from controlling generation and reasoning effort.

For a long-document analysis using 200K input tokens and 4K output tokens, LinkModel's calculated charge is $0.374 rather than $0.44. Across 1,000 identical requests, that becomes $374 versus $440.

Monthly Sonnet 5.5 API Cost at Different Volumes

Assume each request uses 15K fresh input tokens and 1K output tokens.

These are comparable token-charge estimates, not observed customer invoices.

At low usage, the dollar difference may be modest. At sustained high volume, the same percentage discount can become significant.

For production planning, use your actual token mix rather than assuming every request resembles a simple chat exchange.

Claude Sonnet 5.5 Prompt Caching Pricing: Break-Even and Real Costs

Sonnet 5.5 cached input reads cost $0.10/M through Anthropic and $0.085/M through LinkModel, 95% below the respective fresh-input rates. Prompt caching is especially valuable when many requests reuse large, stable instructions or documents.

However, creating a cache costs more than processing fresh input once. The economics depend on how frequently the content is reused.

Sonnet 5.5 Cache Read vs Cache Write Costs

The five-minute write costs 1.25 times fresh input, while the one-hour write costs twice fresh input.

Once eligible content is reused successfully, the cache-read rate is substantially lower.

Case Study: Ten Requests Reusing a 100K-Token Repository

Consider a coding assistant that uses the same 100K-token repository context across 10 requests.

Without caching, that repeated context costs:

Anthropic: $2.00

LinkModel: $1.70

Now assume the first request creates a cache and the next nine successfully read it.

The calculation excludes changing instructions, generated output, tool usage, and cache refreshes.

With a five-minute cache, the repeated-prefix cost falls 83% compared with ten uncached requests.

This example demonstrates two independent cost levers: caching reduces the amount charged at fresh-input rates, while LinkModel reduces the published price of the resulting token categories.

When Does Sonnet 5.5 Caching Break Even?

The break-even point follows directly from the cache-write premium and the read discount.

For a five-minute cache, the first successful reuse already makes two cached interactions cheaper than processing the same prefix twice as fresh input.

For a one-hour cache, two successful reads are required before cumulative charges become lower than three uncached uses.

The calculation assumes identical reusable content and successful cache hits.

How to Improve Cache Efficiency in Practice

The most useful caching candidates are stable prompt prefixes: system instructions, repository documentation, coding standards, reference manuals, and shared project context.

Place frequently changing instructions after stable reusable material where the API's caching behavior permits.

Monitor cache-read and cache-write usage rather than assuming repeated text automatically produces cache hits.

A workflow that continually modifies its shared prefix may create new cache entries instead of realizing the expected savings.

For multi-step coding agents, effective caching can matter more than removing a small number of tokens from individual instructions.

Claude Sonnet 5.5 Batch API Pricing and 1M Context Costs

Anthropic's Batch API offers a 50% discount on eligible Sonnet 5.5 input and output tokens, reducing standard rates to $1/M input and $5/M output.

Batch processing is designed for asynchronous workloads, such as scheduled extraction, classification, and offline evaluation.

Sonnet 5.5 Standard API vs Batch Pricing

For a workload with 100M input tokens and 10M output tokens:

Batch saves $150 under these assumptions.

The trade-off is processing mode: applications requiring immediate responses should not assume asynchronous Batch is suitable.

These are Anthropic's published Batch rates. They are not an additional confirmed discount on LinkModel's standard prices.

Sonnet 5.5 Context Window and Maximum Output

Sonnet 5.5 supports a 1M-token context window and a 128K standard maximum output-token limit. Anthropic also documents a higher output limit for an eligible Batch beta configuration.

These limits serve different purposes.

The context window determines how much material the model can consider in a request. The output limit constrains the amount it can generate.

A larger context can support repository analysis or extensive document review, but it does not guarantee that sending every available file is the most efficient approach.

For large workloads, compare full-context processing with selective retrieval and caching.

Other Charges That Can Affect Sonnet 5.5 Costs

Anthropic lists additional pricing conditions for certain tools and deployment configurations.

Its published web-search charge is $10 per 1,000 searches, separate from associated token usage. Supported US-only inference configurations may apply a 1.1× token-pricing multiplier.

These are Anthropic-specific conditions and should not automatically be applied to every third-party route.

A production estimate should distinguish model tokens, caching, tools, and provider-specific charges.

Claude Sonnet 5.5 Agent Costs: What Development Cases Reveal

Agentic workflows can be much more expensive than single API calls because they repeatedly process context, generate reasoning, invoke tools, and retry unsuccessful operations.

The correct economic comparison is therefore not just price per million tokens, but cost per accepted result.

Public development cases illustrate why this distinction matters, although their reported figures must be interpreted within their original execution environments.

Three.js Coding Agent Case: Execution Volume Matters

A public developer comparison examined the creation of a transparent-keyboard assembly animation using Three.js.

The reported execution metrics were:

These figures describe a particular reported execution, not a controlled benchmark of all coding tasks.

The most useful observation is the difference in execution volume.

Nineteen agent instances and 206.8M input tokens represent a very different cost profile from four instances and 6.8M input tokens.

However, raw token totals do not reveal how much input was served from cache, how requests were billed, or whether the accounting includes repeated internal activity.

For that reason, a trustworthy API cost comparison needs the corresponding billing categories before assigning a reproducible dollar amount.

Practical takeaway: For coding agents, monitor agent instances, repeated context, cache usage, retries, and task completion. A lower token rate will not compensate for unlimited failed iterations.

Code-Driven Video Case: Measure the Finished Deliverable

Another public development example involved creating video through a code-driven workflow using browser composition and FFmpeg.

The described project included a 30-second, 1080p, 60fps output.

A separate shorter-version report included API-equivalent cost estimates for Sonnet 5.5 and Opus 5.5, but those estimates were associated with a subscription-based workflow rather than reconciled API invoices.

That distinction matters because subscription usage and direct API billing are not interchangeable.

For a code-driven video project, the economic result depends on whether the generated implementation renders successfully, how many revisions are required, and how much manual repair remains.

Practical takeaway: Measure cost per successfully rendered deliverable, including failed generations and correction work. Do not compare model prices using code-token totals alone.

Long-Running Claude Code Case: Subscription Usage Is Not an API Bill

A public Claude Code usage account described an approximately eight-hour development session consuming around 15% of a Max 20x subscription's weekly allowance.

That observation illustrates how substantial long-running agent activity can be.

It does not establish a dollar-denominated API cost because subscription allowances follow different accounting rules.

Practical takeaway: Before migrating a long-running workflow from a subscription environment to API billing, collect actual fresh-input, cached-input, output, and tool-usage measurements.

Cost per Accepted Result: A Better Comparison

Cost per accepted result = Total workflow cost ÷ Number of accepted results

Consider two illustrative workflows processing 100 tasks.

Workflow A is cheaper per accepted result despite having a lower success rate.

But if its failed tasks require substantial human correction, that advantage may disappear.

These are hypothetical numbers used to demonstrate the method, not observed Sonnet 5.5 results.

For a meaningful model comparison, define acceptance criteria before testing. Record successful outputs, failed attempts, retries, latency, and human correction.

A provider's lower token rate is most valuable when the application preserves acceptable quality and execution behavior.

Claude Sonnet 5.5 vs Sonnet 5, Sonnet 4.6, and Opus 5.5

Sonnet 5.5 has lower standard input and output rates than Sonnet 4.6 and Opus 5.5, while retaining Sonnet 5's $2/M input and $10/M output prices.

Its cached-input read rate is also lower than the other listed models.

Claude Model API Price Comparison

At Anthropic's standard rates, Sonnet 5.5 is:

- 33.3% cheaper per input and output token than Sonnet 4.6.

- 50% cheaper per cached-read token than Sonnet 5.

- 50% cheaper per input and output token than Opus 5.5.

These are comparisons of token rates, not guaranteed differences in total task cost.

Does Sonnet 5.5 Offer Better Value Than Sonnet 5?

Anthropic's published evaluation reported 70.6% on Terminal-Bench 4.0 for Sonnet 5.5 versus 10.3% for Sonnet 5.

The model publisher also reported faster output generation and lower cost per task in selected evaluations.

Those findings support evaluating Sonnet 5.5 for coding workloads, but they do not guarantee identical improvements in every deployment.

The relevant question is whether Sonnet 5.5 completes your representative tasks with fewer retries, less correction, or lower total usage.

When Might Opus 5.5 Be Worth More?

Opus 5.5 costs twice as much per standard input and output token as Sonnet 5.5.

Nevertheless, a more expensive model can sometimes complete difficult tasks with fewer attempts or less total generated reasoning.

For straightforward coding, structured extraction, and general document processing, Sonnet 5.5 is a sensible starting point to evaluate.

For complex reasoning or difficult engineering tasks, compare both models using the same acceptance criteria and total workflow cost.

Choose based on successful outcomes, not benchmark scores or token rates in isolation.

Claude Sonnet 5.5 API Providers: Is LinkModel Worth Choosing?

LinkModel's clearest verified advantage is its published 15% lower Sonnet 5.5 token pricing. For developers already satisfied with Sonnet 5.5, this creates a concrete opportunity to reduce model charges without selecting a different model.

However, a provider decision should also consider API feature support, billing visibility, reliability, and payment terms.

Anthropic vs OpenRouter vs LinkModel Pricing

OpenRouter pricing and routes can change, so the applicable rate should be checked at the time of use.

The price comparison is useful, but it answers only one part of the buying decision.

What Should You Verify Before Paying for a Sonnet 5.5 API Provider?

Before committing production traffic or a significant budget, check the features that your application actually needs.

A 15% token discount is valuable only when the route supports the workflow you need.

This checklist is particularly important for coding agents and applications using prompt caching, thinking controls, or extensive tool interaction.

How to Evaluate LinkModel Before Scaling

A practical provider evaluation does not need to begin with a large benchmark.

Start with a small set of representative requests that reflect your application.

For each request, record the prompt size, generated output, cache usage where applicable, response quality, latency, errors, and actual charges.

Then compare those results with the same acceptance criteria used for the existing route.

If the application behaves comparably and billable token quantities remain similar, LinkModel's published rates provide a clear cost advantage.

For example, 100M fresh input tokens and 20M output tokens cost $340 at LinkModel's listed rates versus $400 at Anthropic's standard rates. That is a $60 difference before additional charges.

The next question is whether the actual integration and billing preserve the expected benefit.

You can review the model's current rate categories and available access details on LinkModel's Claude Sonnet 5.5 page.

How to Estimate Your Claude Sonnet 5.5 API Bill Before Paying

The most reliable way to budget for Sonnet 5.5 is to use your expected token mix, caching behavior, and retry rate—not a single average price per request.

A useful estimate should answer three questions: How much does a normal request cost? How much repeated context can be cached? How much extra usage results from failures and tool activity?

Step 1: Estimate Input and Output Usage

Start with a representative request.

Suppose an application uses 20K fresh input tokens and 2K output tokens.

At Anthropic's standard rates:

Input: 20,000 × $2 ÷ 1,000,000 = $0.04

Output: 2,000 × $10 ÷ 1,000,000 = $0.02

Total: $0.06 per request

At LinkModel's published rates:

Input: $0.034

Output: $0.017

Total: $0.051 per request

At 10,000 identical requests, the calculated token totals are $600 versus $510.

Step 2: Separate Cached and Uncached Tokens

If much of the input is reused, do not bill all input at the fresh-input rate in your estimate.

For example, a request containing 20K fresh input tokens, 80K cached-read tokens, and 2K output tokens has a different cost structure.

This example assumes the cache already exists and excludes its creation cost.

A realistic monthly budget should also account for cache writes, expiration, and unsuccessful reuse.

Step 3: Account for Retries and Failed Tasks

Suppose an application receives 10,000 user requests but requires 12,000 model calls because some tasks are retried.

If each model call costs $0.06, total token charges become $720, not the $600 implied by counting user requests alone.

At $0.051 per call, the corresponding LinkModel estimate is $612.

The additional calls matter regardless of provider.

For agentic applications, track the number of model calls per successful user task rather than assuming a one-to-one relationship.

Step 4: Reconcile Estimates Against Actual Usage

Before scaling, compare the expected bill with recorded usage.

Check whether the provider reports the token categories required for your calculation and whether additional fees apply.

If the observed bill differs from the estimate, investigate cache misses, output-token growth, repeated tool calls, retries, or pricing assumptions.

The strongest reason to choose a provider is not merely an attractive rate table—it is a rate advantage that holds up when measured against your own workload.

How to Reduce Claude Sonnet 5.5 API Costs in Production

Cost optimization works best when it targets the largest source of unnecessary spending.

For Sonnet 5.5, that usually means reducing repeated context, controlling output and reasoning, avoiding unsuccessful agent loops, and selecting an appropriate processing method.

Optimize Repeated Context Before Trimming Small Prompts

A 100K-token reference document reused repeatedly can create far more avoidable spending than a few hundred words of ordinary instructions.

Identify stable content, configure caching appropriately, and measure successful reuse.

When cache hits are reliable, the reduction in repeated-prefix charges can be substantial.

Match Reasoning Effort to Task Difficulty

Sonnet 5.5 supports adaptive thinking, with high effort as the default on the Claude Platform.

Higher effort may be valuable for difficult engineering tasks, but routine classification or straightforward extraction may not require the same level of reasoning.

Evaluate available settings using task quality, output usage, and latency together.

The objective is the lowest sustainable cost that still meets the required quality standard.

Set Limits on Agent Retries and Tool Loops

Agent workflows should have clear completion criteria and safeguards against repeated unsuccessful operations.

Monitor total model calls, tool calls, token usage, and failure recovery.

The Three.js development example illustrates why execution volume can dominate the cost of a single deliverable.

Reducing unnecessary loops can lower spending without requiring a different model.

Use Asynchronous Processing When Appropriate

For eligible background workloads, Anthropic's Batch API offers substantial input and output discounts.

It is useful when tasks can be completed asynchronously.

For interactive applications, prioritize response-time requirements and compare standard API routes using the same task set.

Frequently Asked Questions

Conclusion: Claude Sonnet 5.5 API Pricing and Real-World Value

Claude Sonnet 5.5 costs $2/M input and $10/M output through Anthropic, while LinkModel lists $1.70/M and $8.50/M, alongside 15% lower published cache rates. Prompt caching can dramatically reduce repeated-context charges, Anthropic's Batch API can halve eligible asynchronous token rates, and disciplined agent execution can prevent expensive retries. The development cases reinforce why cost per accepted result matters more than headline token prices alone. For developers already choosing Sonnet 5.5, LinkModel offers a concrete pricing advantage worth evaluating: estimate your actual token mix, confirm the API capabilities and billing terms your application requires, and compare a representative workload before committing a larger budget. Explore Claude Sonnet 5.5 on LinkModel to see the current rates and assess the potential savings.