Claude Batch API Pricing and When to Use It

Last updated 19 September 2026. This page explains claude batch api pricing: how the Message Batches API discounts token usage, what limits and feature exclusions apply, how prompt caching stacks on a best-effort basis, and when async jobs are the right cost lever versus sync Messages. Product headers, rates, and beta availability evolve — confirm live behavior in Anthropic’s Batch Processing docs and the current API rate card. [VERIFY: 2026-09-19]

Not affiliated with Anthropic. Claude Token Optimization is an independent site and audit service. Claude® and related product names are trademarks of Anthropic PBC. Plan prices, model rates, beta headers, batch limits, and usage metering change; always confirm on Anthropic’s own docs. [VERIFY: 2026-09-19]

Searches for claude batch api pricing, Message Batches discount, and “when should I use Anthropic Batch” usually want the same answer: you get 50% off standard API usage for work that can wait, with a 24-hour completion window and results retained for 29 days after creation. This spoke sits under the Pricing hub. Pair it with the API pricing rate card, prompt caching, cost per task, cut token usage, tool-use costs, and how tokens work. Soft CTA to a written review at the end — no dollar price on this page.

What the Message Batches API is

Anthropic’s Message Batches API lets you submit many Messages requests asynchronously instead of waiting on each sync call. You create a batch, poll or webhook for completion, then download results. Most batches finish in under one hour; the documented processing window is up to 24 hours. Results remain available for 29 days after the batch is created. [VERIFY: 2026-09-19]

That design matches offline workloads: evaluation suites, moderation queues, content backfills, bulk generation, overnight report jobs, and any pipeline where a few hours of latency is cheaper than paying full sync rates. It is not a faster Messages endpoint — it is a cheaper, deferred one. If your product needs interactive chat or sub-second tool loops, stay on sync Messages (and see tool-use cost patterns for those paths).

Batches are workspace-scoped. Concurrent in-flight work can slightly exceed a Workspace spend limit because multiple requests may already be running when the limit trips — plan budgets with a small headroom buffer. [VERIFY: 2026-09-19]

Claude Batch API pricing: 50% off standard usage

Message Batches are billed at 50% of standard API usage across input, output, and special token categories that apply to the underlying Messages request. There is no separate “batch subscription” — you still pay per million tokens, at half the sync card. [VERIFY: 2026-09-19]

The table below matches the Batch lines on our live API pricing page (standard rates halved). Figures are USD per million tokens (MTok) on the first-party Claude API. [VERIFY: 2026-09-19]

[VERIFY: 2026-09-19]

Legacy SKUs still on the card: Sonnet 4.5 / 4.6 Batch is $1.50 / $7.50 (half of $3 / $15). Opus 4.x family Batch remains $2.50 / $12.50 (half of $5 / $25), matching Opus 5 Batch dollars on the headline card. If your code still pins sonnet-4-5 IDs, you are not on Sonnet 5’s cheaper Batch line — migrating model IDs is often a larger lever than Batch alone. [VERIFY: 2026-09-19]

Quick mental math: 1M input + 200k output on Sonnet 5 Batch is about $1 + $1 = $2 versus ~$4 on sync at $2 / $10. Scale linearly, then subtract any prompt-cache hits you actually achieve. [VERIFY: 2026-09-19]

Batch limits, expiry, and what is not billed

Each batch is capped at 100,000 Message requests or 256 MB of request payload, whichever comes first. Split larger jobs into multiple batches rather than stuffing one oversized submission. [VERIFY: 2026-09-19]

[VERIFY: 2026-09-19]

A batch expires if it is not complete within 24 hours. Cancelled, expired, and errored individual requests are not billed — you pay for successfully processed Messages work, not for failed queue slots. Build idempotent custom IDs so you can safely retry only the failures. [VERIFY: 2026-09-19]

What Batch supports (and what it does not)

Feature coverage is broad but not identical to sync Messages. Plan your product surface before you route everything through Batch. [VERIFY: 2026-09-19]

Supported

• Vision and image inputs in Messages requests.
• Tool use, including server tools where available on the Messages surface.
• System messages, multi-turn conversations, and most betas that apply to Messages.
• Extended thinking — useful for hard eval items, but remember thinking tokens still bill as output under current metering; see extended thinking costs.

Not supported in Batch

• stream: true — no token streaming; results arrive when the batch item completes.
• speed / Fast mode — Fast mode is a sync / research-preview path with its own rate card, not a Batch option.
• max_tokens: 0 cache pre-warming — that warm-up pattern stays on sync Messages.

[VERIFY: 2026-09-19]

If your pipeline needs streaming UX or Fast mode latency, keep that traffic on sync and reserve Batch for the offline slice. Mixing both is normal: interactive agents sync, nightly evals Batch.

Extended output beta on Batches only

The extended output beta header output-300k-2026-03-24 raises max_tokens to 300k for certain models on Batches only — not on sync Messages. Documented models include Opus 5 / 4.8 / 4.7 / 4.6 and Sonnet 5 / 4.6. It is not currently available on Amazon Bedrock, Google Cloud / Vertex, or Microsoft Foundry for this path — first-party Batches only unless Anthropic updates partner docs. [VERIFY: 2026-09-19]

Long outputs are still expensive even at 50% off. A 100k-token Batch completion on Opus 5 is half of sync, but it is still a large output line. Prefer structured shorter answers, schemas, and stop sequences before you lean on 300k ceilings. Pair with cut token usage habits.

Prompt caching + Batch (best-effort stacking)

Prompt caching stacks with Batch on a best-effort basis. Typical hit rates in shared-context batches land around 30–98% depending on how stable your prefixes are and how the batch is scheduled. Prefer a 1-hour cache duration when many items share the same system prompt, tools, or document block so more of the batch can hit the same cached prefix. [VERIFY: 2026-09-19]

Operational tip: put the large shared context first, mark cache_control on that block, and keep per-item user content in the variable tail. Randomizing order or mutating the system prompt between items destroys hit rate. Details on multipliers and break-even live on prompt caching pricing; the sync rate card on API pricing shows write / hit dollars before the Batch half applies.

Do not assume 98% hits in a forecast. Model a pessimistic band (for example 40% hits) and a best case, then meter cache_read_input_tokens from results. Batch already halves the base; cache hits compound that savings when they land.

When to use Batch (and when not to)

Use Batch when: the business outcome can wait minutes to hours; you have thousands of similar requests; or you are backfilling history. Evals, moderation queues, dataset labeling, overnight content generation, and offline RAG answer regeneration are classic fits.

Do not use Batch when: UX is interactive; you need stream: true; you require Fast mode; or a human is blocked on the next token. Also avoid Batch as a “free retry” loop — failed items are unbilled, but a poorly designed job that errors half the time still burns eng time and delays the 29-day result window.

For product teams comparing providers on finished-task dollars, fold Batch into cost per task only when your competitors’ batch tiers apply to the same latency class. A sync Claude call versus a Batch Gemini job is not an apples-to-apples UX comparison.

Worked cost examples (illustrative)

The examples below use the Batch rate card on this page and the sync rates on API pricing. They are arithmetic illustrations, not quotes — re-run with your token shapes before you budget. [VERIFY: 2026-09-19]

Overnight eval: 50,000 Sonnet 5 items

Assume each item averages 2,000 input + 400 output tokens, with a shared 1,500-token system prompt cached at a high hit rate after the first write. Raw volume without cache:

• Sync Sonnet 5: 50k × (2k × $2 + 400 × $10) / 1e6 ≈ 50k × $0.008 = ~$400.
• Batch alone (50%): ≈ ~$200.

If ~1,500 of the 2,000 input tokens are cache hits at $0.20 / MTok on Sonnet 5, then Batch-discounted math on the hit portion compounds further on a best-effort basis — treat cache as upside on top of the 50% Batch cut, not a guaranteed second halving. Meter real cache_read_input_tokens from a pilot batch before you put the number in a board deck. [VERIFY: 2026-09-19]

Moderation backfill: 200,000 Haiku 4.5 classifications

Short prompts (800 input + 80 output) are where Haiku Batch shines. Sync Haiku at $1 / $5 would be roughly 200k × (800×$1 + 80×$5) / 1e6 ≈ ~$240. Batch at $0.50 / $2.50 lands near ~$120. Split into at least two batches because 200k requests exceeds the 100k request cap. [VERIFY: 2026-09-19]

Opus deep review: 5,000 long documents

Heavy items (12k input + 2k output) on Opus 5 sync ($5 / $25) run about 5k × (12k×$5 + 2k×$25) / 1e6 ≈ ~$550. Batch halves that to roughly ~$275. If many of those documents still need human-in-the-loop review the same afternoon, the dollar win may not be worth the latency — keep a sync path for priority tickets and Batch the backlog. [VERIFY: 2026-09-19]

These shapes also show why cost per finished task beats staring at list prices: retries, tool loops, and bad schemas can erase a 50% Batch discount faster than model choice alone. Pair Batch with cut token usage so you are not multiplying waste at half price.

Batch vs seats vs sync API (same company, three invoices)

Teams often confuse three Claude cost surfaces:

1. Subscription seats (Pro, Max, Team) — capacity bars inside Claude apps and Claude Code when authenticated as a seat. See Pricing and usage limits.
2. Sync Messages API — per-token invoices at full rate; streaming and Fast mode live here.
3. Message Batches API — same Messages shape, async, 50% off, no streaming / Fast mode. [VERIFY: 2026-09-19]

Moving a Cowork-style interactive session onto Batch does not make sense. Moving a nightly dataset job off sync Messages onto Batch usually does. If you are still deciding seat vs API for humans, read Pro vs API; Batch is an API-side discount, not a substitute for a Max seat.

Partner platforms (Bedrock, Vertex, Foundry) may expose their own batch or async offerings with different multipliers and feature flags — see Bedrock vs API for how the AWS side compares. The 300k extended-output Batches beta called out above is documented as first-party Batches for listed Opus / Sonnet IDs — confirm partner docs separately before you assume parity. [VERIFY: 2026-09-19]

How Batch fits your Claude cost stack

Batch is one lever among several. Order of operations for most API-heavy teams:

1. Route the model correctly — Haiku for classification, Sonnet for agents, Opus only when failure is expensive (model routing).
2. Shrink repeated prefixes with prompt caching and thinner tool results (caching, tool-use costs).
3. Move offline volume to Batch for the 50% cut once the request shape is stable.
4. Meter rate limits and spend limits separately from subscription usage bars — see the Usage hub and upcoming rate-limits spoke; for now start at usage and usage limits. Workspace spend can be briefly exceeded under Batch concurrency. [VERIFY: 2026-09-19]

Estimate volume in the cost calculator with a Batch percentage applied, then compare against sync-only. If the bill is still dominated by fat prompts rather than unit price, fix structure before you chase another discount.

Implementation checklist

• Cap each batch under 100k requests / 256 MB; shard larger corpora. [VERIFY: 2026-09-19]
• Assign stable custom IDs; retry only cancelled / expired / errored items (unbilled). [VERIFY: 2026-09-19]
• Prefer 1-hour cache on shared system + tools; measure hit rate from usage fields. [VERIFY: 2026-09-19]
• Do not set stream, speed, or max_tokens: 0 on Batch items. [VERIFY: 2026-09-19]
• Download results within 29 days; archive elsewhere if you need longer retention. [VERIFY: 2026-09-19]
• For 300k max output needs, confirm output-300k-2026-03-24 on first-party Batches for your model — not sync, not Bedrock/GCP/Foundry currently. [VERIFY: 2026-09-19]

Get a written look at Batch vs sync in your stack

Rate cards explain the unit discount. Your queues explain the multiplier: which jobs are truly offline, which still need sync, and whether cache hit rates make Batch + caching beat a model downgrade alone.

If you have production Messages traffic or a representative sample of eval / backfill jobs and want a written map of where tokens go — and which slice should move to Batch — request a written audit of your prompts. Soft CTA only on this page; confirm current pricing on the audit page itself.