# GPT-6.2 Sol and GPT-6.2 Astra: Release Date and Access

By SeedRouter · Published 2026-11-18 · Updated 2026-11-18

OpenAI released **GPT-6.2 Sol and GPT-6.2 Astra on November 17, 2026**. Its announcement names three places to use them: ChatGPT Work, Codex and the OpenAI API. On November 18, we also checked SeedRouter with a customer API key. Both model lookups returned HTTP 200, one for `gpt-6.2-sol` and one for `gpt-6.2-astra`. You can repeat those lookups before spending credit on a generation. [1](https://openai.com/index/introducing-gpt-6-2-astra-sol/)

## Where do I select Sol or Astra?

In ChatGPT Work, open the model control beneath the composer. If your interface shows a Power slider, choose **Advanced** to see the models and reasoning settings available to your account. OpenAI describes a new Work chat starting with Sol at Light on supported consumer plans. That makes opening Advanced particularly useful if you want Astra for one difficult assignment and Sol for the next. [2](https://learn.chatgpt.com/docs/models)

The launch announcement includes Plus, Pro, Enterprise and Edu users in ChatGPT Work and Codex. Check the workspace you are signed into as well as the plan. For example, someone who belongs to a company workspace and also has a personal account can see different options when they switch between them. OpenAI lists separate eligibility for **Ultrafast**. If you can select Astra but cannot select Ultrafast, you have already answered the question about Astra itself. Look at the service-tier terms next. [1](https://openai.com/index/introducing-gpt-6-2-astra-sol/)

In the Codex CLI, the model selector or the model setting for the active session tells you which ID you've requested. Check how you signed in, too. Codex supports ChatGPT sign-in and API-key authentication. The first uses the permissions of your ChatGPT workspace. The second uses your API organization. An entitlement attached to one account won't follow you into a different account simply because you run the same command from the same laptop. [2](https://learn.chatgpt.com/docs/models) [3](https://learn.chatgpt.com/docs/auth)

## Check API access before sending a prompt

Start with the API host you actually use. A key issued by SeedRouter belongs with `https://api.seedrouter.ai/v1`. If you normally call OpenAI directly, use your OpenAI project key with OpenAI's API. Keep those pairs together, including when you switch environments between a terminal and a deployed application. A model picker in a browser cannot tell you which key a service picked up when it started.

Here is the read-only check we ran. Save your key locally in `SEEDROUTER_API_KEY`, then request the records individually. This works in a shell with curl and doesn't require an SDK installation or a prompt.

```bash
for model in gpt-6.2-sol gpt-6.2-astra; do
  curl --silent --show-error \
    -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
    --write-out '\nHTTP %{http_code}\n' \
    "https://api.seedrouter.ai/v1/models/$model"
done
```

| ID requested    | HTTP status on November 18 | Object returned                 |
| --------------- | -------------------------- | ------------------------------- |
| `gpt-6.2-sol`   | 200                        | `model` with ID `gpt-6.2-sol`   |
| `gpt-6.2-astra` | 200                        | `model` with ID `gpt-6.2-astra` |

Both records also contained the same `created` value, `1626777600`. Converting that value to a calendar date would place the launch years too early. The Models API defines it as a timestamp on the model object. Use the dated launch announcement for the release date and the returned `id` for the value to put in your code. A screenshot of a label and a model's answer to “Which model are you?” are poor substitutes for either check. [4](https://developers.openai.com/api/reference/resources/models/methods/retrieve) [1](https://openai.com/index/introducing-gpt-6-2-astra-sol/)

There's a practical spelling trap here. The SeedRouter page URL uses hyphens throughout, while the API ID contains a **period between 6 and 2**. Copy the ID from the record or from the appropriate model page. Sending the page slug as the model string changes the request. The two pages also show the current prices for their respective IDs. [GPT-6.2 Sol](https://seedrouter.ai/models/gpt-6-2-sol) · [GPT-6.2 Astra](https://seedrouter.ai/models/gpt-6-2-astra)

## What should the first generation look like?

On November 18 we ran four requests per model on SeedRouter. We gave Sol a one-sentence ticket about Alex sending an invoice by Friday. Its structured reply contained `"owner": "Alex"` and `"due_weekday": "Friday"`. We gave Astra a release decision with one failed migration. It returned `"decision": "hold"` and `"failed_migrations": 1`. Both models also returned the requested `record_city` function call with Paris as its argument. The model pages include the prompts and their recorded outputs. [Sol example](https://seedrouter.ai/models/gpt-6-2-sol#playground) · [Astra example](https://seedrouter.ai/models/gpt-6-2-astra#playground)

A lookup answers the access question for your key. A generation adds a separate test: can your application send the expected input and read the result? Choose a short input with an obvious answer. If your program extracts invoice numbers, for instance, supply a one-line example containing one number you know. Check what your program actually read, including stray punctuation, before testing a multi-page invoice.

Both models accept the Responses and Chat Completions formats. In Responses, send `input` and set optional reasoning effort under `reasoning.effort`. In Chat Completions, send `messages` and set `reasoning_effort` at the top level. The launch changelog directs callers to Responses when using tools. An integration that lists both available model IDs and then fails on its first tool request should check the endpoint and the body together. [5](https://developers.openai.com/api/docs/changelog) [6](https://developers.openai.com/api/docs/guides/latest-model?model=gpt-6.2-astra)

For a billable text request in Python, this example uses the OpenAI SDK. The single line after the request prints the text extracted by the SDK, which makes it easy to compare with the expected invoice number. Substitute `gpt-6.2-astra` to use the other model.

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.seedrouter.ai/v1",
    api_key=os.environ["SEEDROUTER_API_KEY"],
    max_retries=0,
)
response = client.responses.create(
    model="gpt-6.2-sol",
    reasoning={"effort": "low"},
    max_output_tokens=256,
    input="Return only the invoice number from: Invoice IN-417, due Friday.",
)
print(response.output_text)
```

If you're moving an older integration over, inspect the request after your own defaults have been applied. Both GPT-6.2 models reject `none` for reasoning effort. A shared configuration file can add this value even if the call at the top of your application looks correct. Record the model, endpoint, effort and complete error text when you compare calls. Leave the key out of that record. [7](https://developers.openai.com/api/docs/models/gpt-6.2-sol) [8](https://developers.openai.com/api/docs/models/gpt-6.2-astra)

## Does the release change what my workload costs?

OpenAI publishes separate prices for the two models and for different token categories. Its launch announcement says that Sol retained the previous Sol model's standard token rates, while Astra's standard input and output rates fell by 20 percent from GPT-6 Astra. Those figures describe OpenAI's own API. For calls through SeedRouter, read the per-model pricing table before estimating a batch. The two sites can quote different rates for the same model ID. [1](https://openai.com/index/introducing-gpt-6-2-astra-sol/) [Sol pricing](https://seedrouter.ai/models/gpt-6-2-sol#pricing) · [Astra pricing](https://seedrouter.ai/models/gpt-6-2-astra#pricing)

Use a sample from the work you plan to run. The invoice above has such a short answer that it tells you little about a workflow that writes a page of commentary per invoice. A better comparison would keep the same input documents, extraction rules and output schema for both models. Score the fields against known values and count the tokens used for every attempt, including answers that would need human correction. A lower rate per output token is useful only alongside the amount of output you need to finish the job.

For a coding migration, save the same starting revision and failing test for each run. Give each model the same tools and reasoning setting. See whether the patch fixes the failure and passes the neighboring tests. If Astra solves a case that Sol misses, note the case and run another example of that kind before changing the default for every job. OpenAI's published evaluations describe its tasks and scoring conditions. Your test captures the cost of a correct result on your own codebase. [1](https://openai.com/index/introducing-gpt-6-2-astra-sol/)

## Which “GPT-6 Astra” did the search result mean?

### Is GPT-6 Astra available to the public?

The earlier model has an official API entry under `gpt-6-astra`. The November 17 release added a distinct ID, `gpt-6.2-astra`. If you're following an older article about the first Astra launch, check the exact ID in its code sample. Searches also surface speculative names. Neither GPT-6.2 model page lists “Bel” as an ID for these models. [9](https://developers.openai.com/api/docs/models/gpt-6-astra) [7](https://developers.openai.com/api/docs/models/gpt-6.2-sol) [8](https://developers.openai.com/api/docs/models/gpt-6.2-astra)

### Is GPT-6 Astra better than GPT-6.1 Sol?

OpenAI positioned GPT-6.1 Sol as a lower-cost option for work approaching the original Astra's performance. Individual coding and professional tasks give different results. If your decision concerns one of those older models, use the corresponding comparison. If you are deciding whether to migrate to 6.2, keep the older model in your evaluation as a baseline and run the same tasks on its proposed replacement. [GPT-6.1 Sol model page](https://seedrouter.ai/models/gpt-6-1-sol) · [Earlier Sol and Astra comparison](https://seedrouter.ai/blog/gpt-6-1-sol-vs-gpt-6-astra)

### How can I access GPT-6 Astra and find its price?

For the original model, look up `gpt-6-astra` with your key and use the price table for that exact ID. OpenAI’s model price table, checked on November 18, 2026, lists standard input at $10 and output at $50 per million tokens for short-context requests. Cached input and long prompts have separate rates. For the November release, use the dotted 6.2 ID throughout, from lookup to generation to cost estimate. [9](https://developers.openai.com/api/docs/models/gpt-6-astra) [Original Astra on SeedRouter](https://seedrouter.ai/models/gpt-6-astra#pricing)
