On this page · 11 sections
- What OpenAI launched on 17 November
- The new rates, model by model
- Where the windows sit between Standard, Flex and Batch
- How to send a windowed request
- Four limits to check before you switch
- Which business workloads can wait
- A worked cost model
- A rollout plan for the next four weeks
- India-specific considerations
- How eCorpIT can help
- References
Summary. On 17 November 2026 OpenAI put discounted background completion windows into public beta in the Responses API. A request sent with background mode and a 2h window pays model token rates 30% below Standard; an 8h window pays 40% below Standard. Four models qualify: gpt-6.2-astra, gpt-6.2-sol, gpt-6.1-terra and gpt-6-luna. On GPT-6.2 Astra that turns $8 input and $40 output per million tokens into $5.60 and $28 at two hours, or $4.80 and $24 at eight hours. The windows sit between Standard, which answers now at full price, and the Batch API, which charges 50% of Standard but takes a file of independent requests and up to 24 hours. Two catches matter. GPT-6.2 Astra and Sol launched without Flex processing, and OpenAI is winding the Flex beta down, so on those two models the windows are the only discount short of Batch; on Terra and Luna, Flex still runs at Batch rates and costs less than the 8-hour window until OpenAI sets a retirement date. And windowed requests draw on the same queued-token limit as Batch. Our verdict: move anything a person reads tomorrow morning, and any multi-step agent run that nobody watches, to the 8-hour window; keep Batch for large sets of independent prompts.
About this article. This is for engineering leads, platform owners and finance teams who pay OpenAI API bills and want to know which jobs can trade speed for price. We checked every rate, parameter, model and limit on 20 November 2026 against OpenAI's pricing page, changelog, background mode, Batch, Flex, rate limit, prompt caching, webhook and data controls guides, and the four model pages. Rupee figures use European Central Bank reference rates. The feature is a public beta and OpenAI changes prices, so re-check before you budget; this is not financial advice, and no vendor paid for inclusion. Researched with AI assistance and checked against the primary sources listed in the references.
What OpenAI launched on 17 November
The changelog entry for 17 November 2026 lists the Responses API and four models, and says developers can now choose a two-hour or eight-hour background completion window at lower token rates. The pricing page repeats the terms: for eligible background requests on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna, model token rates are 30% below Standard for the 2-hour window and 40% below Standard for the 8-hour window. Each of the four model pages carries the same public beta note.
Background mode itself is not new. It already let a Responses API request run asynchronously, with the result fetched later by response ID or delivered by webhook. What changed is the new field background_options.completion_window, which takes three values.
| Window | What the API aims for | Discount on model token rates | OpenAI's example use |
|---|---|---|---|
| soonest (default) | Start as soon as possible | None | An on-demand report someone is waiting for |
| 2h | Complete within 2 hours of acceptance | 30% below Standard | Morning support tickets analysed before an afternoon triage meeting |
| 8h | Complete within 8 hours of acceptance | 40% below Standard | A set of documents reviewed overnight for the next morning |
The table above summarises OpenAI's background mode guide as checked on 20 November 2026. Note the wording: the API targets completion within the window after it accepts the request. That is a target, not a service-level guarantee, and the guide does not state a credit or refund if a response arrives late.
The new rates, model by model
The table below applies the 30% and 40% discounts to OpenAI's Standard short-context rates per million tokens, and sets them beside Batch and Flex from the same pricing page. Short context means requests up to 272,000 input tokens; above that, input rates double and output rates rise by half for the whole request.
| Model | Standard in / out | 2h window in / out | 8h window in / out | Batch in / out | Flex in / out |
|---|---|---|---|---|---|
| gpt-6.2-astra | $8.00 / $40.00 | $5.60 / $28.00 | $4.80 / $24.00 | $4.00 / $20.00 | Not offered |
| gpt-6.2-sol | $2.00 / $10.00 | $1.40 / $7.00 | $1.20 / $6.00 | $1.00 / $5.00 | Not offered |
| gpt-6.1-terra | $1.00 / $5.00 | $0.70 / $3.50 | $0.60 / $3.00 | $0.50 / $2.50 | $0.50 / $2.50 |
| gpt-6-luna | $0.10 / $0.50 | $0.07 / $0.35 | $0.06 / $0.30 | $0.05 / $0.25 | $0.05 / $0.25 |
The window columns are our arithmetic: Standard multiplied by 0.7 for two hours and by 0.6 for eight hours. OpenAI publishes the percentages, not a separate rate table, so check the first invoice against these numbers. Cached input follows the same pattern if the discount applies to all model token rates as the pricing note says; on Astra, Standard cached input is $0.40 per million.
Three things are left out of the discount by the way OpenAI words it. Tool fees, such as $10 per 1,000 web search calls, are not model token rates. Regional processing endpoints carry a 10% uplift for models released on or after 5 March 2026, and the pricing page does not say how that uplift combines with a window discount. And older models, including GPT-6 Astra and GPT-6.1 Sol, are not on the list.
Where the windows sit between Standard, Flex and Batch
OpenAI now sells the same GPT-6.2 tokens in several ways. The background guide says that, starting with GPT-6.2 Astra and Sol, new models launch without service_tier: flex, and it points long-running Responses API work to the discounted windows instead. The pricing page adds that Flex stays on the older models it already covers while OpenAI winds the beta down, with a retirement date to follow in the Flex guide.
| Option | Price vs Standard | When you get the answer | Request shape | Main trade-off |
|---|---|---|---|---|
| Ultrafast (GPT-6.2) | 3x to 28 Feb 2027, 6x from 1 Mar 2027 | Faster than Fast | Single request | Price doubles in March |
| Fast mode | 2x Standard | Faster than Standard | Single request | Pays more for speed |
| Standard (soonest) | 1x | Now, synchronous or background | Single request | Full price |
| 2h window | 0.7x | Target within 2 hours | Single request or chained follow-ups | Background only, no streaming |
| 8h window | 0.6x | Target within 8 hours | Single request or chained follow-ups | Background only, no streaming |
| Flex | 0.5x (Terra, Luna, older models) | Slower, can be refused | Single request | 429 errors when capacity is short |
| Batch API | 0.5x | Within 24 hours | File of independent requests | No follow-ups inside the job |
The Fast and Ultrafast multiples come from the pricing page and the GPT-6.2 model pages, the Flex terms from the Flex guide and the Batch terms from the Batch guide. Our note on the GPT-6.2 Ultrafast price change covers the top tier.
Two comparisons decide most cases.
Windows versus Batch. Batch is cheaper, at 50% of Standard, and its completion window can only be set to 24h. But a batch is a file of requests you submit together up front. The background guide makes the split explicit: use Batch for independent requests you can submit together, and background mode for long-running requests and multi-step agent runs, where your application reads one response, runs a tool, and sends a follow-up. A 24-hour batch also fails the morning-report test if it is submitted in the evening and lands after lunch.
Windows versus Flex on Terra and Luna. For these two models, Flex is still listed at Batch rates, half of Standard, so it costs less than even the 8-hour window. Flex has a cost of its own: slower responses, more timeouts, and occasional 429 Resource Unavailable errors when OpenAI lacks capacity, though OpenAI does not charge for those refused requests. The windowed requests run on Standard processing, and once the API accepts a 2h or 8h request it retries eligible capacity errors itself. If your Terra or Luna job already handles Flex refusals well, stay on Flex for now, but plan the move: OpenAI has said Flex will retire and has not yet given the date. If retries and timeouts cost you engineering time, the 8-hour window buys that back for 10 percentage points of discount.
How to send a windowed request
The rules are short, but each one disqualifies a request if missed.
- Use the Responses API. The feature is not listed for Chat Completions.
- Set
backgroundtotrue.
- Set
background_options.completion_windowto2hor8h.
- Set
service_tiertodefault. Withauto, the request qualifies only if the API happens to pick Standard.
- Leave
streamunset orfalse. Streaming works only with the defaultsoonestwindow.
- Collect the result by webhook on
response.completed, or poll the response ID while its status isqueuedorin_progress.
A minimal request body for an overnight review on Terra looks like this, based on the parameters in OpenAI's guide:
{
"model": "gpt-6.1-terra",
"background": true,
"service_tier": "default",
"background_options": {
"completion_window": "8h",
"continuation_id": "contract-review-2026-11-20"
},
"input": "Review the attached supplier contract for missing approval clauses."
}
Chained agent runs keep the discount. For a workflow that calls a tool, your application receives the first response, runs the function, and sends a follow-up with the same model, service tier, background setting, window and continuation_id. The discount applies to each eligible request, including follow-ups, and reusing the continuation ID makes follow-ups eligible for higher queue priority. The completion target, however, applies to each response from its own acceptance, so a five-step agent run on the 8-hour window could in principle take far longer than eight hours end to end. Design for that.
Webhooks need a fast endpoint. OpenAI retries webhook deliveries that do not get a 2xx response within a few seconds, for up to 72 hours with exponential backoff, so verify the signature, deduplicate on the webhook ID and hand the work to a queue.
Four limits to check before you switch
The queued-token limit is shared with Batch. Requests with 2h or 8h windows count against the Batch/Background Rate Limit, which caps total input tokens queued for a model, counted at submission. A team that already runs large batches can find its new background jobs refused, or its batches squeezed, because both now draw on one pool. Requests on the default soonest window keep the normal per-minute limits.
Prompt caches do not cross over. Standard requests outside the discounted windows cannot reuse prompt cache entries created by 2h or 8h requests, even with an identical prompt. If your interactive chatbot and your overnight job share a long system prompt, they will each pay to write their own cache. On Astra a 30-minute cache write costs $10 per million tokens and a 12-hour write $20, so a large shared prefix is worth measuring before and after.
Data is stored, even under zero data retention. Background mode temporarily stores response data even with store set to false or with Zero Data Retention, and encrypts that content at rest for all three windows. OpenAI's data controls page confirms that ZDR projects can use the 2h and 8h windows, with store treated as false and application state kept only to run the request and return the result. That is a real difference from Batch: the same table marks /v1/batches as not eligible for zero data retention. For personal data, record this temporary storage in your processing records; our guide to OpenAI zero data retention limits covers which endpoints are eligible.
It is a beta. OpenAI labels the windows public beta on all four models. Keep the window choice behind a configuration flag so a job can fall back to Standard or Batch without a code change.
Which business workloads can wait
The test is simple: who reads the output, and when. If a person is waiting on screen, use Standard. If the output feeds a meeting, a morning queue or another system that runs on a schedule, the windows usually fit. The table below maps common workloads to the cheapest option that still meets the deadline, using the terms above.
| Workload | When the output is needed | Best fit | Why |
|---|---|---|---|
| Customer chat, copilots, live agents | Seconds | Standard or Fast | A person is waiting |
| Support ticket triage and routing summaries | Same shift | 2h window | OpenAI's own example; tickets age if left 24 hours |
| Sales call and meeting summaries for CRM | Same day | 2h window | Reps update deals in the afternoon |
| Contract, policy and document review | Next morning | 8h window | Often needs tool lookups between steps |
| Code review notes on pull requests opened late | Next working day | 8h window | Reviewers read them at stand-up |
| Weekly management or board pack drafts | Next morning | 8h window | Scheduled, multi-step, nobody watching |
| Overnight agent runs with tools, such as reconciliation | Before office hours | 8h window with continuation ID | Follow-ups keep the discount; Batch cannot chain |
| Classifying or tagging 500,000 catalogue records | Within a day or two | Batch | Independent prompts, 50% beats 40% |
| Model evaluations and regression suites | Before the next release | Batch, or Flex on Terra and Luna | Cheapest, deadline is loose |
| Lead and account enrichment from a CRM export | Within a day | Batch, or 8h if tool calls are needed | Independent rows suit Batch |
Two judgement calls sit behind this table. First, a 40% discount on a workload that is 5% of your bill is not worth a new queue, a webhook and a failure path; start with the jobs that dominate spend. Our AI cost attribution playbook explains how to find them by team and feature. Second, Batch remains the floor. If a job is a list of independent prompts and the next-morning deadline survives a 24-hour window, Batch saves a further 10 percentage points over the 8-hour window.
A worked cost model
Take one monthly workload of 500 million input tokens and 100 million output tokens, all short context, with no caching, priced from OpenAI's Standard and Batch tables and the window percentages.
| Model | Standard per month | 2h window | 8h window | Batch | Monthly saving, 8h vs Standard |
|---|---|---|---|---|---|
| gpt-6.2-astra | $8,000 | $5,600 | $4,800 | $4,000 | $3,200 |
| gpt-6.2-sol | $2,000 | $1,400 | $1,200 | $1,000 | $800 |
| gpt-6.1-terra | $1,000 | $700 | $600 | $500 | $400 |
| gpt-6-luna | $100 | $70 | $60 | $50 | $40 |
The arithmetic for Astra at Standard is 500 x $8 plus 100 x $40, which is $4,000 plus $4,000, or $8,000. At the 8-hour window that becomes 500 x $4.80 plus 100 x $24, or $2,400 plus $2,400, which is $4,800. The saving of $3,200 a month is $38,400 a year.
In rupees, at ₹93.30 to the dollar (our cross of the ECB reference rates for 19 November 2026, rounded to two decimals), the Astra workload falls from ₹7,46,400 a month at Standard to ₹4,47,840 at the 8-hour window, a saving of ₹2,98,560 a month. On Luna the same token volume costs ₹9,330 at Standard and ₹5,598 at eight hours, which shows why model choice still matters more than the window. Moving from Astra to Sol on the 8-hour window cuts the bill by a further three quarters, if Sol's quality holds on your evaluation set.
Three caveats apply. Real bills include cached input, cache writes and tool fees, so model your actual usage export rather than these round numbers. Requests above 272,000 input tokens are billed at long-context rates for the whole request. And if a job moves from Standard to a window, its cache entries no longer serve your interactive traffic, which can raise the Standard side of the bill.
A rollout plan for the next four weeks
- Week 1: rank jobs by spend and deadline. Pull usage by project and model, and list every job whose output is consumed on a schedule. Put each in one of three buckets: needs Standard, fits a window, fits Batch.
- Week 1: check the shared limit. Look up the Batch/Background queued-token limit for each model in your organisation's limits page and add your current batch volume to the planned window volume.
- Week 2: build the plumbing once. A webhook endpoint that verifies signatures and deduplicates, a job table keyed by response ID, and a poller as a fallback.
- Week 2: pilot one job on the 8-hour window. Pick a single-request job on Terra or Sol, set
service_tiertodefault, and log acceptance and completion times for two weeks.
- Week 3: measure lateness and cost. Compare the invoice line for that project against the expected 40% reduction and record how many responses finished outside the window.
- Week 4: extend to chained agent runs. Add
continuation_id, persist each response output in case the previous response expires, and keep a flag to fall back to Standard.
If you are moving off older models at the same time, our GPT-5 and o3 retirement cost comparison sets out Sol, Terra and Luna pricing, and our GPT-6.2 Astra and Sol pricing guide covers the new models themselves.
India-specific considerations
Time zones help Indian teams. An 8-hour request accepted at 22:00 IST targets completion by 06:00 IST, before most offices open, so the overnight review, reconciliation and reporting jobs common in Indian back offices fit the window without changing working patterns. A US-hours batch submitted at Indian close of business may not.
Rupee budgets. At ₹93.30 per dollar, every $1,000 of Standard spend moved to the 8-hour window saves ₹37,320 a month. Ask your finance team to update the monthly AI budget line once the first discounted invoice arrives, rather than booking the saving in advance.
DPDP and storage. If you process personal data under the Digital Personal Data Protection Act 2023, treat the windows as a new processing step. Background mode stores request content temporarily, encrypted at rest, even with zero data retention, so document it before sending customer records through the windows.
How eCorpIT can help
eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our AI and machine learning services team can rank your OpenAI jobs by spend and deadline and move the right ones to the 2-hour, 8-hour or Batch tiers. Talk to us at /contact-us/.
Last updated: 20 November 2026.