Claude API Pricing: Cost per Token for Every Model (2026)
Claude API pricing in November 2026: per-token prices for Fable, Opus, Sonnet and Haiku, caching and batch discounts, tool fees, and real monthly cost examples.
By AI Tool Verdicts Editorial Team · Published
Bottom line: Sonnet 5.5 at $2 in and $10 out per million tokens is the default for most apps. Use Haiku 5.5 for high-volume simple work, cache your system prompt, and batch anything that can wait.
Claude API pricing is per million tokens, with no subscription. As of November 2026, Haiku 5.5 costs $0.10 for input and $0.50 for output, Sonnet 5.5 costs $2 and $10, Opus 5.5 costs $4 and $20, and Fable 5.1 costs $10 and $50. Output always costs five times input.
Two discounts change the real bill more than the model choice. Prompt caching makes repeated input up to 40 times cheaper, and the Batch API halves everything for jobs that can wait a few hours.
How we researched this: Anthropic's API pricing docs, rate limits docs, batch and token counting docs, and claude.com/pricing, checked November 2, 2026. The monthly cost examples are our own math from those list prices.
Claude API pricing per model
All prices are in US dollars per million tokens (MTok), for the current models:
| Model | Input | Cache write (5 min) | Cache write (1 hour) | Cache read | Output |
|---|---|---|---|---|---|
| Haiku 5.5 (prompt up to 100K) | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
| Haiku 5.5 (prompt over 100K) | $0.50 | $0.625 | $1 | $0.05 | $2.50 |
| Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 |
| Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 |
| Fable 5.1 | $10 | $12.50 | $20 | $0.25 | $50 |
Older models are still on the price list, and some cost more than their replacements. Opus 4.5 to 4.8 and Opus 5 cost $5 and $25, Sonnet 4.5 and 4.6 cost $3 and $15, and Haiku 4.5 costs $1 and $5. If your app still points at one of those, moving to the 5.5 version is a price cut as well as an upgrade.
Mythos 5.1 has the same price as Fable 5.1, but Anthropic only offers it to verified organizations.
What does a Claude token cost in practice?
A token is a piece of a word. Anthropic's glossary says a token was about 3.5 English characters on earlier models. Claude 4.7 and later use a newer tokenizer that produces about 30% more tokens for the same text.
By our estimate, that makes 1,000 English words about 2,200 tokens on current models. In cost terms:
| 1,000 words of English | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 | Fable 5.1 |
|---|---|---|---|---|
| As input | $0.0002 | $0.0044 | $0.0088 | $0.022 |
| As output | $0.0011 | $0.022 | $0.044 | $0.11 |
For an exact count, the token counting endpoint is free. Pass the model ID you'll actually use, since the count differs between tokenizers.
One more hidden cost: tool definitions. When you give Claude tools, the API adds a system prompt of about 286 tokens on the 5.5 models, plus the length of your tool schemas. Computer use adds about 4,500 tokens per request.
Is there a long-context surcharge?
Not on most models. Opus 5.5, Sonnet 5.5, Fable 5.1 and every model from Claude 4.6 onward include the full 1M-token context window at standard prices. Anthropic's docs say a 900K-token request costs the same per token as a 9K-token one.
The exception is Haiku 5.5. When a prompt goes over 100,000 tokens, including cached tokens, the whole request is billed at the higher rate in the table. Each request is priced on its own.
How prompt caching cuts the bill
If your requests repeat a long prefix, such as a system prompt, documents or a conversation history, you can cache it. Writing to the cache costs a bit more than normal input. Reading from it costs far less.
| Cache operation | Price vs normal input |
|---|---|
| Write, 5-minute cache | 1.25x |
| Write, 1-hour cache | 2x |
| Read, Sonnet 5.5 and Opus 5.5 | 0.05x |
| Read, Fable 5.1 | 0.025x |
| Read, Haiku 5.5 and older models | 0.1x |
Anthropic's rule of thumb is that the 5-minute cache pays off after a single read, and the 1-hour cache after two. A cached read on Sonnet 5.5 costs $0.10 per million tokens instead of $2.
Caching also helps with rate limits. For most models, cache reads don't count toward your input tokens per minute.
Batch API: 50% off
The Batch API halves input and output prices in exchange for waiting. Most batches finish within an hour, and every batch finishes or expires within 24 hours. Each batch can hold up to 100,000 requests.
| Model | Batch input | Batch output |
|---|---|---|
| Haiku 5.5 (up to 100K) | $0.05 | $0.25 |
| Sonnet 5.5 | $1 | $5 |
| Opus 5.5 | $2 | $10 |
| Fable 5.1 | $5 | $25 |
Batch and caching discounts stack. Cache hits inside a batch are best-effort, though, because requests run in any order. Batch results are kept for 29 days.
Tool, region and speed charges
These come on top of token prices:
- Web search: $10 per 1,000 searches. Failed searches aren't billed.
- Web fetch: no extra fee, only the tokens of the page you fetch. Anthropic estimates a 10 KB page at about 2,500 tokens.
- Code execution: free when used with the current web search or web fetch tools. Otherwise each organization gets 1,550 free container hours a month, then $0.05 per hour.
- US-only inference: setting
inference_geoto US costs 1.1x on every token type. - Fast mode (Opus only): Opus 5.5 at $8 input and $40 output, double the standard price, for up to 2.5x faster output. It doesn't work with the Batch API.
- Managed Agents: $0.08 per session hour while running, plus tokens.
Real Claude API cost examples
These use the list prices above. Your token counts will differ, but the ratios hold.
A support chatbot
Say 10,000 conversations a month, each with 6,000 input tokens and 1,200 output tokens across a few turns. That's 60M input and 12M output tokens.
| Model | No caching | With a cached 4,000-token system prompt |
|---|---|---|
| Haiku 5.5 | $12 | about $8.40 |
| Sonnet 5.5 | $240 | about $164 |
| Opus 5.5 | $480 | about $328 |
The cached column assumes 40M of the input tokens are cache reads, and leaves out the small cost of cache writes. Output is most of the bill once caching is on, so keeping replies short saves more than switching models.
Summarizing 1,000 long documents
Each document is about 20,000 input tokens, with a 500-token summary. That's 20M input and 0.5M output tokens.
| Model | Standard | Batch API |
|---|---|---|
| Haiku 5.5 | $2.25 | $1.13 |
| Sonnet 5.5 | $45 | $22.50 |
| Opus 5.5 | $90 | $45 |
Summaries rarely need an instant answer, so this is the textbook case for the Batch API.
A coding agent
Agents resend their whole context with every step, so they burn far more tokens than chat. In our Claude Code pricing guide, one medium coding task of about 30 requests works out to roughly $0.99 on Sonnet 5.5 and $1.98 on Opus 5.5, with caching on. Two hundred such tasks a month cost about $200 on Sonnet 5.5.
Rate limits and monthly spend limits
Anthropic places every API organization in a usage tier based on its usage history and account standing. New accounts may start in a lower Evaluation tier. Each tier has a monthly spend cap:
| Tier | Monthly spend cap | Requests per minute (Sonnet 5.5) | Input tokens per minute (Sonnet 5.5) |
|---|---|---|---|
| Start | $500 | 4,000 | 2M |
| Build | $1,000 | 10,000 | 5M |
| Scale | $200,000 | 13,000 | 10M |
| Custom | No cap | Custom | Custom |
Figures are from Anthropic's rate limits docs. When you hit your tier's cap, the API pauses until 00:00 UTC on the first of the next month. To raise it, request a tier increase from the limits page in the Claude Console.
You can also set your own lower limit, which we'd do on any new project. Open Billing in the Claude Console, find Spend limits, and choose Set limit. Workspaces can have their own limits too.
Claude API vs a Claude subscription
The API is billed separately from Claude Pro and Max. A subscription doesn't give you API access, and API credit doesn't pay for the Claude apps. Some higher plans include monthly API credits; our Claude pricing guide lists what each plan includes.
For coding, a subscription is usually far cheaper than paying per token, as long as you stay within its limits. Our guide to whether Claude Code is free covers the cheapest ways to try it on an API key.
Claude API pricing on AWS, Google Cloud and Azure
Microsoft Foundry and Claude Platform on AWS bill the same per-token rates as Anthropic's API, through each cloud's billing. Amazon Bedrock and Google Vertex AI set their own prices, so check their pricing pages. Anthropic notes that regional endpoints there cost 10% more than global ones for current models.
How to keep Claude API costs down
- Start on Sonnet 5.5. Move simple, high-volume steps to Haiku 5.5, and use Opus 5.5 only where Sonnet measurably fails. Our Opus 5.5 vs Fable 5.1 vs Sonnet 5.5 comparison helps you choose.
- Cache anything you send more than once, starting with the system prompt.
- Send work that can wait to the Batch API.
- Cap
max_tokensand ask for short answers. Output is the most expensive token type. - Keep Haiku 5.5 prompts under 100,000 tokens to stay on its cheap rate.
- Set a spend limit in the Console before you launch anything public.
FAQ
How much does the Claude API cost per token?
As of November 2026, input costs $0.10 to $10 per million tokens and output $0.50 to $50, depending on the model. Sonnet 5.5, the usual default, is $2 input and $10 output per million tokens, so one token costs $0.000002 in and $0.00001 out.
Is the Claude API free?
No. New accounts get a small amount of free credit to test with, but Anthropic doesn't state the amount. After that you pay per token. Token counting itself is free.
What is the cheapest Claude API model?
Haiku 5.5, at $0.10 input and $0.50 output per million tokens for prompts up to 100,000 tokens. With the Batch API it drops to $0.05 and $0.25.
Does Claude Pro include API access?
No. Claude Pro covers the Claude apps and Claude Code. The API is a separate, pay-per-token account in the Claude Console.
How do I see my Claude API usage?
The Usage page in the Claude Console shows tokens and spend by model, workspace and API key. Each API response also returns the exact input, output and cache tokens used for that request.