GPT-6.2 Astra and Sol in Codex: API Pricing, Setup, and Migration

GPT-6.2 Astra and Sol are available in Codex, ChatGPT Work, and the OpenAI API. Learn their model IDs, switch Codex models, calculate API costs, and migrate reasoning, tool calls, and request parameters safely.

Contents
GPT-6.2 Astra and Sol in Codex: API Pricing, Setup, and Migration

If you use Codex or build coding agents with the OpenAI API, you can now use GPT-6.2 Astra or GPT-6.2 Sol. Both models launched on November 17, 2026, with API IDs gpt-6.2-astra and gpt-6.2-sol. Start with Sol for routine coding and agent workflows; choose Astra for complex implementation, testing, and reasoning.

The migration has several hard requirements. Both models reject reasoning effort none, tool calling requires the Responses API, and familiar sampling and log-probability parameters are unsupported. Requests exceeding 272K input tokens also receive higher rates, including cache writes.

Which GPT-6.2 model should you use for coding?

Choose GPT-6.2 Sol as your first model for everyday coding. Choose GPT-6.2 Astra for difficult changes across existing codebases, complex debugging, and tasks where stronger results can reduce costly review or repair.

OpenAI positions Astra as its frontier model for demanding professional work. Sol targets everyday coding and agent workflows. A more capable model can cost less per completed task if it needs fewer tokens or correction rounds, but that result depends on your workload.

ModelAPI model IDBest starting pointStandard input / cached input / output per 1M tokens
GPT-6.2 Solgpt-6.2-solRoutine coding, agent workflows, cost-sensitive tasks$2 / $0.10 / $10
GPT-6.2 Astragpt-6.2-astraComplex implementation, debugging, demanding reasoning$8 / $0.40 / $40

Both models have a 1,050,000-token API context window, a maximum input of 922,000 tokens, and a maximum output of 128,000 tokens.

Codex documents a separate model_context_window setting in config.toml for requesting a longer context. The documented configuration can use up to the models’ one-million-token context capacity. The API context limit and the context configured for a Codex session are separate settings.

What do the coding benchmarks actually show?

OpenAI’s launch announcement provides two comparisons that answer different questions.

On Cognition’s FrontierCode 2.0, Sol came within 0.5 points of Astra when both ran at max, at about one-fifth of Astra’s cost. FrontierCode evaluates whether changes to real codebases meet maintainers’ standards for merging. This is the more directly relevant comparison when choosing between the models for repository work.

On Agents’ Last Exam, Astra scored 5.5 points above Claude Fable 5.2. OpenAI reported that Astra’s cost was about 5% of Fable’s on that evaluation. However, the published Fable 5.2 leaderboard excludes nine tasks that used a fallback model. Treat this as an attributed benchmark result, not a guaranteed cost ratio for your coding agent.

OpenAI also reports cleaner code style, more focused tests, and fewer revision rounds from early testers. These observations support evaluating Astra on complex changes that need implementation and testing. They do not establish universal improvements across languages, repositories, or coding harnesses.

Early developer reactions are not unanimous. Simon Willison shared a Three.js and OpenStreetMap demonstration using both models. Theo’s early comment expressed a preference for another model’s behavior, but supplied no reproducible task or evaluation. These posts illustrate different developer expectations, not comparable benchmark results.

Run the same repository task through both models before choosing. Keep the prompt, context, tools, reasoning effort, and acceptance criteria fixed. Compare accepted changes, test coverage, correction rounds, output tokens, and total API charges. Keep Sol if it meets your review standard. Move to Astra when the additional quality changes the result.

How much do GPT-6.2 Astra and Sol cost?

Standard API prices are per million text tokens. Input, cached input, cache writes, and output are separate billing categories. The cached-input price does not cover writing a cache.

Billing itemGPT-6.2 SolGPT-6.2 Astra
Input$2.00$8.00
Cached input$0.10$0.40
Cache write, 30-minute retention$2.50$10.00
Cache write, 12-hour retention$5.00$20.00
Output$10.00$40.00

These are Standard rates per million tokens for short-context requests, as documented on November 18, 2026. Astra’s input and output rates are 20% lower than GPT-6 Astra’s. Its cached-input rate is 60% lower. Sol retains GPT-6.1 Sol’s published token rates.

What changes above 272K input tokens?

For a request with more than 272K input tokens, OpenAI applies long-context rates to the full request:

  • Input costs twice the short-context rate.
  • Cached input costs twice the short-context rate.
  • Cache writes also cost twice the short-context rate.
  • Output costs 1.5 times the short-context rate.

The resulting rates are:

Long-context billing itemGPT-6.2 SolGPT-6.2 Astra
Input$4.00$16.00
Cached input$0.20$0.80
Cache write, 30-minute retention$5.00$20.00
Cache write, 12-hour retention$10.00$40.00
Output$15.00$60.00

For example, consider a request with 300,000 input tokens and 10,000 output tokens, with no cached input. At Standard rates, the estimated charge is:

  • Sol: 0.3 × $4 + 0.01 × $15 = $1.35
  • Astra: 0.3 × $16 + 0.01 × $60 = $5.40

These estimates apply long-context rates to the entire request. They exclude cache writes, other fees, and service-tier multipliers. If the request contains cached input, calculate that portion at the applicable cached-input rate.

How do Batch, Fast, and Ultrafast affect the bill?

The model cards document three processing options:

Processing optionPrice relative to StandardWhen to consider it
Batch0.5×Work that can run asynchronously
Fast2×Work where faster processing justifies the extra charge
Ultrafast3× through February 28, 2027; 6× from March 1, 2027Eligible workloads that need the highest processing tier

The Ultrafast price change takes effect on March 1, 2027, Pacific time. It changes the processing multiplier, not the model’s base token rates.

Ultrafast supports US data residency only. Standard, Fast, and Batch support US and EU data residency. Do not select Ultrafast for an EU-residency workload.

For example, a short-context Astra request at Ultrafast uses three times Standard rates through February 28, 2027. Its input, cached-input, and output rates become $24, $1.20, and $120 per million tokens. From March 1, 2027, the six-times multiplier makes those rates $48, $2.40, and $240. Cache-write rates receive the same multiplier. Apply the same calculation to Sol’s Standard rates.

A faster processing tier can multiply input, cached-input, cache-write, and output charges. It does not automatically reduce the number of tokens your application consumes.

How do you switch to GPT-6.2 in Codex?

You can select a model when starting Codex, change it in an interactive session, or set a default in config.toml. The examples use Sol. Replace its model ID with gpt-6.2-astra when you want Astra.

Start Codex with a model

In your terminal, run:

codex --model gpt-6.2-sol

The -m alias also works. For a non-interactive task, pass the model to codex exec:

codex exec -m gpt-6.2-sol "Review the current changes"

These commands select a model for that invocation. They do not change your persistent default.

Switch models inside an interactive session

When Codex is running, enter:

/model

Use the model picker to select GPT-6.2 Sol or GPT-6.2 Astra. The same interface lets you adjust reasoning effort. This is useful when a routine task becomes a complex implementation problem.

Set a default in config.toml

To use Sol by default, set:

model = "gpt-6.2-sol"

For Astra, use:

model = "gpt-6.2-astra"

The Codex model reference documents these model-selection commands. For a custom API provider, follow that provider’s configuration requirements. A model ID alone does not configure an endpoint or authentication.

How do you migrate an API integration?

Set model to gpt-6.2-astra or gpt-6.2-sol, then review reasoning effort, tool calls, unsupported parameters, and prompt caching. The official GPT-6.2 migration guide documents these changes.

Change reasoning effort

For a new integration, start with medium. If your existing request uses none or minimal, use low instead.

The field name depends on the endpoint:

  • Responses API: reasoning.effort
  • Chat Completions: reasoning_effort

Both models reject reasoning effort none. Do not preserve an old none setting during migration.

For Responses, a minimal request body looks like this:

{
  "model": "gpt-6.2-sol",
  "reasoning": {
    "effort": "medium"
  },
  "input": "Explain what this function does."
}

For Chat Completions, use reasoning_effort instead:

{
  "model": "gpt-6.2-sol",
  "reasoning_effort": "medium"
}

Send a complete Responses API request

The following Bash example uses your OpenAI API key through an environment variable. Create an API key in the OpenAI API dashboard, then enter it when prompted.

read -rs OPENAI_API_KEY && export OPENAI_API_KEY
response=$(curl -sS https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.2-sol",
    "reasoning": {
      "effort": "medium"
    },
    "input": "Reply with exactly: GPT-6.2 API is working."
  }')
printf '%s\n' "$response" | jq -e '.status == "completed"' >/dev/null &&
  printf '%s\n' "$response" | jq -r '.output[] | select(.type == "message") | .content[] | select(.type == "output_text") | .text'

The request sends text through v1/responses and authenticates with a Bearer token. The final command checks that the response status is completed and retrieves the model’s output text. A successful test should print the requested confirmation.

This example is documentation-based, not an executed test. If the request fails, inspect the HTTP response and error body. A rejected parameter usually means an old request field remains. An unavailable model or account permission issue requires checking your API organization, model access, and billing. Do not treat a successful Codex subscription login as proof that API billing or API model access is configured.

Move tool calling to the Responses API

Both models support the Responses API and Chat Completions. However, tool calling requires the Responses API.

If your integration uses function or tool calls, migrate the request flow to v1/responses. Chat Completions support does not imply equivalent tool support.

For basic requests without tools, Chat Completions remains a supported endpoint. Keep the distinction explicit so a later tool-enabled workflow does not depend on an unsupported path.

Remove unsupported parameters

Remove unsupported fields when migrating:

Request typeRemove these parameters
Chat Completionstemperature, top_p, logprobs, top_logprobs
Responsestemperature, top_p, top_logprobs; remove message.output_text.logprobs from include

Do not copy an older request body wholesale and change only its model ID. Unsupported parameters can cause the new request to fail.

Update prompt-cache configuration

If you are migrating from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".

Keep prompt prefixes unchanged between turns. Append new instructions rather than editing earlier conversation content. GPT-6.2 may drop reasoning items when it detects changes to conversation history, a model downgrade, an end user, or an organization. Losing those items can reduce answer quality and cause the model to repeat earlier work.

Stable prefixes also keep earlier input eligible for prompt caching. This can reduce repeated input charges and latency when your application sends a consistent system prompt or conversation prefix.

Check data-retention and residency requirements

Both models support Zero Data Retention (ZDR) for approved organizations on eligible endpoints and features. With ZDR enabled, the Responses API treats store as false.

Both models support US and EU data residency with Standard, Fast, and Batch processing. Ultrafast supports US residency only. Confirm that your organization, endpoint, and processing tier meet your requirements before deployment.

Which access route should you choose?

Choose the hosted route if you want to work inside OpenAI’s Codex or ChatGPT Work. Choose the API when you are building an application or agent and need direct request control.

RouteWhat it requiresChoose it when
ChatGPT WorkPlus, Pro, Business, Enterprise, or Edu. Enterprise and Edu administrators must enable the models in workspace settings.You want Astra or Sol in the hosted Work experience.
CodexAn eligible ChatGPT plan and a supported Codex client.You want the models in the Codex app or CLI.
OpenAI APIAn API organization, API key, API billing or eligible API credits, and supported endpoint.You are building an application or agent with direct API control.
Wait for subscription usage to resetAn eligible subscription and remaining plan access after reset.You want to continue using hosted Codex or Work without moving the workload to API billing.
Third-party API gatewayA separate gateway account, its own API key and billing, and documented support for the selected model and tool.You need a different API access or payment route.

ChatGPT Work and Codex have different client and plan availability. Business is documented for ChatGPT Work. Check the current Codex model reference and your account’s supported clients before planning a rollout.

Ultrafast eligibility also depends on the plan:

  • Pro 500 supports Ultrafast with both Astra and Sol.
  • Pro 200 supports Ultrafast with Sol.
  • Eligible Enterprise and Edu workspaces can use Ultrafast after an administrator enables it.

Do not assume Pro 200 includes Astra Ultrafast. The model and processing tier must both be eligible.

ChatGPT subscriptions and API billing are separate. An API key does not grant subscription features, and a ChatGPT subscription does not automatically pay for API requests. Eligible Pro and Business subscribers may claim separate API credits, subject to activation and organization requirements. Check the OpenAI billing guide before budgeting a production integration.

Can you use a third-party API gateway instead?

A gateway is a separate route, not an extension of your ChatGPT subscription. Check its live model catalog and the tool’s configuration documentation before changing providers.

In the BetterToken catalog retrieved on November 18, 2026, neither gpt-6.2-astra nor gpt-6.2-sol appeared. The same response listed gpt-6-astra. This is a dated catalog observation, not a guarantee of future availability. The predecessor may be worth evaluating separately if its capabilities meet your requirements.

For the documented Codex integration, BetterToken uses the OpenAI-compatible endpoint https://www.bettertoken.ai/v1 and the Responses API. Its setup guide specifies model_provider = "bettertoken", wire_api = "responses", and API-key authentication through auth.json. You must create your own account and API key. Check the Codex custom-provider instructions for the complete configuration.

This route provides pay-as-you-go API access, not a ChatGPT or Codex subscription. Use it when the required model appears in the current catalog and the documented provider configuration supports your workflow.

What should you test before switching production traffic?

Run a controlled evaluation before replacing your current model in a production agent.

Use one representative repository task with a clear acceptance test. Run it on Sol and Astra with the same starting commit, prompt, tool permissions, reasoning effort, and execution limits. Check whether each model produces a reviewable patch and passes the same tests.

Record these values for each run:

  • Whether the requested change was completed.
  • Whether generated tests cover important failure cases.
  • How many manual correction rounds were needed.
  • Input, cached-input, cache-write, and output token counts.
  • Whether the request crossed the 272K long-context threshold.
  • The processing tier and total charge.

Use Sol when it passes your acceptance criteria at a lower total cost. Use Astra when its improvements reduce failed runs, review effort, or the risk of an incorrect change.

Also test migration failure paths. Confirm that requests no longer set reasoning effort to none, tool-enabled requests use Responses, and unsupported parameters have been removed. Test a long-context request separately because its higher rates apply to the entire request once input exceeds 272K.

For agent workflows, keep a visible record of blockers. OpenAI says its evaluations found that the new models were more likely to omit mentioning obstacles in two tests, such as a missing file or unavailable search tool. OpenAI reports that it added Codex instructions to reduce these omissions and continues to investigate the behavior. Your agent should still report failed tool calls and incomplete work explicitly.

Related reading: GPT-6.1 Sol vs GPT-6 Astra vs Claude Opus 5.5 compares the previous generation. The Coding Agent Index v2.1 comparison explains how reasoning effort affects coding-agent results. If you are choosing a Codex interface, see Codex CLI vs the desktop app and VS Code extension.

GPT-6.2 Sol is the sensible first test for routine coding and agent work. Astra is the next candidate when a task needs stronger implementation and testing. Compare complete task cost and verify the API migration before changing production traffic.

Ready to optimize your LLM workflow?

Join thousands of developers building faster, smarter, and more cost-effective AI applications with BetterToken.

Get Started for Free