Claude API pricing: every model, cache and batch rate
Claude API prices run from $0.10/$0.50 per million tokens (Haiku 5.5) to $10/$50 (Fable 5.1). Caching and batch cut bills by half or more. October 2026.
Anthropic charges for the Claude API per million tokens (MTok), with separate prices for input and output. As of October 31, 2026, the current models cost $0.10 input and $0.50 output per MTok for Claude Haiku 5.5, $2 and $10 for Sonnet 5.5, $4 and $20 for Opus 5.5, and $10 and $50 for Fable 5.1. Prompt caching cuts the price of repeated input by 90% to 97.5%, and the Batch API halves both input and output, so a real monthly bill is often less than half of what the list price suggests.
We haven’t run workloads on the Claude API ourselves. Every price below comes from Anthropic’s pricing documentation and its claude.com pricing page, both read October 31, 2026, and matches AskGPU’s model data (checked October 25, 2026). The monthly bills are our own arithmetic from those published rates, using token counts we state for each example.
How much does the Claude API cost per million tokens?
Anthropic lists these prices for its current models. “Cache hit” is the price of input read back from the prompt cache.
| Model | Input | Output | 5-min cache write | 1-hour cache write | Cache 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 up to 100,000 tokens) | $0.10 | $0.50 | $0.125 | $0.20 | $0.01 |
| Claude Haiku 5.5 (prompts over 100,000 tokens) | $0.50 | $2.50 | $0.625 | $1 | $0.05 |
All prices in US dollars per million tokens. Source: Anthropic pricing docs, read October 31, 2026.
Older models are still on sale at their own prices:
| Older model | Input | Output | Cache hit |
|---|---|---|---|
| Claude Fable 5 | $10 | $50 | $1 |
| Claude Opus 5, 4.8, 4.7, 4.6 and 4.5 | $5 | $25 | $0.50 |
| Claude Sonnet 5 | $2 | $10 | $0.20 |
| Claude Sonnet 4.6 and 4.5 | $3 | $15 | $0.30 |
| Claude Haiku 4.5 | $1 | $5 | $0.10 |
Anthropic’s page marks Opus 4.1, Opus 4, Sonnet 4 and Haiku 3.5 as retired on its own API, though some remain on Amazon Bedrock or Google Cloud. Claude Mythos 5 and 5.1 carry the same prices as Fable 5 and Fable 5.1 but are limited to organizations verified through Anthropic’s programs, such as its Cyber Verification Program.
Two pricing notes on the page are worth knowing:
- Sonnet 5’s launch price is now permanent. Anthropic says the $2/$10 price “announced at launch as introductory pricing through August 31, 2026, is now the standard price,” and the planned rise to $3/$15 “will not occur.”
- Opus 5.5 is cheaper than the Opus models before it. It lists at $4/$20, against $5/$25 for Opus 5 and 4.8.
For a quick estimate with your own token counts, use the AI token cost calculator.
What is the cheapest Claude model?
Claude Haiku 5.5 is the cheapest by far: $0.10 per million input tokens and $0.50 per million output tokens, as long as the prompt is 100,000 tokens or less. That is one twentieth of Sonnet 5.5’s price and one fortieth of Opus 5.5’s.
Haiku 5.5 is also the only current model priced by prompt length. Anthropic says a request whose prompt is over 100,000 tokens pays the higher rates ($0.50 input, $2.50 output) for the whole request, and that the count includes cache reads and cache writes. The jump is a cliff, not a sliding scale:
- A 99,000-token prompt with a 2,000-token answer: 0.099 × $0.10 + 0.002 × $0.50 = $0.0109
- A 150,000-token prompt with the same answer: 0.15 × $0.50 + 0.002 × $2.50 = $0.08
The second request is about 1.5 times longer and costs about 7 times as much. If your app sends long documents to Haiku 5.5, splitting them below 100,000 tokens keeps them on the lower rate.
Every other current model includes its full 1M-token context window at the standard price. Anthropic’s example: “A 900k-token request is billed at the same per-token rate as a 9k-token request.”
Our model pages have more detail on Claude Opus 5.5 and Claude Sonnet 5.5.
How does prompt caching lower the bill?
Prompt caching stores the start of a prompt, such as a long system prompt, a product manual or a codebase, so later requests can read it back cheaply. Anthropic prices it as multiples of the base input price:
| Cache operation | Price | How long it lasts |
|---|---|---|
| 5-minute cache write | 1.25x base input | 5 minutes |
| 1-hour cache write | 2x base input | 1 hour |
| Cache hit (read) | 0.1x base input on most models; 0.05x on Opus 5.5 and Sonnet 5.5; 0.025x on Fable 5.1 and Mythos 5.1 | Same as the write it reads |
Anthropic says a cache hit also refreshes the cache. With the standard 0.1x read price, caching “pays off after one cache read for the 5-minute duration (1.25x write), or after two cache reads for the 1-hour duration (2x write).” On Opus 5.5 and Sonnet 5.5, where a read costs only 5% of input, the savings are larger.
There are two ways to switch it on, per the docs: automatic caching, with one cache_control field at the top of the request, or explicit breakpoints on individual content blocks.
Caching only helps with input that repeats. Output is never cached, so a model that writes long answers stays expensive whatever you do with the prompt.
What does the Batch API save?
The Batch API processes requests asynchronously “with a 50 percent discount on both input and output tokens.” Batch prices for the current models:
| Model | Batch input | Batch output |
|---|---|---|
| Claude Fable 5.1 | $5 | $25 |
| Claude Opus 5.5 | $2 | $10 |
| Claude Sonnet 5.5 | $1 | $5 |
| Claude Haiku 5.5 (prompts up to 100,000 tokens) | $0.05 | $0.25 |
| Claude Haiku 5.5 (prompts over 100,000 tokens) | $0.25 | $1.25 |
Anthropic says batch and caching discounts “can be combined,” and that caching multipliers stack with the batch discount. Batch suits work nobody is waiting on: overnight summaries, classifying a backlog of tickets, generating product descriptions. It doesn’t suit chat, where a user expects an answer in seconds. The pricing page doesn’t state a turnaround time.
What does a month of Claude API use cost? Three examples
These are hypothetical workloads. The token counts are our assumptions; the rates are Anthropic’s.
Example 1: a customer support bot, 20,000 replies a month. Each request sends a 3,000-token system prompt plus 500 tokens of conversation and gets a 300-token reply.
Without caching, input is 20,000 × 3,500 = 70M tokens and output is 20,000 × 300 = 6M tokens:
| Model | Input cost | Output cost | Monthly total |
|---|---|---|---|
| Haiku 5.5 | 70 × $0.10 = $7 | 6 × $0.50 = $3 | $10 |
| Sonnet 5.5 | 70 × $2 = $140 | 6 × $10 = $60 | $200 |
| Opus 5.5 | 70 × $4 = $280 | 6 × $20 = $120 | $400 |
With a 1-hour cache on the system prompt, assume the cache is rewritten once an hour (720 writes a month, 2.16M tokens) and every other request reads it (19,280 × 3,000 = 57.84M tokens). The 500 conversation tokens per reply (10M a month) stay at the normal rate. On Sonnet 5.5:
- Cache writes: 2.16 × $4 = $8.64
- Cache reads: 57.84 × $0.10 = $5.78
- Uncached input: 10 × $2 = $20
- Output: 6 × $10 = $60
- Total: about $94.42 a month, down from $200
The same arithmetic gives about $188.85 on Opus 5.5 (from $400) and about $5.01 on Haiku 5.5 (from $10). In every case output becomes the biggest line, which is why a shorter reply limit saves more than any other setting once caching is on.
Example 2: a document summarizer run as a batch. 2,000 documents a month, 20,000 tokens each, with a 1,000-token summary: 40M input and 2M output tokens.
| Model | Standard API | Batch API |
|---|---|---|
| Haiku 5.5 | 40 × $0.10 + 2 × $0.50 = $5 | $2.50 |
| Sonnet 5.5 | 40 × $2 + 2 × $10 = $100 | $50 |
| Opus 5.5 | 40 × $4 + 2 × $20 = $200 | $100 |
Example 3: one developer using an agent for coding. Assume 40M input tokens a month, of which 4M are written to the 5-minute cache and 36M are cache reads, plus 1.5M output tokens.
- Opus 5.5: 4 × $5 + 36 × $0.20 + 1.5 × $20 = $20 + $7.20 + $30 = $57.20
- Sonnet 5.5: 4 × $2.50 + 36 × $0.10 + 1.5 × $10 = $10 + $3.60 + $15 = $28.60
Anthropic’s own docs give a smaller unit for agents: a one-hour Claude Managed Agents session on Opus 5.5 with 50,000 input and 15,000 output tokens costs $0.58, including $0.08 of session runtime, or $0.428 when 40,000 of the input tokens are cache reads.
What extra fees are on top of tokens?
Tokens are most of the bill, but Anthropic lists several add-ons:
| Item | Price |
|---|---|
| Web search tool | $10 per 1,000 searches, plus tokens for the results |
| Web fetch tool | No extra charge beyond tokens |
| Code execution (without web search or fetch) | 1,550 free hours per organization per month, then $0.05 per hour per container; 5-minute minimum |
| Code execution with web search or web fetch | Free beyond tokens (with the 2026-02-09 or later tool versions) |
| Claude Managed Agents session runtime | $0.08 per session-hour while running |
US-only inference (inference_geo: "us") |
1.1x on all token prices, Claude 4.6 and later models |
| Fast mode, Opus 5.5 | $8 input, $40 output per MTok |
| Fast mode, Opus 5 and Opus 4.8 | $10 input, $50 output per MTok |
Tools also add input tokens. Anthropic lists a hidden tool-use system prompt of 286 tokens on Opus 5.5, Sonnet 5.5 and Haiku 5.5 whenever tools are provided, 974 tokens for the text editor tool on newer models, and about 4,500 tokens for the computer use toolset. These are small per request but add up over millions of calls.
Fast mode can’t be combined with the Batch API.
Is the Claude API free, and can a subscription replace it?
The API has no free plan. Anthropic’s FAQ says “New users receive a small amount of free credits to test the API,” without giving an amount. Billing is based on monthly usage, in US dollars, by credit card, with invoicing for enterprise customers.
A Claude chat subscription is a separate product with its own usage limits, not API access. But the claude.com pricing page, read October 31, 2026, shows some plans now include API credits:
| Plan | Price | Monthly API credits |
|---|---|---|
| Pro | $20 a month, or $17 a month billed annually ($200 up front) | None |
| Max | $100 a month | $100 |
| Ultra | $200 a month | $200 |
| Team, standard seat | $20 per seat a month billed annually, $25 monthly | Pooled, up to $500 a month per team |
| Team, premium seat | $100 per seat a month billed annually, $125 monthly | Pooled, up to $500 a month per team |
Using Example 3, a solo developer whose API use runs about $57 a month on Opus 5.5 would have it covered by Max’s $100 of API credits, with the chat and Claude Code allowance on top. Someone who only needs the API and spends $20 a month is better off paying for tokens directly. Our report on API credits in Max and Team has the terms from when the credits launched, and the ChatGPT, Gemini and Claude plan comparison covers the chat plans.
How do Claude’s prices compare with OpenAI and Google?
At list price, from AskGPU’s model data (checked October 25, 2026):
| Model | Input | Output | Cached input |
|---|---|---|---|
| Claude Sonnet 5.5 | $2 | $10 | $0.10 |
| Gemini 4 Argon | $2 | $10 | $0.10 |
| GPT-6.1 Sol | $2 | $10 | $0.10 |
| Claude Haiku 5.5 (up to 100K-token prompts) | $0.10 | $0.50 | $0.01 |
| GPT-6 Luna | $0.10 | $0.50 | $0.01 |
| Claude Fable 5.1 | $10 | $50 | $0.25 |
| GPT-6 Astra | $10 | $50 | $1 |
At the middle tier the three list the same per-token prices, so the real difference is how many tokens each model uses for your text and your task. Anthropic says Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text” than Sonnet 4.6 and earlier. Anthropic’s models overview puts 1M tokens at roughly 555,000 words on the current tokenizer, against about 750,000 words on models before it. A rough comparison: text that is 1M tokens on Sonnet 4.6 ($3 input) would be about 1.3M tokens on Sonnet 5.5, or about 1.3 × $2 = $2.60, so the newer model still costs less for the same text. Anthropic says the exact increase depends on the content, so count tokens with its token-counting endpoint before you budget.
What to watch for
- The Haiku 5.5 100,000-token threshold. One long prompt moves the whole request to rates five times higher.
- The tokenizer change. Moving from a Claude 4.6-or-earlier model to a newer one changes the token count for the same text by about 30%, so old usage figures won’t carry over.
- Cache expiry. A 5-minute cache that expires between requests is written again at 1.25x. Low-traffic apps may do better with the 1-hour cache.
- Data residency. US-only inference adds 10% to every token price on Claude 4.6 and later.
- Cloud marketplaces price differently. On Amazon Bedrock and Google Cloud (Google managed), regional and multi-region endpoints carry a 10 percent premium over global endpoints, and those clouds set their own regional prices. Claude Platform on AWS and Claude in Microsoft Foundry bill in Claude Consumption Units at $0.01 each, at the same rates as the Claude API.
- Retirements. Anthropic retires older models; when a model you use is retired, you move to a newer one with a different price and tokenizer.
- Rate limits. Anthropic sets rate limits by usage tier (Start, Build, Scale). A low tier can cap throughput before cost does.
Which Claude model should you pick on cost?
- High-volume, simple tasks (classification, routing, short replies): Haiku 5.5. At $0.10/$0.50 per MTok, the support bot above costs about $10 a month without caching.
- Most production apps and coding tools: Sonnet 5.5. It has the 0.05x cache-read price, so a cached system prompt costs $0.10 per MTok to reuse.
- Hard reasoning and agent work where quality matters more than price: Opus 5.5 at $4/$20, which Anthropic’s model overview suggests as the starting point for most workloads.
- The most demanding long-running agent tasks: Fable 5.1 at $10/$50, which Anthropic suggests for “demanding reasoning and long-horizon agentic work.” Its 0.025x cache read ($0.25) makes long cached contexts cheaper than its list price suggests.
- Work that can wait hours: any model through the Batch API at half price.
- A single developer who also wants the chat app: compare your API spend with Max’s $100 of monthly API credits.
More models from every major provider are on our AI models hub.
Sources
- Anthropic: Pricing (Claude Platform docs) (read October 31, 2026)
- Anthropic: Claude pricing (claude.com) (read October 31, 2026)
- Anthropic: Models overview (read October 31, 2026)
- AskGPU data: Claude, GPT and Gemini per-token prices in
llm-models.json(checked October 25, 2026)