Anthropic Claude API pricing in 2026: every model, explained

What Anthropic's API actually charges, per model

Anthropic publishes one number that matters most if you're calling Claude directly: the per-token rate for each model in the current lineup, from the cheapest Haiku build up to the priciest Fable one. If you're hitting the API yourself, through the Anthropic SDK, a framework like LangChain or LiteLLM, or raw curl, this is the bill you're actually paying, separate from any Claude.ai seat or Claude Code subscription price. The Claude Code pricing guide covers those subscription tiers and only touches on API rates in passing. This page goes deeper: every model's current price and exact request string, how prompt caching and the Batch API change what you actually pay, and where the rate limits sit by usage tier.

Anthropic's own docs list the exact request string for each: claude-haiku-4-5, claude-sonnet-5, claude-opus-5-5, claude-opus-5, and claude-fable-5-1. Sonnet 5's $2/$10 rate isn't a special deal. It's the standard price. Anthropic had a scheduled increase to $3/$15 lined up for September 1, 2026, and let it lapse instead of raising the rate, so the introductory launch price just became permanent. Haiku 4.5 stays the cheapest way to run routine, high-volume work. Opus 5.5, released September 22, 2026, is the newest reasoning option: $4 input and $20 output per million tokens, a 20% cut from Opus 5's $5/$25 that Anthropic says works out to roughly 40% less on typical workload cost, alongside faster output. Opus 5 remains available at its original rate. Fable 5.1 sits at the top of the range, Anthropic's most capable model and correspondingly its most expensive, at $10 input and $50 output per million tokens.

Prompt caching: the discount that actually moves your bill

Prompt caching is where the real savings live if your requests repeat the same system instructions, tool definitions, or long reference documents. Anthropic charges a premium to write a prompt into the cache and a steep discount to read it back. A 5-minute cache write costs 1.25x the model's normal input price; a 1-hour write costs 2x. Reading from an existing cache costs 0.1x the base input rate on most models, 0.05x on Opus 5.5, and 0.025x on Fable 5.1, the two cheapest cache-read rates in the lineup. Work out the break-even and it's short: a 5-minute cache pays for itself after a single hit, and a 1-hour cache needs two hits before it beats not caching at all. For an agent that resends the same system prompt and tool schema on every turn of a long session, that's most of the input cost gone within the first few turns.

• 5-minute cache write: 1.25x the model's base input price
• 1-hour cache write: 2x the base input price
• Cache read (a hit): 0.1x base input on most models, 0.05x on Opus 5.5, and 0.025x on Fable 5.1
• On Sonnet 5 that's a $2.50/MTok write and a $0.20/MTok read
• On Opus 5.5 that's a $5/MTok write and a $0.20/MTok read
• On Opus 5 that's a $6.25/MTok write and a $0.50/MTok read

Batch API: half price if the job can wait

The Batch API is a separate lever from caching, and the two stack. Submit a batch of requests and Anthropic processes them asynchronously within a 24-hour window, billing both input and output tokens at half the normal rate. There's no volume threshold to unlock it and no separate contract to sign; every model gets the same flat 50% off. It's a poor fit for anything that needs a response in the same request cycle, a chat interface, a live agent turn, but a good one for work that doesn't: bulk classification, document summarization, dataset labeling, offline evaluation runs, anything you can queue and check on later. Cache the stable part of a batch request and you're combining roughly a 90% discount on that cached input with 50% off everything else, which is how some teams report cutting effective spend by as much as 90-95% on the workloads where both apply.

Rate limits: the part that actually throttles you

Price per token is only half the constraint. The API also caps how fast you can send requests, through three separate ceilings tracked per model: requests per minute, input tokens per minute, and output tokens per minute. Where you land depends on your usage tier. Anthropic calls them Start, Build, Scale, and Custom, and accounts move up automatically as usage and payment history build, with each tier also carrying its own monthly spend cap. Treat the published numbers as rough guides rather than facts to bank on: third-party trackers put an early tier at somewhere around 20,000 input tokens per minute and 4,000 output tokens per minute for Sonnet-class models, roughly doubling at the next tier, but Anthropic adjusts these without much warning, and your account's actual current limits only live in the Claude Platform console. One detail worth knowing if you lean on caching: cached reads generally don't count against your input-tokens-per-minute limit on current models, so a cache-heavy workload can push more effective throughput than the raw ITPM number suggests.

The API meter vs the Claude Code meter

It's easy to confuse this page with Claude Code pricing, and the two do overlap at the edges since Claude Code falls back to metered API billing once you run past a subscription plan's usage pool. But they're different meters for different audiences. Claude Code's Pro, Max, and Team tiers bundle a fixed monthly price with usage headroom sized for one person working in a terminal. The raw per-token pricing on this page is what you pay calling Claude directly through the Anthropic SDK, LangChain, LiteLLM, or your own code, with no subscription in between and no bundled allowance, just tokens in and tokens out. If you're building a product on top of Claude rather than using Claude Code as a personal tool, this is the pricing model you're actually working against. Claude's usage limits guide covers the consumer-plan side if that's what you're comparing against instead.

Where a flat-rate lane fits in

Everything above is genuinely usage-based: run more tokens, pay more, no way around it short of a cheaper model, caching, or batching. For teams that want a predictable, flat-rate line item for the routine share of their coding-agent traffic (tests, boilerplate, straightforward refactors), that's a different shape of problem than per-token API pricing solves. NeverMetered runs Qwen3.8-27B, an open-weight model, on its own servers, priced by how many requests can run in parallel rather than by the token, so a long session doesn't chip away at a token budget the way metered API use does. It's not a replacement for Opus or Fable on your hardest problems: it runs a different, smaller model. But as a second lane for volume work sitting next to a Claude API key, it can take pressure off the metered bill. See current plans or how it actually runs for the details, including what happens to your prompts.