OpenAI's New Pricing Split: One Model Cuts Your Bill 80%, the Other Cuts Your Wait 8x for 6x the Price
Correction October 12, 2026: the cached-input row described the discount as 90% off input for both models. It is 90% for Astra ($1.00 per 1M against $10.00) and 95% for Sol ($0.10 against $2.00); the prices listed in the table were already correct. Source: OpenAI API pricing page.
Updated October 10, 2026. Every price and benchmark figure below was re-checked against the sources listed at the end on that date. The October update section near the end records what changed after this piece first ran on September 30.
At DevDay 2026 on September 29, OpenAI announced two upgrades to its flagship API lineup that pull in opposite directions. GPT-6.1 Sol prices its tokens at roughly one-fifth of GPT-6 Astra's rate while scoring almost identically on independent benchmarks. A new "Ultrafast" tier for Astra generates tokens up to 8 times faster in Codex, but charges 6 times more per token to do it. Neither number means much on its own -- an 8x speed claim says nothing about whether the extra speed is worth paying for, and an 80% discount says nothing about whether the cheaper model is good enough for the task at hand. This piece converts both into dollars and minutes for one realistic coding task, using OpenAI's own published prices and a third-party benchmark score, so the tradeoff is visible rather than assumed.
What was actually announced, in prices rather than adjectives
OpenAI's own DevDay 2026 recap and independent coverage of the pricing sheet give three distinct offerings to compare. All prices below are per 1 million tokens, as published at the time of the announcement.
| Model / tier | Input price | Output price | Speed | Artificial Analysis Intelligence Index |
|---|---|---|---|---|
| GPT-6 Astra (standard) | $10 | $50 | baseline | 53 |
| GPT-6.1 Sol | $2 | $10 | similar to standard Astra | 52 |
| GPT-6 Astra Ultrafast | $60 | $300 | up to 300 tokens/sec in Codex (~8x standard), ~6x in API | 53 (same model, faster serving) |
Two things stand out immediately. First, Sol's price cut (80% off both input and output) is nearly proportional to nothing lost in the benchmark score -- 52 versus 53 is within normal run-to-run variance for this kind of index, not a meaningful capability gap. Second, Ultrafast is not a different, smarter model -- it is the same Astra model served on faster infrastructure, and OpenAI charges 6x the token price for roughly 6-8x the speed. That means the cost per unit of output time is similar to standard Astra; what changes is wall-clock time, not the total compute cost per token generated.
Worked scenario: a real test-generation job, priced both ways
Take a concrete, unremarkable job: an engineering team uses the API to auto-generate a test suite for an existing codebase, a task that in practice consumes roughly 200,000 input tokens (the code being read and the prompts) and 500,000 output tokens (the generated tests and explanations) -- a realistic size for a multi-file test-writing pass, not a toy example.
| Option | Input cost | Output cost | Total cost |
|---|---|---|---|
| GPT-6 Astra, standard | 200,000 × $10/1M = $2.00 | 500,000 × $50/1M = $25.00 | $27.00 |
| GPT-6.1 Sol | 200,000 × $2/1M = $0.40 | 500,000 × $10/1M = $5.00 | $5.40 |
| GPT-6 Astra Ultrafast | 200,000 × $60/1M = $12.00 | 500,000 × $300/1M = $150.00 | $162.00 |
Switching this one job from standard Astra to Sol saves $21.60, or about 80% of the bill, which lines up with the independent benchmark finding that Sol costs roughly $0.72 per Index task against Astra's $3.26 -- about 22% of the cost for a 1-point difference in score. Running the identical job on Ultrafast instead costs $135.00 more than standard Astra, not less -- Ultrafast is not a cheaper option under any circumstance, it is a faster one that costs more per token to get there.
Worked scenario: the same job, timed
Time is where Ultrafast's case has to be made, since its case cannot be made on price. OpenAI states Ultrafast reaches up to 300 tokens per second in Codex, an up-to-8x improvement, which implies a standard Astra baseline in Codex of roughly 300 ÷ 8 ≈ 37.5 tokens per second. For the 500,000-output-token test-generation job used above, that difference compounds into a real amount of wall-clock time:
| Option | Output speed (Codex) | Time for 500,000 output tokens |
|---|---|---|
| GPT-6 Astra, standard | ~37.5 tokens/sec | ~13,333 sec ≈ 222 minutes (3.7 hours) |
| GPT-6 Astra Ultrafast | up to 300 tokens/sec | ~1,667 sec ≈ 28 minutes |
That is roughly 194 minutes saved -- about 3.2 hours -- for $135.00 more on this one job, or a little over $40 per hour of wall-clock time bought back. Whether that is a good trade depends entirely on what the 3.7-hour wait is blocking: a nightly batch job that runs while no one is watching gets no value from Ultrafast at all, while a test suite blocking a deployment pipeline that a team is actively waiting on might easily be worth $40 an hour in engineer idle time. The spec sheet cannot tell you which situation you are in; only the job itself can.
A second scenario: high-volume, short-output work
The test-generation example above is a low-frequency, high-output job, which is exactly the profile where Ultrafast's time savings are largest. Most production API traffic looks nothing like that. Take a customer-support chatbot handling 100,000 conversations a month, each consuming roughly 300 input tokens (the user's message plus retrieved context) and 150 output tokens (a short, direct reply) -- a realistic profile for a support bot, not a coding assistant.
| Option | Monthly input cost | Monthly output cost | Monthly total | Time per single reply |
|---|---|---|---|---|
| GPT-6 Astra, standard | 30,000,000 × $10/1M = $300.00 | 15,000,000 × $50/1M = $750.00 | $1,050.00 | 150 ÷ 37.5 ≈ 4.0 sec |
| GPT-6.1 Sol | 30,000,000 × $2/1M = $60.00 | 15,000,000 × $10/1M = $150.00 | $210.00 | ≈4.0 sec (similar speed to standard Astra) |
| GPT-6 Astra Ultrafast | 30,000,000 × $60/1M = $1,800.00 | 15,000,000 × $300/1M = $4,500.00 | $6,300.00 | 150 ÷ 300 = 0.5 sec |
Here the picture flips completely from the test-generation example. Switching this chatbot from standard Astra to Sol saves $840 a month -- a much larger absolute number than the coding example, because volume, not per-task size, is what drives cost at this scale. Switching to Ultrafast instead adds $5,250 a month to cut each reply from about 4 seconds to half a second. For a chat interface, a 4-second reply is already within normal conversational latency; shaving it to half a second is very unlikely to be worth 6x the monthly bill for most support use cases, even though the same tier looked like a reasonable trade in the earlier coding scenario. The lesson is not that Ultrafast is overpriced -- it is that the same tier can be an easy call in one workload and an easy pass in another, depending entirely on whether the baseline wait time was already a problem worth solving.
The catch that the price tags don't show
Sol and Ultrafast currently cannot be combined. OpenAI's own materials list an Ultrafast version of Sol as "coming soon" rather than available now, meaning today's actual choice is a three-way split, not a two-by-two grid: cheap-and-normal-speed (Sol), expensive-and-fast (Astra Ultrafast), or the old standard (Astra) as a middle ground with no advantage over either newer option on paper. As of the September 29 announcement, a team that wants both the 80% cost cut and the 8x speed boost on the same job could not get both, and had to pick which constraint -- budget or time -- binds harder for that specific workload.
The other catch is that the benchmark parity between Sol and Astra (52 vs. 53) is an aggregate score across many task types on one index, not a guarantee for any single use case. A 1-point gap on a broad intelligence index can hide a larger gap on a narrow skill a particular workflow depends on, such as long-context tool use or a specific coding pattern. The responsible read of "almost the same score for one-fifth the price" is "worth testing on your own task before switching production traffic," not "safe to switch everything today without checking."
Checklist before switching a production workload
- Estimate your job's actual input and output token counts from real logs, not guesses -- the savings and costs above scale linearly, so a job twice this size doubles both the Sol savings and the Ultrafast premium.
- Ask whether the job is blocking a human or a deadline right now, or running unattended -- that answer alone decides whether Ultrafast's time savings have any dollar value to your team.
- Run your own eval on Sol against your current Astra outputs for your specific task before a full switch; a 1-point aggregate benchmark gap does not tell you how either model performs on your workload specifically.
- Remember Sol and Ultrafast are not yet combinable -- budget for the standard Astra Ultrafast price if speed is the priority, not a hypothetical discounted-and-fast combination.
All prices, speeds, and benchmark scores are as published or reported around OpenAI's September 29, 2026 DevDay announcement and are subject to change; token counts in the worked examples are illustrative estimates for a representative job, not measurements of any specific team's actual usage.
Three cheaper levers that were not on the keynote slide
The announcement framed the decision as cheap model versus fast tier. OpenAI's published price table carries three further levers that move the same bill without changing the model at all: cached input, the Batch and Flex tiers, and the context-length boundary. Figures below are per 1 million tokens from OpenAI's developer pricing tables, read on October 10, 2026, at the short-context rate unless the row says otherwise.
| Lever | GPT-6 Astra | GPT-6.1 Sol | Condition attached |
|---|---|---|---|
| Standard input / output | $10 / $50 | $2 / $10 | Baseline |
| Cached input | $1.00 | $0.10 | 90% off input for Astra and 95% for Sol, and only for requests that share a long identical prefix |
| Batch or Flex input / output | $5 / $25 | $1 / $5 | 50% off both, but gives up the latency guarantee Ultrafast is sold on |
| Long context input / output | $20 / $75 | $4 / $15 | A penalty, not a discount: crossing into the long-context band doubles input |
Run those against the support-chatbot workload used above, 30 million input and 15 million output tokens a month. Standard Astra is 300 dollars plus 750 dollars, or $1,050. If 70 percent of that input is a repeated system prompt and document set that hits the cache, input becomes 30M x 0.7 x $1 plus 30M x 0.3 x $10, which is $21 plus $90, so the month lands at $861 with the same model and the same latency. The identical cache ratio on Sol takes $210 down to about $170. Shifting the share of traffic nobody is waiting on to Batch pricing is larger still: an all-Batch month on Sol is $30 plus $75, or $105, a tenth of the standard-Astra bill.
These levers stay out of the headlines because each carries a condition the price sheet does not charge for. Caching pays only when prompts repeat almost verbatim, Batch and Flex are unusable for anything a person is waiting on, and the long-context row works in reverse: a retrieval step that quietly pads a prompt past the short-context boundary doubles the input rate on every call after it, which can eat an entire tier change.
The October update: Sol can now be ordered fast
Two things moved in the eleven days after the keynote, and both cut against the original three-way framing.
First, the published pricing table now lists Ultrafast rates for GPT-6.1 Sol: $12 input and $60 output per 1M tokens on short context, $24 and $90 on long context, read October 10, 2026. That is 6x the standard Sol rate, the same multiple Astra pays for Ultrafast, and five times cheaper than Astra Ultrafast at $60 and $300. The DevDay recap still describes Sol Ultrafast as coming soon, so a posted price is not the same thing as a shipped tier: treat it as priced rather than promised and confirm availability in the API before planning a migration around it. On the chatbot workload it would run 30M x $12 plus 15M x $60, which is $360 plus $900, or $1,260 a month. That is about 20 percent more than standard Astra for a tier sold on 8x faster generation, and a far easier purchase than Astra Ultrafast at $6,300.
Second, the speed parity this article assumed for the cheaper model is not what independent measurement shows. Artificial Analysis listed Sol at 59 output tokens per second against Astra's 48 on the standard tier when this was checked on October 10, 2026 (that page remeasures continuously, so the gap shown there today may be smaller), with blended prices of $1.47 and $7.70 per 1M tokens at its 7:2:1 cache, input and output mix. Where that holds, the cheaper model is also the faster one before any premium tier is bought, which shrinks the set of jobs for which paying 6x buys latency the base model would not have delivered anyway. The intelligence-index gap between the two, 52 against 53, has not moved.
Sources
- OpenAI -- DevDay 2026 Recap (official)
- OpenAI -- API pricing tables for standard, Batch, Flex, Fast and Ultrafast tiers (read 2026-10-10)
- Artificial Analysis -- GPT-6.1 Sol vs GPT-6 Astra: index score, output speed and blended price (read 2026-10-10)
Related on this site
Start Here: every guide by topic · About · Privacy Policy
Comments
Post a Comment