GPT-6 Astra is OpenAI's reasoning model for complex coding, research, computer use and professional work. Its API identifier is gpt-6-astra. The practical buying question is whether its results justify a premium over less expensive models handling the same task.
A newer version is available: GPT-6.2 Astra. It has lower published token prices. For a new deployment, also compare GPT-6.2 Sol. This article preserves the specifications and pricing of GPT-6 Astra.
Quick verdict: Astra is worth evaluating for difficult work that requires sustained reasoning or several connected tool steps. For a new deployment, evaluate the linked 6.2 successors first. The comparison with GPT-6.1 Sol below preserves the earlier generation’s pricing context. Astra costs $10 per million input tokens and $50 per million output tokens at Standard short-context rates, five times Sol's corresponding input and output rates. That price difference is verified; any quality advantage on your workload still needs to be measured.
GPT-6 Astra specifications
OpenAI's model documentation lists the following limits and supported features. The context window includes more than the space available for your input, so the maximum input and maximum output deserve separate attention.
Specification | Documented value |
|---|---|
API model ID | gpt-6-astra |
Context window | 1,050,000 tokens |
Maximum input | 922,000 tokens |
Maximum output | 128,000 tokens |
Knowledge cutoff | April 30, 2026 |
Input | Text and images |
Output | Text |
Reasoning effort | low, medium, high, xhigh, max |
Supported APIs | Responses and Chat Completions; use Responses for tools |
Verification date | November 17, 2026 |
A million-token context window can accommodate a large body of source material, but it does not prove that every relevant detail will be retrieved correctly. A document-review application should test questions whose answers appear in different parts of the input and check that the response cites the correct passages. Retrieval mistakes can remain expensive even when the entire document fits.
How much does GPT-6 Astra cost?
The official pricing table distinguishes short context, long context, cache reads and cache writes. Standard short-context rates apply to requests with no more than 272,000 input tokens. Above that threshold, the higher rates apply to the full request, rather than only the tokens above the threshold.
Standard API charge | Up to 272K input tokens | More than 272K input tokens |
|---|---|---|
Input, per million tokens | $10 | $20 |
Output, per million tokens | $50 | $75 |
Cached input, per million tokens | $1 | $2 |
30-minute cache writes, per million tokens | $12.50 | $25 |
12-hour cache writes, per million tokens | $25 | $50 |
This matters when a team adds more documents to an otherwise unchanged workflow. Crossing the input threshold increases the output rate as well. A cost estimate based only on document length can therefore miss part of the increase. Check the actual input usage after adding system instructions, conversation history, retrieved files and tool results.
The following examples use Standard rates and assume uncached input with no cache-write charge, no tool fees and no retries. Output figures represent billed output tokens. These are arithmetic illustrations, not measured task costs or predictions of how much reasoning a task will consume.
Example request | Input cost | Output cost | Token subtotal |
|---|---|---|---|
100,000 input and 10,000 output tokens | $1.00 | $0.50 | $1.50 |
250,000 input and 10,000 output tokens | $2.50 | $0.50 | $3.00 |
300,000 input and 10,000 output tokens | $6.00 | $0.75 | $6.75 |
For asynchronous workloads, Batch and Flex can reduce token rates to half of Standard. Faster service modes cost more. OpenAI's pricing page currently lists Fast at twice Standard and Ultrafast at six times Standard for this model. These modes should be selected around the application's timing requirements, with availability and processing conditions checked before deployment.
Processing mode | Short-context input / output per million | Practical consideration |
|---|---|---|
Standard | $10 / $50 | Baseline for cost comparisons |
Batch | $5 / $25 | Suitable for eligible batch workloads |
Flex | $5 / $25 | Check service constraints for the application |
Fast | $20 / $100 | Higher price for faster processing |
Ultrafast | $60 / $300 | Reserve for workloads that justify the premium |
GPT-6 Astra versus GPT-6.1 Sol
GPT-6.1 Sol's official model page describes it as a lower-cost option for complex coding, computer use and professional work. The models share the documented context and output limits shown below. Capacity alone is therefore not a reason to choose Astra.
Documented feature | GPT-6 Astra | GPT-6.1 Sol |
|---|---|---|
Standard short-context input, per million | $10 | $2 |
Standard short-context output, per million | $50 | $10 |
Standard short-context cached input, per million | $1 | $0.10 |
Maximum input | 922,000 tokens | 922,000 tokens |
Maximum output | 128,000 tokens | 128,000 tokens |
Input and output | Text/image input; text output | Text/image input; text output |
Reasoning effort | low through max | low through max |
At identical uncached input and output volumes under those Standard rates, Astra's token subtotal is five times Sol's. Real task costs can differ because the models may consume different amounts of reasoning, require different numbers of tool calls or produce different retry rates. Cached input has a different price ratio, and human review can outweigh the API bill.
A useful deployment pattern is to start straightforward tasks on Sol and escalate difficult cases to Astra. That is an editorial recommendation based on the documented price difference, not a claim that we have measured a particular savings or pass-rate improvement. Teams should define the escalation condition in advance, such as a failed validation check or an unresolved coding task.
For more detail, see our GPT-6.1 Sol guide and AI model directory.
What Astra's tool support means in practice
The GPT-6 integration guide says tool calling requires the Responses API. Support for Chat Completions should not be interpreted as support for the same tool workflow on both endpoints.
Astra supports tools including web search, file search, code execution, hosted shell, computer use, MCP and tool search through Responses. These capabilities let an application connect reasoning to live information or actions. They do not automatically supply the application's permissions, data connections or verification rules.
Workload | Relevant documented capability | What the application must check |
|---|---|---|
Repository changes | Hosted shell, apply_patch, code execution | Tests, reviewability and repository permissions |
Research with current sources | Web search and file search | Source relevance, publication dates and citation accuracy |
Visual application workflows | Image input and computer use | Correct screen state and successful saved changes |
Structured records | Structured Outputs and function calling | Schema validity and correctness of field values |
Connected business tools | MCP and tool search | Tool access, account scope and action confirmation |
The base model returns text. Its support for an image-generation tool is separate from native image output through an image endpoint. Similarly, accepting screenshots does not make Astra a speech or realtime audio model. The model page lists Realtime, speech generation, transcription and fine-tuning as unsupported.
Reasoning settings and migration details
Astra supports five reasoning levels, from low to max, and does not support none. More reasoning is a setting to evaluate, not a guarantee that the final answer will be correct. A task that already passes at low effort may not justify additional latency or token usage.
OpenAI's integration guidance also identifies behavior that can affect an application: Astra may ask for clarification more readily, can be sensitive to instructions in accessible files, and may test more broadly than a small coding change requires. These are provider-described behaviors rather than findings from a new test conducted for this article.
Integration detail | Practical consequence |
|---|---|
No none reasoning level | Replace incompatible settings with a supported effort |
Tool calling requires Responses | Review endpoint choice before porting an existing agent |
Sampling parameter restrictions with reasoning | Check temperature, top_p and logprob settings against the integration guide |
Sensitivity to instructions in files | Audit project instructions and retrieved instruction-like content |
Greater tendency to clarify | Specify when the application should ask and when it may proceed |
Thorough coding verification | Set an appropriate test scope for small versus consequential changes |
These details are often more relevant to migration than a headline capability claim. A workflow can become slower because it asks unnecessary questions, performs excessive verification or changes the shape of its answers, even when its underlying reasoning improves. Compare complete workflows with their actual prompts and tools.
Availability and access
OpenAI currently documents Astra in its API catalog with published rate limits and a Responses endpoint. The model page also lists openai.gpt-6-astra for Amazon Bedrock and identifies Google Cloud access as a private preview. Account-level access and limits should be checked in the relevant provider account.
ChatGPT subscriptions, API billing and cloud-provider access are different products. An API model listing does not establish that a particular ChatGPT plan includes the model, and a subscription does not establish a particular API rate limit. Check the route you intend to use rather than relying on launch-week announcements.
Is Astra worth the premium?
Astra is most useful as a candidate for work where incomplete reasoning or repeated failure is costly: difficult repository changes, research requiring several connected sources, and professional tasks that combine documents with tools. The official model description supports evaluating those uses; it does not establish superiority on every task within them.
Keep the comparison tied to a concrete deliverable. For a coding change, record whether the patch passes relevant tests and survives review. For research, check whether every consequential statement is supported by the cited source. For document production, measure factual corrections and the time a reviewer spends making the result usable.
A small set of representative tasks can show whether a larger evaluation is justified. Run the same tasks with Astra and Sol using equivalent tools, explicit effort settings and a fixed acceptance standard. Count failed attempts and review time alongside token charges. Avoid selecting a model from one unusually good response.
Frequently asked questions
What is GPT-6 Astra's context window?
OpenAI documents a 1,050,000-token context window, a maximum input of 922,000 tokens and a maximum output of 128,000 tokens. Requests above 272,000 input tokens have higher API rates for the full request.
Is GPT-6 Astra open source?
No. This guide covers OpenAI's hosted proprietary model. Its API documentation describes supported endpoints and provider access, rather than downloadable model weights.
Does Astra support realtime voice?
The model page lists Realtime and speech endpoints as unsupported. It accepts text and images and returns text. A voice application would need other components, with their own capabilities and charges.
Should I replace GPT-6.1 Sol with Astra?
Only when the additional quality or reduced rework justifies the higher total cost. Sol shares the documented context limits and costs substantially less per token. Compare completed tasks before moving an entire workload.
Does this guide report an independent benchmark?
No. Specifications and integration behavior here are attributed to official documentation. The cost examples are calculations using published rates. They do not establish measured accuracy, speed or task completion for either model.
Sources and updates
Specifications and API support were checked on November 17, 2026 against OpenAI's Astra model page. Rates, context tiers and service modes follow the official API pricing table. Integration constraints and provider-described behavior follow the GPT-6 guide. The direct comparison uses Sol's model documentation. Prices, processing modes and availability can change; review the relevant provider documentation before committing a workload.