Claude API Cost Calculator (2026)

Claude pricing has three input rates instead of two: standard input, cache-write input (premium), cache-read input (90% discount). For a single call with no cache, the formula matches OpenAI's:

``` cost = (input_tokens / 1,000,000) × input_price_per_M + (output_tokens / 1,000,000) × output_price_per_M ```

When caching is enabled, the prefix you mark as cacheable bills at the cache-write rate on the first call (1.25x for 5-min TTL or 2x for 1-hour TTL), then bills at the cache-read rate (10% of base) on every subsequent call until the TTL expires. The amortized cost across N calls in the same TTL window:

``` amortized_cost = (cache_write_cost + (N-1) × cache_read_cost + N × non_cached_input_cost + N × output_cost) ```

Break-even on the 1-hour cache write (2x premium) happens after 2 cache hits. After that, every additional hit is pure savings. For a stable 2,000-token system prompt + tools on Sonnet 4.6 read across 100 calls in an hour: cache write = 2000 × $6/1M = $0.012 once, cache reads = 99 × 2000 × $0.30/1M = $0.0594 — vs reading the same prefix 100x at standard input = 100 × 2000 × $3/1M = $0.60. That is a **88% saving on the prefix portion**.

The Batch API stacks on top of everything else: 50% off both input and output for asynchronous jobs.

Same canonical call as our OpenAI calculator: a 1,000-token prompt that returns a 500-token answer, with no caching. At standard rates:

Claude Fable 5: (1000/1,000,000) × $10 + (500/1,000,000) × $50 = $0.010 + $0.025 = **$0.035 per call**.

Claude Opus 4.8: 0.001 × $5 + 0.0005 × $25 = $0.005 + $0.0125 = **$0.0175 per call**.

Claude Sonnet 4.6: 0.001 × $3 + 0.0005 × $15 = $0.003 + $0.0075 = **$0.0105 per call**.

Claude Haiku 4.5: 0.001 × $1 + 0.0005 × $5 = $0.001 + $0.0025 = **$0.0035 per call**.

Note Sonnet 4.6 ($0.0105) lands almost identical to OpenAI's gpt-5.4 ($0.010) on the same call. The choice between them is rarely about price at this volume; it is about quality on the specific task. For high-volume traffic, the 10x spread between Fable 5 and Haiku 4.5 is the real lever.

Same per-call shape — 1,000 in / 500 out — at 100,000 calls/month with a 700-token cacheable system prompt that hits cache 90% of the time on the 1-hour TTL:

Base path (no cache): 100,000 × $0.0105 = **$1,050/month** on Sonnet 4.6.

Cached path: cache writes ≈ 10,000 × (700/1M × $6) = $42. Cache reads ≈ 90,000 × (700/1M × $0.30) = $18.90. Non-cached input (the other 300 tokens × 100,000) = 30,000,000 / 1M × $3 = $90. Output = 100,000 × (500/1M × $15) = $750. Total = **$900.90/month** — a 14% saving on this workload.

Cache wins compound at higher prefix-share. If 1,800 of every 2,000 input tokens are cacheable and hit 90% of the time, the same 100k workload drops from $1,050 to roughly $810 — a 23% saving. Restructure prompts so as much of the prefix as possible is stable, and the cache does the rest.

Production high-volume workloads (classification, summarization, intent detection) routinely live on Haiku 4.5. At 1M calls × 1,000-in / 500-out:

Base path: 1,000,000 × $0.0035 = **$3,500/month**.

With Batch API on the 60% of workload that's asynchronous: 0.6 × $3,500 × 0.5 + 0.4 × $3,500 = $1,050 + $1,400 = **$2,450/month** (30% saving).

Layer in prompt caching on the system prefix (assume 800 of 1,000 input tokens cache 80% of the time): saves another ~$280. Total: **~$2,170/month** for 1M Haiku calls — about $0.00217 per call. This is the price floor for serious production Claude traffic.

Compare gpt-5.4-mini at $3,000/month standard for the same workload — Claude Haiku 4.5 is cheaper at scale once you batch + cache.

Agent loops on Claude follow the same shape as OpenAI: the model replays the full transcript each turn. Take a 5-turn loop with a 2,500-token system prompt + tools, growing context 600 tokens per turn:

Turn 1: 3,100 in / 250 out. Turn 2: 3,250 in / 250 out. Turn 3: 3,400 in / 250 out. Turn 4: 3,550 in / 250 out. Turn 5: 3,700 in / 250 out. Total: 17,000 input + 1,250 output. On Opus 4.8: 0.017 × $5 + 0.00125 × $25 = $0.085 + $0.03125 = **$0.117 per query** uncached.

Now apply 1-hour cache on the 2,500-token system + tools prefix. Cache write turn 1: 2500 × $10/1M = $0.025. Cache reads turns 2-5: 4 × 2500 × $0.50/1M = $0.005. Non-cached input (the growing transcript portion) ≈ 5,000 × $5/1M = $0.025. Output: $0.03125. Total: **$0.086 per query** — a 26% saving and the cache lasts an hour, so cross-session reuse adds more.

If your agent serves 10k queries/hour, the cache writes amortize across thousands of reads — the per-query cost lands closer to $0.060.

**Claude Fable 5** ($10 / $50): the new-frontier model. Best for high-complexity reasoning where Opus 4.8 hits its quality ceiling — multi-step agentic planning, dense scientific reasoning, large-context literature synthesis. 2x the price of Opus 4.8; reach for it only when the marginal quality lift earns the premium.

**Claude Opus 4.8** ($5 / $25): high-stakes reasoning and creative writing. Strong on long-form coherence, legal-grade drafting, complex code synthesis. Worth the premium over Sonnet 4.6 when correctness costs more than throughput.

**Claude Sonnet 4.6** ($3 / $15): the production default. Best general-purpose model for chat, agentic workflows, content generation. Sweet spot of quality + price for most teams — and the natural pair to gpt-5.5 for cross-model A/B tests.

**Claude Haiku 4.5** ($1 / $5): high-volume tasks where speed and price beat reasoning depth — classification, extraction, summarization, routing, simple Q&A. Cheaper than gpt-5.4-mini at scale once you cache. For the full cross-provider comparison see our GPT vs Claude vs Gemini calculator.

Anthropic's two cache TTLs cover different traffic shapes. The 5-minute cache write costs 1.25x base input — break-even after roughly 0.25 cache hits, so almost always positive EV for any prefix re-read within minutes. The 1-hour cache write costs 2x base input — break-even after 2 hits, which is trivial for any production agent serving multiple users per hour.

Rule of thumb: use 1-hour for system prompts + tool definitions + few-shot examples (anything stable across a session or across users). Use 5-minute for per-conversation context that does not survive long. Mark cache breakpoints explicitly in the messages array with `cache_control: { type: 'ephemeral' }`.

The single biggest mistake we see: caching the wrong layer. Caching only the system prompt and leaving 3,000-token tool definitions uncached misses the largest cache win. Caching everything stable up to and including the tools array is the right default. See Anthropic's prompt caching docs for breakpoint placement.

Anthropic's Batch API mirrors OpenAI's: 50% off both input and output for asynchronous jobs completing within 24 hours. Submit a JSONL file of message-creation requests; poll or webhook for completion.

Workloads that fit: nightly classification, evaluation runs, training-set generation, weekly digests, embedding-equivalent dense-retrieval precompute, automated content moderation across yesterday's data, exception reporting. If the consumer of the output is asynchronous, batch it.

Batch + cache stack the way OpenAI's do — multiplicatively. A batched Sonnet 4.6 call that hits a 1-hour cache for 80% of input lands at roughly $0.0036 per 1,000-in / 500-out call, vs $0.0105 standard. That is a 66% blended saving across the workload.

Anthropic runs two parallel billing relationships. The **API** (priced per-token in the table above, accessed via console.anthropic.com / docs.anthropic.com) is for developers building on Claude. The **Claude.ai consumer** subscription (Claude Free, Claude Pro at $20/month, Claude Max at $40/month) is for end-users chatting with Claude in a UI. They share infrastructure but billing is separate.

What this means for builders: a $20/month Claude Pro subscription does **not** include API credit. If you're building an application on Claude, you set up API billing independently at console.anthropic.com — same way OpenAI's consumer plans don't include API credit.

Claude Max ($40/month, launched 2025) is the consumer power-user tier with higher message caps on Opus and Sonnet, longer context windows in the UI, priority access during high-demand periods, and (as of mid-2026) included Computer Use beta access. It's the rough Claude equivalent of ChatGPT Pro's positioning but at a lower price point. Heavy users who chat with Claude daily across multi-hour sessions are the target audience.

For teams: Anthropic offers Claude Team at $25/seat/month annually (similar to ChatGPT Team) with shared workspace, admin controls, and SSO/SCIM at higher tiers. Distinct from the API — Team is a Claude.ai subscription, the API is the per-token developer product.

Claude's web search tool — enabled via the `web_search` tool definition in a messages call — bills at $10 per 1,000 searches in addition to standard token charges. Each search invocation returns top results that count toward your input token bill on the next turn.

For research-heavy assistants, the search add-on is a clean per-call surcharge: budget $0.01 per search, plus the input cost of the results (typically 500-2,000 tokens each, depending on how many sources Claude pulls). At Sonnet 4.6 input rates, a 1,500-token search result costs $0.0045 extra on top of the $0.01 search fee — call it $0.015 all-in per searched turn.

Use search when the answer requires post-training data (current events, live pricing, recent papers). Disable it on workloads that can run from model weights alone — every search adds $0.01-$0.02 to the bill with no offsetting input savings.

Every Claude price in this guide comes from Anthropic's live pricing page at docs.anthropic.com/en/docs/about-claude/pricing and the Anthropic console pricing surface at anthropic.com/pricing, fetched on 2026-06-20. Numbers were verified against three independent corroborating sources (community pricing aggregators, integration commits in the anthropic-sdk-python and anthropic-sdk-typescript repos, and the public Anthropic cookbook).

Anthropic publishes a cleaner pricing changelog than most providers — material price changes typically appear in their docs release notes within 48 hours. The current prices have been stable through 2026: Sonnet 4.6 at $3/$15, Haiku 4.5 at $1/$5, Opus 4.8 at $5/$25, Fable 5 at $10/$50. The 1-hour cache write tier is the newest addition (rolled out in late 2025) and remains the highest-EV cost lever for production traffic.

**How to verify before you budget**: open docs.anthropic.com/en/docs/about-claude/pricing in any browser (no auth required), copy your target model's full row (input / cache write 5-min / cache write 1-hour / cache read / output) into a spreadsheet. Compare against the table above. The Opus 4.7 → Opus 4.8 transition in early 2026 kept pricing unchanged, but the tokenizer shift means token counts moved ~35% higher for the same English text. Re-budget if you ported from Claude 3 era prompts.

**Reproducible methodology**: the GEO Playbook driving this guide (2026-06-19) requires every $ value to be sourced from the live provider page. Every row in the table above has a citation; every worked example references those rows; the FAQs reflect them. If you find a discrepancy with the live page, the live page is canonical.