Anthropic API Pricing at a Glance (2026)
Quick answer: Anthropic API pricing in 2026 is per million tokens (MTok), billed separately for input and output. Claude Fable 5.1, Anthropic’s most capable generally available model, costs $10/$50 per MTok. Claude Opus 5.5 costs $4/$20, the first Opus price cut after several generations at $5/$25. Claude Sonnet 5.5 and Sonnet 5 both cost $2/$10. Claude Haiku 5.5 costs $0.10/$0.50 for prompts up to 100,000 tokens and $0.50/$2.50 above that. Claude Haiku 4.5 stays at $1/$5. Batch processing is 50% cheaper across all models. Prompt caching cuts cached input cost by 90% on most models, 95% on Opus 5.5 and Sonnet 5.5, and 97.5% on Fable 5.1. Claude 4.6 and later models, except Haiku 5.5, include the full 1M token context window at standard rates.
New blog: Fable 5 & Mythos 5 pricing review and tips
Note on Opus 4.7 tokenizer: Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text. Per-token prices are what you see in the tables, but cost per request depends on token count. If you are migrating from Sonnet 4.6, Opus 4.6 or earlier, benchmark before you switch.
Prices verified October 20, 2026 from official Anthropic documentation.
Current generation — standard API rates per million tokens
Claude Fable 5.1: $10.00 input / $50.00 output
Claude Opus 5.5: $4.00 input / $20.00 output
Claude Sonnet 5.5: $2.00 input / $10.00 output
Claude Sonnet 5: $2.00 input / $10.00 output
Claude Haiku 5.5: $0.10 input / $0.50 output (prompts up to 100K tokens)
Claude Haiku 4.5: $1.00 input / $5.00 output
AI API spend has become one of the fastest-growing and least-governed line items in engineering budgets. Anthropic's Claude powers chatbots, coding assistants, agentic workflows, and data-intensive pipelines across industries — and because pricing is based on tokens, usage can escalate quickly without the right controls in place.
Understanding how Anthropic charges — and where the levers are — is essential for FinOps practitioners, engineering leaders, and product teams managing AI at scale. This guide covers every current model, every pricing mechanism, and the practical optimizations that make the biggest difference in production.
Tracking Claude spend across teams? Finout's Anthropic integration pulls token-level costs into your MegaBill alongside AWS, GCP, and Kubernetes — so you can see which team or product is driving spend.
Anthropic API Pricing by Model
Anthropic charges per million tokens (MTok) with separate rates for input tokens (what you send) and output tokens (what the model returns). Output tokens are consistently more expensive, reflecting the additional compute required to generate responses.
| Model | Input | Output | Batch Input | Batch Output | Cache Hit | Long Context |
|---|---|---|---|---|---|---|
| Claude Fable 5.1 | $10.00 | $50.00 | $5.00 | $25.00 | $0.25 | Standard rate up to 1M |
| Claude Opus 5.5 | $4.00 | $20.00 | $2.00 | $10.00 | $0.20 | Standard rate up to 1M |
| Claude Sonnet 5.5 | $2.00 | $10.00 | $1.00 | $5.00 | $0.10 | Standard rate up to 1M |
| Claude Sonnet 5 | $2.00 | $10.00 | $1.00 | $5.00 | $0.20 | Standard rate up to 1M |
| Claude Haiku 5.5 (prompts up to 100K) | $0.10 | $0.50 | $0.05 | $0.25 | $0.01 | Higher rate above 100K |
| Claude Haiku 5.5 (prompts over 100K) | $0.50 | $2.50 | $0.25 | $1.25 | $0.05 | |
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.50 | $2.50 | $0.10 | 200K context window |
All prices per million tokens (MTok). Batch pricing requires the Message Batches API. Claude Mythos 5.1 has the same rates as Fable 5.1 but is limited to organizations verified through Anthropic’s verification programs.
Previous generation and retired models
| Model | Input | Output | Batch Input | Batch Output | Cache Hit |
|---|---|---|---|---|---|
| Claude Fable 5 | $10.00 | $50.00 | $5.00 | $25.00 | $1.00 |
| Claude Opus 5, 4.8, 4.7, 4.6, 4.5 | $5.00 | $25.00 | $2.50 | $12.50 | $0.50 |
| Claude Sonnet 4.6 | $3.00 | $15.00 | $1.50 | $7.50 | $0.30 |
| Claude Sonnet 4.5 (deprecated) | $3.00 | $15.00 | $1.50 | $7.50 | $0.30 |
| Claude Opus 4.1 and Opus 4 (retired on the Claude API) | $15.00 | $75.00 | $7.50 | $37.50 | $1.50 |
| Claude Sonnet 4 (retired on the Claude API) | $3.00 | $15.00 | $1.50 | $7.50 | $0.30 |
| Claude Haiku 3.5 (retired, except on Google Cloud) | $0.80 | $4.00 | $0.40 | $2.00 | $0.08 |
Retired models may still be available on Amazon Bedrock or Google Cloud. If any production workload still runs on Opus 4.1 or Opus 4 through a cloud platform, moving to Opus 5.5 cuts the per-token rate by about 73% ($4 vs $15 input, $20 vs $75 output). Benchmark first, since the newer tokenizer produces more tokens for the same text.
Already using Claude at scale? See how Finout tracks it
Model Profiles: Capabilities & When to Use Each
Claude Fable 5.1: Most Capable
API ID: claude-fable-5-1 | Price: $10.00/$50.00 per MTok | Context: 1M tokens
Anthropic positions Fable 5.1 for demanding reasoning and long-horizon agentic work, and recommends it when evals on Opus 5.5 at higher effort still fall short. Its cache hit rate is $0.25 per MTok, just 2.5% of base input. That puts cached input within 1.25× of Opus 5.5 ($0.20), even though uncached input is 2.5× the price. On cache-heavy agent workloads, the real gap between the two models comes mostly from output tokens.
Best for: The hardest reasoning and long-running agentic tasks, where Opus 5.5 has already been tested and falls short.
Claude Opus 5.5: Recommended Starting Point
API ID: claude-opus-5-5 | Price: $4.00/$20.00 per MTok | Context: 1M tokens
Anthropic’s model overview tells developers who are unsure which model to use to start with Opus 5.5 for most workloads. It costs 20% less than Opus 5 per token, and its cache hits cost $0.20 per MTok compared to $0.50 on Opus 5.
Fast Mode on Opus 5.5 costs $8/$40 per MTok, twice the standard rate.
Migration from Opus 5 or Opus 4.8: Both already use the newer tokenizer, so moving to Opus 5.5 lowers cost per request directly. Migration from Opus 4.6 or earlier: the roughly 30% increase in token count can offset the 20% price cut. In a workload that sees the full increase, cost per request comes out about 4% higher. Benchmark on your own traffic before you switch.
Best for: Long-running agentic coding and knowledge work, and the default choice when you have not yet benchmarked other tiers.
Claude Sonnet 5.5 and Sonnet 5
API IDs: claude-sonnet-5-5, claude-sonnet-5 | Price: $2.00/$10.00 per MTok | Context: 1M tokens
Both Sonnet models cost half as much as Opus 5.5 per token. Sonnet 5.5 cuts the cache hit rate in half compared to Sonnet 5 ($0.10 vs $0.20 per MTok). For cache-heavy workloads, it is the cheaper of the two at the same list price.
Migration from Sonnet 4.6: Per-token prices drop by a third ($2/$10 vs $3/$15), but Sonnet 4.6 uses the older tokenizer. If your workload sees the full ~30% increase in token count, cost per request still comes out roughly 13% lower.
Best for: The majority of production workloads where Opus-level reasoning is not required.
Claude Haiku 5.5 and Haiku 4.5: Budget
API IDs: claude-haiku-5-5, claude-haiku-4-5-20251001 | Price: $0.10/$0.50 (Haiku 5.5, prompts up to 100K) and $1.00/$5.00 (Haiku 4.5)
Haiku 5.5 is the cheapest model in the lineup by a wide margin, but its pricing depends on prompt length. Any request whose prompt goes over 100,000 tokens pays 5× the per-token rate for the whole request, including cache reads. Keep prompts under the threshold to get the low rate.
Best for: High-volume, short-prompt workloads such as classification, routing, extraction, summarization, and moderation.
Prompt Caching: The Biggest Cost Lever Available
Prompt caching is Anthropic's most impactful pricing feature. It lets you store frequently reused content, such as system prompts, documents, examples, tool definitions, so subsequent API calls can read from cache instead of reprocessing the full input. Cache hits cost 90% less than standard input on most models, 95% less on Opus 5.5 and Sonnet 5.5, and 97.5% less on Fable 5.1.
How Prompt Caching Works
There are two ways to enable it. Automatic caching adds a single cache_control field at the top level of the request and lets the system manage cache breakpoints as conversations grow. Anthropic recommends this as the starting point for most use cases. Explicit breakpoints place cache_control on individual content blocks for fine-grained control. On the first request, Anthropic processes and stores the cached content. The write costs 1.25× standard input for a 5-minute TTL, or 2× for a 1-hour TTL. Subsequent requests within the TTL window pay the cache hit rate. Reading a cached block refreshes it, so high-frequency applications rarely pay write costs after the initial warm-up. At the standard 0.1× hit rate, a 5-minute cache pays for itself after one read and a 1-hour cache after two.
Prompt Caching Pricing by Model
| Model | Standard Input | 5-min Write | 1-hr Write | Cache Hit | Hit Discount |
|---|---|---|---|---|---|
| Claude Fable 5.1 | $10.00 | $12.50 | $20.00 | $0.25 | 97.5% |
| Claude Opus 5.5 | $4.00 | $5.00 | $8.00 | $0.20 | 95% |
| Claude Sonnet 5.5 | $2.00 | $2.50 | $4.00 | $0.10 | 95% |
| Claude Sonnet 5 | $2.00 | $2.50 | $4.00 | $0.20 | 90% |
| Claude Haiku 5.5 (up to 100K) | $0.10 | $0.125 | $0.20 | $0.01 | 90% |
| Claude Haiku 4.5 | $1.00 | $1.25 | $2.00 | $0.10 | 90% |
| Claude Opus 5 / 4.8 | $5.00 | $6.25 | $10.00 | $0.50 | 90% |
Caching Cost Example: RAG Application
Scenario: A RAG app with a 50K-token knowledge base in the system prompt, queried 1,000 times per day on Sonnet 5.5. For simplicity, this example counts only the knowledge base tokens. User questions and output cost the same with or without caching.
Without caching: 1,000 queries/day at 50K tokens each
- Input tokens per day: 50M tokens
- Standard input cost ($2.00/MTok): $100.00/day
- Monthly cost: ~$3,000/mo
With caching: same workload, 1-hour cache rewritten once an hour
- 24 cache writes per day ($4.00/MTok × 50K tokens × 24): $4.80/day
- 976 cache hits per day ($0.10/MTok × 50K tokens × 976): $4.88/day
- Monthly cost: ~$290/mo
- Daily spend: ~$9.68 (about 90% lower)
Key insight: Prompt caching is not just an optimization. For any application with a large, reused system prompt or document context, it is the single most impactful change you can make to your Anthropic bill. Applications that query the same knowledge base repeatedly should always use caching.
Batch Processing: 50% Off for Async Workloads
The Anthropic Message Batches API processes requests asynchronously and returns results within 24 hours, at exactly 50% off standard token prices. There is no quality difference between batch and real-time responses, only timing. Batch and caching discounts stack.
| Model | Standard Input | Batch Input | Standard Output | Batch Output | Saving |
|---|---|---|---|---|---|
| Claude Fable 5.1 | $10.00 | $5.00 | $50.00 | $25.00 | 50% |
| Claude Opus 5.5 | $4.00 | $2.00 | $20.00 | $10.00 | 50% |
| Claude Sonnet 5.5 / Sonnet 5 | $2.00 | $1.00 | $10.00 | $5.00 | 50% |
| Claude Haiku 5.5 (up to 100K) | $0.10 | $0.05 | $0.50 | $0.25 | 50% |
| Claude Haiku 4.5 | $1.00 | $0.50 | $5.00 | $2.50 | 50% |
Best workloads for batch processing: document processing pipelines, data enrichment at scale, nightly analytics jobs, offline evaluations, content generation queues, and any task where a few hours of latency is acceptable.
Long-Context Pricing: What Changes With Prompt Length
Claude 4.6 and later models include the full 1M token context window at standard pricing, so a 900K-token request is billed at the same per-token rate as a 9K-token request. The one exception in the current lineup is Haiku 5.5.
| Model | Long-Context Rule |
|---|---|
| Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Sonnet 5 | Flat rate up to 1M tokens |
| Claude Opus 5, 4.8, 4.7, 4.6, Sonnet 4.6 | Flat rate up to 1M tokens |
| Claude Haiku 5.5 | 5× higher rate for any request whose prompt exceeds 100K tokens |
| Claude Haiku 4.5 | 200K context window |
Haiku 5.5 long-prompt warning: The 100K threshold counts every input token in the request, including cache reads and cache writes. Each request is priced on its own, and a request over the threshold pays the higher rate even if most of its prompt is a cache hit. A 120K-token prompt on Haiku 5.5 costs $0.50 per MTok of input, not $0.10. If your prompts regularly cross 100K, compare Haiku 5.5 against Sonnet 5.5 before you commit.
Fast Mode
Fast Mode delivers significantly faster output in exchange for a price premium. It is available on the Claude API (first party) and, for Opus 5.5, on Claude in Microsoft Foundry. It is not available on Claude Platform on AWS, partner cloud platforms, or the Batch API.
| Mode | Input | Output | vs Standard |
|---|---|---|---|
| Standard (Opus 5.5) | $4.00 | $20.00 | |
| Fast Mode (Opus 5.5) | $8.00 | $40.00 | 2× premium |
| Fast Mode (Opus 5 / Opus 4.8, research preview) | $10.00 | $50.00 | 2× premium |
Fast Mode pricing applies across the full context window, and caching and data residency multipliers stack on top of it.
Still: benchmark standard Sonnet 5.5 first. Sonnet 5.5 costs half as much as standard Opus 5.5. If your latency requirement is met at Sonnet’s standard speed, that remains the cheaper choice. Reserve Opus 5.5 Fast Mode for workflows where maximum model quality and low latency are both required, such as user-facing coding assistants, live incident triage, and real-time agentic loops.
Never use Fast Mode as a default. At $8/$40 per MTok, a 1M-token input alone costs $8, compared to $4 at standard speed. Reserve Fast Mode for genuinely latency-critical scenarios where the speed premium is justified by a concrete business outcome.
Consumer & Team Subscriptions vs API Billing
Anthropic offers subscription plans for individuals and teams alongside the API. These are separate products. Subscriptions provide access to claude.ai and desktop apps, not the API. All API usage is always billed per token.
| Plan | Price | For | API Access? |
|---|---|---|---|
| Free | $0 | Casual users, trials | No |
| Pro | $20/mo ($17/mo annual) | Individual productivity (claude.ai) | No |
| Max | From $100/mo | Power users — 5× or 20× Pro usage | No |
| Team (Standard seat) | $25/seat/mo ($20 annual) | Teams up to 150 people | No |
| Team (Premium seat) | $125/seat/mo ($100 annual) | Power users on team — 5× usage | No |
| Enterprise | $20/seat + API rates | Large orgs with compliance needs | Yes (billed per token) |
| API (direct) | Per token | Developers building on Claude | Yes |
Key distinction: If you are building a product or automation that calls Claude programmatically, you are using the API and paying per token — regardless of whether you also have a Pro or Max subscription. Subscription plans do not provide API credits or reduce API costs.
Rate Limits & Usage Tiers
Rate limits vary by usage tier and affect how many requests you can make. Anthropic’s standard tiers are:
- Start: entry-level limits for getting started
- Build: increased limits for growing applications
- Scale: the highest standard limits, for production workloads
For limits beyond the Scale tier or custom pricing, Anthropic directs customers to its sales team. Teams operating at scale should request limit increases proactively, before reaching capacity during peak periods. Being throttled in production costs more in engineering time and SLA impact than moving up a tier early.
Additional costs to plan for: Web search tool calls via the Anthropic API cost $10 per 1,000 searches, on top of token costs. US-only data residency via the inference_geo parameter applies a 1.1× multiplier to all token categories on Claude 4.6 and later models. Code execution includes 1,550 free hours per organization per month, then $0.05 per hour per container. It is free when used alongside the current web search or web fetch tools. Claude Managed Agents adds $0.08 per session-hour of runtime on top of token costs. These are not reflected in base model pricing.
Real-World Cost Scenarios
All scenarios use standard rates from Anthropic’s pricing page. Token counts are per request, and actual counts vary by model tokenizer. Monthly figures assume 30 days.
Scenario 1: High-Volume Customer Support Chatbot (10,000 conversations/day)
Per conversation: a shared 5K-token system prompt (1-hour cache, rewritten once an hour), plus 2,000 uncached input tokens and 500 output tokens. Every model uses the same caching setup, so the comparison is like for like.
| Model | Daily Cost | Monthly Cost | Notes |
|---|---|---|---|
| Haiku 5.5 | ~$5 | ~$151 | Prompts stay well under the 100K threshold |
| Haiku 4.5 | ~$50 | ~$1,507 | |
| Sonnet 5.5 | ~$95 | ~$2,864 | |
| Opus 5.5 | ~$191 | ~$5,729 | 2× Sonnet 5.5, rarely needed for support |
Scenario 2: Bulk Document Processing (100,000 docs/month)
Per document: 5,000 input tokens and 500 output tokens, async batch, no caching.
| Model + Mode | Per-doc Cost | Monthly Cost | Notes |
|---|---|---|---|
| Haiku 5.5 Batch | ~$0.0004 | ~$38 | Best value for bulk processing |
| Haiku 4.5 Batch | ~$0.0038 | ~$375 | |
| Sonnet 5.5 Batch | ~$0.0075 | ~$750 | Use if quality requires it |
| Opus 5.5 Batch | ~$0.0150 | ~$1,500 | Rarely justified for batch extraction |
Scenario 3: Agentic Coding Assistant (500 sessions/day, ~20K tokens each)
Per session: 17,500 input tokens and 2,500 output tokens, real time, no caching.
| Model | Daily Cost | Monthly Cost |
|---|---|---|
| Fable 5.1 | ~$150 | ~$4,500 |
| Opus 5.5 | ~$60 | ~$1,800 |
| Sonnet 5.5 | ~$30 | ~$900 |
| Haiku 5.5 | ~$1.50 | ~$45 |
For agentic coding, routing by task complexity delivers the best outcome: use Haiku for simple completions and quick lookups, Sonnet for most code tasks, and Opus or Fable only for the most complex architectural reasoning. Agentic sessions often resend the same context each turn, so caching can lower these figures significantly in practice.
Best Practices: How to Optimize Anthropic API Spend
- Choose the right model tier for every task. Use Haiku 5.5 for classification, routing, extraction, and high-volume short-prompt queries. Use Sonnet 5.5 for most production tasks at half the per-token price of Opus 5.5. Reserve Opus 5.5 for complex reasoning and agentic work, and Fable 5.1 for problems Opus 5.5 cannot solve.
- Implement prompt caching on any reused content. If your system prompt, knowledge base, or document context is shared across many requests, caching is the single highest-ROI optimization available. On Sonnet 5.5, a cached 50K-token system prompt costs about 90% less than processing it fresh with every request (see the RAG example above).
- Route async work through the Batch API. Any workload that can tolerate a few hours of latency — document processing, data enrichment, nightly reports, evaluation runs — should use the Message Batches API. The 50% discount is automatic and applies to every token with no quality trade-off.
- Move from Opus 5 or Opus 4.8 to Opus 5.5. The per-token price is 20% lower, cache hits drop from $0.50 to $0.20 per MTok, and there is no tokenizer change between these models. From Opus 4.6 or earlier, benchmark first.
- Watch the Haiku 5.5 threshold. Prompts over 100K tokens pay 5× the rate. Monitor prompt length so long requests do not quietly erase the savings.
- Write lean, structured prompts. Every unnecessary token in your system prompt costs money at scale. Audit prompts for redundancy — verbose instructions, repeated context, examples that aren't improving output quality. Structured formats (numbered steps, clear headers) reduce ambiguity and often shorten outputs, cutting both input and output costs.
- Monitor and allocate spend proactively. Pull token and cost data via the Anthropic usage API. Break down spend by model, by feature, and by team. Anomalies are much cheaper to catch early than to absorb on a monthly bill. FinOps platforms like Finout automate this across your full AI and cloud stack.
- Plan capacity upgrades before you need them. Request higher usage tiers and rate limit increases proactively — before peak periods, not after you hit a wall. Being throttled in production is far more expensive than the deposit required to raise a tier.
- Don’t default to Opus for routine workloads. Claude Opus 5.5 costs 2× Sonnet 5.5 on both input and output. Using it for support, classification, or summarization that Sonnet handles equally well doubles that part of your bill with no quality benefit.
- Don't confuse consumer subscriptions with API access. A Pro or Max subscription gives access to claude.ai — not the API. API usage is always billed per token. Teams building on Claude pay for both independently.
- Don’t use Fast Mode by default. Opus 5.5 Fast Mode is $8/$40 per MTok, a 2× premium over standard. Use it only for genuinely latency-critical flows, and only after confirming standard Sonnet 5.5 doesn’t already meet your speed requirements.
The Bottom Line
Anthropic's API pricing in 2026 is meaningfully more nuanced than it was a year ago. The lineup now runs from Haiku to Sonnet to Opus to Fable, and the latest generation broke the long-standing $5/$25 Opus price. The cost levers, including prompt caching, batch processing, prompt-length thresholds, and model selection**, create** a wide range of effective costs for the same workload depending on how well you optimize.
The highest-impact changes for most teams, in order of ROI:
- Implement prompt caching on any reused system prompt or document context — 85–90% reduction on cached input
- Audit model tier usage — downgrade from Opus to Sonnet wherever quality is equal; from Sonnet to Haiku for high-volume simple tasks
- Move async workloads to the Batch API — 50% off with no quality penalty
- Upgrade Opus 5 or Opus 4.8 to Opus 5.5: 20% lower per-token price and 60% cheaper cache hitsKeep
- Haiku 5.5 prompts under 100K tokens to stay on the lowest rate
- Migrate off Sonnet 4.5 for large-context work — avoid the 200K surcharge by moving to Sonnet 4.6
- Benchmark migrations from Sonnet 4.6, Opus 4.6 or earlier carefully. The newer tokenizer produces about 30% more tokens for the same text, which can offset some or all of a price cut
- Monitor and allocate spend. You cannot optimize what you cannot see
cloud & AI spend

