# How to use GPT-6.2 Astra and Sol in the API: pricing and limits

> OpenAI's GPT-6.2 Astra and GPT-6.2 Sol: model IDs, per-million-token prices, 1.05M context, rate limits, and how to switch your API calls over.

Source: https://www.epifive.com/blog/gpt-6-2-astra-sol-api-pricing-limits · Published 2026-11-18 · EpiFive

## Key takeaways

- GPT-6.2 Astra is gpt-6.2-astra at $8 input and $40 output per 1M tokens; GPT-6.2 Sol is gpt-6.2-sol at $2 input and $10 output.
- Both models have a 1,050,000-token context window, up to 922,000 input tokens and up to 128,000 output tokens.
- Both reject a reasoning effort of none, and OpenAI says to omit temperature, top_p and top_logprobs.
- Requests above 272K input tokens on Astra double input and cache rates and raise output to 1.5x.
- This guide covers the API only; ChatGPT and Codex availability was not verifiable from official pages we could open.

OpenAI introduced GPT-6.2 Astra and GPT-6.2 Sol on 17 November 2026, according to the date of its announcement. In the API, GPT-6.2 Astra is `gpt-6.2-astra` and GPT-6.2 Sol is `gpt-6.2-sol`; to start, change the `model` value in an existing call, remove the sampling parameters the new models do not accept, and use `low` or higher as the reasoning effort. This guide covers what OpenAI's developer pages confirm: IDs, prices, limits and migration changes. It does not cover ChatGPT or Codex, because we could not open those pages.

## What GPT-6.2 Astra and Sol are

OpenAI's model pages describe the two models this way:

- **GPT-6.2 Astra** is "OpenAI's flagship model for demanding, end-to-end projects": it can build and revise software, operate a computer and work with documents. The model page is the source for this description.
- **GPT-6.2 Sol** is described on its page as "Our go-to model for everyday work, from coding to powering agents at scale."

OpenAI's latest-model guide puts the split in similar terms: Astra for the most demanding tasks, Sol for complex work at lower cost. Both accept text and image input and produce text output only; audio and video are not supported. Both support reasoning, streaming, structured outputs, function calling, file search, image input, web search and prompt caching. Fine-tuning and predicted outputs are not supported on either.

The knowledge cutoff listed on the model pages is May 18, 2026 for Astra and June 1, 2026 for Sol. The pages we opened do not say which earlier models these two replace, and they do not list snapshot names, so this guide does not name a predecessor.

The announcement's own summary line, as shown in the feed that triggered this article, reads: "Introducing GPT-6.2 Astra and Sol, with better professional outputs, coding, computer use, and efficiency at lower cost across ChatGPT Work, Codex, and the API." We could not open the announcement itself (the server refused the request), so we repeat only that summary line and make no claim about how those improvements were measured.

## Who it is for and availability

The table below is limited to what OpenAI's API documentation states. Where a cell says "not confirmed", the pages we opened did not say.

| Item | GPT-6.2 Astra | GPT-6.2 Sol |
| --- | --- | --- |
| Model ID | `gpt-6.2-astra` | `gpt-6.2-sol` |
| Context window | 1,050,000 tokens | 1,050,000 tokens |
| Max input | 922,000 tokens | 922,000 tokens |
| Max output | 128,000 tokens | 128,000 tokens |
| Input price per 1M tokens | $8 | $2 |
| Cached input per 1M tokens | $0.40 | $0.10 |
| Cache writes per 1M tokens | $10 (30-minute retention) | $2.50 |
| Output price per 1M tokens | $40 | $10 |
| Batch | 50% of standard | 50% of standard |
| Fast mode | 2x | 2x |
| Ultrafast | 3x until February 28, 2027, then 6x | not listed on the page we opened |
| Endpoints | Chat Completions, Responses, Batch | Chat Completions, Responses, Batch |
| ChatGPT plans, regions | not confirmed | not confirmed |
| India price in rupees | not published on the pages we opened | not published on the pages we opened |

Prices are in US dollars as shown on 2026-11-18. OpenAI does not list a rupee price on these pages, so convert at your own exchange rate and add any tax that applies to your account.

### Long-context pricing on Astra

The Astra page states that requests over 272K input tokens double the input and cache rates and raise output to 1.5x. Working through it from the listed prices: a request over 272K input tokens is billed at $16 per 1M input tokens and $60 per 1M output tokens, before any batch or fast-mode multiplier. The Sol page we opened did not list a long-context surcharge, so do not assume one either way; check the page before you send very long prompts.

### Rate limits

OpenAI lists the same Standard rate limits on both model pages:

| Usage tier | Requests per minute | Tokens per minute |
| --- | --- | --- |
| Build | 5,000 | 1M |
| Launch | 10,000 | 4M |
| Grow | 15,000 | 40M |

### Data residency

According to the latest-model guide, both models support US and EU data residency with Standard, Fast and Batch processing. Ultrafast supports US residency only.

## Requirements

- An OpenAI API account with access to the models. The model pages do not state any additional approval step.
- An API key and an existing integration that uses Chat Completions or the Responses API. Realtime, Assistants, fine-tuning, image, video, speech, transcription and translation endpoints do not support these models.
- If you use tool calling: the Responses API. The latest-model guide says Chat Completions is supported, but tool calling requires Responses.
- If you use prompt caching with an earlier model: be ready to change the cache parameter (see the migration steps).

## How to switch to GPT-6.2 Astra or Sol, step by step

OpenAI's guide does not publish a copy-ready request for these models, so the steps below are the parameter changes it lists, in the order we would apply them. Test them in a staging project first.

1. **Pick the model.** Use `gpt-6.2-astra` for the most demanding, long-running projects, or `gpt-6.2-sol` for everyday work, coding and agents at scale. Astra costs four times Sol per input token ($8 versus $2) and per output token ($40 versus $10), so test Sol first if cost matters.
2. **Set the `model` field** to the model ID.
3. **Set the reasoning effort.** The API rejects a reasoning effort of `none` on both models. The guide names `none`, `minimal`, `low` and `medium`, tells you to start new integrations at `medium` and to use `low` in place of `none` or `minimal`. In the Responses API the setting is `reasoning.effort`; in Chat Completions it is `reasoning_effort`. The guide also refers to "higher reasoning effort" for persistence on complex tasks without listing every value.
4. **Remove unsupported sampling parameters.** For Chat Completions, omit `temperature`, `top_p`, `logprobs` and `top_logprobs`. For Responses, omit `temperature`, `top_p` and `top_logprobs`, and remove `message.output_text.logprobs` from `include`.
5. **Move tool calling to the Responses API** if you use it on Chat Completions today.
6. **Update prompt caching.** When migrating from GPT-5.5 or earlier, replace `prompt_cache_retention` with `prompt_cache_options.ttl` set to `"30m"`, and review the cache boundary and the cache-write billing change (cache writes are a separate price in the table above).
7. **Keep reasoning items.** The guide says the API drops reasoning items after mid-conversation prefix edits, model downgrades, or changes to the end user or organization, which can lower answer quality and raise token use. To keep them, leave the prefix unchanged between responses.
8. **Zero Data Retention.** With ZDR enabled, `store` is treated as `false`. For multi-turn requests, pass prior output items back in order, including encrypted reasoning items.
9. **Compare cost and quality** on your own prompts before moving production traffic.

An illustrative request shape, assembled from the parameter names above and not copied from an OpenAI sample (we did not run it):

```bash
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": "Summarize this contract clause in two sentences."
  }'
```

### Choosing in ChatGPT or Codex

As of 18 November 2026 we have not opened an OpenAI help page that documents a model picker path for GPT-6.2 in ChatGPT or Codex, so we give no menu path. The announcement title says the models are available across ChatGPT Work, Codex and the API; confirm your plan and rollout status in your own account and in OpenAI's release notes.

## Limitations

- Output is text only; no audio or video input or output.
- No fine-tuning and no predicted outputs.
- Not supported on Realtime, Assistants, image generation or editing, video, speech, transcription or translation endpoints.
- `none` is rejected as a reasoning effort, so short low-latency calls that relied on it need `low` or higher and may use more reasoning tokens.
- Sampling controls (`temperature`, `top_p`) must be omitted.
- Ultrafast is US-residency only, and on Astra its multiplier rises from 3x to 6x after February 28, 2027.
- A multi-agent capability on Astra is described on its page as a beta in the Responses API.

## Privacy and admin notes

The pages we opened say only the following on data handling: both models support US and EU data residency for Standard, Fast and Batch processing, and Zero Data Retention sets `store` to `false`. They do not discuss training use of API data; check OpenAI's data controls documentation for that. Admins should note that cache writes now carry their own price, so a cost dashboard built on input and output tokens alone will under-report spend on cached workloads. Set a project budget and test spend on a small sample.

If you also run OpenAI models through Azure, the retirement and upgrade process there is separate; see [Azure OpenAI model retirement and upgrade runbook](https://www.epifive.com/blog/azure-openai-model-retirement-upgrade-runbook).

## Older models: what OpenAI's deprecations page says

OpenAI's deprecations page, opened on 2026-11-18, does not mention GPT-6.2 by name. It lists retirements whose stated replacements are earlier models:

| Shutdown date | Retiring model | Replacement listed |
| --- | --- | --- |
| Dec 11, 2026 | `gpt-5`, `o3` | `gpt-6.1-sol` |
| Dec 11, 2026 | `gpt-5-pro`, `o3-pro` | `gpt-6.1-sol` with `reasoning.mode: pro` (Responses API) |
| Apr 1, 2027 | `gpt-5.1`, `gpt-5.3-codex` | `gpt-6-sol` |

These replacement names are OpenAI's, not a recommendation to prefer them over GPT-6.2. If you are retiring one of these models anyway, you can test `gpt-6.2-sol` against the listed replacement.

## What we checked

- Opened OpenAI's API models page on 2026-11-18: it lists both models under "Flagship models" with IDs `gpt-6.2-astra` and `gpt-6.2-sol`, a 1.05M context window, $8 and $2 per 1M input tokens and $40 and $10 per 1M output tokens.
- Opened the individual GPT-6.2 Astra and GPT-6.2 Sol model pages the same day. They match the models page on IDs, context window and prices, and add cache prices, endpoints, rate limits and the 272K long-context rule for Astra.
- Opened OpenAI's latest-model guide: it matches the model pages on model IDs and gives the migration parameters in the steps above.
- Opened OpenAI's deprecations page: it does not list GPT-6.2 models, so we give no retirement date for a model they replace.
- Recalculated the Astra long-context rates from the listed prices: $8 x 2 = $16 per 1M input tokens, and $40 x 1.5 = $60 per 1M output tokens.
- Could not open the announcement page (HTTP 403) or OpenAI's help-center release notes (HTTP 403). ChatGPT and Codex availability, plans, regions, rollout dates and benchmark claims are therefore not covered.
- Not tested with a live API key; the sample request is an unverified illustration of the documented parameter names.

Last tested: 2026-11-18

## Sources

- OpenAI announcement (could not be opened; cited for the title and date): https://openai.com/index/introducing-gpt-6-2-astra-sol
- OpenAI API models: https://developers.openai.com/api/docs/models
- GPT-6.2 Astra model page: https://developers.openai.com/api/docs/models/gpt-6.2-astra
- GPT-6.2 Sol model page: https://developers.openai.com/api/docs/models/gpt-6.2-sol
- Latest model guide: https://developers.openai.com/api/docs/guides/latest-model
- Deprecations: https://developers.openai.com/api/docs/deprecations

## Frequently asked questions

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

OpenAI's model page lists $8 per 1M input tokens, $0.40 per 1M cached input tokens, $10 per 1M cache-write tokens and $40 per 1M output tokens for standard processing. Batch is 50% of standard and fast mode is 2x. Requests above 272K input tokens double the input and cache rates and raise output to 1.5x.

### How much does GPT-6.2 Sol cost in the API?

OpenAI's model page lists $2 per 1M input tokens, $0.10 per 1M cached input tokens, $2.50 per 1M cache-write tokens and $10 per 1M output tokens. Batch is 50% of standard and fast mode is 2x the standard rate.

### What are the model IDs for GPT-6.2 Astra and Sol?

Use gpt-6.2-astra for GPT-6.2 Astra and gpt-6.2-sol for GPT-6.2 Sol. Both are supported on Chat Completions, Responses and Batch, and OpenAI recommends the Responses API when you use tool calling.

### Can I set temperature or top_p on GPT-6.2 models?

No. OpenAI's latest-model guide tells you to omit temperature, top_p and top_logprobs (and logprobs on Chat Completions) when you migrate. Remove those parameters from existing requests before switching the model ID.

### Are GPT-6.2 Astra and Sol available in ChatGPT?

The announcement title mentions ChatGPT Work, Codex and the API, but we could not open the announcement page or an OpenAI help article on 2026-11-18, so this guide does not state plans, regions or rollout dates for ChatGPT. Check OpenAI's release notes for your plan.

