GPT-6.2 Astra and Sol API migration: what breaks, tier-by-tier pricing, and a worked monthly bill that puts Astra at $2,840 versus Sol at $710.
Moving to GPT-6.2 is a model ID swap plus a short review: GPT-6.2 Astra costs 20 percent less per token than GPT-6 Astra, and GPT-6.2 Sol keeps GPT-6.1 Sol's price. Astra lists at $8 per million input tokens, $0.40 cached and $40 output. Sol lists at $2, $0.10 and $10.[1][3] The model IDs are gpt-6.2-astra and gpt-6.2-sol. Most of the risk is behavioral, not a hard error: the API rejects reasoning effort none,[4] and it silently drops reasoning items when earlier history changes.[2] On a stated workload of 10,000 agent requests a month, the bill is $3,750 on GPT-6 Astra, $2,840 on 6.2 Astra and $710 on 6.2 Sol. Below: before and after code, a what-breaks table, every pricing tier, the worked bill and a decision table.
Scope note. Everything here comes from OpenAI's announcement, API docs and pricing page, read on November 18, 2026. The code snippets follow the field names and request shapes in those docs and were not run against the live API for this post, so try them in your own project first. Benchmark figures are OpenAI's own and labeled vendor-reported.
The minimum change: before and after
Set model to gpt-6.2-astra or gpt-6.2-sol. Both models take a 1,050,000-token context window, 922,000 max input tokens and 128,000 max output tokens.[4][5] The migration guide says to start new integrations at medium reasoning effort and to use low wherever you used none or minimal.[2] Responses API call:
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6.2-astra", # was "gpt-6-astra"
reasoning={"effort": "medium"}, # "none" is rejected; use "low" if you ran none or minimal
input="Review this diff for race conditions.",
)
print(response.output_text)On Chat Completions the setting is reasoning_effort, and the sampling fields have to go. Chat Completions still works, but the guide says tool calling requires the Responses API.[2]
response = client.chat.completions.create(
model="gpt-6.2-sol", # was "gpt-6.1-sol"
reasoning_effort="low", # was none or minimal
messages=[{"role": "user", "content": "Summarize this support ticket."}],
# removed: temperature, top_p, logprobs, top_logprobs
)
print(response.choices[0].message.content)What breaks, row by row
Each row is a documented change. The guide does not say how GPT-6 Astra or GPT-6.1 Sol handled these fields, so the table states the GPT-6.2 behavior and the fix, not what the old models did.[2][4]
| Area | GPT-6.2 behavior | Fix |
|---|---|---|
Reasoning effort none | The API rejects the request | Use low where you used none or minimal; start new work at medium |
| Sampling and logprobs (Chat Completions) | Guide says to omit temperature, top_p, logprobs, top_logprobs | Delete them from the request |
| Sampling and logprobs (Responses) | Omit temperature, top_p, top_logprobs; remove message.output_text.logprobs from include | Same, plus edit include |
| Tool calling on Chat Completions | Chat Completions is supported, but tools need Responses | Move tool-calling routes to /v1/responses |
| Edited history | The API drops reasoning items on prefix edits, model downgrade, end user or organization change; quality can fall and token use can rise | Append-only history; see next section |
| Prompt cache settings (from GPT-5.5 or earlier only) | prompt_cache_retention is replaced | Set prompt_cache_options.ttl to "30m" |
| Zero Data Retention | Supported for approved organizations; the Responses API treats store as false | Pass prior output items back in order, including encrypted reasoning items |
| Ultrafast data residency | US only; Standard, Fast and Batch support US and EU | Keep EU-resident traffic off Ultrafast |
| Prompt style | Astra writes more concise, direct output by default and may propose a next step and wait | Revisit "be concise" lines; tell it to proceed on reasonable assumptions |
| Security work | Tighter safeguards for higher-risk cyber requests; some legitimate testing is restricted | Plan a fallback; Daybreak access for 6.2 is "work to bring" (OpenAI's wording), not shipped |
The cyber row matters for security vendors. OpenAI says both models meet its Critical threshold for cybersecurity, launch with tighter safeguards, and that its Daybreak program currently offers GPT-6 Sol with reduced cyber refusals, with GPT-6.2 models still to come.[1]
The silent one: prefix edits
Nothing returns a 400 here. The API drops reasoning items that follow a changed prefix, so the model may redo earlier reasoning, which raises tokens, cost and latency.[7] Edits that trigger it include shortening an old tool result, rewriting a developer message, swapping tools or instructions, and replacing old turns with your own summary. The docs prescribe append-only patterns: a configuration_update item to change reasoning effort or output schema mid-conversation, an additional_tools item to add tools, and a new developer message to change instructions.[7] To find the culprit, read input_transformations on the response, and set prompt_cache_options.comparison_response_id to an earlier response ID to see why the cache missed.[7]
One routing trap. The guide lists "model downgrade" as a trigger without defining it. If a router moves a live conversation from Astra to Sol mid-thread, assume it may count. That definition is unconfirmed, so pin a model per conversation, not per turn.[2]
Pricing across every tier
All figures are USD per million tokens, shown as input / cached input / output, from the pricing page.[3] GPT-6 Astra is the reference column. The over-272K row is not a published table row; it applies the long-context rule from the model pages (input and cache rates x2, output x1.5).[4]
| Tier | GPT-6.2 Astra | GPT-6.2 Sol | GPT-6 Astra |
|---|---|---|---|
| Standard | $8 / $0.40 / $40 | $2 / $0.10 / $10 | $10 / $1.00 / $50 |
| Batch | $4 / $0.20 / $20 | $1 / $0.05 / $5 | $5 / $0.50 / $25 |
| Fast | $16 / $0.80 / $80 | $4 / $0.20 / $20 | $20 / $2.00 / $100 |
| Ultrafast through Feb 28, 2027 (3x) | $24 / $1.20 / $120 | $6 / $0.30 / $30 | $60 / $6.00 / $300 |
| Ultrafast from Mar 1, 2027 (6x) | $48 / $2.40 / $240 | $12 / $0.60 / $60 | $60 / $6.00 / $300 |
| Standard, over 272K input | $16 / $0.80 / $60 | $4 / $0.20 / $15 | not confirmed |
Four details change real bills. First, the long-context rule: for a request 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, not only the tokens past 272K.[4] A single 300,000-token uncached prompt with 5,000 output tokens costs 0.3 x $16 + 0.005 x $60 = $4.80 + $0.30 = $5.10 on Astra, against $2.60 at short-context rates. Second, the Ultrafast rate doubles on March 1, 2027 (Pacific time), so a budget built on the 3x launch rate is off by half within four months.[3] Third, the pricing page lists 6.2 Astra and Sol in the Batch, Fast and Ultrafast tables but not in the Flex table, which shows GPT-6 Astra and GPT-6.1 Sol. Fourth, regional processing endpoints add a 10 percent uplift for models released on or after March 5, 2026, which covers the 6.2 models by date.[3]
Eligible background requests get their own discount on the 6.2 models: 30 percent below Standard for the 2-hour completion window and 40 percent below for the 8-hour window. That makes Astra $5.60 / $28 and $4.80 / $24 per million input / output. Batch at $4 / $20 is still cheaper.[3] Ultrafast is set with service_tier, and OpenAI recommends WebSockets for agentic loops with many tool calls.[6] The HTTP form, adapted from the docs' example by swapping in the 6.2 model ID the guide names:
curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-astra",
"input": "Explain why the sky is blue in one sentence.",
"service_tier": "ultrafast"
}'Cache writes are billed, and 12 hours costs double
On GPT-5.6 and later models, a cache write costs 1.25 times the uncached input rate for the default 30-minute lifetime and 2.5 times for a 12-hour lifetime. Reads cost 0.05 times input on Astra and Sol.[8] That is how Astra reaches $10 per million for a 30-minute write and $20 for 12 hours, and $0.40 for reads.[4] The docs' mixed-lifetime example, with Sol as the model, puts the long-lived material behind a 12-hour breakpoint and leaves the current question after the last breakpoint so it incurs no write charge:[8]
{
"model": "gpt-6.2-sol",
"prompt_cache_options": { "mode": "explicit", "ttl": "30m" },
"input": [
{
"role": "developer",
"content": [
{
"type": "input_text",
"text": "Shared instructions and reference material reused throughout the day...",
"prompt_cache_breakpoint": { "mode": "explicit", "ttl": "12h" }
}
]
},
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "The current question, which does not need a cache write..."
}
]
}
]
}The docs example also marks a second 30-minute breakpoint inside the user message. It is trimmed here to one breakpoint, so check the full example before copying.[8]
Worked monthly bill
Assumptions, all ours: an agent service running 10,000 requests a month. Each request has 40,000 cached-read input tokens, 6,000 uncached input tokens, 2,000 tokens written to a 30-minute cache and 5,000 output tokens. The four buckets do not overlap. Monthly totals: 400M cached reads, 60M uncached input, 20M cache-write tokens, 50M output. Token counts are held constant across models. Standard tier, short context.
PRICES = { # USD per 1M tokens: cached read, input, 30m cache write, output
"gpt-6-astra": (1.00, 10.00, 12.50, 50.00),
"gpt-6.2-astra": (0.40, 8.00, 10.00, 40.00),
"gpt-6.2-sol": (0.10, 2.00, 2.50, 10.00),
}
VOLUME_M = (400, 60, 20, 50) # millions of tokens per month
for model, rates in PRICES.items():
total = sum(rate * vol for rate, vol in zip(rates, VOLUME_M))
print(model, total)| Model | Cached reads | Uncached input | Cache writes | Output | Total |
|---|---|---|---|---|---|
| GPT-6 Astra | 400 x $1.00 = $400 | 60 x $10 = $600 | 20 x $12.50 = $250 | 50 x $50 = $2,500 | $3,750 |
| GPT-6.2 Astra | 400 x $0.40 = $160 | 60 x $8 = $480 | 20 x $10 = $200 | 50 x $40 = $2,000 | $2,840 |
| GPT-6.2 Sol | 400 x $0.10 = $40 | 60 x $2 = $120 | 20 x $2.50 = $50 | 50 x $10 = $500 | $710 |
GPT-6 Astra to 6.2 Astra saves $910 a month, 24.3 percent. It beats the headline 20 percent because cached reads fall 60 percent and this workload is read-heavy. Sol costs exactly one quarter of 6.2 Astra on every line ($2,840 / 4 = $710), because each Sol rate is one quarter of the Astra rate. OpenAI's "about one-fifth the cost" claim for Sol is a per-task figure that also reflects token counts, which differ by model.[1]
The same workload on other tiers, each a multiple of Standard per the docs:[4][5]
| Tier | Multiple | 6.2 Astra | 6.2 Sol |
|---|---|---|---|
| Standard | 1x | $2,840 | $710 |
| Batch | 0.5x | $1,420 | $355 |
| Fast | 2x | $5,680 | $1,420 |
| Ultrafast to Feb 28, 2027 | 3x | $8,520 | $2,130 |
| Ultrafast from Mar 1, 2027 | 6x | $17,040 | $4,260 |
One sensitivity, clearly an illustration. OpenAI reports 22 percent fewer output tokens for 6.2 Astra than GPT-6 Astra on its internal GDPval v2 benchmark (vendor-reported).[1] If your workload matched that, output drops from 50M to 39M tokens, or $1,560, and the Astra bill becomes $160 + $480 + $200 + $1,560 = $2,400, a 36 percent cut from $3,750. Your agent will not match a benchmark, so measure output tokens on a replay before you bank it. Price your own volumes in the AI model cost calculator and count real prompts with the token counter. For the previous generation's math, see our GPT-6.1 Sol versus GPT-6 Astra price breakdown.
Astra or Sol: the decision table
| Factor | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| OpenAI's positioning | Hardest projects | Everyday work, agents at scale |
| Standard price per 1M (in / out) | $8 / $40 | $2 / $10 |
| Bill on the workload above | $2,840 | $710 |
| Context, max input, max output | 1,050,000 / 922,000 / 128,000 | Identical |
| Knowledge cutoff | May 18, 2026 | Jun 1, 2026 |
| FrontierCode 2.0 (vendor-reported) | Baseline | Within 0.5 points at about one-fifth the cost, both at max |
| AA-3D Elo (vendor-reported) | 1,318 | 1,259 |
| Rate limits (RPM / TPM) | Build 5,000 / 1M, Launch 10,000 / 4M, Grow 15,000 / 40M | Identical |
Sources for the table: the model pages and the announcement.[1][4][5] Two readings. Sol has the later knowledge cutoff, so Astra is not the fresher model. And OpenAI's own coding benchmark puts Sol within half a point of Astra, which makes Sol the default for most agent traffic and Astra the escalation target for tasks where Sol fails your evals. Escalate per conversation, given the downgrade trap above. The per-token gap is a constant 4x, so Astra needs to finish a task with a quarter of Sol's tokens to break even, and nothing published suggests that.
Pre-flight checklist
- Swap the model ID and set
reasoning.effortexplicitly, withlowreplacing anynoneorminimal. - Strip
temperature,top_p,top_logprobsand, on Chat Completions,logprobs. - Move any tool-calling route off Chat Completions.
- Audit history handling for prefix edits, then read
input_transformationsin staging. - Check Ultrafast and long-context traffic against the March 1, 2027 rate and the 272K threshold, then re-baseline against the Claude Fable 5.2 migration numbers if you run both vendors.
Sources
- Introducing GPT-6.2 Astra and Sol, OpenAI (accessed November 18, 2026)
- Using GPT-6.2, OpenAI API Docs (accessed November 18, 2026)
- Pricing, OpenAI API Docs (accessed November 18, 2026)
- GPT-6.2 Astra model page, OpenAI API Docs (accessed November 18, 2026)
- GPT-6.2 Sol model page, OpenAI API Docs (accessed November 18, 2026)
- Ultrafast mode, OpenAI API Docs (accessed November 18, 2026)
- Keep the prefix unchanged, OpenAI API Docs (accessed November 18, 2026)
- Prompt caching, OpenAI API Docs (accessed November 18, 2026)
Written by
WOWHOW
The WOWHOW team brings 14+ years of production engineering experience. Every tool and product in the catalog is built, tested, and curated in-house.
Monday memo · free
One insight, every Monday. 7am IST.
1 field report, 3 links, 1 tool we actually use. No fluff, no spam.
Beyond the writing
Need production-ready templates?
Free browser tools with no signup, plus premium dev templates and starter kits.
Comments · 0
Beta: comments are stored locally on your device and not visible to other readers.
No comments yet. Be the first to share your thoughts.