Jump to a section
DIRECT ANSWER
How much does Anthropic API cost in 2026?
Anthropic API pricing is usage-based. On the first-party Standard API, Claude Opus 5.5 costs $4 input / $20 output per million tokens; Claude Sonnet 5.5 costs $2 / $10; and Claude Haiku 5.5 starts at $0.10 / $0.50 for requests with prompts of at most 100,000 tokens. Prompt caching, the Batch API, Fast mode and inference geography can change the actual bill.
Claude subscriptions such as Pro and Max are separate from API token usage. For your own workload, use the SXF cost calculator below rather than relying on a single headline price.
Prices verified November 8, 2026 from Anthropic's official pricing documentation. Rates can change; consult the original price list before procurement.
OFFICIAL PRICE BOOK
Anthropic API pricing table: Claude Opus, Sonnet, Haiku and Fable
Searches for Claude model pricing often show only two numbers. However, total API cost depends on five separate token categories: uncached input, output, cache writes lasting five minutes, cache writes lasting one hour and cache reads.
| Model | Input | Output | 5m write | 1h write | Cache read |
|---|---|---|---|---|---|
| Opus 5.5 | $4.00 | $20.00 | $5.00 | $8.00 | $0.20 |
| Sonnet 5.5 | $2.00 | $10.00 | $2.50 | $4.00 | $0.10 |
| Haiku 5.5 · prompt ≤100K | $0.10 | $0.50 | $0.125 | $0.20 | $0.01 |
| Haiku 5.5 · prompt >100K | $0.50 | $2.50 | $0.625 | $1.00 | $0.05 |
| Fable 5.1 | $10.00 | $50.00 | $12.50 | $20.00 | $0.25 |
Critical 2026 distinction: cache reads on Opus 5.5 and Sonnet 5.5 cost 5% of normal input, not the older universal 10% assumption. Haiku 5.5 uses 10%; Fable 5.1 uses 2.5%. For provider-level model specifications and release history, see the SXF Anthropic model portfolio. For many vendors side by side, use SXF’s AI pricing index.
What does MTok mean?
One million billable tokens, not one million words. A 1M-token context window is a capacity limit, not a monthly token allowance.
What about tokenizers?
Anthropic reports the newer tokenizer in Claude 4.7+ may produce approximately 30% more tokens from the same text than older versions, depending on the workload. Compare actual usage, not characters.
EXACT BILLING LOGIC
How to calculate Claude API pricing per request
To calculate a direct token-only cost, use mutually exclusive categories. Read tokens are not simultaneously ordinary input tokens.
Request token cost = (input × input_rate + output × output_rate + cache_write_5m × write_5m_rate + cache_write_1h × write_1h_rate + cache_read × cache_read_rate) / 1,000,000Example on Sonnet 5.5: 8,000 uncached input + 3,000 output + 20,000 cache-read tokens costs $0.016 + $0.030 + $0.002 = $0.048 for the request before separately billed tools.
Eligible Batch usage applies a 0.5 multiplier to token charges. Opus 5.5 Fast mode uses premium rates and cannot be used with Batch. US-only inference routing on eligible models applies a 1.1 multiplier to token pricing. For a complete bill, add external tools, retries and operating expenses.
Use the API's recorded usage.input_tokens, usage.output_tokens, usage.cache_read_input_tokens and usage.cache_creation_input_tokens (including 5m/1h components where provided). Do not infer a cache hit just because you sent cache_control.
ORIGINAL SXF INTERACTIVE TOOL
Claude API cost calculator: input, output, caching, Batch and model tiers
All calculations run in your browser. Enter hypothetical request counts or your observed usage and adjust the inputs. Haiku 5.5 automatically switches to the higher tier when the complete prompt exceeds 100K tokens—including cached tokens.
Claude price comparison for the same input workload
The table holds token assumptions and request volume constant, but model quality and tokenization can differ. When Fast is selected, Opus alone uses Fast rates.
| Model | Estimated monthly token cost | Rate tier |
|---|---|---|
| Sonnet 5.5 | Calculated in browser | Standard |
This model excludes external tool fees, tax, contract discounts, cloud providers, and production failures. For cross-provider estimates see the SXF AI Model Cost Calculator.
SEARCH INTENT: PROMPT CACHING PRICING
Claude prompt caching: five-minute writes, one-hour writes and read costs
Prompt caching stores a reusable prefix. With the Messages API, automatic or explicit cache_control can identify the stable content. A cacheable write costs more than ordinary input, but subsequent successful reads of the identical prefix are priced much lower. The default cache TTL is five minutes and is refreshed after qualifying hits; the extended TTL is one hour.
Five-minute cache write
Costs 1.25× the normal input rate. Best when the same prompt prefix appears again within a few minutes.
One-hour cache write
Costs 2× normal input. Consider when your real request gaps make a one-hour prefix materially more likely to be reused.
Cache reads on Sonnet / Opus 5.5
Cost 0.05× standard input. Fable 5.1 costs 0.025×; Haiku 5.5 costs 0.1×.
Cache misses invalidate shortcuts
Minimum prefix length, expired TTL, changed tools or system prompts, or altered thinking settings may prevent reuse. Measure hit tokens directly.
Cache lifetime starts when the request begins, not when it finishes. Parallel Batch work may have highly variable actual hit rates because calls execute concurrently. Read the official prompt caching specification.
ORIGINAL SXF MATH
When does Claude prompt caching become cheaper? Break-even analysis
Suppose P input tokens form an unchanged, cacheable prefix and are reused in N requests, with one initial write and successful later hits during the same TTL. For this calculation we exclude varying user prompts, outputs and all other costs.
Without cache = N × P × base_input_rateWith cache = P × (write_multiplier + (N−1) × read_multiplier) × base_input_rateFor Sonnet 5.5 or Opus 5.5, the read multiplier is 0.05. With a five-minute cache the total relative price is 1.25 + (N−1)×0.05: two requests cost 1.30 normal-price prefix units instead of 2.00. With a one-hour cache, the total is 2 + (N−1)×0.05: at two requests it costs 2.05 versus 2.00 (not cheaper), but at three it costs 2.10 versus 3.00.
Operational caution: a theoretically profitable cache can lose in practice if traffic is sparse, the prefix is too small, or actual cache hits are uncommon. The break-even result is conditional, not a performance promise.
SEARCH INTENT: ANTHROPIC BATCH DISCOUNT
Anthropic Batch API pricing: 50% lower rates for asynchronous work
Anthropic's Message Batches API processes large numbers of requests asynchronously. It is intended for background document extraction, classification, evaluations and bulk data processing—not user interactions requiring an immediate response. Official prices give eligible Batch usage a 50% reduction compared with normal token rates.
| Model | Standard input / output | Eligible Batch input / output |
|---|---|---|
| Opus 5.5 | $4 / $20 | $2 / $10 |
| Sonnet 5.5 | $2 / $10 | $1 / $5 |
| Haiku 5.5 (≤100K prompt) | $0.10 / $0.50 | $0.05 / $0.25 |
| Haiku 5.5 (>100K prompt) | $0.50 / $2.50 | $0.25 / $1.25 |
Batch and caching can stack, but cache hits are best-effort in concurrent work. Fast mode is not available in Batch. Compare acceptable completion time, error recovery and rate limits before choosing. See Anthropic's Message Batches documentation.
MOST OVERLOOKED EDGE CASE
Claude Haiku 5.5: the 100K-token pricing threshold can change the entire request
Haiku 5.5's headline input cost is $0.10/MTok, but when a request's entire prompt exceeds 100,000 input tokens, its input, output and cache-category rates all switch to the higher tier. The counted prompt includes uncached tokens, cache writes and cache reads. The higher price applies to the whole request, not just the excess tokens.
100,000 prompt tokens + 1,000 output
Using uncached input, the cost is $0.0105 ($0.010 input + $0.0005 output).
100,001 prompt tokens + 1,000 output
At the higher tier, cost is approximately $0.05250 ($0.0500005 input + $0.0025 output).
This threshold jump is a billing discontinuity, not a claim that a one-token-longer request performs differently. SXF's calculator applies it automatically by checking the sum of billable input-category tokens for each request.
ORIGINAL SXF COST LAB · V1.0
Three original Claude API cost simulations with reproducible assumptions
These examples are hypothetical token economics, not recorded API sessions or independent vendor benchmarks. They use source prices and explicit request shapes. Download the SXF scenario CSV and read our methodology and equations to reproduce every result.
100,000 classification requests per month
Assumption: each request has 2,500 uncached input tokens + 300 output tokens, no cache, retries or tool fees.
Haiku has the lowest listed token charge. This does not prove a cheaper cost per correct classification.
10,000 long coding-agent requests
Assumption: each request has 20,000 uncached input tokens + 6,000 output tokens. A request is not a completed coding task.
Higher-priced models may change tool-loop count or task acceptance; an actual decision requires a controlled test corpus.
1,000 Sonnet 5.5 calls sharing a 40K-token context
Assumption: one 40,000-token 5-minute cache write, followed by 999 successful hits before expiry; each request also uses 2,000 fresh input tokens and 1,000 output tokens.
Calculation: $0.10 first write + $3.996 in 999 reads + $4 of fresh input + $10 output = $18.096. Perfect hits are a deliberate mathematical upper-bound-style assumption—not a real-world hit-rate prediction.
SXF has created a reproducible computational model and input fixture here. We have not paid to execute these workloads or measured Claude model reliability. Never interpret the above as observed performance, product rankings or guaranteed budgets.
ORIGINAL SXF ECONOMICS
Cost per successful task: why cheap Claude API tokens can be expensive
A low token price is only one variable. An agent may require more retries, human review or tool calls when it fails. The useful unit is a verified accepted outcome rather than a single generated response.
Cost / accepted task = (model tokens + retries + tool charges + human review + operating overhead) / verified accepted tasksHypothetical demonstration: workflow A costs $0.02 per attempt and succeeds in 60% of cases; workflow B costs $0.04 and succeeds in 95%. Ignoring escalations, cost per accepted task is about $0.0333 versus $0.0421. If every failed A attempt triggers an additional $0.10 of human review, its simplified expected cost rises to ($0.02 + $0.40×$0.10) / 0.60 = $0.10 per accepted task; it is now more expensive despite cheaper API calls.
These percentages are invented to illustrate the decision boundary, not measured Claude accuracies. If the denominator is zero, the metric is undefined, never zero. Use SXF's 25-test agent evaluation protocol and our original agent reliability research to test actual acceptance.
MODEL SELECTION BY WORKLOAD
Claude Opus vs Sonnet vs Haiku: which costs less for your application?
Opus 5.5
Consider for complex coding, demanding long-horizon tool tasks and high-cost errors. Evaluate the accepted outcome rather than assuming premium always wins.
See SXF Opus specs ↗Sonnet 5.5
Good candidate to benchmark for a mix of reasoning, coding and production volume. Its 5% cache-read pricing is relevant to reusable context.
See SXF Sonnet specs ↗Haiku 5.5
Low short-prompt list rates are attractive for routing, extraction and categorization. Watch the 100K prompt tier and error-related costs.
See SXF Haiku specs ↗Fable 5.1
Higher premium rates require a workload-specific value case. Its cache-read multiplier differs from Sonnet and Opus.
See SXF Fable specs ↗For production traffic routing and failover, see the SXF LLM Gateway implementation guide. A valid benchmark compares equal task acceptance requirements, not identical word counts alone.
IMPLEMENTATION AND SOURCE EVIDENCE
How to use Claude API with cached prompts and record real token usage
Keep ANTHROPIC_API_KEY on your server. Version the system prompt and record actual API usage for every successful or failed request. The example below shows where to place an explicit cache marker. A real prefix must meet the model's minimum cacheable length before a hit can occur.
import anthropic
client = anthropic.Anthropic()
stable_prefix = "YOUR_LONG_REVIEWED_CONTEXT" # replace with real content
response = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=512,
system=[{
"type": "text",
"text": stable_prefix,
"cache_control": {"type": "ephemeral"},
}],
messages=[{"role": "user", "content": "Summarize ticket 493"}],
)
usage = response.usage
print({
"uncached_input": usage.input_tokens,
"output": usage.output_tokens,
"cache_read": usage.cache_read_input_tokens,
"cache_write": usage.cache_creation_input_tokens,
})This short example is not itself long enough to demonstrate a cache hit. In production, keep tool schemas, model settings and stable prefix identical as needed. Inspect the cache creation breakdown when separating five-minute from one-hour writes. See the Messages usage schema and SXF's observability reference.
WHAT THE HEADLINE PRICE EXCLUDES
Anthropic API pricing vs Claude Pro, Fast mode, data residency and tools
- Claude chat subscriptions: Pro and Max subscriptions do not mean unlimited or prepaid Claude API tokens.
- Opus 5.5 Fast: official premium rates are $8 input/$40 output per MTok, with cache multipliers on top; Fast is not eligible for Batch.
- US-only inference: eligible first-party Claude models apply a 1.1× token-price multiplier for the US-only geography.
- Cloud providers: Bedrock, Google Cloud and other partner-operated options have their own rate cards and regional billing differences. This article calculates first-party prices only.
- Server tools: Web search, web fetch, code/Bash and some other tools may add billed fees or prompt-token overhead.
- Reprocessing: retries, errors, human escalations and tool-loop steps can make the total bill larger than a single request estimate.
- Tokenizer changes: a fixed English-text word count does not yield identical token counts across models and versions.
Before committing a budget, capture your provider, model ID, exact pricing mode, contract discounts, request length distribution, measured cache hit rate, latency constraints and downstream acceptance criteria. See SXF's full agent TCO study.
DIRECT QUESTIONS FROM SEARCH
Anthropic Claude API pricing FAQ
What is Anthropic API pricing in 2026?
It is usage-based billing by model and token type, not one monthly plan. First-party Opus 5.5 costs $4/$20, Sonnet 5.5 $2/$10, and Haiku 5.5 starts at $0.10/$0.50 per million input/output tokens, with special pricing rules.
How much is Claude Sonnet 5.5 API per million tokens?
Standard input tokens cost $2 and output tokens $10 per million. Five-minute cache writes cost $2.50, one-hour writes $4, and cache reads $0.10 per million tokens.
How much is Claude Opus 5.5 API?
Standard Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens. Its 5-minute cache write costs $5, 1-hour write $8, cache read $0.20, and Fast mode has premium prices.
Is Claude Haiku 5.5 pricing always $0.10 per million input tokens?
No. For a request whose prompt exceeds 100,000 tokens including cached input, Haiku 5.5 moves to $0.50 input and $2.50 output per million tokens, and that tier applies to the entire request.
Does Claude prompt caching reduce Anthropic API cost?
It can. A five-minute cache write costs 1.25 times normal input, a one-hour write 2 times, and later cache reads can be much cheaper. Benefits require cacheable stable prompts and actual hits.
What is Anthropic Batch API pricing?
Eligible asynchronous Message Batches usage receives a 50 percent discount on token charges. Caching can stack with Batch, but hit rates may vary and Batch cannot use Fast mode.
Is Claude API free with Claude Pro or Max?
No. Claude app subscriptions and usage-based Claude API billing are separate products. Check your Anthropic account and API payment terms.
How can I measure the cost of a Claude API request?
Read actual uncached input, output, cache-write and cache-read usage fields; multiply each by its own per-million-token price and apply only eligible modifiers. Include tool fees and retries in total cost.
Which Claude model is cheapest for business agents?
Haiku has the lowest published list rates at short prompt sizes, but the cheapest accepted business outcome depends on reliability, retries, human review, tools, and total task completion rates.
SOURCE CHAIN AND TRANSPARENCY
Primary sources and SXF original methodology
SXF original work: the deterministic calculator, break-even derivation, hypothetical request examples and reproducible CSV. Not performed: paid model testing, independent acceptance-rate measurement, production cache hit-rate observation or customer invoice auditing.
- Anthropic official API pricingStandard and special model rates
- Anthropic prompt cachingTTL and read/write multipliers
- Anthropic Message Batches50% discount and cache caveats
- Claude Opus 5.5 modelPublished model capabilities and prices
- Claude Sonnet 5.5 modelPublished model capabilities and prices
- Claude Haiku 5.5 modelModel tier and specifications
- Messages API usage fieldsInput, output and cached token accounting
Download the calculation protocol and CSV inputs. All prices were checked November 8, 2026; verify live documentation before financial decisions. See SXF editorial standards.
RESEARCH NETWORK · SXF / AI