The discount is the same on both sides. OpenAI's Batch API offers a 50% cost discount compared to synchronous APIs, and Anthropic's Message Batches API charges all usage at 50 percent of the standard API prices. The differences show up elsewhere: how results come back, what happens when the clock runs out, and which settings a batch will reject. It also covers when a 24-hour processing delay is worth paying half price.
The 50% discount on each side
Anthropic says its discount applies to input tokens, output tokens, and any special tokens. OpenAI states its saving against synchronous APIs. In both cases you pay half for work you can wait on.
OpenAI also offers a second benefit. Batch API rate limits come from a new, separate pool. Using the Batch API will not consume tokens from your standard per-model rate limits. Large evaluation suites often run on the same account as live traffic, and that separation keeps an overnight job from slowing the product your customers use. Halving the bill is the obvious savings. Keeping production traffic out of rate-limit trouble may be worth as much.
Anthropic makes a different promise. The failure of one request in a batch does not affect the processing of other requests. One bad prompt in a classification run won't sink the whole job.
Is the 24-hour processing delay worth it?
Both vendors work inside the same 24-hour window. OpenAI says each batch completes within 24 hours (and often more quickly). A batch that misses the deadline ends up in an expired state, which OpenAI defines as not able to be completed within the 24-hour time window. At Anthropic, you can access batch results when all messages have completed or after 24 hours, whichever comes first, and batches expire if processing does not complete within 24 hours.
In practice Anthropic says most batches complete within 1 hour.
Anthropic also warns that a single 300k-token generation can take over an hour to complete, and it tells developers to plan submissions around the 24-hour window. Very long outputs eat into that time.
OpenAI explains in more detail what an expired batch costs. Unfinished requests are cancelled, and any responses to completed requests are made available via the batch's output file. You're charged for tokens consumed from any completed requests. Expired requests go to the error file, where the custom_id lets you retrieve the request data. Anthropic does not charge for requests that never produced a message: errored, canceled and expired requests are not billed.
So is the wait worth it? Probably, if a human will read the results the next morning: nightly evaluations, relabeling a dataset, generating product descriptions. It isn't worth it for anything a user is waiting on.
Getting results back
This is where the two workflows differ most. OpenAI batches start with a .jsonl file, and each request needs a unique custom_id value. Each input file can only include requests to a single model.
The biggest risk is result order. OpenAI says the output line order may not match the input line order. Join your results on custom_id, never on line position. Code that zips inputs and outputs by index will produce mismatched results without throwing any error. Failed requests also come back separately: their error details go to an error file that can be found via the batch's error_file_id. Your parsing code needs to read both files.
Anthropic uses a polling model. Its batch status endpoint is idempotent and can be used to poll for Message Batch completion. Once a batch is done, you fetch results from the results_url field in the response. Those results stay available for 29 days after creation. After that, the batch record still exists but the results can't be downloaded. If your job depends on that output, archive it yourself.
Anthropic also adds access controls. Batches are scoped to a Workspace in the Claude Console, and downloading batch results in the Console can be disabled on the organization level or on a per-workspace basis. That matters to teams batching sensitive documents.
Limits and rejected settings
OpenAI publishes clear limits. A batch may include up to 50,000 requests, and a batch input file can be up to 200 MB in size. Embeddings batches have an extra cap of 50,000 embedding inputs across all requests in the batch. You can create up to 2,000 batches per hour, and the Batch API currently has no output-token limit. Cancelling a batch may take up to 10 minutes. Anthropic allows larger batches: a Message Batch is limited to either 100,000 Message requests or 256 MB in size, whichever is reached first.
OpenAI also fixes the completion window itself: it can only be set to 24h.
Anthropic's Message Batches API supports nearly all features available in the Messages API, including most beta features. The exceptions are stream, speed, fallbacks, and max_tokens: 0, and including any of them returns a validation error. OpenAI applies a similar rule for moderation jobs: the batch worker rejects requests that set stream=true, matching the synchronous moderation endpoint.
| Dimension | OpenAI Batch API | Anthropic Message Batches API |
|---|---|---|
| Price | 50% off synchronous APIs | 50% of standard API prices |
| Discount scope | Synchronous API comparison | Input, output, special tokens |
| Processing window | 24 hours, often quicker | 24 hours or when all complete |
| Expired batch | Completed requests billed | Expired requests not billed |
| Result matching | Order may differ; use custom_id | Fetch from results_url |
| Failure handling | Separate error file | One failure doesn't affect others |
| Result retention | Output file deleted 30 days after completion | 29 days from creation |
| Per-batch size | 50,000 requests, 200 MB file | 100,000 requests or 256 MB |
| Unsupported settings | stream=true (moderations) | stream, speed, fallbacks, max_tokens: 0 |
| Access scope | — | Claude Console Workspace |
Which batch API fits your job
Both APIs cost the same, so choose based on how your pipeline works.
OpenAI's Batch API fits teams that:
- run large single-model jobs from files
- want batch traffic kept out of their production rate limits
- want to split work into many small batches (up to 2,000 an hour)
Its main risk is result order. Treat custom_id as a required key and read the error file on every run.
Anthropic's Message Batches API fits teams that:
- would rather send requests in the API call than upload a .jsonl file
- need workspace-level isolation and download controls
- want one failed request to stay isolated from the rest of the batch
For either vendor, use the batch API for any job where results can wait a day. A synchronous run costs twice as much, and the only thing it buys you is speed you don't need.
Sources
- developers.openai.com – "Batch API"
- platform.claude.com – "Batch processing"