Skip to content

SaaS · Analysis

GPT-6.2 Astra Pricing: What the 20% Cut Really Saves

OpenAI cut GPT-6.2 Astra to $8 input and $40 output per million tokens, matching Claude Fable 5.2, and kept GPT-6.2 Sol at $2 and $10. Here's what that, the new background windows and the caching changes mean per task.

Metarix Editorial · Nov 18, 2026 · 11 min read

Share

Documentation-based research

OpenAI launch artwork reading Astra, GPT-6.2, Sol on a dark starry background
On this page

OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026. Astra costs $8 per million input tokens and $40 per million output tokens, 20% less than GPT-6 Astra, and cached input drops 60% to $0.40. Sol keeps GPT-6.1 Sol's $2 and $10.

The headline cut is real, but it isn't the most useful number. Astra now has exactly the same list price as Anthropic's Claude Fable 5.2, and independent measurements show the two models spend very different numbers of tokens to finish the same work. Same day, OpenAI also added two-hour and eight-hour background windows that take 30% and 40% off, and changed how the Responses API handles prompt caching. Here's what each change does to your bill. Prices as of Nov 18, 2026.

Quick verdict

If you run GPT-6 Astra today, move to GPT-6.2 Astra: per-token rates are lower across the board and Artificial Analysis measures a lower cost per task. If you run GPT-6.1 Sol, GPT-6.2 Sol is the same price, so the decision comes down to quality on your evals. Before you flip the model ID, fix two migration traps that can quietly raise costs: top-level instructions are no longer cacheable, and editing earlier turns now drops reasoning. Any job that can wait two hours or more belongs in a background window or the Batch API.

Scroll the table horizontally on smaller screens.

GPT-6.2 pricing at a glance (Standard, per 1M tokens)
ModelInputCached input30-min cache writeOutput
GPT-6.2 Astra$8.00$0.40$10.00$40.00
GPT-6 Astra (previous)$10.00$1.00$12.50$50.00
GPT-6.2 Sol$2.00$0.10$2.50$10.00
GPT-6.1 Sol (previous)$2.00$0.10$2.50$10.00
Source: OpenAI API pricing page and model pages, accessed Nov 18, 2026. Short-context rates (up to 272K input tokens).

What changed on November 17

  • Two new models. gpt-6.2-astra is OpenAI's new top model for demanding reasoning and coding. gpt-6.2-sol is the everyday model for coding and agent workflows. Both work in the Responses API and Chat Completions, but tool calling needs the Responses API (OpenAI changelog).
  • Astra price cut. Input and output are 20% cheaper than GPT-6 Astra, and cached input is 60% cheaper ($1.00 to $0.40). The 30-minute cache write drops from $12.50 to $10.00 (pricing).
  • Sol price unchanged. GPT-6.2 Sol carries over GPT-6.1 Sol's $2 input, $0.10 cached input and $10 output (OpenAI announcement).
  • Discounted background windows. In the Responses API public beta, a two-hour completion window costs 30% below Standard and an eight-hour window 40% below, on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna (background mode docs).
  • Day-one distribution. Both models went generally available on Amazon Bedrock and in GitHub Copilot for Pro+, Max, Business and Enterprise plans, where Copilot bills them at provider list prices.

Both models share the same specs: a 1,050,000-token context window, up to 922,000 input tokens and 128,000 output tokens, text and image input, and no fine-tuning. Astra's knowledge cutoff is May 18, 2026 and Sol's is June 1, 2026 (Astra model page, Sol model page). Both reject a reasoning effort of none.

The full price sheet, including the fine print

The headline rates apply only to short-context Standard requests. The modifiers below decide what large or latency-sensitive workloads actually pay.

Scroll the table horizontally on smaller screens.

GPT-6.2 Astra and Sol: processing modes and modifiers
Mode or ruleGPT-6.2 Astra (input / output per 1M)GPT-6.2 Sol (input / output per 1M)Notes
Standard, up to 272K input$8 / $40$2 / $10Cached input $0.40 (Astra), $0.10 (Sol)
Standard, over 272K input$16 / $60$4 / $15Long-context rate applies to the whole request
Batch API$4 / $20$1 / $550% of Standard; separate rate-limit pool
Background, 2-hour window30% below Standard30% below StandardResponses API public beta; Standard tier only
Background, 8-hour window40% below Standard40% below StandardShares the Batch/Background rate limit
Fast mode$16 / $80$4 / $202x Standard
Ultrafast, to Feb 28, 2027$24 / $120$6 / $303x Standard (promotional)
Ultrafast, from Mar 1, 2027$48 / $240$12 / $606x Standard
Source: OpenAI API pricing page, Standard, Batch, Fast and Ultrafast tables, accessed Nov 18, 2026. Regional processing (data residency) endpoints add 10%.

Two details are easy to miss. First, the long-context surcharge isn't marginal: once a request crosses 272K input tokens, every token in it is billed at the higher rate. Second, Flex processing, which OpenAI prices at Batch rates, doesn't list either GPT-6.2 model on the pricing page as of Nov 18, 2026. The Flex docs point asynchronous Responses workloads to the new background windows instead, so for now the discounted options on GPT-6.2 are Batch (50% off) and the two windows (30% or 40% off).

Astra vs Fable 5.2 vs Gemini 4 Carbon on price

The 20% cut lands GPT-6.2 Astra on exactly the same input and output rates as Claude Fable 5.2, which Anthropic priced at $8 and $40 on November 9 (see our Claude Fable 5.2 pricing breakdown). Gemini 4 Carbon is still far cheaper per token, though its launch price doubles on December 1 (our Carbon pricing analysis).

Scroll the table horizontally on smaller screens.

Frontier model list prices, per 1M tokens
ModelInputOutputCache hitCache write
GPT-6.2 Astra$8.00$40.00$0.40$10.00 (30 min)
Claude Fable 5.2$8.00$40.00$0.20$10.00 (5 min), $16.00 (1 h)
Gemini 4 Carbon, to Nov 30$2.00$10.00$0.10Implicit caching only
Gemini 4 Carbon, from Dec 1$4.00$20.00$0.20Implicit caching only
GPT-6.2 Sol$2.00$10.00$0.10$2.50 (30 min)
Sources: OpenAI API pricing, Claude API pricing and Gemini API pricing pages, all accessed Nov 18, 2026. Short-context Standard rates; long-context and premium modes cost more.

On cache-heavy agent loops, Fable 5.2 still has the edge per token: its cache hits cost half of Astra's. On everything else the per-token rates are identical, so the bill comes down to how many tokens each model spends.

What a task actually costs

Per-token prices only tell you the ceiling. To make that concrete, here is one illustrative agent request priced at each model's list rates: 50,000 input tokens, of which 40,000 are cache hits, plus 5,000 output tokens. Cache writes are left out to keep the arithmetic readable. This is Metarix arithmetic, not a test.

# Illustrative request: 10K uncached input + 40K cached input + 5K output
# Rates are dollars per 1M tokens, list prices as of Nov 18, 2026
GPT-6 Astra 10K x $10 + 40K x $1.00 + 5K x $50 = $0.390
GPT-6.2 Astra 10K x $8 + 40K x $0.40 + 5K x $40 = $0.296 (-24%)
Claude Fable 5.2 10K x $8 + 40K x $0.20 + 5K x $40 = $0.288
GPT-6.2 Sol 10K x $2 + 40K x $0.10 + 5K x $10 = $0.074
GPT-6.2 Astra, 8h window: $0.296 x 0.60 = $0.178
# Per 1,000 requests: multiply by 1,000 ($296 for GPT-6.2 Astra)

That example assumes every model uses the same number of tokens, which never happens. Reasoning models differ widely in how much they think and how many tool calls they make. The independent numbers show how much that matters.

Bar charts comparing an illustrative request cost and Artificial Analysis cost per task for GPT-6.2 Astra, GPT-6.2 Sol, GPT-6 Astra, Claude Fable 5.2 and Gemini 4 Carbon
Left: one illustrative request at list prices. Right: Artificial Analysis cost per Intelligence Index task. Graphic: Metarix, Nov 18, 2026, from OpenAI, Anthropic and Google pricing pages and Artificial Analysis.

Independent results (attributed)

Artificial Analysis runs every model through the same nine-evaluation Intelligence Index (v5.0.1) and publishes what each run cost. These figures come from its model pages (GPT-6.2 Astra, GPT-6.2 Sol, Claude Fable 5.2, Gemini 4 Carbon, GPT-6 Astra), accessed Nov 18, 2026. They measure the top reasoning setting each model was tested at, and Gemini 4 Carbon's cost reflects its pre-December price, so treat them as a guide, not a quote.

Scroll the table horizontally on smaller screens.

Artificial Analysis Intelligence Index v5.0.1: score and cost
Model (setting)Index scoreCost per index taskTime per taskTokens generated on the index
Claude Fable 5.2 (Max)65$26.5441.1 min275M
GPT-6.2 Astra (Max)62$4.0011.5 min65.8M
Gemini 4 Carbon (High)60$5.4834.2 min205M
GPT-6.2 Sol (Max)57$1.017.9 min60.9M
GPT-6 Astra (Max)57$6.2419.9 min54.3M
Source: Artificial Analysis model pages for GPT-6.2 Astra, GPT-6.2 Sol, Claude Fable 5.2, Gemini 4 Carbon and GPT-6 Astra, accessed Nov 18, 2026. Settings differ by model; results aren't a like-for-like test of your workload.

Read the table this way. Fable 5.2 scores three points higher than Astra but generated roughly four times as many tokens, so at the same list price it cost more than six times as much per task. Sol matches GPT-6 Astra's score at about a sixth of its cost per task. And one caveat cuts against OpenAI's own messaging: on this index, GPT-6.2 Astra generated more tokens than GPT-6 Astra (65.8M vs 54.3M), so its lower cost per task comes from the cheaper rates rather than from fewer tokens.

OpenAI's own numbers (vendor-reported)

  • On Agents' Last Exam, OpenAI says GPT-6.2 Astra scores 5.2 points above GPT-6 Astra at less than a third of the cost, and 5.5 points above Claude Fable 5.2 at about 5% of the cost. OpenAI notes Fable 5.2's leaderboard results exclude nine tasks that used a fallback model (announcement).
  • On Cognition's FrontierCode 2.0, OpenAI says GPT-6.2 Sol comes within 0.5 points of GPT-6.2 Astra at about one-fifth the cost, with both at max reasoning.
  • On its internal GDPval v2, OpenAI reports Astra up 6.2 points over GPT-6 Astra with 22% fewer output tokens, and Sol up 5.3 points over GPT-6.1 Sol.

These are OpenAI's chosen benchmarks and configurations. They point in the same direction as the independent numbers, but they aren't directly comparable with them or with each other.

The new background windows, explained

Background mode isn't new, but the discount is. Set background to true and background_options.completion_window to 2h or 8h, and token rates drop 30% or 40% (OpenAI docs). The API accepts the request, retries eligible capacity errors itself, and you collect the result by webhook or by polling. The constraints matter:

  • Standard tier only. Set service_tier to default. With auto, the request qualifies only if the API happens to pick Standard.
  • No streaming. Leave stream unset or false.
  • Shared limits. These requests draw on the same Batch/Background rate limit as Batch API jobs, and input tokens count when you submit, not when the job runs.
  • Separate cache. Standard requests can't reuse prompt-cache entries created by two-hour or eight-hour requests, even with identical prompts. Don't expect a nightly job to warm the cache for your daytime traffic.
  • Multi-step workflows work. A continuation_id lets follow-up requests (for example, after a function call) keep higher queue priority.

Example request shape, adapted from OpenAI's background-mode guide (illustrative, not run here):

curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" -H "Content-Type: application/json" \
-d '{"model": "gpt-6.2-sol",
"input": "Review this contract for missing approvals: ...",
"background": true, "service_tier": "default",
"background_options": {"completion_window": "8h"}}'

When should you pick Batch instead? Batch is cheaper (50% off) and fits large uploaded job files. Background windows suit per-request jobs that use tools or need follow-up turns, and where a 30% to 40% cut is good enough. If you also need to stay within rate limits, remember both draw on the same pool (see our LLM API rate limits guide).

Migration traps that can raise your bill

OpenAI's GPT-6.2 migration guide lists two behaviour changes in the Responses API that affect cost directly:

  • Top-level `instructions` are no longer cacheable. From GPT-6.2, the Responses API appends top-level instructions after input. If you keep a long system prompt there, it falls out of the cached prefix. Move reusable instructions into a developer message as the first item in input.
  • Prefix edits drop reasoning. Editing earlier turns, some model switches (including downgrades), or changing the end user or organization now drops reasoning items. OpenAI warns quality can fall and the model may spend extra tokens redoing work. Append new instructions instead of rewriting history.
  • Parameter clean-up. Remove temperature, top_p and top_logprobs (plus logprobs in Chat Completions), and swap a reasoning effort of none or minimal for low. OpenAI suggests starting new integrations at medium.
Decision diagram for choosing GPT-6.2 Fast, Ultrafast, Standard, background windows or Batch, with a migration checklist
Choosing a GPT-6.2 processing mode, with the checks to run before switching. Graphic: Metarix, Nov 18, 2026, from OpenAI pricing, background mode and migration docs.

On rate limits, both model pages list 5,000 RPM and 1M TPM at the Build tier, 10,000 RPM and 4M TPM at Launch, and 15,000 RPM and 40M TPM at Grow on their model pages.

Who should switch, and to what

  • GPT-6 Astra users: switch. Lower rates on every line, and a lower measured cost per task. Fix the instructions placement first.
  • Claude Fable 5.2 users: test GPT-6.2 Astra on your own tasks. List prices are identical, Fable keeps cheaper cache hits and the top independent score, and Astra spent far fewer tokens on the Artificial Analysis index.
  • GPT-6.1 Sol users: GPT-6.2 Sol costs the same; run your evals and switch if it holds up. GitHub says it caught nearly twice as many real code-review issues as GPT-6.1 Sol in early testing.
  • Gemini 4 Carbon users: Carbon is still cheapest per token, but its rates double on December 1. Re-run your cost per task with the December prices before deciding.
  • Latency-sensitive apps on Ultrafast: the 3x promotional rate ends February 28, 2027. Budget for 6x, or plan to move to Fast mode at 2x.

Verdict

GPT-6.2 Astra is a straightforward upgrade on price for anyone already paying GPT-6 Astra rates, and the 60% cheaper cached input makes long agent loops noticeably cheaper. The bigger story is that frontier list prices have converged: Astra and Fable 5.2 now charge the same per token, so the only number worth comparing is cost per finished task on your own workload. On the one independent benchmark that reports it, Astra comes out far cheaper than Fable for a slightly lower score.

Our take: move GPT-6 Astra traffic now, put GPT-6.2 Sol in front of most everyday coding and agent work, and push anything that can wait into the 8-hour window or Batch. Just fix the instructions field and stop editing conversation prefixes first, or the caching changes can cancel out the price cut.

Sources

Tools covered in this article

Frequently asked questions

How much does GPT-6.2 Astra cost in the API?
As of November 18, 2026, GPT-6.2 Astra costs $8 per million input tokens, $0.40 per million cached input tokens and $40 per million output tokens at Standard rates. Requests over 272K input tokens cost double for input and 1.5x for output, and the Batch API halves the rates.
Is GPT-6.2 Astra cheaper than GPT-6 Astra?
Yes. Input and output are 20% cheaper ($8 and $40 versus $10 and $50 per million tokens), cached input is 60% cheaper ($0.40 versus $1.00), and the 30-minute cache write falls from $12.50 to $10.00.
Did GPT-6.2 Sol get a price change?
No. GPT-6.2 Sol keeps GPT-6.1 Sol's prices: $2 per million input tokens, $0.10 for cached input and $10 for output, with the same Batch, Fast and Ultrafast multipliers.
What are OpenAI's background completion windows?
A Responses API public beta option that lets you accept a two-hour or eight-hour wait for 30% or 40% lower token rates on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna. Requests must use Standard processing, can't stream, and share the Batch rate-limit pool.
Is GPT-6.2 Astra cheaper than Claude Fable 5.2?
Per token they cost the same: $8 input and $40 output per million tokens, though Fable 5.2's cache hits are cheaper at $0.20. Per task, Artificial Analysis measured about $4.00 for GPT-6.2 Astra versus $26.54 for Fable 5.2 on its Intelligence Index, because Fable used far more tokens.

Share

Keep Reading