GPT-6.2 Quietly Dropped Flex

GPT-6.2 Astra is 20% cheaper at $8/$40 and GPT-6.2 Sol holds at $2/$10, but neither model offers Flex, the half-price lane for work that can wait. Astra's cached input also fell 60%. Work that can wait now picks between a 2-hour background window at 30% off, an 8-hour window at 40% off, and the Batch API at 50% off. A worked nightly job in every lane, a Flex-to-background migration in Python, a grep audit, and why the model choice still moves the bill more than the lane.

Published 2026-11-19 by Dor Amir on the Nadir blog.

Filed under Pricing & Models.

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 AstraGPT-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
Batch50% off50% off50% off50% off
FlexNot offered50% offNot offered
Background 2h / 8h window30% / 40% off30% / 40% off
Ultrafast3x until Feb 28, 2027, then 6x6x3x until Feb 28, 2027, then 6x
Reasoning effort noneRejectedRejectedRejectedRejected

Three things in that table matter for the bill.

Five prices for one model.

Bar chart: GPT-6.2 Sol output price per 1M tokens, short context. Fast mode $20.00 (2x Standard). Standard $10.00. Background 2-hour window $7.00 (30% off, new). Background 8-hour window $6.00 (40% off, new). Batch API $5.00 (50% off, results within 24 hours). Flex $5.00 on GPT-6.1 Sol only, not offered on GPT-6.2.
Bar chart: GPT-6.2 Sol output price per 1M tokens, short context. Fast mode $20.00 (2x Standard). Standard $10.00. Background 2-hour window $7.00 (30% off, new). Background 8-hour window $6.00 (40% off, new). Batch API $5.00 (50% off, results within 24 hours). Flex $5.00 on GPT-6.1 Sol only, not offered on GPT-6.2.

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.

LaneModelPer requestPer month (1.5M requests)Results within
StandardGPT-6.2 Sol$0.0200$30,000Seconds
Background 2hGPT-6.2 Sol$0.0140$21,000Targets 2 hours
Background 8hGPT-6.2 Sol$0.0120$18,000Targets 8 hours
Batch APIGPT-6.2 Sol$0.0100$15,000Up to 24 hours
FlexGPT-6.1 Sol$0.0100$15,000Seconds to minutes, may 429
StandardGPT-6.2 Astra$0.0800$120,000Seconds
Batch APIGPT-6.2 Astra$0.0400$60,000Up to 24 hours
FlexGPT-6 Luna$0.0005$750Seconds 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.

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:

  1. 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.
  2. Do not stream. Leave stream unset or false.
  3. The default window has no discount. completion_window defaults to "soonest". Forget the option and you pay full price for a background call.
  4. For multi-turn work, keep the window. Pass background_options.continuation_id on 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 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.

More on pricing & models

Pages on this site

Machine-readable summaries of this site: llms.txt and llms-full.txt.