Claude API Pricing: What You Actually Pay
The Claude API charges per token: roughly a word or part of a word. You pay one rate for what you send (input) and a higher rate for what Claude writes back (output).
That sounds simple, but the real bill depends on more than the headline price: which model you use, whether you cache repeated prompts, whether you can wait for batch results, and how much the model thinks before answering.
This guide lists every current price from Anthropic's official pricing page, explains each modifier, and walks through real cost examples.
🎯 Quick Answer (30-Second Read)
- Base prices (per million tokens, input / output): Haiku 5.5 $0.10 / $0.50 · Sonnet 5.5 $2 / $10 · Opus 5.5 $4 / $20 · Fable 5.1 $10 / $50
- Prompt caching: reading a cached prompt costs a fraction of normal input (for example $0.10/MTok on Sonnet 5.5 instead of $2)
- Batch API: 50% off input and output for jobs that can wait
- Long context: the full 1M-token window is billed at standard rates, except Haiku 5.5 above 100K tokens
- Thinking tokens count as output, so lower effort means lower bills
- Biggest savings: caching and batching often beat switching to a cheaper model
Claude API Prices by Model
All prices are in USD per million tokens (MTok).
| Model | Input | Output | Cache write (5 min) | Cache write (1 hour) | Cache read (hit) |
|---|---|---|---|---|---|
| Claude Fable 5.1 | $10 | $50 | $12.50 | $20 | $0.25 |
| Claude Opus 5.5 | $4 | $20 | $5 | $8 | $0.20 |
| Claude Sonnet 5.5 | $2 | $10 | $2.50 | $4 | $0.10 |
| Claude Haiku 5.5 (prompts ≤100K tokens) | $0.10 | $0.50 | $0.125 | $0.20 | $0.01 |
| Claude Haiku 5.5 (prompts >100K tokens) | $0.50 | $2.50 | $0.625 | $1 | $0.05 |
Which model for what: Anthropic recommends Opus 5.5 as the default for most workloads, Sonnet 5.5 for speed and lower cost, Haiku 5.5 for high-volume tasks like classification and routing, and Fable 5.1 for the hardest reasoning. See Claude Models Explained for a full comparison.
Every Pricing Modifier Explained
Prompt caching
If many requests share the same long prefix, such as a system prompt, instructions or a document, you can cache it.
- The first request pays a cache write (1.25× input for 5 minutes, 2× for 1 hour).
- Later requests that reuse it pay a cache read: 10% of the input price on most models, 5% on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.1.
A 5-minute cache pays for itself after a single cache read. For chatbots and agents that resend the same instructions every turn, caching is usually the biggest saving.
Batch API: 50% off
Send requests asynchronously and get results back later (within 24 hours) at half price:
| Model | Batch input | Batch output |
|---|---|---|
| Fable 5.1 | $5 | $25 |
| Opus 5.5 | $2 | $10 |
| Sonnet 5.5 | $1 | $5 |
| Haiku 5.5 (≤100K) | $0.05 | $0.25 |
Batching suits reports, bulk tagging, evaluations and content pipelines. Batch and caching discounts stack.
Long context
All current models have a 1M-token context window. For Claude 4.6 and later models, the full window is billed at standard rates, so a 900K-token request costs the same per token as a 9K-token one. The exception is Haiku 5.5, where prompts over 100,000 tokens cost 5× more.
Fast mode (Opus 5.5)
Fast mode, in research preview, gives significantly faster output on Opus 5.5 at $8 input / $40 output per MTok, twice the standard price. It's available on the Claude API only and can't be combined with the Batch API.
US-only inference
On Claude 4.6 and later models, choosing US-only inference (the inference_geo setting) adds a 1.1× multiplier to all token prices. Default global routing uses standard pricing.
Tools
Some server-side tools charge extra. For example, web search costs $10 per 1,000 searches, plus the tokens for the results.
Thinking tokens
Current models think before answering, and thinking tokens are billed as output. The effort setting (low to max) controls how much thinking happens, so lower effort means faster and cheaper responses.
Worked Example: A Support Chatbot
A chatbot handles 10,000 conversations a month. Each request sends 3,000 input tokens (including a 2,000-token system prompt that never changes) and gets 500 output tokens back.
On Sonnet 5.5 without caching:
- Input: 30M tokens × $2 = $60
- Output: 5M tokens × $10 = $50
- Total: ~$110/month
On Sonnet 5.5 with the system prompt cached:
- Cached reads: 20M tokens × $0.10 = $2
- Uncached input: 10M tokens × $2 = $20
- Output: 5M tokens × $10 = $50
- Total: ~$72/month (plus small cache-write costs whenever the cache refreshes)
That's roughly 35% less from one change. Output now dominates the bill, so the next lever is shorter answers or lower effort.
The same workload on other models (with caching):
| Model | Approx. monthly cost |
|---|---|
| Haiku 5.5 | ~$3.70 |
| Sonnet 5.5 | ~$72 |
| Opus 5.5 | ~$144 |
| Fable 5.1 | ~$355 |
Calculated from list prices. Excludes cache-write costs and extra thinking tokens, which raise real bills.
How to Estimate and Track Your Tokens
- Measure before you build. The API has a token-counting endpoint (
count_tokens) that tells you how many tokens a prompt uses. - Read the usage field on every response. It reports input, output and cache tokens:
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY
response = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Summarise our refund policy in 3 bullet points."}],
)
u = response.usage
print("input:", u.input_tokens, "output:", u.output_tokens,
"cache read:", u.cache_read_input_tokens)- Log it per feature. Multiply by the price table above to see which feature costs the most.
How to Cut Your Claude API Bill
| Lever | Typical effect | Effort to implement |
|---|---|---|
| Cache repeated prompts | Large input savings | Low |
| Batch non-urgent jobs | 50% off | Low to medium |
Lower effort |
Fewer thinking tokens | Very low |
| Shorter outputs | Output is the expensive side | Low |
| Right-size the model | Up to 100× between tiers | Medium (test quality first) |
| Keep Haiku prompts under 100K | Avoids 5× long-context rate | Low |
Try them in roughly that order. Model switching saves the most per token, but it's the only lever that risks quality.
Limitations and Things to Watch
- Prices change. Always confirm on Anthropic's pricing page before budgeting.
- Thinking and tool use add tokens beyond what simple maths predicts.
- Cloud marketplaces price separately. Amazon Bedrock and Google Cloud Vertex AI publish their own Claude pricing.
- Claude.ai subscriptions are separate from API billing. A chat subscription doesn't cover API usage.
Frequently Asked Questions
How much does the Claude API cost?
It depends on the model. Per million tokens, Haiku 5.5 costs $0.10 input and $0.50 output, Sonnet 5.5 costs $2 and $10, Opus 5.5 costs $4 and $20, and Fable 5.1 costs $10 and $50. Prompt caching and the Batch API (50% off) can reduce these significantly.
What is the cheapest way to use the Claude API?
Use Haiku 5.5 for simple, high-volume tasks, cache any repeated prompt prefix, and send non-urgent work through the Batch API at half price. Keep Haiku prompts under 100,000 tokens to avoid its higher long-context rate, and use low effort where deep reasoning isn't needed.
How does Claude prompt caching pricing work?
The first request that stores a prompt prefix pays a cache write (1.25× the input price for 5 minutes, or 2× for 1 hour). Later requests that reuse it pay a cache read: 10% of input on most models, 5% on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.1. A 5-minute cache pays off after one read.
Is the 1M context window more expensive?
For Claude 4.6 and later models, no. The full 1M-token window is billed at standard rates, so long requests cost the same per token as short ones. The exception is Haiku 5.5, where prompts over 100,000 tokens are billed at 5× the normal rate.
Do thinking tokens cost extra?
Thinking tokens are billed as output tokens at the model's normal output price. They're not a separate fee, but they add to the bill. The effort setting controls how much the model thinks: lower effort means fewer thinking tokens, faster responses and lower cost.
Conclusion
Claude API pricing starts with four per-token rates, but caching, batching and effort decide what you actually pay. For most apps, the order is: cache repeated prompts, batch what can wait, tune effort and output length, and only then test a cheaper model.
Sources
- Claude pricing, Anthropic docs: all token prices, cache, batch, long-context, fast mode, data residency and web search pricing
- Claude models overview, Anthropic docs: model recommendations and context windows
- Prompt caching, Anthropic docs
Prices verified: 14 October 2026.
Related reads: Claude Models Explained · Claude Code CLI Tutorial · Complete Claude Guide · Vector Databases Explained · RAG Explained
I write about AI dev tools and how real products are built. Follow on LinkedIn or X, or invite me to speak.