Article

When to use OpenAI’s 2h, 8h or Batch discounts

For teams processing documents and support tickets, compare OpenAI’s background discounts with Batch, including costs, deadlines and data limits.

Editorial illustration for When to use OpenAI’s 2h, 8h or Batch discounts: a document represents the research briefing. Not documentary evidence.

OpenAI announced two- and eight-hour background processing windows in public beta on November 17, 2026, for teams handling non-urgent documents, support tickets and other API work. Eligible requests receive 30% or 40% lower model-token rates than Standard processing, respectively, in exchange for accepting a longer response window.

Choose these windows when work can wait hours; Batch remains cheaper at 50% below Standard for independent requests that can tolerate its 24-hour window. Keep time-sensitive customer replies on ordinary processing.

Which work can wait?

Start with when someone needs a usable result. Tokens are the units used to bill a model’s input and output; a lower token rate is useful only if the processing route still fits the job.

  • Ordinary processing: use it when a customer or worker needs a prompt answer. Ordinary background mode, with the default soonest window, is asynchronous but gives no completion-window discount.

  • Two-hour background: consider it for non-live work needed later in the day, with time left for follow-up steps and review.

  • Eight-hour background: consider it for work with more slack, such as document checks that do not need an immediate answer.

  • Batch: choose it when the request inputs are known upfront and a day-long processing window fits the schedule.

OpenAI’s background guide describes the two- and eight-hour windows as response-completion targets after the API accepts the initial request. They are not promises that a whole business task will finish within that time.

What would 10,000 document requests cost?

Consider a hypothetical workload using GPT-6.2 Sol: 10,000 independent text-document requests, each with 2,000 uncached input tokens, including instructions, and 500 total billed output tokens. The output allowance includes any reasoning and other non-visible generated tokens, not just the visible answer; reasoning tokens are billed as output.

That makes 20 million input tokens and 5 million output tokens. OpenAI’s current pricing page lists Standard short-context rates of $2 per million input tokens and $10 per million output tokens, and Batch rates of $1 and $5. Each example request is well inside the short-context band of at most 272,000 input tokens.

Processing route

Input per million tokens

Output per million tokens

Example token bill

Standard

$2.00

$10.00

$90

2h background

$1.40

$7.00

$63

8h background

$1.20

$6.00

$54

Batch, 24h window

$1.00

$5.00

$45

All amounts are US dollars. Standard costs (20 × $2) + (5 × $10) = $90. The two-hour and eight-hour figures apply the documented 30% and 40% reductions to those rates; they are calculated values, not measured bills.

The comparison holds the model and billed token totals constant and assumes every request succeeds on one attempt. It excludes caching, tools, follow-up calls, retries, storage, orchestration, human review, tax, regional uplifts and contract adjustments. Actual token use and output quality may vary; Batch also requires sufficient account capacity and a compliant input file.

For this workload, accepting eight hours instead of two saves another $9. Batch saves a further $9 if its longer window and file-based workflow are suitable. Those incremental amounts are more useful for deciding whether to change a working application than the headline percentages alone.

A token-rate cut is not the same as a reduction in the whole operating bill. For coding teams, reducing an agent’s repeated work is a separate cost lever: it addresses how much work the model does, rather than the price of each token.

Why a response window is not a job deadline

A document-review response may finish by asking the application to retrieve another document. The application must run that tool and send its result in a later request before it can receive the final review. This means an eight-hour submission made exactly eight hours before a hard deadline leaves no allowance for subsequent work.

OpenAI documents discounted follow-up requests that can qualify for higher queue priority when they reuse the project, model, completion window and continuation ID with the required settings. Start times still depend on scheduling.

The continuation_id is a scheduling identifier, not saved conversation history. Carry history using previous_response_id while the earlier response remains available, or replay saved conversation items after it expires.

Batch can return tool calls, but dependent later rounds still need application orchestration. Teams building with Pydantic AI can read the separate guide to Pydantic AI batching costs and recovery limits.

For Batch, the documented input limits are 50,000 requests and 200 MB per file, with one model per file. Match results by custom_id, not output order. A batch can expire with unfinished requests; completed results remain available and completed requests are charged.

Which models and settings qualify?

The public beta covers GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna. The discounted-window documentation requires Standard processing and no streaming; check that your project can access the chosen model.

The Responses API request schema requires background=true and background_options.completion_window set to 2h or 8h, with stream=false or streaming omitted. Set service_tier=default to select Standard. With auto, the request qualifies only if Standard is selected.

Flex processing is a separate beta alternative with Batch-priced tokens, slower responses and possible resource-unavailable errors. The current Flex pricing table includes GPT-6.1 Terra and GPT-6 Luna, but not GPT-6.2 Astra or Sol. The Standard-only background discount does not stack with Flex.

Check queue capacity and temporary storage

Discounted background requests and Batch jobs consume the same per-model queued-input-token allowance, counted at submission. Moving work between them does not create a second capacity pool. Check the project’s limits before scheduling a backlog; the example above does not establish that all 10,000 requests can be admitted at once.

Under OpenAI’s current data-control policy, Zero Data Retention projects can use the two- and eight-hour windows, with store treated as false, but the service still temporarily stores application state to process and retrieve responses. Batch is listed as not eligible for Zero Data Retention.

The roughly ten-minute retention statement in that policy applies to the default background window, not a specified retention duration for the discounted windows. If temporary storage is material to your data requirements, resolve that detail before submitting sensitive records.

For a first rollout, select a small, non-urgent workload and save each accepted response ID. OpenAI automatically retries eligible capacity errors on accepted discounted requests; while the response is queued or in progress, track the same ID through webhooks or polling. Compare final usable results, failures, elapsed time and the full bill before moving a larger workload.