With AI APIs, you can send tasks that don't need to return results right away at a lower rate. OpenAI and Claude (Anthropic) offer three mechanisms for this in total. Both companies offer the Batch API (send requests in a group and receive the results later); OpenAI alone offers discounted time windows for background processing; and OpenAI is moving toward ending Flex. This article first compares the Batch APIs from both companies using the same criteria, then explains the two options available only from OpenAI. It also includes measurements from our site's translation tool comparing OpenAI Batch with regular requests.
Bottom line first
Large volumes of one-shot tasks
50% off with the Batch API
Both OpenAI and Claude offer half-price input and output. The deadline is 24 hours. According to Anthropic, most Claude batches finish within an hour.
Tasks on OpenAI that can wait a few hours
Choose a time window for 30–40% off
Choose a 2-hour window (30% off) or an 8-hour window (40% off) when you submit. The discount applies to a single request as well as to follow-up requests that return tool results.
OpenAI Flex
Don't build anything new with it
It's not available with GPT-6.2 models, and OpenAI is moving toward ending the beta. If you're using it now, decide where to move your workload.
Checked: November 22, 2026. Sources are the official OpenAI and Anthropic materials cited at the end of each section.
1. Three mechanisms offer discounts on tasks that aren't urgent
The three options differ in how long you can wait and whether a task finishes in a single request. If you choose based only on the size of the discount, you may run a task with tool-call round trips through Batch and end up waiting for each round trip.
| Mechanism | Provider | Discount | Wait time | How you submit | Status |
|---|---|---|---|---|---|
| Batch API | OpenAI · Anthropic (Claude) | 50% | 24-hour deadlineAccording to Anthropic, most Claude batches finish within an hour | Group many requests into one submission and receive the results later | Available |
| Background processing time windows | OpenAI | 2-hour window: 30% · 8-hour window: 40% | Target is completion within the selected time window | Send requests one at a time; follow-up requests that return tool results get the same discount | Public beta |
| Flex | OpenAI | 50% (same rate as Batch) | Slower than usual and sometimes unavailable | Add service_tier: "flex" to a regular request | Being phased out · unavailable with GPT-6.2 |
Sources: OpenAI, “Batch API,” “Background mode,” and “Flex processing”; Anthropic, “Batch processing” (checked November 22, 2026). The Gemini API from Google also has a Batch API, with 50% of the regular cost and a 24-hour target.
2. Comparing the OpenAI and Claude Batch APIs
Both let you submit requests in a group and receive all the results together once they're done. The discount is the same 50%, but submission methods, limits, and result retention differ.
| Item | OpenAI Batch API | Claude Message Batches API |
|---|---|---|
| Discount | 50% off input and output | 50% off input and output |
| How you submit | Upload a JSONL file, then create a batch | Send a list of requests directly through the API |
| Limit per batch | 50,000 requests · 200 MB input file | 100,000 requests or 256 MB, whichever comes first |
| Creation and queue limits | You can create 2,000 batches per hour, and there is also a model-specific limit on the number of input tokens you can have queued for processing (check your value under Limits in the dashboard) | Rate limits apply to the number of HTTP requests to the Batches API and to the number of requests queued for processing (limits vary by usage tier) |
| Deadline | 24 hours | 24 hours (according to Anthropic, most batches finish within an hour) |
| When the deadline expires | Completed requests return results and are billed (unfinished requests are canceled; the documentation doesn't specify how they are billed) | Completed requests return results and are billed (requests that expire before being sent to the model aren't billed; the documentation doesn't specify how requests sent to the model are handled) |
| How to check for errors | Requests with errors appear in a separate error file, apart from the output | The result type is errored, and the request isn't billed (canceled requests are marked canceled and also aren't billed) |
| How to retrieve results | Download the output file and match requests using custom_id (the row order may not match the input) | Results are available when all requests finish or after 24 hours; match requests using custom_id |
| Result retention | 30 days by default (you can specify from 1 hour to 30 days when creating the batch) | 29 days after creation |
| What's not supported | Requests with stream | stream · fast mode (speed) · server-side fallbacks (fallbacks) · max_tokens: 0 |
| Combining with caching | Batch has a rate for cached input (half the regular rate) | Cache multipliers combine with the Batch discount |
Sources: OpenAI, “Batch API” (limits, expiration, and result files) and “Pricing” (cached input); Anthropic, “Batch processing” (limits, result types, and unsupported settings) and “Pricing” (how discounts combine). Checked November 22, 2026.
Neither provider guarantees that every request will finish within 24 hours. For work with a deadline, plan for these two procedures separately.
- Resubmit after the deadline: Retrieve results and errors, then sort them by request using
custom_id. Exclude successful requests. Resubmit requests with no result, expired requests, and canceled requests in a new batch or as regular requests. For requests with errors, identify and fix the cause (such as invalid input) before resubmitting. - Switch to regular requests before the deadline: Cancel the batch first and wait for cancellation to finish (OpenAI marks it cancelled; Claude marks it ended. For OpenAI, it can take up to 10 minutes for requests in progress to finish). Requests processed before cancellation are complete and billed, so retrieve their results and exclude them using
custom_id, then submit only the remaining requests as regular requests. If you submit without waiting for cancellation, you may pay twice for the same request.
Decide in advance when to switch by subtracting from the deadline the time to wait for cancellation, retrieve and reconcile results, process the remaining requests as regular requests, and leave room for retries.
Pricing
| Model | Regular (input / output) | Batch (input / output) |
|---|---|---|
| GPT-6.2 Astra | $8 / $40 | $4 / $20 |
| GPT-6.2 Sol | $2 / $10 | $1 / $5 |
| GPT-6.1 Terra | $1 / $5 | $0.50 / $2.50 |
| GPT-6 Luna | $0.10 / $0.50 | $0.05 / $0.25 |
| Claude Fable 5.2 | $8 / $40 | $4 / $20 |
| Claude Opus 5.5 | $4 / $20 | $2 / $10 |
| Claude Sonnet 5.5 | $2 / $10 | $1 / $5 |
| Claude Haiku 5.5 | $0.10 / $0.50 | $0.05 / $0.25 |
US dollars per 1 million tokens. Sources: OpenAI, “Pricing”; Anthropic, “Pricing” (checked November 22, 2026). Input lengths that change the rate: for the four OpenAI models in the table, inputs over 272,000 tokens per request are charged at the long-input rate (the same applies to Batch). For Claude Haiku 5.5, inputs over 100,000 tokens per request are charged at a higher rate ($0.25 / $1.25 for Batch). For the other three Claude models in the table, the rate doesn't change based on input length.
3. OpenAI background processing time windows — discounts also apply to tool round trips
Add background: true to a Responses API request and choose a time window with background_options.completion_window to lower the model's token rates. The discount is determined by the time window you select when submitting, not by the actual time taken. The time window is a target for when the response to that request should be completed.
| Time window | Discount | Suitable use (OpenAI example) |
|---|---|---|
soonest (default) | None | Generating a report while someone is waiting |
2h | 30% below regular rates | Compile morning inquiries before an afternoon meeting |
8h | 40% below regular rates | Read documents overnight and review them by the next morning |
POST /v1/responses
{
"model": "gpt-6.1-terra",
"input": "(Documents to read and instructions)",
"background": true,
"service_tier": "default",
"background_options": { "completion_window": "8h" }
}
Sources: OpenAI, “Background mode” and “Pricing” (checked November 22, 2026). The example above is a minimal version of OpenAI's example of “reviewing documents overnight.”
- Supported models: GPT-6.2 Astra · GPT-6.2 Sol · GPT-6.1 Terra · GPT-6 Luna. Public beta.
- Requirements: Set
service_tiertodefault(standard processing). Withauto, the discount applies only when standard processing is selected. Don't usestream. - Receiving results: Save the ID of the returned response, use the
response.completedwebhook to find out when it finishes, and retrieve the response by ID. If you can't use webhooks, check the status using the same ID. - Follow-up requests: When the model calls a tool, send another request with the tool's result. If you send that next request with a time window, it also gets the discount. In addition, using the same
continuation_idchosen by your application for the same model, time window, and project makes follow-up requests more likely to be prioritized. The time window is a target for each request, not for the entire process. Total elapsed time is the sum of the wait for each request and the time your application takes to run the tools. - Caching is handled separately: Prompt caches created by requests with a time window aren't available to regular requests outside that time window. The cache won't be hit even if the content is identical.
- Queue limits: Requests with 2-hour and 8-hour windows share the same limit as the Batch API for the number of input tokens that can be queued for processing.
- Storage: Background processing temporarily stores response data even if
storeis set to false.
The Claude Messages API pricing table we checked on November 22, 2026, doesn't mention a mechanism that lowers rates with time windows like this. This article compares the Batch API and prompt caching as Claude's options.
4. OpenAI Flex — don't build anything new with it
With Flex, add service_tier: "flex" to a regular request to get the same rate as Batch in exchange for slower responses and occasional unavailability. According to OpenAI's guidance as of November 22, 2026, the status is as follows.
- Supported models: Still available for models with Flex pricing in the pricing table (including GPT-6 Astra · GPT-6.1 Sol · GPT-6.1 Terra · GPT-6 Luna).
- Unsupported models: GPT-6.2 Astra · GPT-6.2 Sol. Don't use it with future models either.
- Policy: Being phased out of beta.
- End date: Not announced. OpenAI says it will add the date and migration guidance to the documentation page once decided.
Source: OpenAI, “Flex processing” (checked November 22, 2026).
If you're currently using Flex, decide where to move your workload in this order.
- Write down when you need the response for each task (in a few minutes, a few hours, or the next day) and whether you need streaming or tool-call round trips.
- If you need streaming, the only options are regular requests and caching (neither Batch nor time windows support streaming). If the task finishes in a single request and there's time to retry within the 24-hour deadline, use the Batch API. If you can't wait 24 hours but can wait a few hours, use a time window (2 hours or 8 hours) regardless of whether tools are involved; these are targets for each request, not guarantees. If there are tool-call round trips, also estimate whether the deadline allows for the total time from the first request to the final response, including the wait for each request in sequence and the time it takes to run tools. If not, use regular requests.
- Try a small number of requests with the candidate option, then compare cost, wait time, and required features against the deadline and your current Flex setup before switching.
5. Can the discount be combined with caching?
For tasks that repeatedly send the same preamble (instructions or materials), the cost can vary further depending on whether the prompt caching discount can be combined with the other discount.
| Mechanism | How it combines with caching |
|---|---|
| OpenAI Batch | It combines. Batch pricing includes a rate for cached input, which is half the rate for cached input in regular processing (for GPT-6.2 Sol, $0.10 → $0.05 per 1 million tokens) |
| Claude Batch | It combines. Cache write and read multipliers stack with the 50% Batch discount (for retention, Anthropic recommends using a 1-hour cache for shared preambles because Batch processing can take more than 5 minutes) |
| OpenAI time windows | Availability: across requests with time windows (not shared with regular requests outside a time window). Pricing: the pricing table doesn't list a cached-input rate for requests within time windows (checked November 22, 2026) |
| OpenAI Flex | The cached-input rate in Flex pricing applies (for GPT-6.1 Sol, $0.05 per 1 million tokens; this isn't an additional discount on top of Batch pricing) |
Sources: OpenAI, “Pricing,” “Background mode,” and “Flex processing”; Anthropic, “Batch processing” and “Pricing” (checked November 22, 2026).
For more about how caching works and what can prevent a cache hit, see “How prompt caching differs between OpenAI and Claude.”
6. Measured results: OpenAI Batch versus regular requests for cost and time
Our site uses APIs to create draft translations of articles. On November 22, 2026, we translated the same article with OpenAI's GPT-6 Luna (reasoning effort: medium) using regular requests and Batch, then compared the cost and time recorded by our tool. The workflow translates into English first, then uses the English version as a reference for the other languages. The preamble (instructions and source text) for each request is about 15,000 tokens in English and about 23,000 tokens in other languages. We didn't measure Claude Batch that day.
In this test, the cost was almost halved, while the wait increased by a few minutes. The HTML structure of the translations (number of headings, tables, and links) matched the Japanese source, just as with regular requests. This was a structural check; translation quality was reviewed separately.
As an example of the full workflow, when we wait for the English translation before submitting the remaining languages, we need to split the work into two batches. The second batch, which grouped the Spanish and Chinese translations, took 154 seconds, and the Chinese request read about 23,000 preamble tokens from the cache. The total for English, Spanish, and Chinese was about 6 minutes and 40 seconds (not a comparison with regular requests).
Results from small tests with 1–2 requests; processing time varies with demand on that day. Larger batches and busy periods may take longer.
7. Which option should you use? Four questions
The 2-hour and 8-hour windows are targets for completing each request, not guarantees. For work with tight deadlines, choose regular requests over a discount. The Claude pricing table we checked doesn't mention a time-window discount, so if you run a task with tool-call round trips through Batch, you'll have to wait for each batch to finish between round trips. For tasks that need streaming, use regular requests from either company.
Before choosing a discount, it can make a big difference to check with representative inputs whether a lower-cost model can still meet your quality standards. Differences in model rates are often larger than the discounts; for example, GPT-6 Luna's rate in the table above is one-twentieth that of GPT-6.2 Sol. See “How to save on AI usage and token costs” for tips on choosing a model.
Summary
For tasks that don't need to return results right away, the Batch API cuts rates in half for both OpenAI and Claude. The deadline is 24 hours, and neither provider guarantees that every request will finish. Requests completed by the deadline are billed. Resubmit requests that didn't return results, and fix the cause of errors before resubmitting those requests. OpenAI also offers 2-hour (30% off) and 8-hour (40% off) time windows selected at submission, which can be used for tasks involving tool-call round trips. Flex isn't available with GPT-6.2 and is being phased out, so don't use it for new tasks. With both companies, Batch discounts can be combined with caching discounts for shared preambles.
FAQ
How long does Batch take to return results?
The deadline is 24 hours for both OpenAI and Claude, and neither guarantees that every request will finish within that time. According to Anthropic, most batches finish within an hour. In our small test (OpenAI, 1–2 requests), results took 2–4 minutes from submission.
Are requests that don't finish within 24 hours still billed?
Both providers bill requests completed by the deadline. Based on what their documentation says, here's how unfinished requests are handled. OpenAI says only that they are canceled and doesn't specify how they're billed. Claude says requests that expire before being sent to the model aren't billed, but doesn't specify how requests that expire after being sent are handled. Claude also doesn't bill requests that error or are canceled.
I'm using Flex. How long can I keep using it?
As of November 22, 2026, no end date has been announced. OpenAI says it will add the date and migration guidance to the Flex documentation page once decided. Flex isn't available for GPT-6.2 Astra, GPT-6.2 Sol, or future models, so it's easier to migrate when you change models.
Can I use caching and Batch at the same time?
Yes. The multipliers stack for Claude, and OpenAI has a cached-input rate for Batch. Putting shared preambles at the beginning of requests makes them more likely to be cached.
Update log
- November 22, 2026Published.
Sources
- OpenAI, “Batch API,” “Background mode,” “Flex processing,” and “Pricing”
- Anthropic, “Batch processing” and “Pricing”
- Google, “Batch API”