Claude API Pricing 2026: Complete Guide to Anthropic Model Costs ($0.10-$50 per MTok)

If you’re searching for Claude API pricing, you’re in the right place. Anthropic’s pricing has moved fast in 2026. The year opened with the Claude 4.5 series, ran through Opus 4.7 and 4.8 in the spring, then shifted to a new generation: Claude Fable 5 in June, Opus 5 and Sonnet 5 over the summer, and the current lineup of Fable 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5 between September 1 and October 7, 2026. For the first time, the newest Opus is also the cheaper Opus. Understanding Anthropic API pricing is now a multi-dimensional optimization problem: base token costs, adaptive thinking and effort levels, tool use, prompt caching, batch processing, Managed Agents runtime, and long-context windows all factor into your real-world spend. For businesses building production AI systems, mastering these pricing levers is the difference between a sustainable product and a runaway budget.

At Metacto, we architect and build enterprise-grade AI applications on the latest Claude models. We have navigated Anthropic’s complete pricing structure, from base token costs to adaptive thinking, tool use, and advanced caching strategies, and we are providing a definitive breakdown for October 2026.

Short on time? Here’s the summary: Anthropic offers four current-generation model tiers: Haiku 5.5 ($0.10/$0.50 per million tokens on prompts up to 100K) for speed and volume, Sonnet 5.5 ($2/$10) for the best balance of intelligence and cost, Opus 5.5 ($4/$20) for agentic coding and knowledge work, and Fable 5.1 ($10/$50) for the hardest reasoning and longest-horizon agent runs. Every current model has a 1 million token context window, and all but Haiku 5.5 bill the full window at standard rates. Combined with prompt caching (90% to 97.5% savings on repeated context), batch API (50% discount), and adaptive thinking with effort controls, Claude remains the most cost-effective frontier AI available today. For help calculating AI workflow ROI, check our dedicated guide. Looking for alternatives? See our guides on OpenAI API pricing, Cohere pricing, and Hugging Face costs.

Anthropic Claude API Pricing 2026: Complete Model Comparison

Here is a comprehensive comparison of all current Claude models. Pricing is shown per million tokens. On the tokenizer used by Claude 4.7 and later, 1M tokens is roughly 555,000 words; earlier models fit about 750,000 words in the same window. The 5.5 generation (Opus 5.5, Sonnet 5.5, Haiku 5.5) plus Fable 5.1 is current. The Opus 5, Sonnet 5, Fable 5, 4.8, 4.7, 4.6, and 4.5 models are still served as legacy options.

Current Generation: Claude 5.5 Series and Fable 5.1

Model	Input (per 1M tokens)	Output (per 1M tokens)	Cache Write (5m)	Cache Write (1h)	Cache Read	Context Window	Best For
Claude Fable 5.1 (Sep 1, 2026)	$10	$50	$12.50	$20	$0.25	1M	Most demanding reasoning, multistep research, long-horizon agents
Claude Opus 5.5 (Sep 22, 2026)	$4	$20	$5	$8	$0.20	1M	Long-running agentic coding and knowledge work
Claude Sonnet 5.5 (Sep 28, 2026)	$2	$10	$2.50	$4	$0.10	1M	Best combination of speed and intelligence
Claude Haiku 5.5 (Oct 7, 2026), prompts up to 100K	$0.10	$0.50	$0.125	$0.20	$0.01	1M	Classification, extraction, routing, subagents
Claude Haiku 5.5, prompts over 100K	$0.50	$2.50	$0.625	$1	$0.05	1M	Long-prompt Haiku workloads

Cache read multipliers differ by model. Most Claude models charge 10% of the input price for a cache hit. Opus 5.5 and Sonnet 5.5 charge 5%, and Fable 5.1 charges 2.5%. That is why Opus 5.5 cache reads ($0.20) cost less than half of Opus 5’s ($0.50) even though the base input price only fell 20%.

Haiku 5.5 is priced by prompt length. A request whose prompt is over 100,000 tokens (counting cache reads and writes) pays the higher rate card for the whole request. Each request is priced on its own.

Previous Generation: Claude 5, Fable 5, and 4.x (Still Available)

Model	Input (per 1M tokens)	Output (per 1M tokens)	Cache Write (5m)	Cache Write (1h)	Cache Read	Context Window	Status
Claude Fable 5	$10	$50	$12.50	$20	$1	1M	Legacy (Jun 9, 2026)
Claude Opus 5	$5	$25	$6.25	$10	$0.50	1M	Legacy (Jul 24, 2026)
Claude Opus 4.8	$5	$25	$6.25	$10	$0.50	1M	Legacy (May 28, 2026)
Claude Opus 4.7	$5	$25	$6.25	$10	$0.50	1M	Legacy (Apr 16, 2026)
Claude Opus 4.6	$5	$25	$6.25	$10	$0.50	1M	Legacy
Claude Opus 4.5	$5	$25	$6.25	$10	$0.50	200K	Legacy
Claude Sonnet 5	$2	$10	$2.50	$4	$0.20	1M	Legacy (Jun 30, 2026)
Claude Sonnet 4.6	$3	$15	$3.75	$6	$0.30	1M	Legacy
Claude Sonnet 4.5	$3	$15	$3.75	$6	$0.30	200K / 1M*	Deprecated, retires Nov 30, 2026
Claude Haiku 4.5	$1	$5	$1.25	$2	$0.10	200K	Legacy

1M Context at Standard Pricing: Every Claude 4.6 and later model except Haiku 5.5 includes the full 1 million token context window at standard pricing. For Claude Sonnet 4.5, requests exceeding 200K input tokens are charged at $6 input / $22.50 output per million tokens (beta, tier 4+).

Fast Mode pricing:

• Claude Opus 5.5 Fast Mode: $8 input / $40 output per million tokens (2x standard)
• Claude Opus 5 / Opus 4.8 Fast Mode: $10 input / $50 output per million tokens (2x standard, research preview)

Fast Mode runs Opus at up to 2.5x the standard output rate on the Claude API (and on Microsoft Foundry for Opus 5.5). It is not available with the Batch API, and it was removed from Opus 4.7.

Retired Models

Model	Final Price (Input / Output)	Status
Claude Opus 4.1	$15 / $75	Retired August 5, 2026
Claude Opus 4	$15 / $75	Retired June 15, 2026
Claude Sonnet 4	$3 / $15	Retired June 15, 2026
Claude Haiku 3	$0.25 / $1.25	Retired April 20, 2026
Claude Haiku 3.5	$0.80 / $4	Retired February 19, 2026
Claude Sonnet 3.7	$3 / $15	Retired February 19, 2026
Claude Opus 3	$15 / $75	Retired January 5, 2026

Some retired models remain available on Amazon Bedrock or Google Cloud at partner pricing.

Estimate Your Claude API Costs

Use our interactive calculator to estimate your monthly Claude API costs. Toggle prompt caching and batch API to see how much you can save.

Deep Dive: Choosing the Right Claude Model Tier

Anthropic now offers four current model tiers for production use: Fable 5.1 for the most demanding reasoning and long-horizon agentic work, Opus 5.5 for agentic coding and knowledge work (and Anthropic’s recommended starting point for most workloads), Sonnet 5.5 for the best balance of speed and capability, and Haiku 5.5 for high-volume, latency-sensitive tasks. All tiers are engineered for building production-grade “agentic” AI systems that can interact with external tools, process extended reasoning tasks, and handle multi-step workflows at scale. For comprehensive guidance on the AI agent stack for production systems, see our dedicated guide.

graph TD
    A["What is your primary requirement?"] --> B{"Hardest reasoning, longest agent runs?"};
    A --> C{"Agentic coding and knowledge work?"};
    A --> D{"Balanced Cost & Capability?"};
    A --> E{"Highest Throughput / Lowest Cost?"};

    B -->|Yes| F["Use Claude Fable 5.1<br/>Cost: $10/$50 per MTok"];
    C -->|Yes| G["Use Claude Opus 5.5<br/>Cost: $4/$20 per MTok<br/>Fast Mode: $8/$40"];
    D -->|Yes| H["Use Claude Sonnet 5.5<br/>Cost: $2/$10 per MTok"];
    E -->|Yes| I["Use Claude Haiku 5.5<br/>Cost: $0.10/$0.50 per MTok"];

    style A fill:#f0f0f0,stroke:#333,stroke-width:2px
    style B fill:#d9edf7,stroke:#3a87ad
    style C fill:#d9edf7,stroke:#3a87ad
    style D fill:#d9edf7,stroke:#3a87ad
    style E fill:#d9edf7,stroke:#3a87ad
    style F fill:#cfffe5,stroke:#4caf50
    style G fill:#cfffe5,stroke:#4caf50
    style H fill:#cfffe5,stroke:#4caf50
    style I fill:#cfffe5,stroke:#4caf50

1. Claude Opus 5.5: The Default Flagship (September 22, 2026)

Claude Opus 5.5 ($4 input / $20 output per million tokens) is Anthropic’s current Opus and the model it recommends starting with for most workloads. It replaces Opus 5 at a 20% lower token rate, a 60% lower cache-read rate, and a 20% lower Fast Mode rate. Three pricing-relevant properties shape how you build with it:

1. Thinking is always on. Adaptive thinking cannot be disabled on Opus 5.5. The model decides how much reasoning to spend, and the only control is effort.
2. Default effort is medium. Opus 5 and Opus 4.8 defaulted to high. Set effort explicitly: low for routine work, high or xhigh for intelligence-sensitive tasks, max when correctness matters more than cost.
3. Cheapest cache reads in the Opus line. At $0.20 per million tokens (5% of input), long agentic sessions that re-read a cached prefix save more than ever. A cache miss costs relatively more, so keeping the cache warm matters.

Best For:

• Long-running agentic coding sessions and multi-agent workflows
• Knowledge work over documents, spreadsheets, and slides
• Workloads where Opus 5’s $5/$25 rate was borderline on budget
• Latency-sensitive interactive tools, now that Fast Mode is $8/$40

Key Advantage: Anthropic reports that Opus 5.5 at default effort matches or beats Opus 5 on most coding, analysis, and vision tasks while consuming fewer tokens. Combined with the lower list price, cost per completed task drops materially.

Watch out: Opus 5.5 rejects forced tool choice and disabled thinking with a 400 error, and its thinking blocks are tied to the model and conversation that produced them. These are API-surface changes, not pricing changes, but they affect migration effort. Priority Tier is not available on any 5.5 model.

2. Claude Fable 5.1: The Most Capable Tier (September 1, 2026)

Claude Fable 5.1 ($10 input / $50 output per million tokens) is Anthropic’s most capable widely released model, built for the most demanding reasoning and the longest-horizon agentic work. It keeps Fable 5’s token prices but cuts cache reads to $0.25 (2.5% of input), a quarter of Fable 5’s $1 rate. Batch pricing is $5/$25.

Best For:

• Multistep research and long-horizon autonomous agent runs
• Long-document, spreadsheet, and slide work where quality justifies the premium
• Cases where evals on Opus 5.5 at higher effort still fall short

Key Advantage: Fable 5.1 is the model to reach for when the task is hard enough that a 2.5x price premium over Opus 5.5 is cheaper than a failed run. Note that Fable 5.1 requires 30-day data retention; it is not available under zero-data-retention agreements without Anthropic’s express authorization.

3. Claude Sonnet 5.5: The Production Workhorse (September 28, 2026)

Claude Sonnet 5.5 ($2 input / $10 output per million tokens) is the optimal choice for most production AI applications. It keeps Sonnet 5’s price (which Anthropic has made permanent after an introductory period) and comes in a third below Sonnet 4.6’s $3/$15. Cache reads are $0.10 (5% of input), and batch rates are $1/$5. Sonnet 5.5 includes the full 1 million token context window at standard pricing. For developers building intelligent agents, RAG systems, or complex automation workflows, Sonnet 5.5 delivers flagship-adjacent performance at a sustainable price point.

Best For:

• Advanced Retrieval-Augmented Generation (RAG) over large document sets
• Intelligent coding assistants and development tools
• Multi-step agentic workflows with tool use and LangChain
• Customer support automation requiring nuanced understanding
• Internal tools requiring sophisticated reasoning
• Building and iterating on an AI MVP

Key Advantage: Sonnet 5.5 provides a level of intelligence that rivals previous flagship models while maintaining cost efficiency that scales to millions of interactions. Combined with prompt caching and batch processing, Sonnet 5.5 can operate at effective costs as low as $0.10 per million input tokens (cache hit) or $1/$5 (batch API). Default effort is high; medium is the cost-saving step-down where quality holds.

Thinking off, when you need it: Unlike Opus 5.5, Sonnet 5.5 lets you turn off up-front thinking with thinking: {type: "between_tools"} at effort high or below, which keeps latency and output tokens down on simple routes.

4. Claude Haiku 5.5: Speed and Scale at Breakthrough Pricing (October 7, 2026)

Claude Haiku 5.5 ($0.10 input / $0.50 output per million tokens on prompts up to 100K tokens) is optimized for high-throughput applications where speed and cost efficiency are paramount. It is 10x cheaper than Haiku 4.5 on short prompts and brings a 1M context window and 128K max output to the Haiku tier for the first time. Prompts over 100,000 tokens are billed at $0.50/$2.50, still half of Haiku 4.5’s rate.

Best For:

• High-volume content moderation and classification
• Real-time chat applications requiring sub-second latency
• Data extraction and transformation at scale
• Agent control flow, routing logic, and subagent tasks
• Document processing pipelines handling millions of documents

Key Advantage: Haiku 5.5 operates at one-twentieth the cost of Sonnet 5.5 on short prompts. With batch processing, costs drop to $0.05/$0.25 per million tokens. For applications processing millions of requests per day, Haiku 5.5’s economics are transformative.

Watch out: The 100K-token threshold counts every input token in the request, including cache reads. A RAG pipeline that stuffs 120K tokens of context into each call pays 5x more per token than one that keeps prompts under the line. Design retrieval budgets accordingly.

5. Legacy Models: Opus 5, Opus 4.8, Sonnet 5, Sonnet 4.6, Haiku 4.5

Claude Opus 5 and Opus 4.8 ($5/$25) remain available but are now strictly more expensive than Opus 5.5 at every price point (tokens, cache, batch, Fast Mode). Sonnet 5 ($2/$10) costs the same as Sonnet 5.5 for tokens but double for cache reads ($0.20 vs $0.10). Sonnet 4.6 ($3/$15) and Haiku 4.5 ($1/$5) use the older tokenizer, so on text-heavy English workloads the real gap to their 5.5 successors is smaller than the list prices suggest. Benchmark before migrating, but plan to migrate.

Adaptive Thinking and Effort: Reasoning as Output Tokens

One of the most powerful features across the Claude 5.x generation is adaptive thinking: the model generates internal reasoning before producing its final response, and decides on its own how much reasoning each task needs. This is particularly valuable for complex problem-solving, multi-step coding tasks, deep research, and autonomous agent work where the quality of reasoning directly impacts outcome quality. Understanding how to control it is crucial for avoiding common AI agent failures.

How Adaptive Thinking Works

On Claude 4.6 and later, you enable thinking with thinking: {type: "adaptive"}. On Opus 5.5, Opus 5, Sonnet 5.5, Sonnet 5, Haiku 5.5, and Fable 5.1, thinking is on by default when you omit the parameter. The model works through the problem step by step before generating the final response. The raw chain of thought is never returned; by default the thinking text is omitted, and you can opt in to a readable summary with display: "summarized".

Supported Models: Adaptive thinking is available on Fable 5.1, Fable 5, Opus 5.5, Opus 5, Opus 4.8, Opus 4.7, Opus 4.6, Sonnet 5.5, Sonnet 5, Sonnet 4.6, and Haiku 5.5. Older models (Opus 4.5, Sonnet 4.5, Haiku 4.5) use the manual extended-thinking mode with a budget_tokens value.

Thinking Pricing Model

Critical detail: Thinking tokens are billed as output tokens, not as a separate pricing tier. Whatever the model spends on internal reasoning is charged at the standard output rate for that model.

Pricing by Model:

• Claude Fable 5.1 / Fable 5: $50 per million output tokens (includes thinking)
• Claude Opus 5 / 4.8 / 4.7 / 4.6 / 4.5: $25 per million output tokens (includes thinking)
• Claude Opus 5.5: $20 per million output tokens (includes thinking)
• Claude Sonnet 5.5 / Sonnet 5: $10 per million output tokens (includes thinking)
• Claude Sonnet 4.6 / 4.5: $15 per million output tokens (includes thinking)
• Claude Haiku 5.5: $0.50 per million output tokens on prompts up to 100K (includes thinking)
• Claude Haiku 4.5: $5 per million output tokens (includes thinking)

The Effort Parameter Is Your Cost Dial

Set output_config.effort to low, medium, high, xhigh, or max. Effort controls thinking depth and overall token spend, and it matters more on the 5.x models than on any prior generation. Defaults differ by model:

Model	Default effort	Can thinking be turned off?
Fable 5.1	high	No (always on)
Opus 5.5	medium	No (always on)
Opus 5	high	Only at high or below
Sonnet 5.5	high	Up-front thinking only, via between_tools at high or below
Haiku 5.5	medium	Only at high or below

Cost rule of thumb: Lower effort before adding “think less” prompt instructions. On the newest models, low or medium effort often matches prior-generation quality at high while spending far fewer output tokens. Reserve xhigh and max for workloads where measurement shows headroom at the level below.

When Deeper Thinking Is Worth the Cost

Higher effort adds cost (more output tokens) but delivers value through higher quality responses. Raise effort when:

• Accuracy matters more than latency: Complex financial analysis, medical research, legal reasoning
• Multi-step workflows require careful planning: Agentic systems orchestrating multiple tools
• Deep code reasoning is required: Architecting complex systems, debugging subtle issues
• Research quality is paramount: Literature synthesis, scientific hypothesis generation

For high-volume, straightforward tasks where speed matters, low effort (or between_tools on Sonnet 5.5) is more cost-effective.

Cost Example: High Effort vs. Low Effort

Scenario: A complex coding task requiring 50,000 tokens of visible output

Low effort (Sonnet 5.5):

• Output: 50,000 tokens × $10/million = $0.50

High effort (Sonnet 5.5):

• Thinking: 8,000 tokens × $10/million = $0.08
• Output: 50,000 tokens × $10/million = $0.50
• Total: $0.58 (16% premium for deeper reasoning)

For mission-critical applications, this premium is typically justified by the improvement in output quality and reduction in iterations needed to reach the correct solution.

Prompt Caching: Up to 97.5% Cost Reduction

Prompt caching is arguably the most powerful cost optimization feature in Anthropic’s API. For applications that repeatedly send similar context (large documents, system prompts, knowledge bases), prompt caching reduces input costs by 90% on most models, 95% on Opus 5.5 and Sonnet 5.5, and 97.5% on Fable 5.1 for every cache hit. For a deeper look at caching architectures beyond Anthropic’s native feature, see our LLM caching production strategy guide.

How Prompt Caching Works

When you send a request to Claude, you can mark portions of the input (typically the system prompt or large document context) for caching. Anthropic stores this content on their servers for a specified duration. Subsequent requests that include the same cached content read from the cache instead of processing as new input tokens. The minimum cacheable prefix is 512 tokens on the 5.x models.

graph TD
    A["Initial Request with Large Context"] --> B["Claude API"]
    B --> C{"Cache Write: 1.25x Cost"}
    C -->|Stores Context for Reuse| D["Cached Context"]

    E["Request 1 + Cached Context"] --> F["Claude API"]
    F --> G{"Cache Read: 0.05x Cost<br/>95% Savings"}
    G --> D

    H["Request 2 + Cached Context"] --> I["Claude API"]
    I --> J{"Cache Read: 0.05x Cost<br/>95% Savings"}
    J --> D

    K["Request N + Cached Context"] --> L["Claude API"]
    L --> M{"Cache Read: 0.05x Cost<br/>95% Savings"}
    M --> D

    D --> N["20x Cost Reduction on Repeated Context (Opus 5.5 / Sonnet 5.5)"]

    style A fill:#f9f,stroke:#333,stroke-width:2px
    style C fill:#fcc,stroke:#333,stroke-width:2px
    style G fill:#cfc,stroke:#333,stroke-width:2px
    style J fill:#cfc,stroke:#333,stroke-width:2px
    style M fill:#cfc,stroke:#333,stroke-width:2px
    style N fill:#add8e6,stroke:#333,stroke-width:2px

Prompt Caching Pricing Multipliers

Anthropic offers two cache duration options with different pricing:

Cache Operation	Multiplier	Duration
5-minute cache write	1.25x base input price	Cache valid for 5 minutes
1-hour cache write	2x base input price	Cache valid for 1 hour
Cache read (hit)	0.1x base input price (0.05x on Opus 5.5 and Sonnet 5.5; 0.025x on Fable 5.1)	Same duration as preceding write

Example: Sonnet 5.5 with Prompt Caching

• Standard input: $2.00 per million tokens
• 5-minute cache write: $2.50 per million tokens (1.25x)
• 1-hour cache write: $4.00 per million tokens (2x)
• Cache read: $0.10 per million tokens (0.05x), a 95% saving

These multipliers stack with other pricing modifiers, including the Batch API discount and data residency.

Break-Even Analysis

5-minute cache: You break even after just 1 cache read. Every subsequent read within 5 minutes is pure savings. 1-hour cache: You break even after 2 cache reads. Ideal for agent sessions or multi-step workflows where the context remains relevant for longer periods. A cache read also refreshes the timer at no extra cost, so requests that share a prefix and arrive less than 5 minutes apart keep even a 5-minute cache warm indefinitely.

Real-World Caching Use Cases

1. RAG Systems: Cache your entire knowledge base (documentation, FAQ corpus) and only pay full price once per 5 minutes or hour. Each user query reads from cache at a 90% to 97.5% discount. Learn more about building RAG systems with vector databases.

2. Code Assistants: Cache the full codebase context. Users can ask multiple questions about the code without repeatedly paying to process the entire repository.

3. Document Analysis: Upload a 100-page legal document once (cache write), then ask dozens of questions about it (cache reads at 5% to 10% of cost).

4. Multi-Step Agents: Cache system prompts and tool definitions. Each step in the agent workflow reads from cache rather than reprocessing. For complex agent workflows, consider using LangGraph for stateful applications.

Cost Comparison: With vs. Without Caching

Scenario: RAG chatbot over 200K token documentation corpus, 100 user queries per hour

Without Caching (Sonnet 5.5):

• 100 queries × 200K tokens × $2/million = $40/hour

With 1-Hour Caching (Sonnet 5.5):

• Initial cache write: 200K tokens × $4/million = $0.80
• 99 cache reads: 99 × 200K tokens × $0.10/million = $1.98
• Total: $2.78/hour, a 93% cost reduction

Batch API: 50% Discount for Non-Urgent Workloads

The Batch API offers a straightforward way to cut your API costs in half: submit requests that don’t need immediate responses, and Anthropic processes them asynchronously within 24 hours at a 50% discount on both input and output tokens. On the 5.x, 4.8, 4.7, and 4.6 models, batch requests can also return up to 300K output tokens with the output-300k-2026-03-24 beta header.

Batch API Pricing

All Claude models support batch processing with consistent 50% discounts:

Model	Standard Input	Standard Output	Batch Input	Batch Output
Claude Fable 5.1 / Fable 5	$10	$50	$5	$25
Claude Opus 5.5	$4	$20	$2	$10
Claude Opus 5	$5	$25	$2.50	$12.50
Claude Opus 4.8 / 4.7 / 4.6 / 4.5	$5	$25	$2.50	$12.50
Claude Sonnet 5.5 / Sonnet 5	$2	$10	$1	$5
Claude Sonnet 4.6 / 4.5	$3	$15	$1.50	$7.50
Claude Haiku 5.5 (prompts up to 100K)	$0.10	$0.50	$0.05	$0.25
Claude Haiku 5.5 (prompts over 100K)	$0.50	$2.50	$0.25	$1.25
Claude Haiku 4.5	$1	$5	$0.50	$2.50

Note: Fast Mode (Opus 5.5 / Opus 5 / Opus 4.8) is not available with the Batch API. Opus 5.5’s batch rate ($2/$10) is below Opus 5 and Opus 4.8’s ($2.50/$12.50), so the newer model is cheaper in batch as well as online.

Ideal Use Cases for Batch Processing

The Batch API is perfect for workloads where latency isn’t critical:

1. Content Generation at Scale: Generate thousands of product descriptions, blog posts, or marketing emails overnight
2. Data Processing Pipelines: Extract structured data from large document sets, process historical records
3. Model Evaluation: Run comprehensive test suites against your prompts and agent workflows
4. Synthetic Data Generation: Create training datasets for fine-tuning or testing
5. Document Analysis: Process archives of contracts, research papers, or support tickets

Combining Batch API with Other Optimizations

The Batch API discount stacks with prompt caching, creating even more dramatic savings:

Example: Large-Scale RAG Processing (Sonnet 5.5)

• Standard: $2 input / $10 output
• Batch API: $1 input / $5 output (50% off)
• Batch + Caching: $0.05 input (cache read) / $5 output
• Total savings: 97.5% on input, 50% on output

For applications processing millions of tokens per day, combining batch processing with prompt caching can reduce monthly API costs from tens of thousands to hundreds of dollars.

Long Context Pricing: Processing Up to 1 Million Tokens

Every current Claude model supports a 1 million token context window, enough to process entire codebases, full-length books, or extensive conversation histories in a single request. Pricing differs depending on which model you use.

Claude 4.6 and Later: 1M Context at Standard Pricing

A major pricing improvement that began with the Claude 4.6 generation: every Claude 4.6 and later model except Haiku 5.5 includes the full 1M token context window at standard pricing. A 900K-token request is billed at the same per-token rate as a 9K-token request. No premium surcharges for large contexts.

Model	Input (any context size)	Output (any context size)
Claude Fable 5.1	$10 per million tokens	$50 per million tokens
Claude Opus 5.5	$4 per million tokens	$20 per million tokens
Claude Opus 5 / 4.8 / 4.7 / 4.6	$5 per million tokens	$25 per million tokens
Claude Sonnet 5.5 / Sonnet 5	$2 per million tokens	$10 per million tokens
Claude Sonnet 4.6	$3 per million tokens	$15 per million tokens

Prompt caching and batch processing discounts apply at standard rates across the full context window. Fast Mode pricing (Opus 5.5 / Opus 5 / Opus 4.8) also applies across the full window.

Claude Haiku 5.5: Two Rate Cards by Prompt Length

Haiku 5.5 is the one exception. It has a 1M context window, but requests whose prompt exceeds 100,000 tokens are billed at a higher rate card:

Prompts up to 100K tokens:

• Input: $0.10 per million tokens
• Output: $0.50 per million tokens

Prompts over 100K tokens:

• Input: $0.50 per million tokens (5x)
• Output: $2.50 per million tokens (5x)

The prompt length counts all input tokens, including cache reads and cache writes. A request over the threshold pays the higher prices for its whole prompt, even when part of it is a cache hit. Each request is priced on its own.

Claude Sonnet 4.5: Tiered Long Context Pricing (Deprecated)

For Claude Sonnet 4.5 (deprecated, retiring November 30, 2026), the 1M context window is in beta for organizations in usage tier 4 and above. Requests exceeding 200K input tokens trigger premium pricing: $6 input / $22.50 output per million tokens, applied to all tokens in that request. Upgrading to Sonnet 5.5 eliminates the surcharge and cuts the base rate: you pay $2/$10 instead of $6/$22.50 on large requests. This is essential for continuous AI operations running smoothly.

When to Use Long Context

The 1M token window enables entirely new application patterns:

1. Whole Codebase Analysis: Load an entire repository for architectural questions, refactoring, or bug detection
2. Multi-Document Synthesis: Analyze dozens of research papers or contracts simultaneously
3. Extended Conversations: Maintain full context across thousands of messages without truncation
4. Complete Book Processing: Analyze entire manuscripts for editing, summarization, or question answering

Tool Use Pricing: Understanding the Complete Cost

When building agentic AI applications that interact with external APIs, databases, or custom functions, understanding tool use pricing is critical. Tool use adds token overhead beyond the basic input/output costs.

Base Tool Use Overhead

Every Claude API request using tools includes a system prompt that enables tool functionality. This overhead is automatically added. Per Anthropic’s official docs (as of October 2026):

Model	Tool Choice: auto or none	Tool Choice: any or specific tool
Claude Opus 5.5 / Sonnet 5.5	286 tokens	Not supported (returns 400)
Claude Opus 5 / Haiku 5.5	286 tokens	406 tokens
Claude Opus 4.8	290 tokens	410 tokens
Claude Sonnet 5	354 tokens	474 tokens
Claude Opus 4.7	675 tokens	804 tokens
Claude Opus 4.6 / Sonnet 4.6	497 tokens	589 tokens
Claude Opus 4.5 / Sonnet 4.5 / Haiku 4.5	496 tokens	588 tokens

Cost Impact (Sonnet 5.5, auto): 286 tokens × $2/million = $0.0006 per request. Note that the 5.5 models and Fable 5.1 no longer accept forced tool choice (any or a named tool). Use auto with strict: true on the tool definition, or structured outputs, to get schema-valid arguments.

Per-Tool Definition Overhead

Each tool you define in the tools parameter adds tokens based on its name, description, and JSON schema:

• Simple tool (basic function): ~50-100 tokens
• Complex tool (detailed schema): ~200-500 tokens
• Server-side tools (Anthropic-hosted): Fixed overhead

Example: An agent with 5 tools (average 150 tokens each) adds 750 tokens per request.

Tool Execution Tokens

When Claude actually calls a tool, additional tokens are consumed:

1. Tool use request: The tool_use content block (parameters passed to tool)
2. Tool result: The tool_result content block (data returned from tool)

Both are charged as standard input/output tokens based on their size.

Example Chain (Sonnet 5.5):

• User prompt: 500 tokens (input)
• Tool use overhead: 286 tokens (input)
• 3 tool definitions: 450 tokens (input)
• Tool execution request: 200 tokens (output)
• Tool result data: 2,000 tokens (input)
• Final response: 800 tokens (output)
• Total: 3,236 input / 1,000 output, about $0.0165 at $2/$10

Server-Side Tool Pricing

Anthropic provides several hosted tools with specific pricing:

Web Search Tool:

• Cost: $10 per 1,000 searches
• Plus: standard token costs for search results
• Use case: Real-time information retrieval

Web Fetch Tool:

• Cost: Free (only token costs for fetched content)
• Limit: Use max_content_tokens to control costs
• Average page: ~2,500 tokens
• Large PDF: ~125,000 tokens

Code Execution Tool:

• Free when used with web search or web fetch tools
• Without web tools: $0.05 per hour per container (after 1,550 free hours/month)
• Minimum: 5 minutes per execution
• Use case: Running analysis scripts, data processing

Bash Tool:

• Fixed overhead: 325 input tokens (Claude 4.7 and later), 244 tokens (4.6 and earlier)
• Variable: stdout/stderr content
• Use case: Command execution, file operations

Text Editor Tool:

• Fixed overhead: 974 input tokens (Claude 4.7 and later), 745 tokens (4.6 and earlier)
• Variable: file content
• Use case: Code editing, document modification

Computer Use Toolset:

• Toolset definition: about 4,500 input tokens (computer_toolset_20260801, required on 5.5 models)
• Plus: screenshot costs (vision pricing)
• Use case: UI automation, testing

Cost Optimization for Tool-Heavy Agents

For applications with extensive tool use:

1. Cache tool definitions: Define tools once, cache for 90% to 97.5% savings on subsequent requests
2. Minimize tool schemas: Use concise descriptions and lean JSON schemas
3. Batch tool calls: When possible, combine multiple operations in one call
4. Smart tool selection: Use tool search with defer_loading so only relevant tools are loaded per request
5. Result filtering: Return minimal necessary data from tool executions

Example Optimization:

• Before: 10 tools always included, 1,000 tokens overhead
• After: Dynamic tool loading, cache tool definitions, ~100 effective tokens
• Savings: 90% reduction in tool overhead

Claude Managed Agents Pricing

Anthropic launched Claude Managed Agents in public beta (April 2026), providing a hosted runtime for stateful, long-running agent sessions. If you’re exploring the 2027 AI operations playbook, managed agents represent a significant simplification of agentic infrastructure.

Pricing Model: Tokens + Session Runtime

Managed Agents bills on exactly two dimensions:

Component	Rate	Details
Tokens	Standard model rates	Same rates as Messages API (see tables above)
Session Runtime	$0.08 per session-hour	Measured to the millisecond; only accrues while session status is running

Key Details:

• No flat fees: No monthly subscription, per-agent license, or infrastructure charge
• Idle time is free: Time spent waiting for input or tool confirmations does not count toward runtime
• Web search: Standard $10 per 1,000 searches rate applies within sessions
• Prompt caching: Standard caching multipliers apply identically

What Doesn’t Apply to Managed Agents

Several Messages API modifiers do not apply to Managed Agents sessions:

Modifier	Why It Doesn’t Apply
Batch API discount	Sessions are stateful and interactive, with no batch mode
Fast mode premium	Inference speed is managed by the runtime
Data residency multiplier	inference_geo is set on the agent’s model config, not per request

Cost Example: Coding Session with Opus 5.5

A one-hour coding session using Claude Opus 5.5:

• 50,000 input tokens, 15,000 output tokens
• No caching

Line Item	Calculation	Cost
Input tokens	50,000 x $4 / 1,000,000	$0.20
Output tokens	15,000 x $20 / 1,000,000	$0.30
Session runtime	1.0 hour x $0.08	$0.08
Total		$0.58

With prompt caching (40,000 of input tokens from cache reads):

Line Item	Calculation	Cost
Uncached input	10,000 x $4 / 1,000,000	$0.04
Cache reads	40,000 x $0.20 / 1,000,000	$0.008
Output tokens	15,000 x $20 / 1,000,000	$0.30
Session runtime	1.0 hour x $0.08	$0.08
Total		$0.43

Data Residency Pricing

For Claude 4.6 and later models (including every 5.x model and Fable 5.1), specifying US-only inference through the inference_geo parameter incurs a 1.1x multiplier on all token pricing categories (input, output, cache writes, and cache reads). On Haiku 5.5, the multiplier also applies to the over-100K rate card. Global routing (the default) uses standard pricing. Earlier models do not support the inference_geo parameter and always use standard pricing.

How Much Does Claude API Cost? Real-World Pricing Scenarios

Understanding token pricing in isolation is one thing. Estimating your actual monthly Claude API cost requires thinking about complete application architectures. Here are realistic cost scenarios for common use cases.

Scenario 1: Customer Support Chatbot

• Model: Claude Sonnet 5.5
• Volume: 10,000 conversations/day, average 2,000 input + 500 output tokens each
• Optimization: Prompt caching (system prompt cached), no batch

Component	Calculation	Daily Cost
System prompt (cached read)	10K x 800 tokens x $0.10/MTok	$0.80
User messages (standard)	10K x 1,200 tokens x $2/MTok	$24.00
Output tokens	10K x 500 tokens x $10/MTok	$50.00
Total		$74.80/day (~$2,250/month)

Without caching, the system prompt alone would cost $16/day. Caching saves $15.20 daily. On Sonnet 4.6 the same workload cost $113.40/day.

Scenario 2: Document Processing Pipeline

• Model: Claude Haiku 5.5 (batch, prompts under 100K)
• Volume: 50,000 documents/day, average 5,000 tokens each, 200 token output

Component	Calculation	Daily Cost
Input (batch)	50K x 5,000 tokens x $0.05/MTok	$12.50
Output (batch)	50K x 200 tokens x $0.25/MTok	$2.50
Total		$15/day (~$450/month)

At standard Sonnet 5.5 pricing without batch, this workload would cost $600/day. Choosing Haiku 5.5 with batch processing delivers a 97% cost reduction. The same pipeline on Haiku 4.5 batch cost $150/day.

Scenario 3: AI-Powered Code Review Tool

• Model: Claude Opus 5.5 with adaptive thinking (default effort: medium)
• Volume: 500 reviews/day, 20,000 input + 5,000 output + 10,000 thinking tokens each

Component	Calculation	Daily Cost
Input tokens	500 x 20K x $4/MTok	$40.00
Output + thinking	500 x 15K x $20/MTok	$150.00
Total		$190/day (~$5,700/month)

On Opus 5 or Opus 4.8 ($5/$25): $237.50/day. Opus 5.5 saves 20% at identical token counts.

With caching the repository context (15,000 of the 20,000 input tokens served from cache at $0.20/MTok): input drops to $11.50/day and the total to about $161.50/day (~$4,850/month).

With effort: low for simple PRs: thinking tokens often drop 40 to 60% on routine changes. If half the reviews run at low effort, output spend falls by roughly $37/day, bringing real-world cost to roughly $125/day.

Beyond Tokens: The Hidden Engineering Challenges of Scaling

As your AI application scales, the API bill is just one of your concerns. Production-readiness introduces a host of technical challenges that can quickly overwhelm a team focused solely on the model itself.

1. API Rate Limiting & Reliability

All providers enforce strict rate limits based on usage tiers. Production systems require sophisticated exponential backoff and retry logic with jitter to handle these limits gracefully without failing user requests. Anthropic’s API uses tiered rate limits (requests per minute, tokens per minute, tokens per day) that vary significantly between tiers, and each 5.x model has its own rate-limit pool. Priority Tier is not offered on the 5.5 models or Fable 5.1. Our guide to LLM rate limiting and token quotas in production covers these patterns in depth.

Production Requirements:

• Implement request queuing and throttling
• Build graceful degradation when limits are hit
• Monitor rate limit headers in responses
• Scale across multiple API keys if needed

2. API Key Security & Rotation

A leaked API key is a critical security breach that can result in thousands of dollars in fraudulent usage within hours. A robust system requires:

• Secure, isolated storage (AWS Secrets Manager, HashiCorp Vault, or similar)
• Automated key rotation policy to programmatically invalidate and replace keys
• Separate keys for development, staging, and production environments
• Audit logging of all API key usage
• Alert systems for unusual spending patterns

3. Architecting for Latency

Claude API calls can take several seconds, and single requests on hard tasks at high effort can run for minutes. Your application’s architecture must handle this asynchronously:

• Background job queues (Redis, RabbitMQ, AWS SQS)
• Real-time update mechanisms (WebSockets, Server-Sent Events)
• User experience patterns for “AI is thinking” states
• Timeout handling and partial result streaming
• Fallback strategies when calls exceed acceptable latency

4. Observability and Cost Tracking

When an agentic workflow fails or costs spike unexpectedly, you need detailed visibility. Tools like LangSmith provide LLM observability to track these metrics:

• Structured logging of every API call (prompt, model, token counts, latency, cost)
• Token usage analytics broken down by user, feature, and endpoint
• Alert thresholds for unusual spending or error rates
• Dashboard for real-time cost monitoring
• Attribution of costs to specific product features or customers

Learn more about calculating the true cost of AI tools per developer and measuring ROI of AI development tools.

5. Prompt Management and Versioning

As your application evolves, managing prompts becomes critical infrastructure:

• Version control for system prompts and tool definitions
• A/B testing frameworks for prompt variations
• Rollback capabilities when new prompts degrade quality
• Environment-specific prompt configurations
• Caching strategies for static prompt components

These are not “nice-to-haves”; they are fundamental requirements for a reliable product. The AI development services at Metacto are designed to build this resilient infrastructure from day one, preventing common failures that often require a costly project rescue.

Overwhelmed by Scaling Challenges?

Building a production-ready AI app is more than just API calls. Our team handles the complexities of security, rate limiting, and monitoring so you can focus on your product. Schedule a free consultation to discuss your project's architecture.

Get a Free Architecture Review

Conclusion: Mastering Claude API Pricing in 2026

The Claude 5.5 generation is the first in which the newest flagship is also the cheapest flagship. With Opus 5.5 at $4/$20 (20% below Opus 5 and 73% below the retired Opus 4.1), Sonnet 5.5 at $2/$10, Haiku 5.5 from $0.10/$0.50, standard-price 1M context windows across the lineup, deeper prompt caching discounts (up to 97.5%), 50% batch processing savings, and a cheaper $8/$40 Fast Mode, building production AI applications is more economically viable than ever.

Key Takeaways

1. Choose the right model tier: Haiku 5.5 ($0.10/$0.50) for volume and speed, Sonnet 5.5 ($2/$10) for balanced intelligence, Opus 5.5 ($4/$20) for agentic coding and knowledge work, Fable 5.1 ($10/$50) only when Opus 5.5 at higher effort falls short

2. Set effort explicitly: Opus 5.5 and Haiku 5.5 default to medium; Sonnet 5.5 and Fable 5.1 default to high. Use low for routine work and reserve xhigh / max for measured gains. Effort is the first quality-trading cost lever after caching

3. Count tokens, not just prices: Every model from 4.7 onward uses a tokenizer that yields about 30% more tokens than the 4.6 series. Benchmark dollars per task before and after migrating

4. Exploit the deeper cache discounts: Cache reads cost 5% of input on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.1. Keep caches warm with append-only histories and stable prefixes

5. Mind Haiku 5.5’s 100K threshold: Prompts over 100K tokens pay 5x. Keep retrieval budgets under the line or route long-prompt work to Sonnet 5.5

6. Stack optimizations aggressively: Combining prompt caching, batch API, and smart architecture can reduce effective costs by 95% or more compared to naive implementations

7. Evaluate Managed Agents for stateful workflows: At $0.08 per session-hour plus standard token costs, Managed Agents can simplify infrastructure for long-running agent applications

8. Build the infrastructure: Rate limiting, API key security, cost monitoring, and prompt management aren’t optional. They are fundamental to sustainable AI products

The most critical insight is that Claude API pricing is no longer a simple “cost per token” calculation. It’s a multi-dimensional optimization problem where the right architecture, caching strategy, effort setting, and model selection can mean the difference between a $50,000/month bill and a $2,000/month bill for the same functionality.

Comparing AI Providers? Explore our comprehensive cost guides for OpenAI API, Cohere, Hugging Face, and Google Gemini. For a broader comparison, see our guide on understanding LLMs for app innovation.

Building Your First LLM Application? Check out our guides on LangChain development, choosing between RAG vs fine-tuning, and understanding when to use LLMs vs alternatives.

If you’re ready to build a production AI application that intelligently leverages these pricing levers while maintaining the resilient infrastructure required for scale, talk to our team at Metacto. We specialize in architecting cost-efficient, production-ready AI systems that grow with your business. Schedule a free consultation to discuss your project’s requirements and optimization strategy.

---

Related Reading

Controlling these costs in production:

• LLM Caching: A Production Strategy: Architecting cache layers that cut token spend
• LLM Routing in Production: Sending each request to the cheapest model that can handle it
• LLM Rate Limiting and Token Quotas: Keeping usage and spend within bounds

AI Cost and ROI:

• AI Cost Optimization: Getting More Value: Strategies for reducing AI infrastructure costs
• The Hidden Variable in AI ROI: Understanding the full cost picture
• AI Workflow ROI: Calculating Savings: Methods for measuring AI investment returns

Building AI Agents:

• Building AI Agents That Actually Work: Practical implementation patterns
• The AI Agent Stack for Production Systems: Architecture decisions for reliable agents
• AI Agent Failures and How to Avoid Them: Common pitfalls and solutions

AI Operations:

• The 2027 AI Operations Playbook: Planning for enterprise AI at scale
• Continuous AI Operations: Running Smoothly: Maintaining production AI systems

---

Frequently Asked Questions About Anthropic Claude API Pricing

How much does the Anthropic Claude API cost per million tokens in 2026?

As of October 19, 2026, Anthropic offers four current tiers: Claude Haiku 5.5 at $0.10 input / $0.50 output per million tokens on prompts up to 100K tokens ($0.50/$2.50 above that), Claude Sonnet 5.5 at $2 input / $10 output (balanced), Claude Opus 5.5 at $4 input / $20 output (agentic coding and knowledge work), and Claude Fable 5.1 at $10 input / $50 output (most demanding reasoning). All four have a 1M token context window, and all but Haiku 5.5 bill it at standard pricing. Legacy models still available include Opus 5 and Opus 4.8 at $5/$25, Sonnet 5 at $2/$10, Sonnet 4.6 at $3/$15, and Haiku 4.5 at $1/$5.

What is Claude Opus 5.5 and how is it priced?

Claude Opus 5.5 was released September 22, 2026 at $4 input / $20 output per million tokens, 20% below Opus 5 and Opus 4.8 ($5/$25). Cache reads are $0.20 per million (5% of input, versus 10% on earlier models), batch pricing is $2/$10, and Fast Mode is $8/$40. Adaptive thinking is always on and cannot be disabled; you control depth with the effort parameter (low / medium / high / xhigh / max), which defaults to medium. Anthropic reports it matches or beats Opus 5 on most coding, analysis, and vision tasks while using fewer tokens.

Is Claude Opus 4.8 still the newest model?

No. Claude Opus 4.8 (released May 28, 2026) has been succeeded twice: by Claude Opus 5 on July 24, 2026 at the same $5/$25 price, and by Claude Opus 5.5 on September 22, 2026 at $4/$20. Opus 4.8 is still served as a legacy model, but Opus 5.5 is cheaper on every dimension: tokens ($4/$20 vs $5/$25), cache reads ($0.20 vs $0.50), batch ($2/$10 vs $2.50/$12.50), and Fast Mode ($8/$40 vs $10/$50).

How is Claude Haiku 5.5 priced?

Claude Haiku 5.5, released October 7, 2026, has two rate cards chosen by prompt length. Prompts up to 100,000 tokens are billed at $0.10 input / $0.50 output per million tokens. Prompts over 100,000 tokens are billed at $0.50 / $2.50. The prompt length counts every input token, including cache reads and writes, and each request is priced on its own. Batch pricing is $0.05/$0.25 and $0.25/$1.25 respectively. Haiku 5.5 has a 1M token context window and 128K max output, up from 200K and 64K on Haiku 4.5, which remains available at $1/$5.

What is adaptive thinking and how is it priced?

Adaptive thinking lets Claude generate internal reasoning before its final response and decide on its own how much reasoning each task needs. Thinking tokens are billed as output tokens at standard rates, not as a separate pricing tier. On Opus 5.5 and Fable 5.1 thinking is always on; on Sonnet 5.5, Sonnet 5, Opus 5, and Haiku 5.5 it is on by default. You steer the cost/quality trade-off with the effort parameter (low / medium / high / xhigh / max). Opus 5.5 and Haiku 5.5 default to medium; Sonnet 5.5, Sonnet 5, Opus 5, and Fable 5.1 default to high. The manual budget_tokens mode is only for older models like Haiku 4.5.

How does prompt caching work and how much can I save?

Prompt caching allows you to store frequently-used context (system prompts, large documents, knowledge bases) on Anthropic's servers. Cache writes cost 1.25x the base input price (5-minute cache) or 2x (1-hour cache). Cache reads cost 0.1x on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1, which is a 90% to 97.5% saving. You break even after just 1 cache hit with 5-minute caching, or 2 hits with 1-hour caching. For applications with repeated context like RAG systems or code assistants, caching can reduce input costs by 90-97%.

What is the Batch API and when should I use it?

The Batch API processes requests asynchronously within 24 hours at a 50% discount on both input and output tokens. It's ideal for non-urgent workloads like bulk content generation, data processing pipelines, model evaluation, or document analysis. The discount stacks with prompt caching, potentially reducing costs by 95% or more. For example, Claude Opus 5.5 drops from $4/$20 to $2/$10 per million tokens with batch processing, and Sonnet 5.5 drops from $2/$10 to $1/$5. Note: Fast Mode for Opus 5.5 / Opus 5 / Opus 4.8 is not available with the Batch API.

What is Claude Managed Agents and how is it priced?

Claude Managed Agents (public beta launched April 8, 2026) provides a hosted runtime for stateful, long-running agent sessions. Pricing is straightforward: standard token rates plus $0.08 per session-hour of runtime. Runtime is measured to the millisecond and only accrues while the session status is running; idle time waiting for input or tool confirmations is free. No flat fees, per-agent licenses, or infrastructure charges apply. Batch API and Fast Mode modifiers do not apply to Managed Agents sessions.

How much does tool use cost with Claude?

Tool use adds several layers of cost: a base system prompt (286 tokens on Opus 5.5, Sonnet 5.5, Opus 5, and Haiku 5.5; 290 on Opus 4.8; 497 on the 4.6 series), per-tool definitions (50-500 tokens each), and tokens for tool execution (both the request and result data). Server-side tools have additional fees: web search costs $10 per 1,000 searches, code execution is free when paired with web search/fetch (otherwise $0.05/hour after 1,550 free hours/month per organization), and web fetch is free (only token costs). Optimize by caching tool definitions and using tool search to defer loading of rarely used tools.

Which Claude model should I use for my application?

Anthropic recommends starting with Claude Opus 5.5 ($4/$20 per million tokens) for most workloads; it is the current Opus and cheaper than its predecessors. Use Claude Sonnet 5.5 ($2/$10) when you want the best combination of speed and intelligence for production applications, RAG, and agents. Use Claude Haiku 5.5 ($0.10/$0.50 on prompts up to 100K) for high-volume, latency-sensitive tasks like classification, extraction, routing, and subagents. Reach for Claude Fable 5.1 ($10/$50) only for the most demanding reasoning and long-horizon agentic work, or when Opus 5.5 at higher effort still falls short on your evals.

What is long context pricing and when does it apply?

Every Claude 4.6 and later model except Haiku 5.5 includes the full 1M token context window at standard pricing, with no surcharge regardless of input size. Haiku 5.5 is priced by prompt length: prompts over 100,000 tokens pay $0.50/$2.50 instead of $0.10/$0.50 per million tokens. For the deprecated Sonnet 4.5 (retiring November 30, 2026), requests exceeding 200K input tokens are charged at $6 input / $22.50 output per million tokens (beta, tier 4+), with the entire request billed at the higher rate.

How is Opus 5.5 Fast Mode priced and is it worth it?

Opus 5.5 Fast Mode is priced at $8 input / $40 output per million tokens, double the standard $4/$20 rate but 20% cheaper than Fast Mode on Opus 5 and Opus 4.8 ($10/$50). It delivers up to 2.5x the standard output speed using the same Opus 5.5 model. Fast Mode is available on the Claude API and on Microsoft Foundry for Azure-hosted deployments, stacks with prompt caching and data residency multipliers, and is not available with the Batch API or on Amazon Bedrock or Google Cloud. Use it for latency-sensitive interactive workloads like developer tools and real-time chat with reasoning.

Why do I need Metacto to build with Claude API?

Using Claude for a prototype is straightforward, but production applications require sophisticated infrastructure: API rate limit handling with exponential backoff, API key security and rotation, async architecture for latency management, detailed cost tracking and observability, and prompt versioning systems. Metacto builds this resilient infrastructure from day one, preventing the costly mistakes that often lead to project rescues. We optimize your architecture to leverage caching, batch processing, effort controls, and smart model selection, reducing costs by 90% or more while maintaining reliability.