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
- GPT-6.2 Astra
- GPT-6.2 Sol
- OpenAI API
- Claude Fable
- Gemini 4 Carbon
- GPT-6.1 Sol
- GitHub Copilot
- Amazon Bedrock
- OpenAI
- Anthropic
- Google DeepMind
- Artificial Analysis
- SaaS Ecosystem & Business
- Benchmarks & Deep Dives
Documentation-based research

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.
| Model | Input | Cached input | 30-min cache write | Output |
|---|---|---|---|---|
| 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 |
What changed on November 17
- Two new models.
gpt-6.2-astrais OpenAI's new top model for demanding reasoning and coding.gpt-6.2-solis 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.
| Mode or rule | GPT-6.2 Astra (input / output per 1M) | GPT-6.2 Sol (input / output per 1M) | Notes |
|---|---|---|---|
| Standard, up to 272K input | $8 / $40 | $2 / $10 | Cached input $0.40 (Astra), $0.10 (Sol) |
| Standard, over 272K input | $16 / $60 | $4 / $15 | Long-context rate applies to the whole request |
| Batch API | $4 / $20 | $1 / $5 | 50% of Standard; separate rate-limit pool |
| Background, 2-hour window | 30% below Standard | 30% below Standard | Responses API public beta; Standard tier only |
| Background, 8-hour window | 40% below Standard | 40% below Standard | Shares the Batch/Background rate limit |
| Fast mode | $16 / $80 | $4 / $20 | 2x Standard |
| Ultrafast, to Feb 28, 2027 | $24 / $120 | $6 / $30 | 3x Standard (promotional) |
| Ultrafast, from Mar 1, 2027 | $48 / $240 | $12 / $60 | 6x Standard |
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.
| Model | Input | Output | Cache hit | Cache 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.10 | Implicit caching only |
| Gemini 4 Carbon, from Dec 1 | $4.00 | $20.00 | $0.20 | Implicit caching only |
| GPT-6.2 Sol | $2.00 | $10.00 | $0.10 | $2.50 (30 min) |
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, 2026GPT-6 Astra 10K x $10 + 40K x $1.00 + 5K x $50 = $0.390GPT-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.288GPT-6.2 Sol 10K x $2 + 40K x $0.10 + 5K x $10 = $0.074GPT-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.

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.
| Model (setting) | Index score | Cost per index task | Time per task | Tokens generated on the index |
|---|---|---|---|---|
| Claude Fable 5.2 (Max) | 65 | $26.54 | 41.1 min | 275M |
| GPT-6.2 Astra (Max) | 62 | $4.00 | 11.5 min | 65.8M |
| Gemini 4 Carbon (High) | 60 | $5.48 | 34.2 min | 205M |
| GPT-6.2 Sol (Max) | 57 | $1.01 | 7.9 min | 60.9M |
| GPT-6 Astra (Max) | 57 | $6.24 | 19.9 min | 54.3M |
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_tiertodefault. Withauto, the request qualifies only if the API happens to pick Standard. - No streaming. Leave
streamunset 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_idlets 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
instructionsafterinput. If you keep a long system prompt there, it falls out of the cached prefix. Move reusable instructions into adevelopermessage as the first item ininput. - 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_pandtop_logprobs(pluslogprobsin Chat Completions), and swap a reasoning effort ofnoneorminimalforlow. OpenAI suggests starting new integrations atmedium.

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
instructionsplacement 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
- OpenAI: Introducing GPT-6.2 Astra and Sol (Nov 17, 2026)
- OpenAI API changelog (Nov 17, 2026 entries)
- OpenAI: GPT-6.2 Astra model page and GPT-6.2 Sol model page (accessed Nov 18, 2026)
- OpenAI API pricing, Background mode, Flex processing and Using GPT-6.2 (accessed Nov 18, 2026)
- Anthropic: Claude API pricing and Google: Gemini API pricing (accessed Nov 18, 2026)
- Artificial Analysis: GPT-6.2 Astra and related model pages (accessed Nov 18, 2026)
- AWS: GPT-6.2 Astra and Sol on Amazon Bedrock and GitHub Changelog: GPT-6.2 in Copilot (Nov 17, 2026)
- The Decoder: OpenAI launches GPT-6.2 Astra and Sol with lower API prices (Nov 17, 2026)
Tools covered in this article
Tool
GPT-6.2 Astra
AI Agents & Coding · Paid
Tool
GPT-6.2 Sol
AI Agents & Coding · Paid
Tool
OpenAI API
SaaS Ecosystem & Business · Paid
Tool
Claude Fable
AI Agents & Coding · Paid
Tool
Gemini 4 Carbon
AI Agents & Coding · Paid
Tool
GPT-6.1 Sol
AI Agents & Coding · Paid
Tool
GitHub Copilot
AI Agents & Coding · Paid
Tool
Amazon Bedrock
Cloud & Architecture · Paid
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.