A three-column price ladder for GPT-6.2 Astra: Standard at $8.00 input and $40.00 output per million tokens with streaming and no discounted window, a 2h window at 30% below Standard reading $5.60 input, $0.28 cached and $28.00 output with no streaming, and an 8h window at 40% below Standard reading $4.80 input, $0.24 cached and $24.00 output, footered as a target rather than a guarantee. The OrcaRouter logo sits in the bottom-right corner.
Guides & Insights

GPT-6.2 Astra Background Mode: 40% Off, Paid in Wall Clock

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

O​penAI's cheapest route to GPT-6.2 Astra does not change the price of the model. It changes when you are willing to receive the answer. Send the same request through the Responses API with background set to true and background_options.completion_window set to 8h, and the GPT-6.2 Astra tokens that list at $8 for input and $40 for output per million bill at $4.80 and $24. On GPT-6.2 Sol the $2 and $10 card becomes $1.40 and $7. Same weights, same reasoning, same context window. GPT-6.2 Sol, the cheaper of the pair, gets the identical treatment: $1.40 and $7 in the eight-hour window against $2 and $10 at Standard. What changed is your place in a queue.

That trade shipped on 17 November 2026, in the same changelog window as the two models themselves, and it is easy to misread as a price cut. It is not one. A price cut follows the model wherever it is called. A completion window is a flag on one endpoint, and every property that makes it valuable to O​penAI's scheduler is a property you have to accept: no streaming, no cache sharing with normal traffic, and a rate-limit budget you now share with the Batch API.

The reason it deserves more than a line in a changelog is that the discount is unusually deep for a tier that keeps full model quality. Batch has been 50% off for years, but Batch only takes requests you can submit as a file and forget. This is 40% off for a live agent conversation, with follow-up turns and tool output, as long as the conversation can tolerate a queue. For a lot of production workloads that is the difference between an affordability question and an architecture question.

What the window is, in API terms

Background mode itself is not new: it is the Responses API's way of running a long request asynchronously. You set background to true, get a response ID back immediately, and collect the result later through a webhook on response.completed or by polling the retrieve endpoint while the status reads queued or in_progress. Background mode was always about not holding a connection open for a twenty-minute agent run.

The new part is that the background queue now has tiers with prices. background_options.completion_window accepts soonest, 2h or 8h. Soonest is the default and carries no discount; it is the "generate a report while someone is waiting" case. 2h is 30% below Standard and 8h is 40% below, and the documentation is specific that the target clock starts when the API accepts the initial request and applies to that response.

"Targets completion within the selected window" is the phrase to read twice. It is a scheduling target, not a guarantee and not a fixed delay, and the API's own advice is that start times depend on scheduling. A request in the eight-hour window is not held for eight hours and then run; it is run when capacity allows and, if it finishes in four minutes, you get it in four minutes. What you have surrendered is the right to complain when it does not.

The ladder in dollars

Both models the window covers, priced at each tier, per million tokens, using O​penAI's published Standard rates as the baseline:

• GPT-6.2 Astra, Standard — $8 input, $0.40 cached input, $40 output

• GPT-6.2 Astra, 2h window — $5.60 input, $0.28 cached, $28 output

• GPT-6.2 Astra, 8h window — $4.80 input, $0.24 cached, $24 output

• GPT-6.2 Sol, Standard — $2 input, $0.10 cached, $10 output

• GPT-6.2 Sol, 2h window — $1.60 input, $0.08 cached, $8 output

• GPT-6.2 Sol, 8h window — $1.40 input, $0.06 cached, $7 output

• For scale, the same model at the fast end — Fast mode doubles the Standard rate to $16 and $80; Ultrafast is 3× Standard at $24 and $120 through 28 February 2027 and 6× at $48 and $240 from 1 March 2027

Three stacked bars showing what a 40% window does to a $4.00 Artificial Analysis task on GPT-6.2 Astra: $4.00 at Standard, about $2.80 in the 2h window and about $2.40 in the 8h window, beside a card breaking the $4.00 into $1.19 of cache reads, $1.10 of cache writes, $1.64 of output and $0.07 of uncached input. The OrcaRouter logo sits in the bottom-right corner.

Those are token rates, and token rates are not what a task costs. Artificial Analysis's weighted bill for a finished Intelligence Index task on GPT-6.2 Astra comes to $4.00 at Standard, on its v5.0.1 index measured at maximum effort. If the window discount applied uniformly across the categories in that bill, the same task would come to $2.80 in the two-hour window and $2.40 in the eight-hour one. Across ten thousand tasks, that is $28,000 and $24,000 instead of $40,000.

That "if" is doing real work. O​penAI's documentation describes the discount as applying to model token rates on each eligible request, including follow-ups, and its pricing page repeats the same phrasing. Neither page breaks the discount out by token category, and a token bill on this model is not mostly raw input: in Artificial Analysis's measurement, $1.19 of the $4.00 was cache reads, $1.10 was cache writes and only $0.065 was uncached input, with $1.64 in output. Cache writes are priced at their own rate — $10 per million for the 30-minute cache and $20 for the 12-hour cache — so a workload dominated by writing large prompts into cache may not fall by exactly 40%. Treat the 40% as the shape of the discount and measure your own bill rather than assuming the multiplier.

Four conditions you inherit

The discount is not available on every request, and the exclusions are where implementations usually go wrong.

• Standard processing only. Discounted windows require service_tier set to default. If you leave it on auto, the request qualifies only when the API happens to select Standard, which means your discount becomes a coin flip you cannot see in advance.

• No streaming. Streaming works only with soonest. For 2h and 8h you must omit stream or set it to false, and you cannot stream a response later if it was not created with streaming.

• One shared rate limit. Requests in the two-hour and eight-hour windows share the Batch/Background rate limit with Batch API jobs, and input tokens are counted at submission. An experiment that sends a million-token document into eight-hour background does not just wait; it consumes headroom your Batch jobs were using.

• Follow-ups must match. An agent run is a chain, and the discount survives the chain only if each follow-up repeats the window, the continuation_id, the model, the project and the background setting. Reuse the continuation ID and the follow-up also becomes eligible for higher queue priority. Change any one of those and the next turn is a Standard request.

A 2x2 grid of cards headed 'Four things the window takes with it': Standard processing only with the Flex tier gone, no streaming so you receive the finished response rather than tokens, a rate limit shared with Batch jobs where input tokens count at submission, and a split prompt cache whose window-written entries are invisible to Standard requests. The OrcaRouter logo sits in the bottom-right corner.

There is a fifth condition hiding in the cache rules, and it is the one with the longest tail. Standard requests outside the discounted windows cannot reuse prompt cache entries created by two-hour or eight-hour background requests, even when the prompt is identical, and the reverse holds too. If half your traffic runs in a window and half runs on demand, you have quietly split your prompt cache in two and are paying to write the same prefix twice. The discount on one side of that split is offset by a cache write on the other, and the model with a $10 per million cache write is exactly the wrong one to split.

The cost that is not on the invoice

The discount buys tokens with time, and the time is not bounded by the window. Consider the overnight document review the documentation itself uses as the example: one eight-hour request, a tool call, and a follow-up that carries the retrieved document back. Both responses qualify for the 40%, and the target restarts for the second one. In the best case the whole run is done before breakfast. In the worst case each of the two responses takes close to its full target, which makes the end-to-end ceiling roughly sixteen hours rather than eight.

That arithmetic does not scale well for long agents. A twelve-turn workflow that sends every turn through the eight-hour window has a ceiling of four days, and real scheduling sits somewhere between the best case and that ceiling with no published distribution. The honest way to deploy it is to decide per workflow, not per call: a pipeline whose output is consumed the next morning is a natural fit, and an interactive session is not, no matter how many tokens it would save. The window is a bid for cheap capacity, and bids get filled when there is capacity to fill.

The Flex hole nobody mentions

Before these windows, the way to buy a discount on this model family was service_tier: flex: 50% below Standard, at a lower priority. Flex still exists on the older models — GPT-6 Astra lists at $5 and $25 in the Flex table against $10 and $50 at Standard — but O​penAI's background guide states plainly that starting with GPT-6.2 Astra and Sol, new models launch without Flex processing, and that long-running work should use discounted completion windows with Standard processing instead.

Read the two numbers side by side and the direction of travel is visible. On the previous generation, a patient caller could buy 50% off. On this one the deepest tier is 40%, and it requires that you frame the work as background. The replacement is not a straight improvement on the old option; it is a narrower option at a smaller discount, and it arrives attached to a request shape — asynchronous, non-streaming, single response ID — that not every integration can adopt.

Batch still goes deeper, and is the wrong tool for half of this

The Batch API remains 50% off with a 24-hour turnaround, and on price alone it beats every background window. The distinction is structural rather than a matter of degree. Batch takes a JSONL file of independent requests and returns a file of results; the workflow has no memory between lines. Background mode is for one response at a time, with conversation state carried forward through previous_response_id and a chain of tool calls the application has to execute in between.

So the decision is not "which is cheaper" but "does my workload have a middle". Five thousand independent classification calls belong in Batch and always did. One agent run that reads a document, calls a function, and then writes a report cannot be expressed as a batch at all — its second request does not exist until the first one returns. That is the gap the windows fill, and it is a real one: the 40% is the first discount O​penAI has offered for stateful, multi-turn work.

The storage footnote with compliance consequences

Background mode stores response data temporarily even when store is false or the project uses Zero Data Retention, because the API needs the data to run the request and make the result retrievable. It is encrypted at rest for every window including soonest, and the guidance is to save the original input and the full response output yourself while you can still retrieve it. There is no stated time-to-live on that temporary storage.

For a team that selected Zero Data Retention for a regulated workload, "temporarily stored" is a sentence that needs to go to whoever signed off on the data-handling review, and it needs to go before the first eight-hour job is queued rather than after. The discount does not change the compliance posture of the endpoint; it does change how long a request and its output sit in a state you cannot see.

What routing does and does not add here

One thing worth being precise about, because it is easy to get wrong when a discount is announced: this is a scheduling feature, not a list price. OrcaRouter passes provider list price through with 0% markup, which is why a genuine O​penAI price cut shows up on our side the same day — but a completion window is a flag on O​penAI's own endpoint, and it does not travel with the model. Calling GPT-6.2 Astra through a router does not reproduce the 40%, and no router can, because the discount is the scheduler's to grant.

That leaves the two things routing is actually good for in this shape of deployment. The first is model choice: of the four models the windows cover — GPT-6.2 Astra, GPT-6.2 Sol, G​PT-6.1 Terra and GPT-6 Luna — the cheap end is already on our catalogue with GPT-6 Luna and GPT-6.1 Sol at list price, so the tiering decision and the provider decision stay on one key rather than two contracts. The second is protecting the calls that cannot wait. A system that puts its overnight jobs in an eight-hour window has made its latency-sensitive path more important, not less, and automatic failover on that path is what stops a single provider incident from turning a five-second call into an outage. The queue and the failover are complements: you spend the patience where you have it, so you can afford to be intolerant everywhere else.

OpenAI's developer documentation page for Responses API background mode, showing the background flag set to true, the background_options object with its completion_window values of soonest, 2h and 8h, and the notes on polling or webhook notification of the completed response.

The rule of thumb

If a response is consumed by a human who is watching, nothing here applies: use soonest, stream it, and pay Standard. If a response is consumed by a scheduled job, a report that lands before a morning meeting, or a pipeline whose next stage runs tonight, the eight-hour window is a 40% discount on full-quality tokens and the only real question is whether your integration can live without streaming and with a split prompt cache. The two-hour window at 30% is the awkward middle — deep enough to be worth an architecture change only if the work is genuinely deadline-bounded at two hours, which most batch-shaped work is not.

The number to watch is not the discount percentage but the share of your traffic that already waits. Teams that run agents overnight are getting 40% off a bill they were going to pay anyway. Teams that run them interactively are being offered a discount they cannot use, on a model that no longer sells the 50% Flex tier that used to be their fallback. That second group should read the pricing page before the architecture page, because on 17 November the cheapest way to call GPT-6.2 Astra stopped being a tier you select and became a schedule you accept.

Compared in this article1

Detected from this article · Benchmarks: Artificial Analysis · updated daily