OpenAI Ultrafast pricing: 6x the rate on Sol and Astra, and when it pays
Ultrafast multiplies input, cache read, cache write and output by six on GPT-6.1 Sol and GPT-6 Astra. OpenAI publishes no speed multiple, so the decision is a measured cost per hour saved.
Ultrafast is 6× the Standard rate, and it is now offered on two models: GPT-6 Astra, which had it first, and GPT-6.1 Sol, where it became available to all API users on 8 October 2026. The multiplier lands on all four price figures at once — input, cached input, cache writes and output — which makes it the most expensive line on the price list. It is a tier you buy to hit a deadline, never one you buy to save money.
The useful way to think about it is as a wall-clock purchase. Ultrafast does not make the model better, and it does not reduce the work. It shortens how long the work takes, and you pay six times the Standard rate for that.
What 6× multiplies, on each model
Every rate is multiplied by six. That includes the cached-input rate, which is easy to overlook because it is small until it is multiplied.
| figure | Sol Standard | Sol Ultrafast | Astra Standard | Astra Ultrafast |
|---|---|---|---|---|
| input | $2.00 | $12.00 | $10.00 | $60.00 |
| cache read | $0.10 | $0.60 | $1.00 | $6.00 |
| cache write | $2.50 | $15.00 | $12.50 | $75.00 |
| output | $10.00 | $60.00 | $50.00 | $300.00 |
Rates are USD per million tokens at short context, taken from OpenAI's pricing documentation on 27 October 2026. The cache-write figure is the standard short-lifetime write; OpenAI also offers a longer cache lifetime at a higher write rate on GPT-5.6 and later models.
One consequence of that table is easy to miss. Sol Ultrafast output, at $60.00 per million, is only slightly above Astra Standard output at $50.00. If your reason for considering Astra Ultrafast is speed rather than Astra's quality, Sol Ultrafast is the comparison to run first.
Which models have it, and where they can run
| model | Ultrafast | regions OpenAI lists for Ultrafast |
|---|---|---|
| GPT-6.1 Sol | available since 8 October 2026 | US and EU data residency, global processing |
| GPT-6 Astra | available | US data residency and global processing only |
| GPT-6 Luna, GPT-5.6 Sol, GPT-5.6 Terra | not offered | — |
The residency column matters as much as the price. A product with an EU data-residency requirement cannot use Astra Ultrafast at any price, but it can use Sol Ultrafast. Before Sol's tier opened, "we need it faster and it must stay in the EU" had no Ultrafast answer at all. Now it has one, on the cheaper model. The regional source is OpenAI's Ultrafast guide.
Ultrafast also has its own rate limits, separate from Standard and Fast. Fast mode draws from the same limits as Standard; Ultrafast does not. A job that is throttled on Standard is not automatically throttled on Ultrafast, and the reverse is also true, so check your own limits page before you size a run.
A bulk run, priced on both models
Take a bulk generation job of 10,000 requests, each sending 4,000 input tokens and producing 2,000 output tokens, with no caching.
| model and tier | input / call | output / call | cost / call | 10,000 calls |
|---|---|---|---|---|
| Sol Standard | $0.0080 | $0.0200 | $0.0280 | $280 |
| Sol Ultrafast | $0.0480 | $0.1200 | $0.1680 | $1,680 |
| Astra Standard | $0.0400 | $0.1000 | $0.1400 | $1,400 |
| Astra Ultrafast | $0.2400 | $0.6000 | $0.8400 | $8,400 |
The Ultrafast premium for the run is $1,400 on Sol and $7,000 on Astra. Those are the only certain numbers in the decision. What the premium buys — how many hours it saves — is not published, which is why the next section matters.
Pricing the speed you actually get
OpenAI describes Ultrafast as its fastest service tier, but it does not publish a speed multiple. Earlier versions of this page repeated a "6× the speed" figure; we could not trace it to an official page and have removed it. The honest way to make the decision is to measure.
- Send a sample of real requests — a few dozen is enough to see the shape — on Standard and on Ultrafast, with the same prompts and the same effort level.
- Record wall-clock time per request, and the end-to-end time for a batch of them at your usual concurrency.
- Scale that to the full run to get the hours Ultrafast would save.
- Divide the premium by the hours saved. That is the price of an hour on this job.
Suppose your measurement says the Standard run takes six hours and Ultrafast finishes it in two. On Astra, the $7,000 premium buys four hours, about $1,750 per hour saved. On Sol the same four hours cost $1,400, or $350 an hour. Those two numbers are hypothetical because the speed-up is yours to measure, but the arithmetic is the whole decision: if finishing four hours sooner is worth more than the hourly figure, the tier is rational.
When the trade pays
Ultrafast is rational in a narrow band of situations, and they share one feature: the deadline is real and the compute is a small part of the value.
- A launch or event where the generation must be ready at a fixed time.
- A run that gates a release, where an extra day of waiting has a cost.
- Interactive bulk generation where a person is watching a long job progress.
- A one-off where the value of the output dwarfs the API bill.
If the API bill for the run is a rounding error against the value of finishing on time, 6× is cheap. If the run's cost is a line item anyone would notice, 6× needs a deadline to justify it. It is also a poor fit for anything you will run again tomorrow, because a repeat run pays the whole premium again.
When it is pure waste
Most of the time Ultrafast is the wrong answer, and the alternatives are much cheaper.
- If nobody is waiting, Batch is 0.5× — twelve times cheaper than Ultrafast's 6×.
- If the job is retryable and non-critical, Flex is also 0.5×.
- If a person is waiting but the wait is short, Fast at 2× is a third of the Ultrafast rate.
- If the workload needs EU residency and you are on Astra, Ultrafast is unavailable; Sol Ultrafast is the only route.
Ultrafast and Batch are twelve times apart on the same model. Before paying for speed, check whether the job actually needed to finish today.
The first line of that list settles most debates. If the run can happen overnight, Ultrafast is not a speed purchase. It is twelve times the money for a result nobody was going to read until morning.
Ultrafast and caching together
Caching still helps on Ultrafast, in proportion. On Astra a cache read is $6.00 per million against $60.00 for uncached input, a tenth of the rate. On Sol it is $0.60 against $12.00, a twentieth. On a workload with a large stable prefix, caching removes most of the input cost before the 6× has anything to multiply.
Take the Astra run with a 3,000-token stable prefix inside each 4,000-token input. Sent uncached across 10,000 requests, that is 30 million prefix tokens at $60.00 per million, or $1,800. Cached, the prefix is written once at $75.00 per million and read back at $6.00 per million, so most of that $1,800 disappears. The speed premium is real, but it does not have to land on tokens you have already paid to cache.
Ultrafast above 272K input
OpenAI re-prices a whole GPT-6 request once its input crosses 272,000 tokens: input and cached input double and output rises by half. OpenAI's pages do not say how that long-context band combines with the Ultrafast multiplier. The calculator multiplies the two together, which is the conservative reading, and the methodology page lists this as an assumption. If you are planning a long-context Ultrafast run, confirm the rate on your own usage report before you budget it.
Alternatives to paying 6×
Before paying six times the rate, check whether the wall-clock problem can be solved another way.
- Run the job on Batch overnight. Twelve times cheaper, and often fast enough once the deadline stops being same-day.
- Split the work across more parallel requests. Concurrency at Standard rates can beat one faster stream, within your rate limits.
- Use Sol for the bulk and reserve Astra for the hard cases.
- Shorten the output. Generation is the slow part on long answers, and a tighter output cap shortens the run.
The short version
- Ultrafast is 6× the Standard rate on input, cache read, cache write and output together.
- It is offered on GPT-6.1 Sol (since 8 October 2026) and GPT-6 Astra.
- Sol Ultrafast supports EU data residency; Astra Ultrafast does not.
- A 10,000-request bulk run costs $280 → $1,680 on Sol and $1,400 → $8,400 on Astra.
- OpenAI publishes no speed multiple. Measure your own and price the decision as cost per hour saved.
- Batch is twelve times cheaper, so Ultrafast is only rational when a real deadline is binding.
Frequently asked
Which models support Ultrafast?
GPT-6.1 Sol and GPT-6 Astra. Astra had it first; Sol Ultrafast became available to all API users on 8 October 2026. The other models on the current price list do not offer the tier.
What does the 6x multiplier apply to?
All four figures: input, cache read, cache write and output. On GPT-6.1 Sol that moves input from $2.00 to $12.00 per million tokens and output from $10.00 to $60.00. On GPT-6 Astra input goes from $10.00 to $60.00 and output from $50.00 to $300.00.
How much faster is Ultrafast?
OpenAI describes it as its fastest service tier but does not publish a speed multiple. Measure the wall-clock time of a sample of your own requests on both tiers before you put a number on it.
Does Ultrafast support EU data residency?
On GPT-6.1 Sol, yes: OpenAI lists US and EU data residency as well as global processing. On GPT-6 Astra, only US data residency and global processing are supported, so an EU residency requirement rules Astra Ultrafast out.
Is Ultrafast ever cheaper than Batch?
No. Batch is 0.5x the Standard rate and Ultrafast is 6x, a factor of twelve apart on the same model. Ultrafast is a latency purchase, never a saving.