Claude API Pricing 2026: Every Model, Every Rate, and How to Cut Your Bill
Claude API pricing is simple on paper: you pay per million tokens, and output costs five times as much as input on every current model. The bill gets complicated once you add prompt caching, batch processing, long context, cloud-provider routing and the fact that newer models count tokens differently.
This guide gives you the full Anthropic API pricing rate card, explains each billing mechanic, and shows the math on how much each discount takes off your Claude API cost, with worked examples you can adapt to your own workload.
1. Claude API Pricing at a Glance (Current Rate Card)
All Claude API pricing below is in USD per million tokens (MTok) on the direct Claude API at standard rates. The cache write column shows the 5-minute and 1-hour options. Batch API pricing is half of every rate in the table.
| Model | Input $/MTok | Cached input (read) | Cache write (5 min / 1 hr) | Output $/MTok | Context window |
| Claude Fable 5.1 and Mythos 5.1 | $10.00 | $0.25 | $12.50 / $20.00 | $50.00 | 1M tokens |
| Claude Opus 5.5 | $4.00 | $0.20 | $5.00 / $8.00 | $20.00 | 1M tokens |
| Claude Sonnet 5.5 | $2.00 | $0.10 | $2.50 / $4.00 | $10.00 | 1M tokens |
| Claude Haiku 5.5 | $0.10 | $0.01 | $0.125 / $0.20 | $0.50 | 1M tokens (see long-context note below) |
Rates checked against Anthropic's official pricing page.
Three things on the rate card are easy to miss:
- Output is always 5x input. Across the whole lineup the ratio is fixed, so output-heavy workloads cost far more than the input price suggests.
- Cache read multipliers differ by model. Reads cost 0.1x input on Haiku 5.5, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and Mythos 5.1.
- Batch halves everything. The Batch API takes 50% off both input and output, and it stacks with caching.
Some add-ons are priced separately from tokens: US-only inference carries a 1.1x multiplier, fast mode on Opus 5.5 is $8 input and $40 output per MTok (and not available in batch), web search is $10 per 1,000 searches, and Managed Agents sessions run $0.08 per session-hour.
Earlier models are still served on the API at their own rates, shown below. Opus 4, Opus 4.1, Sonnet 4 and Haiku 3.5 are retired and not listed.
| Model | Input $/MTok | Cached input (read) | Output $/MTok |
| Claude Fable 5 and Mythos 5 | $10.00 | $1.00 | $50.00 |
| Claude Opus 5 | $5.00 | $0.50 | $25.00 |
| Claude Opus 4.8, 4.7, 4.6 and 4.5 | $5.00 | $0.50 | $25.00 |
| Claude Sonnet 5 | $2.00 | $0.20 | $10.00 |
| Claude Sonnet 4.6 | $3.00 | $0.30 | $15.00 |
| Claude Sonnet 4.5 (deprecated) | $3.00 | $0.30 | $15.00 |
| Claude Haiku 4.5 | $1.00 | $0.10 | $5.00 |
2. How Anthropic Bills for API Usage
Every API call is metered in tokens, and the bill is the sum of four things: fresh input tokens, output tokens, cache writes and cache reads. Understanding which of those dominates your workload is the first step to controlling your Claude API cost.
Per-token pricing: input vs output
Input tokens are everything you send: system prompt, conversation history, retrieved documents, tool definitions and tool results. Output tokens are everything the model generates, including any extended thinking. Because output is priced at 5x input, a call that sends 2,000 tokens and receives 500 spends about as much on output as on input.
A useful yardstick: at 2,000 input tokens and 500 output tokens per request, 1,000 requests cost about $0.45 on Haiku 5.5, $9 on Sonnet 5.5, $18 on Opus 5.5 and $45 on Fable 5.1.
One caution when comparing against older Claude models: Claude 4.7 and later use a tokenizer that produces roughly 30% more tokens for the same text. A model with a lower rate card price can therefore cost about the same per request as its predecessor. Sonnet 5.5 at $2 per MTok behaves like roughly $2.60 per MTok in prior-tokenizer terms, which is still below the $3 a prior-generation Sonnet charged. Opus 5.5 at $4 works out to about $5.20, slightly above a $5 prior-generation Opus. Measure your own prompts before assuming a price drop shows up on the invoice.
Prompt caching: cache writes vs cache reads, and the TTL tiers
Prompt caching lets you pay a reduced rate to reuse a prefix (a long system prompt, a document, a tool set) across calls. There are two sides to the price:
- Cache write: the first time a prefix is stored you pay a premium over normal input: 1.25x for the 5-minute TTL, or 2x for the 1-hour TTL.
- Cache read: every later call that hits the cache pays a fraction of input price: 0.1x on Haiku 5.5, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and Mythos 5.1.
The 5-minute tier suits chat and agent loops where calls arrive close together. The 1-hour tier suits workloads with gaps, like a support bot with sporadic traffic or batch jobs that revisit the same prefix. On Sonnet 5.5, a 5-minute write on a 50,000-token prefix costs $0.125 and each read costs $0.005, so the cache pays for itself on the first reuse.
Batch processing discount for asynchronous workloads
The Message Batches API processes requests asynchronously at a flat 50% discount on input and output tokens. The trade-off is latency: results are returned when the batch completes rather than in real time, so batch fits evaluations, classification backfills, document processing, embeddings-style enrichment and nightly reports, not user-facing chat. Batch discounts stack with prompt caching, although cache hits inside a batch are best-effort because requests may be processed in any order.
Context window and long-context considerations
Current models support up to a 1M-token context window at standard pricing, with no separate long-context premium on Fable, Opus or Sonnet. The exception is Haiku 5.5, where prompts above 100,000 tokens are billed at 5x the normal rate. Large context is still not free: every token you put in the window is billed as input on every call unless it is served from cache. A 500,000-token prompt on Sonnet 5.5 is $1.00 of input per call uncached, or about $0.05 per call when read from cache.
How API billing differs from consumer subscription billing
The API is pay-as-you-go: you load credits or are invoiced for exactly what you consume, with no included allowance. Consumer plans such as Pro and Max are flat monthly fees with usage limits. The next section covers how to compare the two.
3. Claude API vs Claude Subscription: Which Is Cheaper for You?
The answer depends on who is using Claude and how. Subscriptions are built for one person working interactively. The API is built for software, teams and anything that scales with traffic.
How subscription plans are metered vs how the API is metered
Claude Pro costs $20 per month ($17 per month billed annually). Max starts at $100 per month for 5x Pro usage, with a 20x tier above it, and Team and Enterprise plans are priced per seat. These plans do not charge per token. Instead they enforce a five-hour rolling usage limit and a weekly limit, and heavy users can buy usage credits billed at API rates once they hit the cap. Max and Team plans can also include API credits.
The API has no limits in that sense, only rate limits and spend caps. You are billed on actual tokens, so cost scales linearly with use.
The break-even point, modelled
Subscription prices can be translated into token budgets at API rates as a yardstick for comparison. Plans do not actually deliver a fixed token allowance, since their limits are set in rolling five-hour and weekly windows rather than in tokens, so read these as equivalents, not entitlements. At Sonnet 5.5 rates:
- $20 buys 10 million input tokens or 2 million output tokens.
- $100 buys 50 million input tokens or 10 million output tokens.
At Opus 5.5 rates those budgets halve: $20 is 5M input or 1M output, and $100 is 25M input or 5M output. If a person's real monthly consumption would cost less than the plan price at API rates, the API is cheaper. If a person routinely burns through more tokens than their plan price would buy, the subscription is subsidizing them. That is why heavy interactive coding on a subscription tends to beat pay-per-token pricing, while light or bursty use does not.
When the API wins: production apps, automation, multi-user systems, variable load
A subscription cannot power a product. If you are serving customers, running scheduled jobs, or have usage that swings from near zero to thousands of calls a day, the API is the only option and the cost model fits: you pay only when work happens. It also gives you caching and batch discounts, programmatic spend controls, workspaces for isolation, and cloud-provider routing, none of which a seat license offers.
When the subscription wins: individual interactive use
For one person using Claude all day in chat or a coding assistant, a flat plan caps downside. A developer who would consume tens of millions of tokens a month through an agentic coding tool will often spend far less on Max than on the equivalent API calls. Predictability matters too: a subscription cannot produce a surprise bill.
Worked comparison table
| Situation | Better fit | Why |
| One person, occasional chat questions | Pro ($20) | Light use; flat fee with no metering to manage |
| One person, all-day interactive coding or research | Max ($100+) | Token volume at API rates would exceed the plan price |
| Internal tool called a few thousand times a month | API | Cost is tens of dollars, and a seat plan cannot be called programmatically |
| Customer-facing feature, steady volume | API | Needs programmatic access, caching and per-customer attribution |
| Nightly classification or enrichment jobs | API with Batch | 50% discount, no user waiting |
| Small team sharing chat with admin controls | Team plan | Per-seat pricing with central billing |
4. Stacking the Discounts
Claude offers three levers on cost: caching, batching and model choice. They multiply rather than add, so the order you apply them in matters less than whether you apply them at all.
Prompt caching: what it saves and which workloads benefit
Caching pays off whenever a large, stable prefix is reused. The best candidates are agents that resend a long conversation and tool list on every step, RAG applications with a fixed system prompt, document Q&A over the same file, and coding assistants that keep repository context in the window. On Sonnet 5.5, a cache read costs $0.10 per MTok against $2.00 for fresh input, a 95% reduction on the cached portion. Workloads with short prompts or highly unique inputs see little benefit, and output tokens are never discounted by caching.
Batch API: the flat discount and the latency trade-off
Batch takes a flat 50% off. It is the right default for any job that does not need an immediate response, and many teams run more of their workload asynchronously than they realize: scoring, tagging, summarizing backlogs, nightly report generation and evaluation runs.
Combining both: effective rate math with a worked example
Because batch and caching stack, cached reads inside a batch cost half of the normal cache read price. That works out to 5% of standard input on Haiku 5.5, 2.5% on Opus 5.5 and Sonnet 5.5, and 1.25% on Fable 5.1 and Mythos 5.1.
Worked example on Sonnet 5.5: 10,000 requests, each with a 50,000-token shared prefix, 1,000 tokens of new input and 500 tokens of output.
| Approach | Total cost | vs standard |
| Standard, no caching | $1,070.00 | baseline |
| Batch only | $535.00 | -50% |
| Caching only (1-hour write) | $120.20 | -89% |
| Batch plus caching | $60.10 | -94% |
The prefix is what makes this so dramatic. When most of your input is a repeated context, caching does the heavy lifting, and batch cuts the remainder in half. Note that this example assumes every request hits the cache; in a batch, hits are best-effort, so treat $60 as the best case and plan for somewhat higher.
Choosing the right model tier for the task (the largest lever of all)
Model choice dwarfs every other discount. Moving a task from Opus 5.5 to Sonnet 5.5 cuts rates by half, and moving it to Haiku 5.5 cuts them by roughly 95%, before any caching or batching. The same 1,000 requests that cost $18 on Opus 5.5 cost $0.45 on Haiku 5.5. The practical approach is to route by task difficulty: use Haiku for classification, extraction and routing; Sonnet for most generation and tool-use work; and reserve Opus or Fable for the hard reasoning steps where quality visibly improves. Test the cheaper tier on a sample of real traffic before committing, since a retry or a longer, more verbose answer can erase the savings.
5. Claude API Pricing vs Other Providers
Teams usually compare Claude against OpenAI and Google tier against tier: a flagship reasoning model, a mid-range workhorse and a small fast model. The rates below show where each vendor lands, and why the rate card alone is a poor guide to what you will actually pay.
Brief comparison against OpenAI and Google equivalents at each tier
Claude and OpenAI list identical rates at the small and mid tiers, and Google is cheaper at the mid tier but costs more at the small tier. Prices are USD per million tokens (input / output) at standard rates.
Tier | Claude | OpenAI | |
Flagship | Opus 5.5: $4 / $20 Fable 5.1: $10 / $50 | GPT-6 Astra: $10 / $50 | Gemini 4 Argon: $4 / $20 from Dec 1, 2026 ($2 / $10 until Nov 30) |
Mid | Sonnet 5.5: $2 / $10 | GPT-6.1 Sol: $2 / $10 | Gemini 3.8 Flash: $1.50 / $7.50 from Jan 1, 2027 ($0.75 / $3.75 until Dec 31) |
Small | Haiku 5.5: $0.10 / $0.50 | GPT-6 Luna: $0.10 / $0.50 | Gemini 3.5 Flash-Lite: $0.30 / $2.50 |
At the flagship tier, Opus 5.5 and Gemini 4 Argon sit at $4 and $20, while Fable 5.1 and GPT-6 Astra both sit at $10 and $50. Long prompts shift the picture: OpenAI charges higher rates on the whole request above 272,000 input tokens, Haiku 5.5 charges five times its normal rate above 100,000, and Claude's other models include the full 1M-token window at standard rates. Gemini's output rates include reasoning tokens. The full side-by-side is in our LLM cost comparison.
Why rate-card comparison alone misleads (output verbosity, reasoning tokens, retry rates)
Three things move your real cost away from the rate card:
- Output verbosity. Models differ in how long their answers run. With output priced at 5x input, a model that writes 30% more text can erase a 20% price advantage.
- Reasoning tokens. Thinking tokens are billed as output. A model that reasons at length on easy prompts costs more per task than its price per token suggests.
- Retry rates. A cheaper model that fails a tool call or structured output 10% of the time costs more than its rate says, because you pay for each failed attempt and the retry.
The honest comparison is cost per successful task on your own workload, which means running a sample through each candidate and dividing total spend by completed outcomes.
6. Three Real Monthly Cost Scenarios
The scenarios below are modeled workloads, not customer data. Each shows the monthly Claude API cost under stated assumptions so you can swap in your own numbers, and each is calculated at standard rates with no discounts unless noted. Treat the totals as order-of-magnitude guides.
Internal tool, light usage
Assumptions: 2,000 requests a month, 3,000 input tokens and 600 output tokens each (an internal summarizer or Q&A bot).
| Model | Monthly cost |
| Haiku 5.5 | $1.20 |
| Sonnet 5.5 | $24 |
| Opus 5.5 | $48 |
At this scale the bill is a rounding error whichever model you pick, so choose on quality. This is also the profile where API pay-as-you-go beats a seat license: you are paying for 2,000 calls, not for a person.
Production customer-facing feature, steady volume
Assumptions: 1 million requests a month, 2,000 input tokens each of which 1,500 is a cached shared prefix, and 400 output tokens.
| Model | Without caching | With caching |
| Haiku 5.5 | $400 | $265 |
| Sonnet 5.5 | $8,000 | $5,150 |
| Opus 5.5 | $16,000 | $10,300 |
Caching saves about 34 to 36% here, and no more, because output is roughly three quarters of the remaining bill. That is the pattern in most customer-facing features: once the input is cached, output length and model choice are what is left to optimize. Capping response length and routing easy requests to a smaller model will do more than further caching work.
Agentic workflow with heavy context (where bills surprise people)
Assumptions: 20,000 tasks a month, 25 model calls per task, an average 60,000-token context per call (about 54,000 read from cache, 6,000 new and written to cache), and 800 output tokens per call.
| Model | Without caching | With caching |
| Haiku 5.5 | $3,200 | $845 |
| Sonnet 5.5 | $64,000 | $14,200 |
| Opus 5.5 | $128,000 | $28,400 |
This is where bills surprise people. Each of the 25 calls in a task resends the whole growing context, so input tokens multiply by the number of steps. Without caching, the Sonnet 5.5 bill here is $64,000, and with it $14,200. A single agent stuck in a loop adds calls at full context size, so the cost of a bug is the cost of a call times however many iterations it ran before anyone noticed. That is why the last section of this guide is about catching it early.
7. Accessing Claude Through Cloud Providers
You can buy Claude through the cloud you already use, which changes where the bill appears and sometimes your Claude API cost.
Bedrock, Vertex and Azure availability
Claude is available through Amazon Bedrock (operated by AWS), Google Cloud's Vertex AI, Claude Platform on AWS, and Claude in Microsoft Foundry. Bedrock and Vertex are run by the cloud provider; Claude Platform on AWS and Claude in Microsoft Foundry are operated by Anthropic and billed through the cloud marketplace. Feature availability varies by platform, and some newer API features arrive on the direct API first, so check the feature you need before you commit.
How pricing and billing differ from the direct API
- Regional endpoints. On Bedrock and Google Cloud, regional or multi-region endpoints carry a 10% premium over global endpoints.
- Marketplace billing. Claude Platform on AWS and Claude in Microsoft Foundry bill through the cloud marketplace in Claude Consumption Units (CCUs) at $0.01 each, metered hourly and invoiced monthly in arrears.
- Where the line item lands. Usage appears on your cloud invoice rather than a separate Anthropic invoice.
When routing through your cloud provider makes commercial sense
Routing through a cloud provider is worth it when you have an existing committed-spend agreement that Claude usage can draw down, when procurement and security reviews are simpler under a vendor you already use, or when you want a single consolidated bill. It is less attractive if you need the newest API features on day one or would pay the regional endpoint premium for no compliance benefit.
8. How to Track and Control Anthropic API Spend
Token costs scale with usage you do not directly see, so spend control needs to be set up before the bill arrives, not after.
Native usage tracking in the console and its limits
The Claude Console has Usage and Cost pages, and a Usage and Cost Admin API (requires an admin key) provides the same data programmatically with data fresh to about five minutes. The Cost API is daily granularity only. These tools show you totals by model and workspace, but they stop there: they do not know which of your teams, features or customers generated a given call, and they cannot see spend on other clouds or vendors.
Attributing spend to teams, features and customers
Workspaces are the native attribution tool. You can create up to 100 by default, set spend and rate limits per workspace, and each one isolates its own prompt cache. Giving each team or product its own workspace and API key is the simplest way to see who spent what. Finer attribution (per feature or per customer) requires tagging requests in your own application and joining that metadata to the usage data.
Setting budgets and alerts before month-end
Anthropic enforces monthly organization spend caps by usage tier: $500 on Start, $1,000 on Build and $200,000 on Scale. When you hit a tier cap, requests return HTTP 429 and stay blocked until 00:00 UTC on the first of the next month, with no retry-after header. A limit you set yourself behaves differently and returns HTTP 400. Both stop production traffic, so treat the cap as a last resort and set alerts well below it, at 50%, 80% and 90% of expected spend.
Catching runaway agent loops early
Most surprise bills come from loops: an agent retrying a failing tool, a pipeline reprocessing the same documents, or a prompt that grows each iteration. Three controls help: a hard cap on steps per task in your own code, per-workspace spend limits so one runaway job cannot consume the whole organization budget, and rate-limit headers monitored for sudden jumps in request volume. Alerting on spend per hour rather than per month is the difference between a $200 incident and a $20,000 one.
How nOps tracks Anthropic spend
Fully optimizing Claude spend means understanding how token consumption, model choice, and application demand affect the broader cloud environment powering them, across AWS, GCP, and Azure, and across every model provider running on top of them. Claude usage through Bedrock lands on your AWS bill alongside everything else.
That's where nOps comes in: helping FinOps teams understand, allocate, and optimize AI token costs alongside the rest of their cloud and AI infrastructure.
- Unified visibility: Get all of your spending from AWS, GCP, Azure, AI, and SaaS in one place, including Anthropic API spend and Claude usage through Bedrock. Cost allocation by application, customer, team, or business unit covers spend that was never tagged, with costs broken down by model and token type and anomaly detection on spend that moves off its baseline, hourly for Bedrock and daily for direct Anthropic API spend.
- Commitment Management: Automatically maximize discounts and minimize commitment risk across eligible cloud infrastructure supporting your AI workloads. Customers typically save ~20% by switching to nOps, and with results-based pricing, you pay only when you get better results.
We've talked to companies that can save millions on their cloud bills by switching to nOps from competitors. Book a free savings analysis to quantify exactly how much more you could save across the infrastructure supporting your AI workloads and the rest of your cloud environment.
nOps manages $5B+ in cloud spend and was recently rated #1 in G2's Cloud Cost Management category.
Frequently Asked Questions
How much does the Claude API cost per million tokens?
It depends on the model. Under current Anthropic API pricing, input costs $0.10 on Haiku 5.5, $2 on Sonnet 5.5, $4 on Opus 5.5 and $10 on Fable 5.1 and Mythos 5.1. Output is five times input on every model, so $0.50, $10, $20 and $50 respectively.
Is the Claude API cheaper than a Claude subscription?
If you only need a chat interface, a subscription is the simpler fit. If you need programmatic access, or your usage is light or bursty, the API is usually cheaper: $20 of API spend covers the equivalent of 10 million input tokens on Sonnet 5.5. For heavy all-day interactive use, a Max plan usually costs less than the same tokens at API rates. Anything that serves software or multiple users needs the API regardless.
Is there a free tier for the Claude API?
There is no permanent free tier, but Anthropic's pricing page says new users receive a small amount of free credits to test the API. Beyond that the API is pay-as-you-go, and new organizations may start in an Evaluation tier with limits below the standard ones while account history is established, then move up to Start (a $500 monthly spend cap), Build ($1,000) and Scale ($200,000) as usage grows. If you only want to try Claude without paying per token, the free Claude chat app is the closer fit.
How much does prompt caching save on Claude?
Cache reads cost 0.1x input on Haiku 5.5, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and Mythos 5.1, so up to 95 to 97.5% off the cached portion of your input. Whole-bill savings are smaller: about 34 to 36% in our steady-volume scenario, because output is not discounted.
How does Claude API pricing compare to OpenAI?
Compare tier to tier and measure cost per successful task, not the rate card, because verbosity, reasoning tokens and retry rates shift the real cost. See our full LLM cost comparison.
What are cache write vs cache read rates?
A cache write costs 1.25x the input price for the 5-minute TTL or 2x for the 1-hour TTL. A cache read costs 0.1x on Haiku 5.5, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and Mythos 5.1.
How do I track and control my Anthropic API spend?
Use the Console's Usage and Cost pages and the Admin API for totals, separate workspaces with spend limits for each team or product, and alerts well below your tier's monthly cap. For attribution by feature or customer, and for spend across Anthropic, cloud and SaaS in one view, use a FinOps platform such as nOps.
