Skip to content
, ,

How to Migrate to GPT-6.2 Astra and Sol in the OpenAI API

10–15 minutes
Woman at a tech conference hall holding a card with the OpenAI logo, hook GPT-6.2 migration, Sol still $2

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.

TLDR

  • Model ids: gpt-6.2-astra ($8 in / $0.40 cached / $40 out per 1M tokens) and gpt-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 none effort. Use low, medium, high, xhigh or max. Start at medium.
  • Remove: temperature, top_p, top_logprobs and logprobs settings.
  • Use the Responses API for tools. Chat Completions still works for plain text, but tool calling needs Responses.
  • Watch out: top-level instructions now go after input, 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 instructions now append after input. For cacheable system text, put a developer message as the first item in input instead.
  • 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
Quick answer: Default to 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.

  1. Update your SDK. Run pip install -U openai (or the npm equivalent) so new fields like prompt_cache_options are typed.
  2. Change the model string. Replace gpt-6.1-sol with gpt-6.2-sol, or gpt-6-astra with gpt-6.2-astra. Keep it in an env variable so you can roll back without a deploy.
  3. Set reasoning effort. Use reasoning.effort in Responses or reasoning_effort in Chat Completions. If you used none or minimal on an older model, switch to low. Requests with none are rejected.
  4. Remove sampling parameters. Delete temperature, top_p and top_logprobs. In Chat Completions also drop logprobs. In Responses, remove message.output_text.logprobs from include.
  5. Move system text into a developer message. Because instructions now come after input, put stable rules in the first developer item so they cache.
  6. Move tool calls to Responses. Function calling, web search, file search and computer use should go through /v1/responses.
  7. Update caching settings. Coming from GPT-5.5 or earlier? Replace prompt_cache_retention with prompt_cache_options.ttl set to "30m" (or "12h").
  8. Keep the prefix stable. Append new turns instead of editing old ones. To change effort mid-conversation, append a configuration_update input item rather than editing top-level reasoning.effort.
  9. Check structured outputs. JSON schema output works on both models. Re-run your schema tests, since shorter default answers can change optional fields.
  10. 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 a reasoning object.
  • Remove: temperature, top_p, logprobs and top_logprobs.
  • Structured output: keep using response_format with 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.

  1. Build an eval set. Collect 100 to 500 real prompts with known good answers, including edge cases and JSON outputs.
  2. 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.
  3. Shadow traffic. Send a copy of live requests to the 6.2 model in the background. Log results but never show them to users.
  4. Compare cost per task. Use usage from each response, including reasoning and cache write tokens, not just list prices.
  5. Canary release. Route 5% of real users to 6.2, then 25%, then 100%, watching error rates at each step.
  6. Keep a kill switch. Read the model id from config so you can roll back in seconds.
  7. 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.toml and set model = "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 /model command 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, not gpt-6-2-sol or gpt6.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, logprobs or top_logprobs.
  • Effort none: the API rejects none. Use low.
  • Bad cache TTL: prompt_cache_options.ttl only 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

Free weekly email

Get new AI guides every week

One short weekly email with our newest local AI, ComfyUI and AI tool guides. No spam, no pop-ups, just the good stuff.

Free. Unsubscribe anytime in one click. We only use your email to send this newsletter. See our privacy policy.

Woman at a tech conference hall holding a card with the OpenAI logo, hook GPT-6.2 migration, Sol still $2