Claude API pricing in 2026: every model, every tier, and what you'll actually pay

Claude API pricing is charged per million tokens, billed separately for input and output, with additional rates for cached reads, cache writes, and batch processing. There is no monthly platform fee and no minimum commitment — you pay for exactly the tokens you send and receive. That sounds simple, and the published rate card is simple. What is not simple is the effective price you actually pay, which after caching, batching, retries, tool-call loops, and thinking tokens routinely lands 40–70% away from a naive rate-card estimate in either direction. This guide covers both: the exact numbers, and the math that determines your real invoice.

The short answer: Claude API rates per million tokens. Anthropic prices three model tiers. Claude Opus, the frontier reasoning tier, is the most expensive and is priced at roughly $15 input / $75 output per million tokens. Claude Sonnet, the balanced workhorse most production traffic runs on, sits at roughly $3 input / $15 output per million. Claude Haiku, the fast small tier, is roughly $0.80 input / $4 output per million. Output tokens cost 5× input tokens across every tier — a ratio that matters enormously, because it means verbose responses, not long prompts, are what blow up your bill. Anthropic adjusts these rates as new model generations ship, so always confirm against the current pricing page before you build a budget on them; the structure, however, has been stable for two years.

Why output tokens dominate your Claude bill. Teams instinctively optimize prompts, because prompts are the part they wrote. But at a 5:1 output-to-input price ratio, a 500-token prompt returning a 1,000-token answer on Sonnet costs $0.0015 for input and $0.015 for output — output is 91% of the request cost. The single highest-leverage change most teams can make to Claude spend is not prompt compression; it is capping max_tokens realistically, instructing the model to answer concisely, and using structured output schemas that stop the model from narrating its work. We routinely see 25–35% reductions from output discipline alone, with zero quality impact and no model change.

Prompt caching: the biggest lever in Claude pricing. Anthropic's prompt caching lets you mark a stable prefix — system prompt, tool definitions, a retrieved document, few-shot examples — and reuse it across requests. Writing to the cache costs a premium over the base input rate (roughly 1.25× for a 5-minute TTL, higher for the extended TTL), and reading from it costs roughly 0.1× the base input rate. That is a 90% discount on every cached input token. The break-even is straightforward: with a 1.25× write premium and a 0.1× read rate, you recover the write cost after about two reads, and everything past that is nearly free input. If a stable prefix is reused four or more times inside the TTL window, caching is unambiguously correct. If your prefix rotates — rotating few-shot examples, per-user context injected at the top, timestamps in the system prompt — you pay the write premium repeatedly and never amortize it, and caching raises your bill by 15–20%. Measure prefix stability before you enable it; do not enable it by default.

Batch processing: 50% off if you can wait. The Message Batches API accepts up to tens of thousands of requests asynchronously and returns results within 24 hours, at a 50% discount on both input and output tokens. For any workload that is not user-facing — nightly enrichment, backfills, evals, document classification pipelines, embedding-adjacent labeling — this is the cheapest possible way to run Claude, and it stacks with prompt caching. The mistake teams make is assuming batch means slow: most batches complete in well under an hour. If your workload tolerates minutes rather than milliseconds, run it through batches and halve the line item.

Extended thinking and how it is billed. Claude's extended thinking mode produces reasoning tokens before the final answer, and those thinking tokens are billed as output tokens at the full output rate. This is the most common source of surprise invoices we see. A request with a modest visible answer can generate thousands of billed thinking tokens, turning a $0.015 request into a $0.15 one. Extended thinking is genuinely valuable for hard multi-step reasoning, math, and complex agentic planning — and it is pure waste on classification, extraction, and formatting. Gate it per route, set a thinking budget, and log thinking-token counts separately so the cost is visible rather than buried in your output total.

Real cost-per-request math. Consider a customer-support assistant on Sonnet: a 4,000-token cached system prompt and knowledge base, 300 tokens of fresh user context, and a 400-token answer. Uncached, that is 4,300 input tokens ($0.0129) plus 400 output tokens ($0.006) = $0.0189 per request. With caching on the 4,000-token prefix, input drops to roughly $0.0012 (cached read) + $0.0009 (fresh) = $0.0021, and the request costs about $0.008 — a 57% reduction. At a million requests a month that is the difference between $18,900 and $8,100. Now move the intent-classification step in the same pipeline from Sonnet to Haiku: that sub-call drops from $3/M input to $0.80/M, and the blended pipeline cost falls another 20–30%. None of these are exotic optimizations; they are the default configuration of a well-run Claude deployment.

Claude vs GPT-4o vs Gemini on effective cost. On sticker price, Claude Sonnet ($3/$15) is more expensive than GPT-4o (roughly $2.50/$10) on output and comparable on input, and both are well above Gemini Flash. On effective cost the picture changes, because the discount mechanics differ. OpenAI applies automatic caching at roughly a 50% read discount with no write premium — better for sporadic, unpredictable reuse. Anthropic requires explicit cache control but pays back a 90% read discount — decisively better for high-frequency reuse of a large stable prefix, which describes most RAG and agent workloads. For a support agent replaying a 10,000-token knowledge prefix hundreds of times an hour, Claude Sonnet with caching is frequently cheaper per request than GPT-4o with automatic caching, despite the higher list rate. Compare effective cost per successful outcome, never rate cards.

How to estimate your Claude bill before you ship. Take your expected requests per month, multiply by average input tokens and average output tokens separately, apply the per-million rates, then apply three adjustments: subtract the cached fraction of input at 0.9× savings, subtract the batchable fraction at 0.5× savings, and add a 10–15% overhead for retries, tool-call round trips, and failed generations. That overhead line is real and almost always omitted. An agent that makes four tool calls per user turn is billing five Claude requests, not one — the conversation history grows with each hop, so the fourth call carries the tokens of the first three. Agentic workloads are quadratic in cost, which is why they surprise teams that budgeted linearly.

Seven ways to cut Claude API costs without hurting quality. (1) Cap max_tokens and prompt for brevity — output is 5× the price of input. (2) Enable prompt caching on any prefix reused 4+ times per TTL, and only there. (3) Route classification, extraction, and routing decisions to Haiku with a quality probe that falls back to Sonnet on regression. (4) Move every non-interactive workload to the Batches API for a flat 50% cut. (5) Gate extended thinking per route and budget the thinking tokens. (6) Trim conversation history aggressively in agent loops — summarize past turns instead of replaying them verbatim. (7) Set per-tenant rate limits so one heavy customer cannot consume the month's budget in a weekend. Applied together, these reliably take 40–60% off a Claude bill, and the first four require no model changes at all.

Monitoring what you actually pay. Anthropic's console shows spend by API key and workspace. That is enough until you have more than one feature calling the API, at which point you need to know which product feature and which tenant generated the tokens — a question no provider dashboard can answer, because the provider does not know your product. Instrument at the call site: tag every request with feature, tenant, model, and prompt fingerprint, then track cost per successful outcome rather than cost per token. That metric is the only one that tells you whether a cheaper model actually saved money or just shifted the cost into retries and human escalations.

The bottom line. Claude API pricing is transparent at the rate card and highly variable in practice. Sonnet at $3/$15 per million tokens is the reference point most teams should budget from; caching, batching, and tier routing then move your effective rate by 40–70%. Teams that instrument early treat Claude spend as a dial they control. Teams that do not discover their true unit economics in the first invoice after launch. SpendTensor gives you token-accurate Claude traces, feature and tenant allocation, a quality-guarded router across Claude tiers, and a forecast of next month's Anthropic invoice within ±3% — connect your Anthropic key and see the numbers on your own traffic in an afternoon.