> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# GPT-6.2 API: Astra and Sol pricing vs GPT-6.1

> Call gpt-6.2-astra and gpt-6.2-sol on LaoZhang API: which to pick, standard and long-context prices, reasoning effort rules, and API examples.

OpenAI released GPT-6.2 on November 17, 2026: Astra for the hardest work and Sol for everyday use. Both run on any `default`-group key. Astra costs \$8 input and \$40 output per 1M tokens, 20% less than GPT-6 Astra; Sol costs \$2 and \$10, the same as GPT-6.1 Sol.

* **Published**: November 18, 2026
* **Last verified**: November 18, 2026
* **Status**: Active; available in the `default` token group

## Key facts

| Item | Details |
| - | - |
| Model IDs | `gpt-6.2-astra`, `gpt-6.2-sol` (responses return the same names; there are no dated snapshot IDs) |
| OpenAI release date | November 17, 2026 |
| Available on LaoZhang API | November 18, 2026 |
| Endpoints | Base URL `https://api.laozhang.ai/v1`; Chat Completions `POST /v1/chat/completions`, Responses `POST /v1/responses` |
| Token group and billing | `default` group, usage-based (per token) |
| Price | Same as OpenAI's Standard rates; see [Pricing](#pricing) |
| Context length (OpenAI) | 1,050,000-token context window, up to 128,000 output tokens |
| Tool calling | Chat Completions or Responses |

## Astra or Sol?

* **`gpt-6.2-sol`**: OpenAI's everyday model, balancing capability and cost. A good default for chat, writing, analysis, and most coding. Knowledge cutoff: June 1, 2026.
* **`gpt-6.2-astra`**: OpenAI's most capable model, for complex reasoning and hard coding problems. It costs four times as much as Sol. Knowledge cutoff: May 18, 2026.
* **High-volume, high-concurrency work**: OpenAI still points to GPT-6 Luna, so keep using `gpt-6-luna`.

## Pricing

These rates come from LaoZhang API's public pricing as of November 18, 2026, in US dollars per 1M tokens. They match the Standard rates on [OpenAI's pricing page](https://developers.openai.com/api/docs/pricing).

| Rate | Astra standard | Astra long context | Sol standard | Sol long context |
| - | -: | -: | -: | -: |
| Input | \$8 | \$16 | \$2 | \$4 |
| Cache read | \$0.4 | \$0.8 | \$0.1 | \$0.2 |
| Cache write | \$10 | \$20 | \$2.5 | \$5 |
| Output | \$40 | \$60 | \$10 | \$15 |

* Requests with up to 272K input tokens use the standard rates. Above 272K input tokens, the whole request is billed at the long-context rates.
* Token usage and the charge for each request are in [call logs](https://api.laozhang.ai/log).
* For current rates, see the [model and pricing catalog](https://docs.laozhang.ai/en/models.md#vendor-openai).

## How GPT-6.2 compares with GPT-6.1 Sol and GPT-6 Astra

### GPT-6.2 Sol vs GPT-6.1 Sol

| | `gpt-6.2-sol` | `gpt-6.1-sol` |
| - | -: | -: |
| Input / output (standard) | \$2 / \$10 | \$2 / \$10 |
| Cache read / write (standard) | \$0.1 / \$2.5 | \$0.1 / \$2.5 |
| Input / output (long context) | \$4 / \$15 | \$4 / \$15 |

* Every rate is identical. To switch, change `model`; your key and endpoint stay the same.
* Reasoning effort levels and tool calling in Chat Completions also work the same way, so existing GPT-6.1 Sol requests need no parameter changes.

### GPT-6.2 Astra vs GPT-6 Astra

| | `gpt-6.2-astra` | `gpt-6-astra` |
| - | -: | -: |
| Input / output (standard) | \$8 / \$40 | \$10 / \$50 |
| Cache read / write (standard) | \$0.4 / \$10 | \$1 / \$12.5 |
| Input / output (long context) | \$16 / \$60 | \$20 / \$75 |

* Moving to GPT-6.2 Astra cuts input, output, and cache-write rates by 20%, and cache reads by 60%.
* If you send `"reasoning_effort": "max"` through Chat Completions today, move those requests to the Responses API when you switch to `gpt-6.2-astra`; see the next section.

## Reasoning effort and parameters

Neither model accepts `none`, and the two endpoints offer different levels. If you need `max` from Chat Completions, use the Responses API instead.

| Endpoint | Parameter | Levels |
| - | - | - |
| Responses | `reasoning.effort` | `low`, `medium` (default), `high`, `xhigh`, `max` |
| Chat Completions | `reasoning_effort` | `low`, `medium`, `high`, `xhigh` |

Sending `none` returns 400 on either endpoint. From the Responses API with `gpt-6.2-sol`, the error reads:

```text theme={null}
Unsupported value: 'none' is not supported with the 'gpt-6.2-sol' model. Supported values are: 'low', 'medium', 'high', 'xhigh', and 'max'.
```

When you migrate from an older model, also check:

* Sampling parameters such as `temperature` and `top_p`: leave them out of the request, or set them to "not set" in your client.
* `max_tokens`: keep it at 128,000 or below; larger values return 400.

## Call GPT-6.2

Create an API key in [Token management](https://api.laozhang.ai/token) in the `default` group, with its billing mode set to Usage first (按量优先, recommended) or Usage-based (按量计费). Then export the key in your terminal:

```bash theme={null}
export LAOZHANG_API_KEY="replace-with-your-LaoZhang-API-key"
```

These examples call `gpt-6.2-sol` through Chat Completions and through Responses; the Responses example raises reasoning effort to `high`. For Python, run `python -m pip install openai` first.

> [tab] Chat Completions
>
> ```bash theme={null}
> curl https://api.laozhang.ai/v1/chat/completions \
>   -H "Authorization: Bearer $LAOZHANG_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "model": "gpt-6.2-sol",
>     "messages": [
>       {"role": "user", "content": "Explain a database index in three sentences."}
>     ]
>   }'
> ```

> [tab] Responses
>
> ```bash theme={null}
> curl https://api.laozhang.ai/v1/responses \
>   -H "Authorization: Bearer $LAOZHANG_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "model": "gpt-6.2-sol",
>     "reasoning": {"effort": "high"},
>     "input": "Explain a database index in three sentences."
>   }'
> ```

> [tab] Python
>
> ```python theme={null}
> import os
> from openai import OpenAI
>
> client = OpenAI(
>     api_key=os.environ["LAOZHANG_API_KEY"],
>     base_url="https://api.laozhang.ai/v1",
>     timeout=300.0,
>     max_retries=0,
> )
> response = client.responses.create(
>     model="gpt-6.2-sol",
>     input="Explain a database index in three sentences.",
> )
> print(response.output_text)
> ```

* For the flagship model, change `model` to `gpt-6.2-astra`; nothing else changes.
* In Chat Completions, the reply text is in `choices[0].message.content`.
* In Responses, the text is in the `output` item whose `type` is `message`; the Python SDK joins it in `response.output_text`.
* For requests with tools, see [function calling](https://docs.laozhang.ai/en/api-capabilities/function-calling.md); both endpoints work.

## Who is affected

* **Affected**: projects that call text models through LaoZhang API's OpenAI-compatible endpoint. Any API key in the `default` group with the Usage first or Usage-based billing mode can call GPT-6.2.
* **Not affected**: existing models. Every GPT-6.1 and GPT-6 model remains available at the same price, and current integrations need no changes.

## Frequently asked questions

### Should I use GPT-6.2 Astra or Sol?

Start with `gpt-6.2-sol`. It is OpenAI's everyday model, costs a quarter of Astra's rates, and handles most chat, writing, and coding work.

Try `gpt-6.2-astra` on the complex reasoning or hard coding tasks where Sol falls short, and compare quality against total cost on your own samples. For cheap bulk work, use `gpt-6-luna`.

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

On LaoZhang API, `gpt-6.2-astra` costs \$8 input and \$40 output per 1M tokens, and `gpt-6.2-sol` costs \$2 and \$10, matching OpenAI's Standard rates as of November 18, 2026. Cache and long-context rates are in [Pricing](#pricing).

### GPT-6.2 Sol costs the same as GPT-6.1 Sol. Should I switch?

There's no rush: prices and request format are the same, and `gpt-6.1-sol` stays available. To try the new version, change `model` and compare quality, latency, and token usage on representative requests before you commit.

### Why does reasoning\_effort "none" return 400?

Neither GPT-6.2 model supports `none`. If your requests send `none` or `minimal`, change them to the lowest level, `low`.

### Can GPT-6.2 call tools in Chat Completions?

Yes. OpenAI says tool calling needs the Responses API, but LaoZhang API's Chat Completions endpoint accepts requests with `tools` and returns `tool_calls`, as it does for GPT-6.1. Clients that only speak Chat Completions can use GPT-6.2 with tools; see [function calling](https://docs.laozhang.ai/en/api-capabilities/function-calling.md) for an example.

### How are requests over 272K input tokens billed?

The whole request is billed at the long-context rates, not just the tokens above 272K. Input and cache rates double, and output rates rise 1.5×; for `gpt-6.2-sol`, output goes from \$10 to \$15 per 1M tokens.

## Sources and related links

* [OpenAI API changelog](https://developers.openai.com/api/docs/changelog): the November 17, 2026 entry for GPT-6.2
* [OpenAI models](https://developers.openai.com/api/docs/models): positioning, context window, maximum output, reasoning effort, and knowledge cutoff for GPT-6.2 Astra and Sol
* [OpenAI API pricing](https://developers.openai.com/api/docs/pricing): standard and long-context rates
* [GPT-6.1 Sol launch](https://docs.laozhang.ai/en/announcements/gpt-6-1-sol-2026-10.md)
* [GPT-6 Astra, Sol, and Luna launch](https://docs.laozhang.ai/en/announcements/gpt-6-launch-2026-09.md)
* [Use OpenAI models with LaoZhang API](https://docs.laozhang.ai/en/api-reference/openai.md)
* [Model and pricing catalog](https://docs.laozhang.ai/en/models.md#vendor-openai)
* [Latest announcements](https://docs.laozhang.ai/en/changelog.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.