GPT-6 Astra API Pricing 2026: 1.05M Context, Critical Cyber

What Is GPT-6 Astra?

GPT-6 Astra is the September 3, 2026 release of OpenAIs flagship frontier model. It is the first OpenAI model where earlier models played a significant role in supervising the training process (per OpenAIs announcement), and the first to reach the Critical cybersecurity threshold on the Preparedness Framework - the highest of the four tiers the framework defines. In OpenAIs own evaluation Astra developed exploits for hardened browsers and operating systems, and discovered two previously unknown V8 engine vulnerabilities during internal testing; the company has committed to disclosing them to the maintainers.

The model ships in two SKUs at launch, Astra and Astra Pro. Astra is the API SKU exposed via gpt-6-astra; Astra Pro is the higher-compute variant available to ChatGPT Pro, Business, and Enterprise plans, with eligible API customers able to use Astra under Zero Data Retention. Unlike GPT-5.6 - which shipped Sol / Terra / Luna as three tiered SKUs - GPT-6 has only Astra and Astra Pro at launch. OpenAIs pricing page lists these tools as supported on the Responses API: Web search, File search, Image generation, Code interpreter, Hosted shell, Apply patch, Skills, Computer use, MCP, and Tool search.

Three characteristics distinguish Astra from OpenAIs own prior models:

• Cybersecurity parity with the red-team tooling - 100% on ExploitBench, 99.2% on SRE-Bench, 42.4% on ExploitGym, all measured with Daybreak Blue access. The Critical-tier classification is a regulatory threshold, not just a marketing claim: it is what triggers OpenAIs enhanced deployment safeguards.
• Long-context retrieval that holds at 1M - 100% MRCR v2 8-needle at 256K to 512K and 96.3% at 512K to 1M, vs Sols 91.5% / 73.8% in the same bands. For workloads that need a million tokens of source material to be present and answerable, Astra is the first OpenAI model that genuinely solves it.
• Coding-agent cost-efficiency frontier - at max effort Astra ties GPT-5.6 Sol on cost while scoring 2 points higher on Artificial Analysis Coding Agent Index, and costs less than half of Claude Fable 5 per task at the same score. This is the metric that matters for IDE / IDE-plugin deployments.

The Verified Pricing Table (September 2026)

OpenAIs official pricing is published on the platform.openai.com/docs/models/gpt-6-astra model page. The full Standard pricing block, copied verbatim:

Three rules govern the table:

• Long-context multiplier - any prompt with more than 272K input tokens is priced at 2x input and cache rates and 1.5x output for the entire request, not just the tokens above 272K. If you send a 500K-token request, every token bills at the long-context rate.
• Cache write pricing - cache writes are billed at 1.25x the uncached input rate, which means cache writes actually cost more than a regular input token. The economics only make sense for prompts you will re-use at least twice.
• Batch and Flex are 50% off Standard - but Batch is asynchronous with up to 24-hour turnaround, and Flex is asynchronous with no turnaround SLA. For interactive workloads Standard is the only option.

Where to find this live: the model page at https://platform.openai.com/docs/models/gpt-6-astra lists the rates in the right-hand panel; the application-level pricing page at https://openai.com/api/pricing/ lists Astra in the Reasoning section with the same $10/$50 headline. Both pages were verified to contain the rates above on September 4, 2026.

The September 2026 Frontier Comparison

Astras pricing matches Claude Fable 5.1 dollar-for-dollar on input/output and cache writes, and is dramatically more expensive than the open-weights alternatives. Here is the verified frontier landscape as of September 4, 2026:

The pricing shape matters as much as the rates. Astra and Fable 5.1 charge the same $10/$50 for fresh tokens, but Fable 5.1 dropped cached input to $0.25 per million (a 75% reduction from Fable 5s $1.00) - so for prompt-cache-heavy workloads Fable 5.1 is four times cheaper on cached reads than Astra. If your workload reuses system prompts heavily (RAG retrieval, agent scaffolding, IDE completions with fixed system instructions), the cache economics still favor Fable 5.1. If your workload sends mostly fresh input (one-shot summarization, document analysis, batch processing of distinct prompts), the $10/$50 headline is the apples-to-apples number and Astra is at parity with Fable 5.1.

Against GPT-5.6 Sol Astra is 2.5x more expensive per token on every dimension. Sols $4/$20 promo is good through November 21, 2026, so for the next ~10 weeks you have a choice: pay 2.5x for better coding, cybersecurity, and 1M-context retrieval, or stay on Sol at the discounted rate. The decision matrix below in §5 covers which workloads justify the upgrade.

Benchmark Performance: Where Astra Wins, Where It Ties

OpenAI published evaluation results in the September 3 announcement; the New Stack reproduced and contextualized them in detail the same day. Three result clusters tell the story:

Cybersecurity - the headline

• ExploitBench: 100% (Sol: 78.5%) - Astra covers every exploit scenario OpenAIs harness tests, while Sol misses roughly one in five.
• ExploitGym: 42.4% (Sol: 30.3%) - Astra completes 4 out of every 10 real-world exploitation tasks vs Sols 3 out of 10.
• SRE-Bench (binary reverse engineering, four attempts): 99.2% (Sol: 68.7%) - the largest gap in the cluster. Astra approaches the ceiling on reverse engineering; Sol misses nearly a third.
• OpenAI MRCR v2 8-needle (256K to 512K): 100% (Sol: 91.5%) - full recall on a moderately long context.
• OpenAI MRCR v2 8-needle (512K to 1M): 96.3% (Sol: 73.8%) - the headline long-context number. OpenAI explicitly markets this as the first model that vanquishes one of the ongoing challenges with long context processing.

OpenAIs cybersecurity results are specifically called out as reflecting access to Daybreak Blue (a Trusted Access Program feature), not Astra on its own. This is a fairness caveat, not a disqualification: every other model in the comparison runs under the same harness rules.

Coding and reasoning - competitive but not dominant

• DeepSWE v1.1 (113-task agentic coding): 74.1% (Sol: 70.8%, Muse Spark 1.3 max: 75.4%, Fable 5.1: 67.4%, Gemini 3.8 Flash: 74%, Opus 5: 74%).
• Terminal-Bench Science 0.1 (70 scientific-research tasks): 64.6% (Fable 5.1: 52.6%, Opus 5: 30%, public leaderboard tops out at 30% pre-Astra).
• BenchCAD (1,000-file Vision2Code subset): 95.9% geometric overlap (Fable 5.1: 84.3%, Sol: 83.3%).
• ARC-AGI-3 (OpenAIs Provider Adapter harness): 99.9% - but this is a system-level score (Astra + Responses API + compaction), not the bare model. The default ARC-AGI harness scores Astra at 62.7% for $26K vs the Provider Adapters 99.9% for $19K.
• FrontierMath Tier 4 (v2): 98% - covers the 41 private problems in the 43-problem tier. Epoch AI, which runs the benchmark, has exclusive access to part of it and OpenAI funded its development, so the result carries the usual caveats about benchmark-funding asymmetry.

On Artificial Analysis Intelligence Index Astra lands at 61 - five points below Fable 5.1 (max with fallback, 66), tied with GPT-5.6 Sol, and behind Meta Muse Spark 1.3 (max). On the Coding Agent Index Astra leads the cost-efficiency frontier: at max effort Astra costs about the same as GPT-5.6 Sol (max) while scoring 2 points higher, and per task Astra is less than half the cost of Claude Fable 5 at the same score.

What Astra is NOT

Artificial Analysis Intelligence Index number is the honest framing: Astra is a competitive frontier model that costs the same as Fable 5.1 but does not leapfrog it on raw IQ. The clear wins are cybersecurity, long-context retrieval, and coding-agent cost efficiency. If your workload is general-purpose chat, summarization, or short-form Q&A, the $10/$50 headline is buying you capabilities you do not need. If your workload is red-team automation, RAG over million-token source sets, or autonomous coding agents that run for hours, Astra is the new default.

The API and the Tools That Come With It

Astra exposes every endpoint OpenAIs flagship models have shipped since GPT-5: Chat Completions, Responses, Realtime, Realtime translation, Realtime transcription, Assistants, Batch, Fine-tuning, Embeddings, Image generation, Image edit, Speech generation, Transcription, Translation, and Moderation. The Responses API is the recommended path for any agent workload because it preserves opaque reasoning state between turns and uses compaction to manage long contexts. That is the system that scored 99.9% on ARC-AGI-3.

Here is a minimal Python call using the Responses API:

from openai import OpenAI

client = OpenAI()  # uses OPENAI_API_KEY

resp = client.responses.create(
    model="gpt-6-astra",
    input="Explain the difference between ExploitBench and ExploitGym in 200 words.",
    reasoning={"effort": "medium"},  # supports low, medium, high, xhigh, max
)

print(resp.output_text)

Reasoning effort is the control surface for trading quality against cost and latency. The OpenAI model page lists the supported values as low, medium, high, xhigh, max. For interactive chat the sweet spot is medium; for batch processing of distinct tasks low saves cost; for the hardest end-to-end work xhigh or max are appropriate. Note that at max the per-token cost is identical - what changes is the total tokens consumed per task (and therefore the wall-clock latency).

For the Tools-using surface the same Responses API call becomes:

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    input=[
        {"role": "user", "content": [
            {"type": "input_text", "text": "Find the recent V8 commit that fixed CVE-2026-XXXX and summarize the patch."},
            {"type": "input_text", "text": "Search the web for the V8 git log."},
        ]}
    ],
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}],
    reasoning={"effort": "high"},
)

print(resp.output_text)

The full tool list supported on Astras Responses API: Web search, File search, Image generation, Code interpreter, Hosted shell, Apply patch, Skills, Computer use, MCP, and Tool search. Fine-tuning is NOT supported - OpenAIs announcement is explicit that Astra is a closed-weight API-only model for the foreseeable future, with no path to fine-tune.

Decision Matrix: When to Pay for Astra vs Stay on Sol

The pricing gap between Astra and Sol ($10/$50 vs $4/$20 promo) is 2.5x per token. The capability gap is real but uneven. Here is the decision matrix:

The headline rule: pay 2.5x for Astra when the workload is cybersecurity, million-token retrieval, or autonomous coding. For everything else, the cheaper models at the same or better capability tier are the right answer. The promo on Sol expires November 21, 2026, after which Sol reverts to its standard $5/$25 pricing - at that point Astras premium narrows to 2x and the value calculus shifts further toward Astra for coding workloads.

Rollout Schedule and Where to Get It

As of September 4, 2026 - the day after OpenAIs announcement - the rollout is staged:

1. Now (Day 1) - GPT-6 Astra is rolling out to OpenAIs Trusted Access Program enterprises (the cohort that previously had access to Daybreak and Daybreak Blue). OpenAIs announcement uses the word today for this group.
2. In the coming days - ChatGPT Plus, Pro, Business, and Enterprise users get access through the ChatGPT surface. Pro, Business, and Enterprise additionally get Astra Pro.
3. In the coming days - the OpenAI API itself opens to all eligible developers. Eligible API customers will also be able to use Astra under Zero Data Retention.
4. To follow (no date given) - AWS Bedrock availability. The Bedrock /openai page currently lists GPT-5.6 Sol and GPT-5.6 Cyber; Astra is not yet there.

For developers the practical path right now is: wait until your OpenAI account gets Astra access (likely within the next 1-3 business days for most accounts based on prior flagship rollouts), then point your existing code at model="gpt-6-astra". The OpenAI SDK requires no changes - base URL stays api.openai.com, the Responses API surface is the same as GPT-5.6 Sols. The model ID for routing is gpt-6-astra; for Astra Pro specifically there is no separate API ID published as of September 4.

OpenRouter and Azure OpenAI: as of the writing of this article GPT-6 Astra is NOT on OpenRouter (the OpenRouter /api/v1/models endpoint lists Claude Fable 5.1 and Muse Spark 1.3 as the newest models). Expect OpenRouter support 7-14 days after API availability stabilizes, consistent with previous flagship rollouts. Azure OpenAI Service availability has not been announced; OpenAIs prior flagships typically take 2-4 weeks to land in Azure AI Foundry after the OpenAI API opens.

Code Examples: Three Real Calls

Example 1 - Long-context RAG retrieval

from openai import OpenAI

client = OpenAI()

# Load a 600K-token source corpus (e.g. a regulatory filing set)
with open("filings_q3_2026.txt") as f:
    corpus = f.read()

resp = client.responses.create(
    model="gpt-6-astra",
    input=[
        {"role": "system", "content": "You answer questions about Q3 2026 SEC filings using only the provided context."},
        {"role": "user", "content": f"Context:
{corpus}

Question: Which companies disclosed material cybersecurity incidents in Q3? List each with citation."},
    ],
    reasoning={"effort": "medium"},
)

print(resp.output_text)
print(f"
Input tokens: {{resp.usage.input_tokens}}, output tokens: {{resp.usage.output_tokens}}")
print(f"Estimated cost: ${{resp.usage.input_tokens * 10 / 1e6 + resp.usage.output_tokens * 50 / 1e6:.2f}}")

At a 600K-token input the request sits well inside the 1.05M context window but above the 272K long-context threshold, so input is billed at $20/M (long-context multiplier) and output at $75/M. For a 600K input + 2K output response the bill is roughly $12.10. Run that on Fable 5.1 at the same parameters and you pay $12.10 (no long-context surcharge on Fable). The cache-read math matters for repeated prompts - see §3.

Example 2 - Cybersecurity analysis with tool use

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    input=[
        {"role": "user", "content": [
            {"type": "input_text", "text": "Review the patch diff in /tmp/v8-fix.patch and identify whether it closes the heap-overflow in JSON.stringify. Then write a regression test that would have caught it."},
        ]},
    ],
    tools=[
        {"type": "code_interpreter"},
        {"type": "file_search"},
    ],
    reasoning={"effort": "xhigh"},  # max for security analysis
)

print(resp.output_text)

This is the workload Astra was designed for. The combination of file_search (to read the patch), code_interpreter (to execute the regression test), and reasoning.effort=xhigh is what gets you close to the 100% on ExploitBench-class tasks. Expect a 3-10 minute wall clock for a substantial patch review at xhigh; the per-token cost is unchanged.

Example 3 - Batch processing of distinct Q&A

import json
from openai import OpenAI

client = OpenAI()

# Build a batch input file (JSONL)
with open("questions.jsonl") as f:
    questions = [json.loads(line) for line in f]

# Write to batch input file
with open("/tmp/astra_batch.jsonl", "w") as out:
    for i, q in enumerate(questions):
        out.write(json.dumps({{
            "custom_id": f"q-{{i}}",
            "method": "POST",
            "url": "/v1/responses",
            "body": {{
                "model": "gpt-6-astra",
                "input": q["text"],
                "reasoning": {{"effort": "low"}},  # batch at low effort
            }},
        }}) + "
")

# Upload and create batch
batch_file = client.files.create(file=open("/tmp/astra_batch.jsonl", "rb"), purpose="batch")
batch = client.batches.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/responses",
    completion_window="24h",
)

print(f"Batch {{batch.id}} created; status: {{batch.status}}")
# Poll: client.batches.batches.retrieve(batch.id)

Batch at $5/$25 is half of Standard, but for general-purpose Q&A the cheaper model is the right choice - Sol at $4/$20 promo or Flash at $0.75/$3.75 do the same work for less. Batch + Astra only makes sense for the workloads in the decision matrix above where you specifically need Astras gains.

Who Should Use GPT-6 Astra

Astra fits three profiles well:

• Security teams running automated red-team workflows - Astras 100% on ExploitBench and 99.2% on SRE-Bench reverse engineering are the first frontier-model scores in this range. If you operate a vulnerability-research platform or build exploit-generation tooling, Astra is the new default.
• Long-context RAG and document-analysis platforms - Astras 96.3% recall at 512K to 1M tokens (vs Sols 73.8% and Fable 5.1s no-published-result) makes it the first frontier model that holds up over a million-token context window. Legal-tech, regulatory-tech, and enterprise-search use cases that have been gated on long-context reliability finally have an answer.
• Autonomous coding agents - Cursor, Codex, Aider, Cline, and any other coding agent that runs for hours across multiple files. The DeepSWE 74.1% (vs Sol 70.8% and Fable 5.1 67.4%) and the per-task cost-efficiency advantage (less than half of Fable 5 at the same score) compound over the hundreds of model calls a single agent session makes.

Astra is a poor fit for:

• General-purpose chat or short Q&A - pay 2.5x for nothing.
• Batch processing of distinct prompts at scale - the cheaper models do the same work.
• Workloads where the system prompt is reused hundreds of times per hour - Fable 5.1s $0.25 cached read is four times cheaper than Astras $1.00.
• Anything that requires fine-tuning - Astra is a closed-weight API-only model with no fine-tuning path.

Verdict

GPT-6 Astra is OpenAIs September 2026 flagship and the first model to clear the Critical cybersecurity tier of the Preparedness Framework. The pricing matches Claude Fable 5.1 dollar-for-dollar on input/output and cache writes ($10/$50 + $12.50), with cached input at $1.00/M (still four times more expensive than Fable 5.1s $0.25/M). The capability picture is asymmetric: the cybersecurity numbers (100% ExploitBench, 99.2% SRE-Bench), the long-context numbers (96.3% MRCR v2 at 512K to 1M), and the coding-agent cost-efficiency lead (less than half the per-task cost of Fable 5 at the same score) are the genuine wins. On Artificial Analysis Intelligence Index Astra is tied with Sol at 61, five points below Fable 5.1 max - it is not a leapfrog on raw IQ, and if you do not need the cyber or long-context wins, the cheaper models do the same work. For the three workloads Astra was designed for (red-team automation, million-token RAG, autonomous coding agents), the September 2026 default switches to Astra. For everything else, GPT-5.6 Sol at the $4/$20 promo through November 21, 2026 remains the right answer.