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.

MechanismProviderDiscountWait timeHow you submitStatus
Batch APIOpenAI · Anthropic (Claude)50%24-hour deadlineAccording to Anthropic, most Claude batches finish within an hourGroup many requests into one submission and receive the results laterAvailable
Background processing time windowsOpenAI2-hour window: 30% · 8-hour window: 40%Target is completion within the selected time windowSend requests one at a time; follow-up requests that return tool results get the same discountPublic beta
FlexOpenAI50% (same rate as Batch)Slower than usual and sometimes unavailableAdd service_tier: "flex" to a regular requestBeing 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.

ItemOpenAI Batch APIClaude Message Batches API
Discount50% off input and output50% off input and output
How you submitUpload a JSONL file, then create a batchSend a list of requests directly through the API
Limit per batch50,000 requests · 200 MB input file100,000 requests or 256 MB, whichever comes first
Creation and queue limitsYou 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)
Deadline24 hours24 hours (according to Anthropic, most batches finish within an hour)
When the deadline expiresCompleted 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 errorsRequests with errors appear in a separate error file, apart from the outputThe result type is errored, and the request isn't billed (canceled requests are marked canceled and also aren't billed)
How to retrieve resultsDownload 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 retention30 days by default (you can specify from 1 hour to 30 days when creating the batch)29 days after creation
What's not supportedRequests with streamstream · fast mode (speed) · server-side fallbacks (fallbacks) · max_tokens: 0
Combining with cachingBatch 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

ModelRegular (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 windowDiscountSuitable use (OpenAI example)
soonest (default)NoneGenerating a report while someone is waiting
2h30% below regular ratesCompile morning inquiries before an afternoon meeting
8h40% below regular ratesRead 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_tier to default (standard processing). With auto, the discount applies only when standard processing is selected. Don't use stream.
  • Receiving results: Save the ID of the returned response, use the response.completed webhook 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_id chosen 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 store is 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.

  1. 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.
  2. 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.
  3. 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.

MechanismHow it combines with caching
OpenAI BatchIt 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 BatchIt 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 windowsAvailability: 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 FlexThe 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.

Cost for one English translation (US dollars, calculated from tokens used)

Regular request$0.0059
Batch$0.0030

Time for one English translation (seconds)

Regular request52 seconds
Batch246 seconds

Cost is not the billed amount; it's calculated by multiplying the token counts in the response's usage by the rates in the pricing table. Regular request: 3 input tokens, 15,389 cache write tokens, and 7,913 output tokens, multiplied by $0.10 for input, $0.125 for a 30-minute cache write, and $0.50 for output (per 1 million tokens), for approximately $0.00588. Batch: 3 input tokens, 15,404 cache write tokens, and 8,199 output tokens, multiplied by the Batch rates of $0.05, $0.0625, and $0.25, for approximately $0.00301. In OpenAI's pricing table, cache writes (30m write) have a separate rate from input. Time for a regular request is from submission until the response arrives; for Batch, it's from submission until results are received and includes the wait while checking status every 30 seconds.

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

A person is waiting for the result (chat or interacting with a screen)Regular request + prompt caching
Many tasks finish in a single request, and the deadline allows time for retries within the 24-hour windowBatch API (50%)
On OpenAI, you can't wait 24 hours but can wait a few hours (whether it's one request or includes tool-call round trips)2-hour window (30%) or 8-hour window (40%). If there are round trips, estimate the full workflow time; if it doesn't fit the deadline, use regular requests
On Claude, the task involves tool-call round tripsGenerally, use regular requests + caching. Use Batch only if the deadline allows for the wait between batch stages plus time for retries

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