GPT-6 Astra Pricing and Benchmarks | What It Really Costs to Run

OpenAI released GPT-6 Astra on 3 September 2026 and called it the most capable model it has ever broadly deployed. Within a day the question in most engineering channels was not whether Astra is smarter. It plainly is on the tasks OpenAI chose to highlight. The question was narrower and more awkward: at $10 input and $50 output per million tokens, is it smarter by enough to justify paying two and a half times what you pay today?

This page answers that question the way we answer every launch on this site. We take the published rate card as the starting point, work through the billing mechanics that sit underneath it, separate vendor-reported benchmark claims from independent measurement, and then reduce the whole thing to a per-request unit cost you can multiply by your own traffic. If you want to run the arithmetic while you read, keep the GPT API cost calculator and the pricing database open in a second tab.

One caveat up front, and it matters for how you read everything below. Astra's rollout is staged. On launch day, access went to a limited set of organisations in OpenAI's Trusted Access Program, with ChatGPT Plus, Pro, Business and Enterprise plans and general API availability following over the following days. If a call to the model identifier returns a not-found error on your account, that is the rollout, not a configuration mistake.

What actually launched on 3 September 2026

GPT-6 Astra is OpenAI's new flagship, positioned above the GPT-5.6 family rather than replacing every member of it. OpenAI describes it as state of the art on computer use, browsing, software engineering, cybersecurity, science and professional work. The published specification is deliberately unglamorous, because the headline change is not the envelope, it is what the model does inside it.

Read that table next to GPT-5.6 Sol and something jumps out: the context window and maximum output are identical. Astra is not a bigger container. It is a better occupant of the same container, with a fifth reasoning effort level added at the top end. Whatever you are paying extra for, you are not paying for room.

The second structural change is the reasoning effort ladder. Where earlier flagships exposed low, medium and high, Astra adds xhigh and max. Those settings do not change the per-token price. They change how many tokens the model spends thinking before it answers, and reasoning tokens bill at the output rate. That makes the effort parameter a cost dial disguised as a quality dial, which is the single most important operational fact on this page.

GPT-6 Astra pricing per million tokens

OpenAI prices Astra across four meters: standard input, cached input, cache writes, and output. Rates below are list prices in USD per one million tokens, taken from OpenAI's API pricing page on 4 September 2026.

Four mechanics decide what you actually pay, and none of them are visible in the headline number.

1. 01The output multiple is five. Output costs five times input. Any workload that generates long answers, writes code, or reasons at length is an output-dominated workload, and its cost curve is set almost entirely by that multiple rather than by prompt size.
2. 02Cached input is a tenth of standard input. At $1.00 against $10.00, a stable prompt prefix is worth more on Astra than on any cheaper model, in absolute dollars. The catch is the cache write at $12.50, which is 25 percent above the standard input rate. Caching a prefix you reuse twice is a loss. Caching one you reuse fifty times is close to free after the first call.
3. 03The long-context cliff applies to the whole request. Cross 272,000 input tokens and the entire request reprices, not just the excess. Input doubles to $20.00 and output rises by half to $75.00. A retrieval step that quietly grows from 260k to 280k tokens does not cost 8 percent more, it costs roughly twice as much.
4. 04Reasoning tokens are billed output you never see. At max effort the model can produce several thousand internal tokens before a two-paragraph answer. On a $50 output rate that is real money per call, and it is why identical prompts can produce wildly different invoices at different effort settings.

OpenAI also lists an asynchronous batch tier at exactly half these rates, $5.00 input and $25.00 output for short context. Anything that does not need a synchronous answer, which in most products means evaluation runs, backfills, nightly enrichment, and document processing queues, belongs there. Teams routinely leave that 50 percent on the table because the batch path was never wired up during the prototype and nobody revisited it.

Two smaller line items are worth knowing before your first invoice. Regional processing endpoints for data residency carry a 10 percent uplift on models released after 5 March 2026, which includes Astra. And OpenAI models served through Amazon Bedrock are billed by AWS and may not match direct OpenAI rates, so a multi-cloud deployment can pay two different prices for the same model string.

GPT-6 Astra vs GPT-5.6 Sol on price

The comparison that matters for existing OpenAI customers is against GPT-5.6 Sol, the flagship Astra displaces. Sol remains available and, at the time of writing, is running promotional pricing that OpenAI has committed to hold at least through 21 November 2026.

The blended column assumes three input tokens for every output token, which is a reasonable shape for assistant and agent traffic and a poor one for summarisation. On that basis Astra costs 2.5 times Sol, 4.4 times Terra, and roughly 44 times Luna. Those multiples, not the raw rates, are what your finance team will eventually ask you to defend.

Put in monthly terms: a service handling 200 million input and 60 million output tokens per month pays about $4,000 on Sol and about $5,000 on Terra at these shapes. The same traffic on Astra is $5,000 in input alone and $3,000 in output, for $8,000 before caching. Move 70 percent of that input to a cached prefix and Astra lands near $4,700. Caching is not a micro-optimisation at this price point, it is the difference between two budgets.

We keep the live figures for all four models, plus the Anthropic and Google equivalents, in the pricing database, and you can put any two of them side by side on the compare page rather than trusting the numbers frozen into this article.

The benchmark picture, vendor claims and independent measurement kept apart

OpenAI's launch material makes strong claims, and they deserve to be reported precisely rather than paraphrased upward. According to the launch post, Astra saturates FrontierMath Tier 4 at 98 percent, reaches 99.9 percent on ARC-AGI-3, and scores 100 percent on ExploitBench. On Terminal-Bench Science 0.1, which tests whether an agent can carry out scientific research workflows through code and terminal tools, OpenAI reports Astra at 64.6 percent against 52.6 percent for Claude Fable 5.1, at roughly 31 percent lower estimated API cost for the task.

That last figure is the most interesting one on the page, and the most easily misread. It is a cost-per-task claim, not a cost-per-token claim. Astra costs more per token and, on that specific benchmark, less per completed task, because it needs fewer attempts and fewer tool calls to finish. Whether that inversion holds on your workload is an empirical question about your task length, not something you can settle from a rate card.

Third-party aggregation is more restrained. On the independent index maintained by LLM Stats, Astra takes the top overall position at 60.7 against Sol's 55.3, winning all 17 directly shared benchmark results, with the largest gaps in agents and coding and a near tie on mathematics composite. Some launch-day analyses using Artificial Analysis measurements found the two models effectively level on the broad composite. Both readings can be true: composite indexes average across task types, and Astra's advantage is concentrated in a handful of them.

• Where the gap is large: long-horizon agentic coding, computer and browser use, cybersecurity evaluation, competition-level mathematics, and multi-step scientific workflows.
• Where the gap is modest: general reasoning, retrieval-augmented question answering, and vision tasks, where Astra leads but not by a margin that survives a 2.5x price multiple.
• Where the gap is effectively zero for cost purposes: classification, extraction, routing, summarisation of short documents, and the long tail of glue-work calls that make up most production token volume.

A model that is 10 percent better and 150 percent more expensive is a bad default and an excellent specialist. The engineering task is not choosing one model, it is deciding which requests deserve the expensive one.

The safety story, and why it affects procurement

Astra is the first OpenAI model to reach the Critical level for cybersecurity capability under the company's Preparedness Framework. In plain terms, OpenAI's own assessment is that with the right tooling and access, the model can discover previously unknown security flaws and develop ways to exploit them across well-protected systems without a human directing each step.

OpenAI's response is a set of controls described in the accompanying safety overview and system card: stronger protections against harmful cyber actions, stricter internal isolation, checkpoint encryption, and universal monitoring of full model trajectories including chains of thought. The company also reports that Astra is better aligned than Sol on a new suite of alignment evaluations, while being candid that its monitorability has decreased, meaning its internal reasoning is a less reliable window into its behaviour than the previous generation's.

This is not an abstract concern for a buyer. Three practical consequences follow. Enterprise workspace access is off by default and an administrator must enable it, which is a real scheduling dependency if your rollout plan assumed availability. Some capabilities may sit behind additional access review. And if you operate in a regulated environment, your security team will want the system card in the file before the model reaches production, not after. Budget a week for that conversation.

Working out your own unit cost

Monthly forecasts built from a guessed token total are almost always wrong. Forecasts built from a measured per-request cost multiplied by real traffic are usually within a manageable margin. The method has four steps and takes about an hour.

1. 01Measure one real request. Take a representative production prompt, not a demo one. Record input tokens, cached input tokens, and output tokens including reasoning tokens from the usage object in the API response. Estimating token counts by eye is where most forecasts go wrong, and the token calculator will get you closer than intuition.
2. 02Price that request. Multiply each meter by its rate and divide by one million. A request with 12,000 fresh input tokens, 40,000 cached input tokens and 3,500 output tokens costs $0.12 plus $0.04 plus $0.175, which is roughly $0.335 on Astra and $0.134 on Sol.
3. 03Multiply by real traffic. Use your actual request count from the last full month, not a projection. Then add a retry allowance. Agentic workloads retry more than chat workloads, and a 15 to 30 percent uplift is realistic rather than pessimistic.
4. 04Model the effort settings separately. Run the same prompt at medium, high and max effort and record the output token counts. On reasoning models the spread between medium and max is frequently 3x or more in billed output, which on a $50 rate dominates every other variable you are tuning.

The number this produces is a cost per completed task, and it is the only figure worth comparing across models. Cost per token flatters cheap models that need three attempts. Cost per task tells you what the work costs.

Should you upgrade? A decision framework

The temptation on launch day is to switch the default model string and see what happens. That is how a controlled 10 percent capability gain becomes an uncontrolled 150 percent cost increase. A better sequence is to treat Astra as a new tier in a routing policy rather than a replacement for an existing one.

Cases where Astra likely pays for itself

• Long-horizon agents that run for many minutes and many tool calls, where a failed trajectory wastes far more tokens than the price difference on a successful one.
• Software engineering work where a wrong patch costs engineer review time. At a loaded engineering cost of even $60 an hour, ten minutes of avoided review pays for a great many Astra calls.
• Computer use and browser automation, where OpenAI's strongest claims sit and where reliability, not eloquence, is the metric that matters.
• Security review, complex scientific analysis, and mathematics-heavy work, where the capability gap is widest and the volume is typically low.

Cases where the upgrade is hard to justify

• High-volume, short-answer traffic: classification, routing, tagging, moderation triage, and structured extraction. Luna or Terra will do these at a fraction of the price with no user-visible difference.
• Consumer chat features priced on a flat subscription, where a 2.5x token cost lands straight on gross margin.
• Any workload you have not benchmarked. If you cannot state the current failure rate, you cannot claim an improvement, and you certainly cannot value one.

A rollout sequence that will not surprise you

1. 01Freeze a small evaluation set of 50 to 100 real tasks with known correct outcomes, drawn from production rather than written for the occasion.
2. 02Run it on your current model at your current settings and record both the pass rate and the total billed tokens. This is your baseline, and without it every later number is decoration.
3. 03Run the same set on Astra at medium effort, then at high. Compare pass rate and cost per passed task, not cost per call.
4. 04Route only the task classes where cost per passed task actually improves. Keep the model identifier in configuration so routing is a runtime decision, never a deployment.
5. 05Add prompt caching to the routed traffic before you scale it, and set a hard budget alert at 150 percent of forecast for the first month.

If your workload spans providers, the same discipline applies across vendors rather than just across OpenAI tiers. Anthropic's Claude Fable 5.1, released two days before Astra, lists at the same $10 input and $50 output, with cache reads at $0.25 per million, which is a quarter of Astra's cached rate. Our Claude cost calculator and the Grok versus Claude comparison cover how those mechanics differ in practice.

What to watch over the next quarter

Three things will likely change the arithmetic above, and none of them require a new model release.

First, Sol's promotional pricing has a stated floor of 21 November 2026. If it lapses rather than renews, the gap between Sol and Astra narrows on paper without Astra moving at all, and every routing decision made this month deserves a second look in December.

Second, flagship rates historically fall as serving efficiency improves and competitive pressure builds. Anthropic and Google both have models in this capability band, and the frontier tier has not been a stable price point in any previous generation.

Third, the effort ladder is new. As teams publish real measurements of the xhigh and max settings against medium, the community will develop rules of thumb about where extra thinking stops paying. Those rules of thumb will move budgets more than any headline rate change, because the effort setting is the one variable entirely under your control.

We track all four OpenAI tiers, plus Anthropic, Google, xAI and the open-weight hosts, in the AIOPLY pricing database, refreshed against provider documentation on a fixed schedule. When a rate on this page changes, that page changes first.

The bottom line

GPT-6 Astra is the strongest model OpenAI has shipped, and on agentic coding, computer use, security work and hard mathematics the evidence for that is straightforward. It is also two and a half times the price of the model most teams are running today, with a long-context cliff at 272,000 tokens and an effort dial that can triple billed output without changing a line of your prompt.

The right answer for the overwhelming majority of production systems is not adoption or rejection. It is segmentation: keep the volume traffic on Sol, Terra or Luna, move the small population of high-stakes, long-horizon tasks to Astra, measure cost per completed task rather than cost per token, and revisit the split when Sol's promotional pricing expires in November. That is less exciting than a model swap. It is also the version that survives contact with an invoice.