OpenAI shipped GPT-6.2 Astra and GPT-6.2 Sol on November 17. The headline is a 20% price cut on Astra, to $8 input and $40 output per million tokens. Sol stays at $2 and $10. The change that hits more budgets is in the docs: neither GPT-6.2 model offers Flex processing. In its place come two discounted background windows on the Responses API: 30% off Standard if the answer can wait two hours, 40% off if it can wait eight. Flex was 50% off. A nightly job that moves from GPT-6.1 Sol on Flex to GPT-6.2 Sol on the 8-hour window pays 20% more for the same tokens. The Batch API still bills half price, so most of that job should go there instead.
Prices come from OpenAI's [pricing page](https://developers.openai.com/api/docs/pricing), the [GPT-6.2 Sol](https://developers.openai.com/api/docs/models/gpt-6.2-sol) and [GPT-6.2 Astra](https://developers.openai.com/api/docs/models/gpt-6.2-astra) model pages and the [background mode guide](https://developers.openai.com/api/docs/guides/background), as of November 19, 2026. Background windows are a public beta. Check the pages before you plan around them.
What changed on November 17.
| GPT-6 Astra (before) | GPT-6.2 Astra | GPT-6.1 Sol (before) | GPT-6.2 Sol | |
|---|---|---|---|---|
| Input / 1M | $10.00 | $8.00 | $2.00 | $2.00 |
| Cached input / 1M | $1.00 | $0.40 | $0.10 | $0.10 |
| Output / 1M | $50.00 | $40.00 | $10.00 | $10.00 |
| Batch | 50% off | 50% off | 50% off | 50% off |
| Flex | Not offered | 50% off | Not offered | |
| Background 2h / 8h window | 30% / 40% off | 30% / 40% off | ||
| Ultrafast | 3x until Feb 28, 2027, then 6x | 6x | 3x until Feb 28, 2027, then 6x | |
Reasoning effort none | Rejected | Rejected | Rejected | Rejected |
Three things in that table matter for the bill.
- Astra got cheaper, and its cached input got much cheaper. Cached input fell from $1.00 to $0.40, a 60% cut, more than the 20% on fresh tokens. Agent loops that re-read a long prefix gain the most.
- The Astra to Sol gap narrowed from 5x to 4x per token. On the Vals Index, OpenAI's launch numbers put Sol at $3.18 per task and Astra at $10.68, about 3.4x (The Decoder). Astra is still the expensive rung. It is less expensive than it was.
- The cheap lane for work that can wait is now three lanes. Batch, the 2-hour window and the 8-hour window, each at a different price.
Five prices for one model.
Flex was the easy lane. It was an ordinary synchronous call with service_tier: "flex", it billed half price, and a request that got a 429 was not billed. You changed one field and kept your code. The background windows are a different shape. The call returns right away with a response ID, and you poll or wait for a webhook. Requests in the 2h and 8h windows share the Batch rate limit, and input tokens count against it at submission.
One more rule changes how you plan caching: a Standard request cannot reuse a cache entry created by a 2h or 8h background request, even when the prompt is identical. If an interactive feature and a nightly job share a long system prompt, they now warm separate caches.
What the same job costs in each lane.
Take a nightly enrichment job: 50,000 requests a night, 30 nights a month, 6,000 uncached input tokens and 800 output tokens per request. On GPT-6.2 Sol at Standard, one request costs $0.012 of input and $0.008 of output, $0.020 in all.
| Lane | Model | Per request | Per month (1.5M requests) | Results within |
|---|---|---|---|---|
| Standard | GPT-6.2 Sol | $0.0200 | $30,000 | Seconds |
| Background 2h | GPT-6.2 Sol | $0.0140 | $21,000 | Targets 2 hours |
| Background 8h | GPT-6.2 Sol | $0.0120 | $18,000 | Targets 8 hours |
| Batch API | GPT-6.2 Sol | $0.0100 | $15,000 | Up to 24 hours |
| Flex | GPT-6.1 Sol | $0.0100 | $15,000 | Seconds to minutes, may 429 |
| Standard | GPT-6.2 Astra | $0.0800 | $120,000 | Seconds |
| Batch API | GPT-6.2 Astra | $0.0400 | $60,000 | Up to 24 hours |
| Flex | GPT-6 Luna | $0.0005 | $750 | Seconds to minutes, may 429 |
An illustrative workload, not a customer's. Prices are list, short context, with no cache hits.
Read the table from the bottom. Luna on Flex is 20x cheaper than Sol on Batch. Picking the lane moves the bill by 2x. Picking the model moves it by 20x or more. If the job is classification, extraction or tagging, check whether Luna or GPT-6.1 Terra passes your eval before you spend a day choosing between Sol's lanes. Both still offer Flex, and both are eligible for the new windows too.
Which lane for which job.
- Someone is waiting on the answer. Standard, or Fast mode if a second of latency is worth twice the price. Ultrafast on GPT-6.2 runs at 3x Standard through February 28, 2027 and 6x from March 1. Put that date in the calendar if you use it, because the price doubles without a deploy.
- Needed within two hours. The 2h window at 30% off. Good for an hourly report, a queue that drains by lunch, a re-check after a deploy.
- Needed by morning. The 8h window at 40% off. Batch costs less, but its window is 24 hours, so a job submitted at midnight may not be done by 9 a.m.
- Needed this week. The Batch API at 50% off. Evals, backfills, re-embedding, labeling.
- You relied on Flex being synchronous. Stay on GPT-6.1 Sol, Terra or Luna with Flex, which are still listed, or rewrite the caller to poll.
- The job sends long prompts. Every lane keeps the 272K line. Above 272K input tokens the whole request bills 2x input and 1.5x output, background or not (The 272K Cliff).
Tutorial: move a Flex call to the 8-hour window.
Before, on GPT-6.1 Sol with Flex:
from openai import OpenAI
client = OpenAI()
resp = client.responses.create(
model="gpt-6.1-sol",
input=document,
service_tier="flex",
)
print(resp.output_text)
After, on GPT-6.2 Sol with the 8-hour window. background_options is passed through extra_body in case your SDK version does not type it yet:
import time
from openai import OpenAI
client = OpenAI()
resp = client.responses.create(
model="gpt-6.2-sol",
input=document,
background=True, # returns immediately with an ID
service_tier="default", # the discount applies to Standard only
extra_body={"background_options": {"completion_window": "8h"}}, # or "2h"
)
while resp.status in {"queued", "in_progress"}:
time.sleep(30)
resp = client.responses.retrieve(resp.id)
if resp.status == "completed":
print(resp.output_text)
else:
print("ended with", resp.status)
Four details from the guide that are easy to miss:
- Set the service tier to Standard. Send
service_tier="default". With"auto", the request gets the discount only if the API happens to select Standard. - Do not stream. Leave
streamunset orfalse. - The default window has no discount.
completion_windowdefaults to"soonest". Forget the option and you pay full price for a background call. - For multi-turn work, keep the window. Pass
background_options.continuation_idon follow-ups, with the same model, tier and background setting. Each follow-up gets the discount and a higher place in the queue.
At more than a few hundred requests, use a webhook on response.completed instead of a polling loop per request. Background mode stores response data for a while even with store=false or Zero Data Retention, so check that with whoever owns your data policy before you move regulated traffic.
A five-minute audit for this week.
# Every call site that sets Flex. Each one either stays on a 6.1 or older model,
# or needs a lane decision before it moves to GPT-6.2.
grep -rnE "service_tier[\"']?\s*[:=]\s*[\"']flex" --include=*.py --include=*.ts --include=*.js .
# Every hard-coded model name that a "latest" alias or a find-and-replace
# might move to GPT-6.2.
grep -rnE "gpt-6(\.1)?-(sol|astra)" --include=*.py --include=*.ts --include=*.js .
A call that sends service_tier: "flex" to a GPT-6.2 model is not one you want to discover from an error log at 2 a.m. Pin the model in the same commit that picks the lane.
Where Nadir fits.
Nadir does not choose the service tier or the background window. That is a latency decision, and you know better than any router when a result is needed. Nadir chooses the model and reasoning effort for each request, which is the 20x column in the table above.
- For interactive traffic, point the OpenAI SDK at
https://api.getnadir.com/v1withmodel="auto". Nadir decides per request between rungs such as Luna, Terra, Sol and Astra, starts in shadow mode, and returns a receipt for each decision with model, effort, cache and cost. - For background and batch jobs, call the decision API first. It returns the plan without calling your provider, and you submit the request to whichever lane you picked. At $0.002 per request, a per-request decision on 1.5M nightly calls costs $3,000 a month. For a job whose requests all look alike, that is too much: run the decision API on a sample in shadow mode, pick the model for the job type, and pin it. Per-request decisions earn their price on mixed traffic.
- Pricing is $0.002 per request, the first 50 a month free, and no markup on model spend. Nadir publishes no universal savings rate, because the result depends on how mixed your traffic is. We wrote down where routing does not help in When LLM Routing Does Not Help.
For the full OpenAI cost checklist, see How to Reduce OpenAI API Costs. For the tier ladder before this change, see Four Prices, One Model and Half Price, One Day Late.
Conclusion.
GPT-6.2 Astra is 20% cheaper, and its cached input is 60% cheaper. GPT-6.2 Sol costs what GPT-6.1 Sol did. Neither offers Flex. Work that can wait now chooses between a 2-hour window at 30% off, an 8-hour window at 40% off, and Batch at 50% off, and a Standard request cannot reuse the cache those background requests warm. Audit your Flex call sites before anything moves to GPT-6.2, send what can wait a day to Batch, and pick the model before the lane, because the model is the bigger number.