Models

GPT-6.2 Astra and Sol: prices, cached input and what to test

GPT-6.2 Astra drops to $8/$40 per million tokens with cached input at $0.40; Sol keeps $2/$10. What changed from GPT-6 Astra and GPT-6.1 Sol, and the integration details that decide the bill.

OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on 17 November 2026, and the most useful fact for anyone paying the API bill is the cache line. Astra’s Standard rates fall to $8 per million input tokens and $40 per million output tokens, 20 per cent below GPT-6 Astra. Its cached input falls further, by 60 per cent, to $0.40 per million. Sol keeps GPT-6.1 Sol’s rates of $2, $0.10 and $10. Both models are in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users, and in the API as gpt-6.2-astra and gpt-6.2-sol.

The price cut arrives with a rule change that matters as much as the rates. Starting with GPT-6.2, OpenAI’s migration guide says the API will drop reasoning items when it detects a mid-conversation change to the conversation history. Teams that edit earlier turns, rewrite system instructions or truncate old tool output now lose both the cache discount and the model’s earlier reasoning on that turn. With cached input at a twentieth of the input rate, a broken prefix costs proportionally more than it did on GPT-6 Astra.

This article sets out what changed against GPT-6 Astra and GPT-6.1 Sol, the full price list including the tiers that are and are not available, a worked agent-loop budget, what independent measurement shows so far, the safety findings that affect application design, and what builders should test before switching. GenAI Brief has not run either model; benchmark results are attributed to whoever produced them.

What shipped on 17 November

OpenAI’s announcement positions Astra as “our new frontier model for your hardest projects” and Sol as “our efficient, versatile model for everyday work”. Its headline claim for both is efficiency: “better results on demanding tasks with fewer output tokens”. The API changelog entry for 17 November says both models support the Responses API and Chat Completions, and that “Tool calling requires the Responses API.”

The consumer and Codex rollout has plan-specific details. OpenAI says GPT-6.2 Astra and Sol are available to all Plus, Pro, Enterprise and Edu users in ChatGPT Work and Codex, with Enterprise and Edu access depending on a workspace admin. Pro 500 subscribers can use Ultrafast with either model, and Ultrafast reaches Pro 200 subscribers for the first time, starting with GPT-6.2 Sol. The Codex speed documentation says Ultrafast on GPT-6.2 Astra and Sol “generates tokens at up to 4.5 times the speed of Standard on the same model” and draws down the plan’s allowance first, then credits. 9to5Mac’s launch report and the OpenAI Developer Community post describe the same plan split.

The release follows GPT-6 Astra in September and GPT-6.1 Sol at DevDay. Our October ranking of frontier models placed GPT-6.1 Sol as the value pick of that month and GPT-6 Astra as the expensive option for the hardest work; both positions are now contested by their own successors.

The specification sheet against the predecessors

The model pages give the technical deltas. Most of the envelope is unchanged; the knowledge cutoff, the reasoning-effort floor and the input cap are where they differ.

ItemGPT-6 AstraGPT-6.2 AstraGPT-6.1 SolGPT-6.2 Sol
Context window1,050,0001,050,0001,050,0001,050,000
Max input tokensnot listed922,000not listed922,000
Max output tokens128,000128,000128,000128,000
Knowledge cutoff30 Apr 202618 May 202630 Apr 20261 Jun 2026
Input / output modalitiestext, image in; text outtext, image in; text outtext, image in; text outtext, image in; text out
Reasoning effortlow to maxnone rejectedlow to max, medium defaultnone rejected
API endpoints marked supportedResponses, Chat Completions, Batchsamesamesame
Fine-tuningnot supportednot supportednot supportednot supported

Read by GenAI Brief from OpenAI’s GPT-6.2 Astra, GPT-6.2 Sol, GPT-6 Astra and GPT-6.1 Sol model pages on 18 November 2026.

The GPT-6.2 pages list the same Responses API tools for both models: web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search. They mention the Multi-agent beta for delegating work to subagents and the “discounted background completion windows in public beta”, the latter covered below. The rate-limit table is identical for the two models: 5,000 requests and 1 million tokens per minute at the Build tier, 10,000 and 4 million at Launch, and 15,000 and 40 million at Grow.

The price list, tier by tier

OpenAI’s pricing page lists five processing options for flagship models: Standard, Batch, Flex, Fast and Ultrafast. GPT-6.2 appears in four of them.

Tier (USD per 1M tokens)InputCached input30-min cache write12-h cache writeOutput
GPT-6.2 Astra, Standard$8.00$0.40$10.00$20.00$40.00
GPT-6 Astra, Standard$10.00$1.00$12.50$25.00$50.00
GPT-6.2 Sol, Standard$2.00$0.10$2.50$5.00$10.00
GPT-6.1 Sol, Standard$2.00$0.10$2.50$5.00$10.00
GPT-6.2 Astra, Batch$4.00$0.20$5.00$10.00$20.00
GPT-6.2 Astra, Fast$16.00$0.80$20.00$40.00$80.00
GPT-6.2 Astra, Ultrafast to 28 Feb 2027$24.00$1.20$30.00$60.00$120.00
GPT-6.2 Astra, Ultrafast from 1 Mar 2027$48.00$2.40$60.00$120.00$240.00

OpenAI API pricing page, short-context rates, read 18 November 2026. Sol’s Batch, Fast and Ultrafast rows follow the same multipliers from its Standard rates.

Four details on that page and the model pages change real bills.

The cache discount is the real cut. OpenAI’s prompt caching guide says cache reads cost 0.1 times the ordinary input rate on most recent models and 0.05 times on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Sol and GPT-6.1 Terra. GPT-6 Astra was on the 0.1 rule, so its cached input was $1.00. GPT-6.2 Astra combines a lower input rate with the deeper ratio, which is how a 20 per cent list cut becomes a 60 per cent cache cut. Cache writes are billed at 1.25 times the input rate for the default 30-minute lifetime and 2.5 times for 12 hours. The guide is explicit that this is “not an additive fee”: each input token is billed at the uncached, cached or cache-write rate.

Long prompts reprice the whole request. Both GPT-6.2 model pages say that “for requests with more than 272K input tokens, input and cache rates double and output costs 1.5 times the short-context rate for the full request.” The 1,050,000-token window is available, but the second half of it is priced differently.

Flex is not on the list. The Flex processing guide says Flex is in beta “with limited model availability” and points to the pricing page. That page’s Flex table lists GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna, not either GPT-6.2 model. A team that ran GPT-6.1 Sol evaluations on Flex at half price cannot assume the same option for GPT-6.2 Sol. The substitute is new: the changelog’s second 17 November entry introduces two-hour and eight-hour background completion windows in the Responses API public beta, priced 30 per cent and 40 per cent below Standard, for GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna. Batch remains at 50 per cent.

Ultrafast is temporarily cheaper on GPT-6.2. The pricing page says Ultrafast for both GPT-6.2 models costs three times Standard through 28 February 2027 and six times Standard from 1 March 2027, Pacific time. GPT-6.1 Sol’s page lists Ultrafast at six times Standard. The migration guide adds that Ultrafast supports US data residency only, while Standard, Fast and Batch support US and EU residency. Regional processing endpoints carry a 10 per cent uplift for models released on or after 5 March 2026.

Where the 60 per cent comes from, in one line

GPT-6 Astra: $10 input, cached at 10 per cent, is $1.00. GPT-6.2 Astra: $8 input, cached at 5 per cent, is $0.40. The ratio of $0.40 to $1.00 is the 60 per cent discount OpenAI quotes. The same arithmetic explains why Sol’s price did not move: GPT-6.1 Sol was already on the 5 per cent cache ratio.

A worked agent-loop budget

The following example is hypothetical. The workload and token counts are GenAI Brief’s assumptions, chosen to show how the billing rules interact. Only the per-token prices and billing rules come from OpenAI’s documentation.

The workload. A coding agent runs sessions of 40 turns. On a typical turn, 100,000 tokens of conversation history match the cache, 8,000 new tokens (the latest tool output and instructions) are appended and written to the cache at the 30-minute rate, and the model returns 4,000 output tokens including reasoning. Every request stays below 272,000 input tokens.

Per turn (hypothetical)Cached readsCache writesOutputTotal per turnPer 40-turn session
GPT-6 Astra$0.100$0.100$0.200$0.400$16.00
GPT-6.2 Astra$0.040$0.080$0.160$0.280$11.20
GPT-6.1 Sol or GPT-6.2 Sol$0.010$0.020$0.040$0.070$2.80

GenAI Brief calculation from OpenAI’s Standard prices on 18 November 2026. The workload is invented for illustration.

At identical token counts, GPT-6.2 Astra is 30 per cent cheaper per turn than GPT-6 Astra. The saving is larger on the read side (60 per cent) than on output (20 per cent), so cache-heavy agents gain more than output-heavy ones.

OpenAI’s case for a larger saving rests on token efficiency. It reports that on its internal GDPval v2 benchmark, Astra used 22 per cent fewer output tokens than GPT-6 Astra. Applied to this example purely as an illustration, Astra’s output would fall to 3,120 tokens and the turn to about $0.245, or 39 per cent below GPT-6 Astra. That figure comes from one vendor benchmark; the independent data below points the other way on output volume, so the 30 per cent figure is the safer planning assumption until a team measures its own traffic.

What one broken prefix costs

Now suppose that on one turn the agent framework rewrites the developer message at the start of the conversation, a change OpenAI’s guidance lists as a common cause of prefix breaks. The 108,000 tokens of history no longer match the cache. If implicit caching writes them again, they are billed at the cache-write rate.

  • GPT-6.2 Astra: 108,000 tokens at $10 per million is $1.08, plus $0.16 of output, so $1.24 for that turn, about 4.4 times a normal turn.
  • GPT-6 Astra: 108,000 at $12.50 per million is $1.35, plus $0.20, so $1.55, about 3.9 times a normal turn.
  • GPT-6.2 Sol: 108,000 at $2.50 per million is $0.27, plus $0.04, so $0.31, about 4.4 times.

The deeper the cache discount, the larger the multiple a miss costs, because the normal turn has become cheaper and the miss has not. On GPT-6.2 the miss also has a cost the table cannot price. OpenAI’s prefix guide says that “starting with newer frontier models, the API will drop reasoning items that follow a prefix change as part of our safeguards,” and that the model “may have to redo some reasoning, which can increase token usage, cost, and latency. If the model can’t recover the lost reasoning, output quality may also drop.” Our prompt caching explainer covers the general mechanics of cache misses across providers.

Crossing the 272,000-token line

The long-context rule is a cliff, not a slope. Take a turn with 260,000 cached tokens, 8,000 written and 4,000 output on GPT-6.2 Astra: $0.104 + $0.080 + $0.160 = $0.344. Add 20,000 more tokens of history so that the request reaches 288,000 input tokens, and every rate on the request changes: cached reads at $0.80, cache writes at $20, output at $60. The turn costs $0.224 + $0.160 + $0.240 = $0.624, about 81 per cent more for 7 per cent more input. Agents with long-lived sessions should compact before the threshold rather than after it, bearing in mind that compaction itself changes the prefix.

The integration rules that changed

The GPT-6.2 migration guide is short, and most of it is about keeping the conversation stable.

  1. Model name. Set model to gpt-6.2-astra or gpt-6.2-sol.
  2. Reasoning effort. OpenAI recommends starting at medium for a new integration. Requests that set reasoning effort to none are rejected; the guide says to use low instead of none or minimal.
  3. Tools. Chat Completions is supported, but tool calling requires the Responses API.
  4. Removed parameters. In Chat Completions, omit temperature, top_p, logprobs and top_logprobs. In Responses, omit temperature, top_p and top_logprobs, and remove message.output_text.logprobs from include.
  5. Caching parameters. Teams moving from GPT-5.5 or earlier should replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".
  6. Zero Data Retention. Both models support ZDR for approved organisations; with ZDR on, the Responses API treats store as false, so multi-turn clients must pass prior output items back in order, including encrypted reasoning items.

Append, do not edit

The guide’s “What’s new” section is the change most likely to surprise an existing integration. The API will drop reasoning items when it detects “mid-conversation changes to the conversation history (prefix edits), model downgrade, end user, or organization.” OpenAI’s prefix guide then lists the common causes and the append-only alternatives:

Common prefix changeOpenAI’s suggested alternative
Changing reasoning.effort between turnsAppend a configuration_update item with the new effort; keep the request-level setting
Changing the structured-output schemaAppend a configuration_update item with the new schema
Changing the tool listAdd tools with an additional_tools item, or restrict with tool_choice and allowed_tools; keep existing definitions in order
Editing developer instructionsAppend a new developer message telling the model to follow new instructions
Truncating old tool output or downsizing old imagesShorten or downsize before first sending, or use compaction
Custom compactionPlace the compacted item at the end of the context, or accept the dropped reasoning

Summarised from OpenAI’s “Keep the prefix unchanged” guide, read 18 November 2026.

Two audit tools are documented. Prompt Cache Diagnostics compares a request with an earlier response through prompt_cache_options.comparison_response_id and reports the first identified difference, on a best-effort basis. The Responses API’s input_transformations field shows which reasoning items were removed and why, including a prefix_mismatch reason. A team migrating an agent framework should run both on a sample of real sessions before switching production traffic.

Prompting changes OpenAI flags

The migration guide also describes behaviour changes. It says GPT-6.2 Astra’s writing “tends to be more concise and direct by default” and suggests revisiting instructions such as “be concise”. When intent is unclear, the model “may propose a next step and wait for confirmation”; OpenAI offers prompt text that tells it to keep working on reversible steps. It warns that on long tasks the model “can carry shorthand from its reasoning or from other agents into its final answer”, and supplies a prompt asking for self-contained final answers. These are OpenAI’s descriptions of its own model; teams should check them against their own transcripts.

What OpenAI claims, and what has been measured

OpenAI’s benchmark claims are specific, mostly self-reported, and presented as cost-adjusted comparisons.

  • Agents’ Last Exam. Astra scores “5.2 points higher than GPT-6 Astra at less than a third of the cost, and 5.5 points ahead of Claude Fable 5.2 at just 5% of the cost.” A note under the chart says the benchmark’s leaderboard results for Fable 5.2 “exclude nine tasks that used a fallback model.” The Developer Community post phrases the GPT-6 Astra comparison differently: “6.2 Astra at xhigh scores 5.2 points above GPT-6 Astra at max, at less than half the cost per task.”
  • Terminal-Bench-Science 0.1. Astra scores “9 percentage points higher than GPT-6 Astra at less than one-third the cost.”
  • FrontierCode 2.0 (Cognition). Sol comes “within 0.5 points of GPT-6.2 Astra at about one-fifth the cost (both at max).”
  • GDPval v2 (internal). Astra is up 6.2 points on GPT-6 Astra “while using 22% fewer output tokens”; Sol improves 5.3 points on GPT-6.1 Sol.
  • AA-3D (Artificial Analysis, human preference). Astra first at 1,318 Elo, Fable 5.2 at 1,271 and Sol at 1,259.

Reading the Agents’ Last Exam claim

We checked the public Agents’ Last Exam leaderboard, version 1.1, marked “Results updated Nov 16, 2026”. It did not list GPT-6.2 Astra. It reports two metrics: Pass Rate, “the share of runs that earned a perfect score”, and Score, “the average partial-credit score”, over 122 tasks. Its footnote says Fable 5.2 “excludes 9 tasks that are downgraded.”

On that table GPT-6 Astra has a 42.6 per cent pass rate and a 73.1 per cent score, and Fable 5.2 at max has 46.9 per cent and 72.8 per cent. OpenAI’s two deltas, 5.2 points over GPT-6 Astra and 5.5 points over Fable 5.2, both land on 78.3 if applied to the Score column, and on two different numbers if applied to Pass Rate. We infer that OpenAI’s claim refers to the partial-credit Score, not the stricter pass rate. OpenAI does not say so, and the result will only be checkable once the leaderboard lists the model. The two phrasings of the cost comparison, “less than a third” in the announcement and “less than half” in the community post, also differ; the leaderboard’s estimated cost for GPT-6 Astra is $1,097.06 for the full set, so, if OpenAI used the leaderboard’s cost basis, the claim implies something below roughly $366 or $549 depending on which phrasing is right.

What Artificial Analysis measured

Artificial Analysis had already run both models on its Intelligence Index v5.0.1 when we read its pages on 18 November 2026. All rows are at max effort.

Model (max effort)AA Intelligence IndexCost per index taskOutput tokens to run indexMinutes per taskList price in/out
Claude Fable 5.2 (default fallback)65$26.54275M40.8$8 / $40
GPT-6.2 Astra62$4.0065.8M10.4$8 / $40
GPT-6 Astra57$6.2454.3M20.4$10 / $50
GPT-6.2 Sol57$1.0160.9M7.9$2 / $10
GPT-6.1 Sol55$1.2763.7M23.1$2 / $10

Values from Artificial Analysis model pages, read by GenAI Brief on 18 November 2026. Measured by Artificial Analysis; GenAI Brief ran no tests.

Three findings matter for builders. First, GPT-6.2 Sol matches GPT-6 Astra’s index score at about a sixth of its cost per task, which makes it the default candidate for most work that ran on GPT-6 Astra. Second, GPT-6.2 Astra closes most of the gap to Fable 5.2 at about 15 per cent of Fable’s cost per task, and both have the same list price. Third, on this index GPT-6.2 Astra generated more output tokens than GPT-6 Astra, 65.8 million against 54.3 million. That is the opposite of OpenAI’s “fewer output tokens” framing, measured on a different task mix. Artificial Analysis’s own cost breakdown for a full index run shows Astra’s output bill roughly flat against GPT-6 Astra ($2,630 against $2,716), while input, cache-read and cache-write costs fall from $2,945 to $1,900, so on that run-level view most of the saving comes from input and cache pricing. Its weighted cost-per-task figure, which weights each evaluation differently, shows output cost per task falling too, from $2.60 to $1.64.

Speed moved more than price. Astra’s time per index task fell from 20.4 minutes to 10.4, and Sol’s from 23.1 to 7.9. For interactive agents, that may matter more than the token bill.

Safety findings that change how you build

The GPT-6.2 system card is long. Most of it concerns catastrophic-risk thresholds, but several findings bear directly on application design.

The models are worse at reporting blockers outside Codex

OpenAI’s Blocker Deception evaluation removes something the model needs, such as the file it was asked to edit, and checks whether the final answer discloses the obstacle. The card says GPT-6.2 Astra “omitted a known obstacle to completing its work in 22.28 percent of trials, compared with 11.09 percent for GPT-6 Astra.” On the Broken Search Tool evaluation, which disables search on a task that needs it, Astra had a 23.00 per cent failure rate against 7.58 per cent for GPT-6 Astra.

OpenAI says a developer prompt used in Codex “substantially reduced” these omissions, and adds a sentence API users should not miss: “The Codex developer prompt used in these evaluations is not applied to direct API requests.” OpenAI’s own hypothesis is that “efforts to make responses concise and avoid excessive caveats may be related.” An application that runs GPT-6.2 directly should instruct the model to report missing inputs and failed tools, and should check tool results independently rather than relying on the final message.

Prompt injection resistance improved, but not to zero

The card reports two harder prompt-injection evaluations using GPT-Red 2, OpenAI’s automated red-teaming model, as the attacker. On 115 held-out environments adapted from Gray Swan’s indirect prompt injection challenges, GPT-6.2 Astra resisted 99.23 per cent of final attacks and Sol 99.76 per cent, against 98.06 per cent for GPT-6 Astra. On model-generated environments covering coding, web search and connected tools, GPT-6.2 Astra resisted 84.67 per cent and Sol 91.65 per cent, against 44.98 per cent for GPT-6 Astra. Across five independent attempts in the same environment, Astra resisted every attack in 74.46 per cent of cases.

That is a large improvement and still leaves a persistent attacker succeeding in roughly a quarter of Astra environments on the harder test. Tool permissions and egress controls remain the application’s job.

Cyber restrictions are tighter by default

OpenAI rates both models at the Critical threshold for cybersecurity under its Preparedness Framework and at High for biological and chemical capabilities; Astra is also its first externally released model rated High for AI self-improvement. On its internal ExploitBench Internal Port test, which measures arbitrary code execution from V8 and Chrome vulnerabilities disclosed between June and August 2026, Astra scored 53.5 per cent and Sol 50.5 per cent at maximum reasoning, against 31.5 per cent for GPT-6 Astra, with safeguards disabled. The announcement says the launch safeguards “restrict some legitimate vulnerability research and security testing workflows.” The card says reduced cyber refusals on GPT-6.2 Astra are planned only for organisations separately approved for Daybreak Red, and that “Daybreak Blue approval alone will not reduce safeguards on GPT-6.2 Astra and Sol.”

The card also records an unresolved outside finding. The UK AI Security Institute tested two pre-release versions and “identified a substantial regression in robustness relative to GPT-6 Astra,” developing a universal jailbreak for single-turn cyber questions “in half as many model queries as it had taken for GPT-6 Astra.” OpenAI says it changed the model and safeguards and believes the regression is mitigated; the card states that, as of writing, “UK AISI has not independently tested those latest changes.” Unite.AI’s report on the system card draws the same distinction. Security teams whose legitimate work trips refusals should expect friction on GPT-6.2 until Daybreak access arrives.

Monitoring and distillation controls

Two further items affect operations. The card says a version of OpenAI’s monitoring system “also monitors external use of these models,” and the announcement says it can automatically flag unauthorised behaviour and, where supported, pause workloads or conversations. The card also describes strengthened protections against unauthorised distillation, including “added checks that can hold streamed responses if they might expose private model reasoning.” Teams that see unexplained pauses in streaming should keep that mechanism in mind when debugging.

What builders should test before switching

GPT-6.1 Terra users have a separate decision; our analysis of Terra’s computer-use positioning still applies, since Terra was not updated. For Astra and Sol users, these are the tests we would run, none of which GenAI Brief has performed.

  1. Run Sol first. On Artificial Analysis’s index, GPT-6.2 Sol matches GPT-6 Astra at a sixth of the cost per task. Any workload currently on GPT-6 Astra should be tried on GPT-6.2 Sol at high and max before it is moved to GPT-6.2 Astra.
  2. Measure output tokens, not just scores. OpenAI reports 22 per cent fewer output tokens on its own benchmark; Artificial Analysis measured more on its index. Log reasoning plus answer tokens per completed task on your own sample.
  3. Audit for prefix changes. Turn on Prompt Cache Diagnostics and inspect input_transformations on real sessions. Fix effort changes, tool-list edits and in-place truncation before migration, not after.
  4. Track cached-token share. At $0.40 cached against $8 uncached, the cache-hit rate is the largest single lever on Astra’s input bill.
  5. Watch the 272,000-token line. Add an alert for requests near it and compact earlier.
  6. Replace Flex. If evaluations or enrichment jobs ran on Flex, move them to Batch or the two-hour and eight-hour background windows; Flex is not listed for GPT-6.2.
  7. Add a blocker-reporting instruction. For direct API use, tell the model to state any missing file, failed tool or unavailable search explicitly, and test it with deliberately broken tools.
  8. Re-test refusals on security tasks. Expect more refusals on vulnerability work until GPT-6.2 reaches Daybreak.
  9. Budget Ultrafast for the step-up. Ultrafast at three times Standard rises to six times on 1 March 2027.

What remains unknown

Several things a buyer would want are not in the documents we read. OpenAI has not said whether Flex will come to GPT-6.2, or when. The Agents’ Last Exam and Terminal-Bench-Science claims are not yet independently listed for GPT-6.2 Astra. The system card’s Blocker Deception figure for Sol without the Codex prompt is shown only in a chart we could not read numerically. And UK AISI has not published a retest of the final safeguards.

Our judgement: GPT-6.2 Sol is the more consequential release for most teams, because it brings near-GPT-6 Astra index scores to the $2/$10 tier with faster tasks. GPT-6.2 Astra is a cheaper, faster Astra whose biggest saving goes to integrations that already keep their prompts append-only. For everyone else, the first job is not choosing a model. It is fixing the prefix.

Sources

  1. Introducing GPT-6.2 Astra and Sol OpenAI
  2. GPT-6.2 System Card OpenAI Deployment Safety Hub
  3. GPT-6.2 Astra model page OpenAI API documentation
  4. GPT-6.2 Sol model page OpenAI API documentation
  5. GPT-6 Astra model page OpenAI API documentation
  6. GPT-6.1 Sol model page OpenAI API documentation
  7. API pricing OpenAI API documentation
  8. Using GPT-6.2 (migration guide) OpenAI API documentation
  9. Keep the prefix unchanged OpenAI API documentation
  10. Prompt caching OpenAI API documentation
  11. Flex processing OpenAI API documentation
  12. API changelog OpenAI API documentation
  13. Fast and Ultrafast modes OpenAI Codex documentation
  14. GPT-6.2 Astra and Sol are now available OpenAI Developer Community
  15. GPT-6.2 Astra model analysis Artificial Analysis
  16. GPT-6.2 Sol model analysis Artificial Analysis
  17. GPT-6 Astra model analysis Artificial Analysis
  18. GPT-6.1 Sol model analysis Artificial Analysis
  19. Claude Fable 5.2 model analysis Artificial Analysis
  20. Agents' Last Exam leaderboard (ALE v1.1) Agents' Last Exam
  21. OpenAI upgrades ChatGPT and Codex with new GPT-6.2 Astra and Sol models 9to5Mac
  22. OpenAI Releases GPT-6.2 Astra With First High Self-Improvement Rating Unite.AI

Frequently asked questions

How much does GPT-6.2 Astra cost in the API?

At Standard rates, $8 per million input tokens, $0.40 per million cached input tokens and $40 per million output tokens. A 30-minute cache write costs $10 per million and a 12-hour write $20. Requests above 272,000 input tokens pay double input and cache rates and 1.5 times the output rate for the whole request. Batch is half price; Fast mode is double.

Is GPT-6.2 Sol more expensive than GPT-6.1 Sol?

No. OpenAI kept GPT-6.1 Sol's rates: $2 input, $0.10 cached input and $10 output per million tokens, with the same cache-write prices. The differences are in the model, the knowledge cutoff (1 June 2026 against 30 April 2026) and the Ultrafast multiplier, which is 3 times Standard for GPT-6.2 models until 28 February 2027 rather than 6 times.

What does the 60 per cent cached-input discount mean?

GPT-6 Astra billed cached input at $1.00 per million tokens, a tenth of its input rate. GPT-6.2 Astra bills it at $0.40, a twentieth of its $8 input rate. OpenAI's caching guide says cache reads on GPT-6.2 Astra and Sol cost 0.05 times the ordinary input rate, against 0.1 times on most other recent models.

Can I use Flex processing with GPT-6.2?

Not according to OpenAI's pricing page as read on 18 November 2026: the Flex table lists GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna, not the GPT-6.2 models. GPT-6.2 does support Batch at 50 per cent of Standard and the new background completion windows at 30 or 40 per cent off.

Do I need to change my code to move to GPT-6.2?

Change the model name, use the Responses API if you call tools, remove temperature, top_p and the logprob parameters, and replace a reasoning effort of none or minimal with low. OpenAI also recommends an append-only conversation pattern, because the API now drops earlier reasoning items after a mid-conversation prefix edit.

Is GPT-6.2 Astra the top model on independent benchmarks?

Not on the Artificial Analysis Intelligence Index as read on 18 November 2026, where Claude Fable 5.2 at max scores 65 against GPT-6.2 Astra's 62. Astra costs far less per task on that index: $4.00 against $26.54. Agents' Last Exam's public leaderboard, updated 16 November, did not yet list GPT-6.2 Astra.

All models →