
GPT-6.2 Astra Background Mode: 40% Off, Paid in Wall Clock
- OrcaNEWOrcaCyber: Hy4 Flash Abliterated / Uncensored2026-11-18$0.07 / $0.28 per 1M tokens · 185 tok/s
- tencentNEWTencent: Hy4 Flash2026-11-16$0.02 / $0.07 per 1M tokens · 214 tok/s
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 87 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 97 tok/s
- orcaNEWOrca: OrcaC2 1.02026-11-079 tok/s
- OrcaOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 90 tok/s
- OrcaOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 131 tok/s
- OrcaOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1M tokens · 76 tok/s
- tencentTencent: Hy42026-11-04$0.83 / $2.50 per 1M tokens · 112 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 114 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 67 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 94 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 41 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 210 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 111 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligence
- DeepSeekDeepSeek: DeepSeek V4.1 Flash 09102026-10-17$0.15 / $0.60 per 1M tokens · 311 tok/s
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligence
OpenAI'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 OpenAI'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 OpenAI'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

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. OpenAI'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.

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 OpenAI'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 OpenAI 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 OpenAI price cut shows up on our side the same day — but a completion window is a flag on OpenAI'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, GPT-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.

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
