OpenAI announced Ultrafast mode on 13 August 2026 with no price on any of its four pricing tables
Summary. OpenAI's API changelog entry for 13 August 2026 announced Ultrafast mode, "a new API service tier for GPT-5.6 Sol that runs up to 14x faster than Standard processing," in limited preview to select customers. As of 24 August 2026, eleven days later, the OpenAI API pricing page publishes four priced tiers for gpt-5.6-sol — Standard at $4.00 per 1M input and $20.00 per 1M output tokens, Batch and Flex at $2.00 and $10.00, and Fast mode at $8.00 and $40.00 — and contains zero occurrences of the string "ultrafast". The Fast mode guide, the Flex processing guide and the API documentation index contain zero occurrences of it too. The only published route is a marketing sign-up form. Meanwhile the tier that is documented carries a quantified trap: Fast mode requests are silently downgraded to Standard speed and Standard rates if a project sends at least 1 million tokens per minute and raises that by more than 50% within 15 minutes.
What was announced, and what was not
The changelog entry is one paragraph. Ultrafast mode is described as an API service tier for GPT-5.6 Sol, up to 14x faster than Standard processing, available in limited preview to select customers, with a link to a form at openai.com/form/ultrafast/ to receive updates.
Everything a team needs to evaluate it is absent. There is no service_tier value documented for it, no guide page, no entry in developers.openai.com/api/llms.txt, and no price. Searching the pricing page in its Markdown form for "ultrafast" returns nothing, on a page that otherwise itemises tier-by-tier token rates for every model.
That absence is the story, because the other four tiers are documented in detail and the gap between them is where the money is.
The four tiers that do have prices
Per 1M tokens, short context, for gpt-5.6-sol as published on 24 August 2026:
| Service tier | Input per 1M tokens | Output per 1M tokens |
|---|---|---|
| Standard | $4.00 | $20.00 |
| Batch | $2.00 | $10.00 |
| Flex | $2.00 | $10.00 |
| Fast mode | $8.00 | $40.00 |
| Ultrafast | not published | not published |
Long-context rates run higher across every tier: $8.00 and $30.00 at Standard, $16.00 and $60.00 at Fast mode. Cached input on Standard is $0.40 per 1M tokens against a $5.00 cache-write charge, which is the detail that decides whether prompt caching pays for itself. GPT-5.6 Sol's current rates are promotional and OpenAI states they hold "at least through November 21, 2026."
Fast mode is the tier Ultrafast would sit above, and its documentation quantifies the trade: "Fast mode delivers up to 2.5× faster speeds and more consistent latency while keeping pay-as-you-go flexibility." So the documented tier buys 2.5x speed for 2x price. Ultrafast claims 14x speed. There is no way to extrapolate a price from a single data point, and OpenAI has not supplied a second one.
The rename that the response object did not follow
Before pricing Ultrafast, most teams have an older problem to fix. Priority processing was renamed Fast mode on 30 July 2026. Both service_tier: "priority" and service_tier: "fast" are accepted in API requests and produce the same behaviour on supported models.
The response object did not follow. OpenAI's Fast mode guide states plainly: "For GPT-5.6 and earlier models, the response returns priority whether the request specifies priority or fast." The usage dashboard inherits the same behaviour — group by service tier and Fast mode requests "appear as priority even when you specify fast."
If you built cost attribution on the service_tier field in the response, or on the dashboard grouping, your reports label the tier by its old name regardless of what your code sends. That is not a billing error, but it will break a reconciliation script that matches request tier against response tier, and it will confuse anyone auditing spend against a migration ticket that says the codebase moved to fast.
The downgrade rule, with numbers
Fast mode's most expensive detail is the ramp limit, and it is stated precisely enough to design against.
If traffic ramps too quickly, OpenAI "may downgrade some Fast mode requests to standard speeds and charge standard rates." The downgraded response carries service_tier: "default". The published threshold: the ramp rate limit "may apply if you send at least 1 million tokens per minute (TPM) and increase TPM by more than 50% within 15 minutes."
Read that as an operational rule rather than a footnote. A product launch, a marketing send, or a batch of retries can move a busy project over 1M TPM and add 50% inside a quarter of an hour without anyone intending it. When that happens, latency reverts to Standard while you are still expecting Fast, and the requests that were downgraded bill at Standard rates rather than the $8.00 and $40.00 Fast rates.
| Behaviour | Value in the response object | What you are charged |
|---|---|---|
Request sent with service_tier: "fast", served fast |
priority on GPT-5.6 and earlier |
Fast rates, $8.00 / $40.00 |
Request sent with service_tier: "priority", served fast |
priority |
Fast rates, $8.00 / $40.00 |
| Fast request downgraded by the ramp limit | default |
Standard rates, $4.00 / $20.00 |
Request sent with service_tier: "flex"
|
flex | Batch rates, $2.00 / $10.00 |
| Project-level default set to Fast, no parameter sent |
priority on GPT-5.6 and earlier |
Fast rates, $8.00 / $40.00 |
Two more constraints that change capacity planning. Fast mode and Standard share the same rate limit for a given model, so moving to Fast buys speed, not headroom. And OpenAI's own guidance is to keep bulk work out of it: "Avoid running large extract, transform, and load (ETL) or batch jobs in Fast mode." Flex exists for that, priced at Batch rates with a longer timeout — the guide's own examples raise the client timeout to 15 minutes.
What to do before Ultrafast opens up
Instrument the tier before you buy a faster one. Three concrete steps.
Log the service_tier field from every response and alert on default, because that value is the only signal that a Fast request was downgraded. Without it, a latency regression looks like a model problem rather than a ramp-limit problem.
Second, decide what the 2.5x is worth on your traffic before evaluating a 14x claim. Fast mode doubles the token price for a documented 2.5x speed improvement. Measure your p95 on Standard first; if the tail is dominated by your own retrieval or tool calls rather than model time, no service tier fixes it.
Third, treat "limited preview to select customers" as a procurement signal, not a product. There is no price, no guide, no service_tier value and no SLA in public. Anything you design around Ultrafast today rests on a changelog paragraph and a form. Teams already routing across models and tiers will recognise the pattern from the hybrid LLM routing decision framework and from the GPT-5.6 Sol price cut and gateway fork, where the same tier metadata drives the routing rule.
The cheapest latency win on this pricing page is still caching, not a tier upgrade. Cached input at $0.40 against $4.00 Standard input is a 90% reduction on the cached portion, set against a $5.00 cache-write charge — the arithmetic we worked through in the prompt caching dashboard and cache-write cost analysis.
India-specific considerations
Indian teams have a second variable on top of the tier choice. OpenAI charges a 10% uplift on regional processing endpoints for models released on or after 5 March 2026 that are eligible for data residency. Stack that on Fast mode and the effective short-context rate for gpt-5.6-sol moves from $4.00 to $8.80 per 1M input tokens, before any Ultrafast premium that has not been published. That is 2.2x the Standard rate for the same tokens, decided by two settings rather than by a model change. Where a workload can tolerate asynchronous processing — model evaluations, enrichment jobs, overnight scoring — Flex at $2.00 and $10.00 is a quarter of Fast mode's rate for the same tokens, and the residency uplift applies to a much smaller bill.
What is still unknown
OpenAI has not published an Ultrafast price, a service_tier value, a rate-limit policy, a ramp-downgrade rule, or a model list beyond GPT-5.6 Sol. It has not said whether Ultrafast shares a rate limit with Standard the way Fast mode does, and it has not said whether the response object will return a new tier name or reuse an old one, which matters given that Fast mode still reports priority. Until a pricing row appears, the honest planning assumption is that Ultrafast does not have a price you can budget.
FAQ
What is OpenAI Ultrafast mode?
An API service tier announced in the OpenAI API changelog on 13 August 2026 for GPT-5.6 Sol, described as running up to 14x faster than Standard processing. It is available in limited preview to select customers, and the changelog links to a sign-up form rather than to documentation or a price.
How much does Ultrafast mode cost?
There is no published price. On 24 August 2026 the OpenAI API pricing page lists four priced tiers for GPT-5.6 Sol — Standard, Batch, Flex and Fast mode — and contains zero occurrences of the word "ultrafast". The Fast mode guide and the API documentation index do not mention it either.
What does Fast mode cost compared with Standard?
For gpt-5.6-sol short context, Fast mode is $8.00 per 1M input tokens and $40.00 per 1M output tokens, against $4.00 and $20.00 on Standard. That is double the token price, and OpenAI documents the benefit as up to 2.5x faster speeds with more consistent latency.
Why does my response say priority when I sent fast?
Priority processing was renamed Fast mode on 30 July 2026 and both parameter values are accepted. OpenAI's guide states that for GPT-5.6 and earlier models the response object returns priority whether the request specified priority or fast. The usage dashboard groups those requests the same way.
When does OpenAI downgrade a Fast mode request?
When traffic ramps too quickly. OpenAI states the ramp rate limit may apply if a project sends at least 1 million tokens per minute and increases that by more than 50% within 15 minutes. Downgraded requests return service_tier: "default", run at Standard speed and bill at Standard rates.
Does Fast mode give me extra rate limit headroom?
No. OpenAI documents that for a given model, Standard processing and Fast mode share the same rate limit, and that Fast mode consumption counts toward rate limits the same way Standard does. Fast mode buys latency, not capacity, so retry logic and backoff still apply unchanged.
Which tier should batch and evaluation jobs use?
Flex. It is priced at Batch API rates, $2.00 per 1M input and $10.00 per 1M output tokens for GPT-5.6 Sol, in exchange for slower responses and occasional resource unavailability. OpenAI's Fast mode guidance is explicit that large extract, transform and load or batch jobs should not run in Fast mode.
How does data residency change these numbers?
Regional processing endpoints carry a 10% uplift for models released on or after 5 March 2026 that are eligible for data residency. Applied to GPT-5.6 Sol Standard input, $4.00 becomes $4.40 per 1M tokens; applied to Fast mode input, $8.00 becomes $8.80. The uplift compounds with whichever tier you select.
How eCorpIT can help
Service-tier selection is a measurement problem: most teams pay a latency premium on traffic where the tail is dominated by retrieval rather than model time. Our engineers instrument service_tier on every response, alert on silent downgrades, and route workloads across Standard, Flex and Fast by request class as part of AI gateway and model-routing FinOps engagements. If your OpenAI bill moved this month and nobody changed the model, book an API spend review and we will start with your tier mix. Related reading: the 2026 frontier model comparison.
References
- OpenAI API changelog
- OpenAI API pricing
- Fast mode guide, OpenAI
- Flex processing guide, OpenAI
- Batch API guide, OpenAI
- OpenAI API documentation index, llms.txt
- GPT-5.6 Sol model page
- Your data guide, regional processing
- Prompt caching guide, OpenAI
- OpenAI API deprecations page
- Ultrafast mode updates form, OpenAI
- Responses API service_tier parameter reference
Last updated: 24 August 2026.
Top comments (0)