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

# GPT-6.2 Astra and Sol Are Live at Provider Pricing

> OpenAI's GPT-6.2 Astra and GPT-6.2 Sol are live on APIYI with 1.05M context. Standard input/output pricing is $8/$40 and $2/$10 per 1M tokens across Default, SVIP and CodexResponses.

## Key points

* **Two distinct roles**: OpenAI released `gpt-6.2-astra` and `gpt-6.2-sol` on November 17, 2026. Astra targets complex professional work, science, computer use and difficult engineering; Sol handles everyday coding, writing and multistep agents
* **Live on APIYI**: both models are available in the Default, SVIP and CodexResponses groups through the Responses API
* **Astra costs less; Sol keeps its price**: Astra is \$8/\$40 per 1M input/output tokens, down 20% from GPT-6 Astra, with cached input down 60%. Sol retains GPT-6.1 Sol's \$2/\$10 pricing
* **Shared capacity**: both provide a 1,050,000-token context window, 922,000 maximum input tokens and 128,000 maximum output tokens, with text and image input and text output
* **Efficiency is central**: on OpenAI's GDPval v2, Astra gains 6.2 percentage points over GPT-6 Astra while using 22% fewer output tokens; Sol gains 5.3 points over GPT-6.1 Sol

## Background

Rather than forcing one model to cover every workload, GPT-6.2 separates the hardest projects from everyday work. Astra handles deep reasoning, cross-tool execution and professional deliverables. Sol brings near-flagship capability to a lower price point.

The release emphasizes **output quality and token efficiency** together. Both models aim to complete difficult tasks with fewer output tokens. For API users, the upgrade should therefore be measured by task completion and total tokens consumed, not list price alone.

APIYI connected both models on November 18, 2026. Standard-tier model prices match OpenAI's list prices; savings come through recharge bonuses rather than a modified token rate.

## Deep dive

### Choosing between Astra and Sol

> [card] GPT-6.2 Astra
>
> Built for cross-service debugging, complex code changes, scientific analysis, professional decks and spreadsheets, precise computer use and interactive 3D design. Its priority is completion quality on the hardest tasks

> [card] GPT-6.2 Sol
>
> Built for pull request reviews, revisions based on feedback, meeting-note synthesis, everyday writing and agents at scale. Its priority is the balance of intelligence, speed and task cost

Start with Sol on real workloads. If its completion rate meets your requirement, there is no need to pay Astra's flagship rate for every request. Bring in Astra for multisource research, complex professional deliverables or long-horizon debugging and compare the results.

### Official benchmark results

| Evaluation | OpenAI's reported result | Cost or efficiency context |
| - | - | - |
| Agents' Last Exam | Astra gains **5.2 points** over GPT-6 Astra and sets a new high | Less than one third of GPT-6 Astra's per-task cost |
| Terminal-Bench-Science 0.1 | Astra gains **9 percentage points** over GPT-6 Astra | Less than one third of GPT-6 Astra's per-task cost |
| GDPval v2 | Astra gains **6.2 percentage points**; Sol gains **5.3 points** over GPT-6.1 Sol | Astra uses **22% fewer** output tokens |
| FrontierCode 2.0 | Sol trails Astra by **less than 0.5 points**, both at Max | Sol costs about one fifth as much as Astra |
| AA-AnalystAgent | Astra answers **62.5%** of questions correctly in all five independent attempts | Uses real spreadsheets and reports |
| AA-3D | Astra scores **1,318 Elo** and Sol **1,259 Elo** | Blind human comparison of interactive 3D work |

> [!NOTE]
>
> These figures come from OpenAI's November 17, 2026 launch material and were checked on November 18. Some evaluations were designed by third parties such as Artificial Analysis and Cognition, but the figures quoted here are OpenAI's reported results and have not been independently reproduced by APIYI.

Astra's improvements extend beyond benchmark scores. OpenAI's examples include valuation workbooks, investment memos, template-aware slide decks, CAD assemblies and driving simulations, pointing toward deliverables that follow professional conventions and remain editable. Sol's value is delivering coding performance close to Astra at roughly one fifth of the cost.

### Specifications

| 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 |
| Maximum input | 922,000 tokens | 922,000 tokens |
| Maximum output | 128,000 tokens | 128,000 tokens |
| Knowledge cutoff | May 18, 2026 | June 1, 2026 |
| Input / output modalities | Text, image / text | Text, image / text |
| Reasoning | Reasoning tokens supported; `reasoning_effort: none` is rejected | Reasoning tokens supported; `reasoning_effort: none` is rejected |
| Provider features | Streaming, function calling, structured outputs, prompt caching | Streaming, function calling, structured outputs, prompt caching |
| APIYI groups | Default, SVIP, CodexResponses | Default, SVIP, CodexResponses |

OpenAI's model documentation lists Responses tools including web search, file search, code interpreter, hosted shell, computer use, MCP and multi-agent delegation. New projects that need a tool chain should start with `/v1/responses` rather than designing around a text-only chat flow.

> [!WARNING]
>
> Both models carry stricter provider safeguards for high-risk cybersecurity assistance. OpenAI also classifies both at its Critical cybersecurity threshold and High biological and chemical capability thresholds. Availability for ordinary programming and defensive security work remains subject to the provider's actual safety decisions.

## Practical use

### Recommended scenarios

* **Cross-service incident diagnosis**: give Astra the failing workflow, code and logs, then ask it to implement a fix and run the relevant tests
* **Everyday code review**: use Sol to review a pull request, revise the implementation from feedback and add targeted tests
* **Professional knowledge work**: use Astra to turn financial reports, templates and domain conventions into workbooks, memos or slide decks
* **Agents at scale**: measure Sol's cost per completed task first and reserve Astra for complex steps where failure is expensive
* **Long documents and repositories**: use the 1.05M context to reduce splitting, while accounting for the pricing tier above 272K input tokens

### Responses API example

```python theme={null}
from openai import OpenAI

client = OpenAI(
    api_key="sk-your-apiyi-key",
    base_url="https://api.apiyi.com/v1",
)

response = client.responses.create(
    model="gpt-6.2-sol",  # Use gpt-6.2-astra for more complex tasks
    reasoning={"effort": "medium"},
    input="Review this code change, list issues by severity, and suggest a test for each one.",
)

print(response.output_text)
print(response.usage)
```

### Best practices

* **Preserve stable prefixes**: keep system instructions, tool definitions and earlier input intact, and append new instructions to improve cache reuse and preserve reasoning across turns
* **Do not send `none`**: both models reject `reasoning_effort: none`; check this parameter when migrating from an older model
* **Watch the context tier**: a request above 272K input tokens moves the entire request into long-context billing, so do not fill the 1.05M window by default
* **Measure total task cost**: track completion rate, output tokens, cache hits and manual rework alongside token prices
* **Require explicit obstacle reporting**: OpenAI's alignment evaluations found that both models are more likely to omit blockers such as missing files or unavailable tools. Critical agent workflows should require a clear blocker list

## Pricing and availability

### Standard-tier pricing

These rates apply to Standard requests with no more than 272K input tokens, in US dollars per 1M tokens:

| Model | Input | Cached input | Cache write (30 min) | Output incl. reasoning |
| - | -: | -: | -: | -: |
| `gpt-6.2-astra` | \$8.00 | \$0.40 | \$10.00 | \$40.00 |
| `gpt-6.2-sol` | \$2.00 | \$0.10 | \$2.50 | \$10.00 |

> [!NOTE]
>
> Model prices match the provider and may change when provider pricing changes. This table is for reference; the **Model Pricing** tab in the top navigation is authoritative: [Model Pricing](https://docs.apiyi.com/en/models/index.md).

Astra's input and output rates are both 20% below GPT-6 Astra's \$10 and \$50, while cached input falls from \$1 to \$0.40. Sol retains GPT-6.1 Sol's standard pricing. Both models enter long-context billing for the entire request above 272K input tokens; consult the live model pricing page for the applicable rates.

### Groups and recharge promotions

Both models are available in Default, SVIP and CodexResponses. Model rates match OpenAI's Standard tier, and **savings come through recharge bonuses**: public recharge tiers bring the effective cost to roughly **83–91% of the list-price amount**, depending on the single-recharge tier, without changing the model amount shown in usage logs.

📖 [See recharge promotions and effective-cost calculations](https://docs.apiyi.com/en/faq/recharge-promotions.md)

## Summary and recommendations

In short, Astra is stronger and cheaper than its predecessor, while Sol moves closer to flagship capability without changing its standard price. Start with `gpt-6.2-sol` for everyday coding, writing and agents at scale. Use `gpt-6.2-astra` for complex professional deliverables, science and long-horizon engineering, and validate the benefit using total tokens and completion rate on your own tasks.

> [!NOTE]
>
> Sources: OpenAI's launch announcement `openai.com/index/introducing-gpt-6-2-astra-sol/` (November 17, 2026), the official GPT-6.2 Astra and Sol model pages, and OpenAI's Codex release notes, checked November 18. APIYI group availability and Standard-tier pricing come from the live platform pricing API on November 18, 2026.


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