OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on 17 November 2026, and both are live in the API as gpt-6.2-astra and gpt-6.2-sol. Swapping the model string is the easy part. A few quiet behaviour changes can break your app or raise your bill if you skip them.
This guide walks you through the full move, step by step. If you want the launch story and benchmarks, read our news write-up on GPT-6.2 Astra and Sol first.
- Model ids:
gpt-6.2-astra($8 in / $0.40 cached / $40 out per 1M tokens) andgpt-6.2-sol($2 / $0.10 / $10). - Sol price: unchanged from GPT-6.1 Sol. Astra is 20% cheaper than GPT-6 Astra on input and output.
- Reasoning: no
noneeffort. Uselow,medium,high,xhighormax. Start atmedium. - Remove:
temperature,top_p,top_logprobsand logprobs settings. - Use the Responses API for tools. Chat Completions still works for plain text, but tool calling needs Responses.
- Watch out: top-level
instructionsnow go afterinput, and editing the conversation prefix drops reasoning items.
What Changed for Developers in GPT-6.2
Here are the specs that matter for your code, taken from the OpenAI models and pricing pages. Both models share the same limits, so the choice between them is about quality and cost.
| Spec | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Model id | gpt-6.2-astra |
gpt-6.2-sol |
| Input / cached / output (per 1M) | $8 / $0.40 / $40 | $2 / $0.10 / $10 |
| Context window | 1.05M tokens | 1.05M tokens |
| Max output | 128K tokens | 128K tokens |
| Reasoning effort | low, medium, high, xhigh, max | low, medium, high, xhigh, max |
| Knowledge cutoff | 18 May 2026 | 1 June 2026 |
| Endpoints | Responses, Chat Completions, Batch | Responses, Chat Completions, Batch |
| Not supported | Realtime, fine-tuning, predicted outputs | Realtime, fine-tuning, predicted outputs |
The behaviour changes that bite
- Instructions order: top-level
instructionsnow append afterinput. For cacheable system text, put adevelopermessage as the first item ininputinstead. - Reasoning items get dropped: if you edit earlier turns, switch models mid-conversation (including downgrades) or change the end user or organization, the Responses API drops prior reasoning. That can lower quality and use more tokens.
- Cheaper cache reads: cache reads on both 6.2 models bill at 0.05x the input rate, versus 0.1x on most models.
- Shorter answers: OpenAI says both models write more concisely by default, so old “be concise” prompts may now cut too much.
- Long prompts cost more: above 272K input tokens, input and cache rates double and output costs 1.5x for the whole request.
Astra vs Sol: Which Model to Pick
OpenAI positions Astra as the frontier model for the hardest projects and Sol as the efficient model for everyday and agentic work. Sol costs a quarter of Astra on every line of the bill.
| Task | Pick | Why |
|---|---|---|
| Chatbots, support, RAG answers | Sol | High volume, so the 4x price gap adds up fast |
| Classification, extraction, JSON output | Sol at low |
Simple tasks rarely need deep reasoning |
| Everyday coding and agent loops | Sol at medium |
OpenAI says Sol nearly matches Astra on merge-ready code changes at about a fifth of the cost |
| Hard multi-step research, big refactors | Astra | The model built for the hardest tasks |
| Code review, computer use, 3D or design output | Astra | Areas OpenAI and early testers highlight |
| Long fiction or prose | Neither | An OpenAI moderator points prose users to GPT-6.1 Terra |
gpt-6.2-sol. Route only the requests that fail your Sol evals to gpt-6.2-astra.Early reviews of Astra are mixed. Some testers called it overly cautious on real projects, so test it on your own workload before paying 4x for it.
Step-by-Step Migration
Follow these steps in order. Most apps only need steps 1 to 5, but read the rest before you ship.
- Update your SDK. Run
pip install -U openai(or the npm equivalent) so new fields likeprompt_cache_optionsare typed. - Change the model string. Replace
gpt-6.1-solwithgpt-6.2-sol, orgpt-6-astrawithgpt-6.2-astra. Keep it in an env variable so you can roll back without a deploy. - Set reasoning effort. Use
reasoning.effortin Responses orreasoning_effortin Chat Completions. If you usednoneorminimalon an older model, switch tolow. Requests withnoneare rejected. - Remove sampling parameters. Delete
temperature,top_pandtop_logprobs. In Chat Completions also droplogprobs. In Responses, removemessage.output_text.logprobsfrominclude. - Move system text into a developer message. Because
instructionsnow come afterinput, put stable rules in the firstdeveloperitem so they cache. - Move tool calls to Responses. Function calling, web search, file search and computer use should go through
/v1/responses. - Update caching settings. Coming from GPT-5.5 or earlier? Replace
prompt_cache_retentionwithprompt_cache_options.ttlset to"30m"(or"12h"). - Keep the prefix stable. Append new turns instead of editing old ones. To change effort mid-conversation, append a
configuration_updateinput item rather than editing top-levelreasoning.effort. - Check structured outputs. JSON schema output works on both models. Re-run your schema tests, since shorter default answers can change optional fields.
- Re-tune prompts. Say clearly what outcome you want and which decisions need a human. OpenAI notes the model may otherwise stop to propose a next step.
Warning: Do not swap models in the middle of a live conversation to save money. The Responses API drops reasoning items on model changes, so the next turn can cost more and answer worse.
Python Examples (Responses API)
New to the SDK? Our OpenAI API Python tutorial covers keys and setup. These examples assume OPENAI_API_KEY is set.
Basic request with a cached developer message
import os
from openai import OpenAI
client = OpenAI()
MODEL = os.getenv("OPENAI_MODEL", "gpt-6.2-sol")
resp = client.responses.create(
model=MODEL,
reasoning={"effort": "medium"},
input=[
{"role": "developer", "content": "You are a support bot for Acme. Answer in plain English."},
{"role": "user", "content": "How do I reset my password?"},
],
prompt_cache_options={"ttl": "30m"},
)
print(resp.output_text)
print(resp.usage)
Note there is no temperature here. Passing it to a 6.2 model with reasoning on will fail.
Structured outputs with Pydantic
from pydantic import BaseModel
from openai import OpenAI
client = OpenAI()
class Ticket(BaseModel):
category: str
priority: str
summary: str
resp = client.responses.parse(
model="gpt-6.2-sol",
reasoning={"effort": "low"},
input=[
{"role": "developer", "content": "Classify the support ticket."},
{"role": "user", "content": "The app crashes every time I upload a PDF."},
],
text_format=Ticket,
)
ticket = resp.output_parsed
print(ticket.category, ticket.priority)
Function calling
tools = [{
"type": "function",
"name": "get_order_status",
"description": "Look up an order by id",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
"additionalProperties": False,
},
"strict": True,
}]
resp = client.responses.create(
model="gpt-6.2-astra",
reasoning={"effort": "high"},
input=[{"role": "user", "content": "Where is order 4417?"}],
tools=tools,
)
for item in resp.output:
if item.type == "function_call":
print(item.name, item.arguments, item.call_id)
Tip: For multi-turn tool loops, pass the earlier output items back in order, including reasoning items. That keeps the prefix stable, so you keep both reasoning and cache hits.
curl Examples
Use these to test access quickly from a terminal. A 404 here means the model is not available to your key yet (see Troubleshooting).
curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-sol",
"reasoning": {"effort": "medium"},
"input": [
{"role": "developer", "content": "Reply in one sentence."},
{"role": "user", "content": "What is a vector database?"}
]
}'
Structured output over curl uses text.format with a JSON schema:
curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-astra",
"reasoning": {"effort": "low"},
"input": "Extract the city and date: Meet me in Pune on 3 December.",
"text": {
"format": {
"type": "json_schema",
"name": "event",
"strict": true,
"schema": {
"type": "object",
"properties": {
"city": {"type": "string"},
"date": {"type": "string"}
},
"required": ["city", "date"],
"additionalProperties": false
}
}
}
}'
If You Stay on Chat Completions
Both models accept Chat Completions, so a plain text app can just change the model id. The rules are a little different here.
- Effort field: use top-level
reasoning_effort, not areasoningobject. - Remove:
temperature,top_p,logprobsandtop_logprobs. - Structured output: keep using
response_formatwith a JSON schema. - Tools: OpenAI’s migration notes say tool calling on these models requires the Responses API, so plan that move.
from openai import OpenAI
client = OpenAI()
resp = client.chat.completions.create(
model="gpt-6.2-sol",
reasoning_effort="low",
messages=[
{"role": "developer", "content": "Answer in one line."},
{"role": "user", "content": "Summarise HTTP 429 in plain English."},
],
)
print(resp.choices[0].message.content)
Cost Math: GPT-6.1 vs GPT-6.2
All prices below are Standard tier, per 1M tokens, from the OpenAI pricing page. For the full price list across models, see our OpenAI API pricing guide.
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $50.00 |
| GPT-6.2 Astra | $8.00 | $0.40 | $40.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 |
| GPT-6.2 Sol | $2.00 | $0.10 | $10.00 |
Worked examples per request
Output tokens include reasoning tokens, so higher effort raises the output line. These examples use fixed token counts to compare list prices only.
| Scenario | GPT-6 Astra | GPT-6.2 Astra | GPT-6.1 / 6.2 Sol |
|---|---|---|---|
| 1M input + 1M output | $60.00 | $48.00 | $12.00 |
| Chat turn: 10K input, 1.5K output, no cache | $0.175 | $0.140 | $0.035 |
| Agent step: 40K cached + 10K fresh input, 3K output | $0.290 | $0.216 | $0.054 |
| 100,000 chat turns a month (row 2) | $17,500 | $14,000 | $3,500 |
How the agent step adds up on GPT-6.2 Astra: 40K x $0.40/1M = $0.016, plus 10K x $8/1M = $0.08, plus 3K x $40/1M = $0.12. That is $0.216, about 25% less than GPT-6 Astra.
Note: Cache writes are billed at 1.25x the input rate with the default 30 minute lifetime, or 2.5x with "12h". The first request that writes the cache costs a bit more, and later reads are cheap.
Other pricing levers
- Batch: 50% off Standard, so 6.2 Sol is $1 / $0.05 / $5.
- Background mode (beta): eligible Responses requests are 30% off with a 2 hour window and 40% off with an 8 hour window.
- Fast: 2x Standard.
- Ultrafast: 3x Standard until 28 February 2027, then 6x from 1 March 2027.
- Data residency: regional processing adds 10%.
Effort is the biggest dial you control. Our guide to reasoning effort settings and API cost explains how each level changes token use.
Testing and Rollout Checklist
Do not flip 100% of traffic on day one. Use this checklist to move safely.
- Build an eval set. Collect 100 to 500 real prompts with known good answers, including edge cases and JSON outputs.
- Run offline evals. Score the old and new model side by side at the same effort. Track accuracy, schema pass rate, latency and tokens per request.
- Shadow traffic. Send a copy of live requests to the 6.2 model in the background. Log results but never show them to users.
- Compare cost per task. Use
usagefrom each response, including reasoning and cache write tokens, not just list prices. - Canary release. Route 5% of real users to 6.2, then 25%, then 100%, watching error rates at each step.
- Keep a kill switch. Read the model id from config so you can roll back in seconds.
- Re-check after a week. Look at cache hit rates. If they dropped, something is editing your prompt prefix.
Switching Codex to GPT-6.2
GPT-6.2 Astra and Sol are available in Codex for Plus, Pro, Enterprise and Edu users. Update the Codex CLI to the latest version first, then pick the model.
- Config file: edit
~/.codex/config.tomland setmodel = "gpt-6.2-sol"(or"gpt-6.2-astra"). - Effort: add
model_reasoning_effort = "medium". Supported levels vary by model and client. - One session only: start Codex with
codex -m gpt-6.2-astra, or use the/modelcommand inside a session. - Desktop app: use Menu, then Check for Updates, and restart.
# ~/.codex/config.toml
model = "gpt-6.2-sol"
model_reasoning_effort = "medium"
Want Codex to migrate your codebase for you? OpenAI’s docs suggest the OpenAI Docs skill with a prompt like $openai-docs migrate this project to the GPT-6 model family. Our Codex guide covers setup and plans.
Troubleshooting
These are the errors you are most likely to hit in the first week. Our OpenAI API errors guide covers the full list.
404 model not found
- Typo: the ids use a dot and hyphens:
gpt-6.2-sol, notgpt-6-2-solorgpt6.2. - Gradual rollout: OpenAI says access depends on rollout progress. Check the models list in your dashboard or call
GET /v1/models. - Wrong project: your key may belong to a project where the model is not enabled. Check project model permissions.
- Wrong endpoint: Realtime and fine-tuning endpoints do not support these models.
400 invalid request errors
- Unsupported parameter: remove
temperature,top_p,logprobsortop_logprobs. - Effort none: the API rejects
none. Uselow. - Bad cache TTL:
prompt_cache_options.ttlonly accepts"30m"or"12h".
429 rate limits and tier access
Standard rate limits on both models are the same per tier. They rise automatically as you spend more.
| Tier | Requests per minute | Tokens per minute |
|---|---|---|
| Build | 5,000 | 1,000,000 |
| Launch | 10,000 | 4,000,000 |
| Grow | 15,000 | 40,000,000 |
- Retry with backoff: add exponential backoff with jitter on 429s.
- Cut tokens: lower effort or trim context. Big reasoning output eats TPM fast.
- Move bulk work: send offline jobs to Batch, which has its own queue limit.
Quality or cost got worse after the switch
- Answers too short: remove old “be concise” lines, since 6.2 is concise by default.
- Bill went up: check for prompts over 272K tokens and for prefix edits that kill cache hits.
- Model stops to ask: state the end goal and which actions it may take without approval.
Frequently Asked Questions
What are the GPT-6.2 model ids in the OpenAI API?
Use gpt-6.2-astra and gpt-6.2-sol. OpenAI lists no dated snapshots for either model yet.
Is GPT-6.2 Sol more expensive than GPT-6.1 Sol?
No. GPT-6.2 Sol costs $2 input, $0.10 cached input and $10 output per 1M tokens, the same as GPT-6.1 Sol.
How much cheaper is GPT-6.2 Astra than GPT-6 Astra?
Input and output are 20% cheaper ($8 vs $10, $40 vs $50 per 1M). Cached input drops 60%, from $1.00 to $0.40.
Can I still use temperature with GPT-6.2?
No. OpenAI’s migration notes say to remove temperature, top_p and top_logprobs on these models. Control output with reasoning effort and prompt wording instead.
Which reasoning effort should I start with?
OpenAI recommends medium for new integrations. Move simple tasks down to low and reserve xhigh or max for the hardest jobs.
Do GPT-6.2 models work with Chat Completions?
Yes, for text requests. For tool calling and the newest features, OpenAI recommends the Responses API.
Is GPT-6.2 available in the Realtime API?
No. Both model pages list Realtime, fine-tuning and predicted outputs as unsupported.
Sources
- OpenAI: Models
- OpenAI: API pricing
- OpenAI: Using the latest model (GPT-6.2 migration notes)
- OpenAI: GPT-6.2 Astra model page
- OpenAI: GPT-6.2 Sol model page
- OpenAI: Prompt caching guide
- OpenAI Developer Community: GPT-6.2 Astra and Sol are now available
- Codex: Sample configuration
- The Next Web: GPT-6.2 Astra and Sol launch



