OpenAI Ultrafast: 6x the Speed at 6x the Price. When It Pays for Itself.

OpenAI Ultrafast is a service tier, not a new model. Add service_tier: "ultrafast" to a Responses API request for gpt-6-astra and OpenAI generates tokens up to 6x faster in the API (up to 8x, or 300 tokens per second, in Codex). It costs 6x Standard: $60 input and $300 output per million tokens, against $10 and $50. The model ID doesn’t change, so answers get faster, not smarter. It pays for itself when a person or a latency-bound step waits on long outputs, and almost never for batch or background work.

OpenAI made Ultrafast broadly available on GPT-6 Astra at DevDay on September 29, 2026 (see everything else from DevDay). This post covers availability, the request, prices, rate limits, and a break-even model you can rerun with your own numbers. For the model itself, read the GPT-6 Astra API guide. You’ll measure both tiers in Apidog before switching.

OpenAI Ultrafast at a glance

Sources: OpenAI’s Ultrafast mode guide and pricing page.

What Ultrafast is, and who can use it

OpenAI’s DevDay recap calls Ultrafast its premium speed tier. Per the guide, GPT-6 Astra Ultrafast is open to all API users at low default rate limits, and organizations with an OpenAI account team can ask for more. The guide also lists preview access for GPT-5.6 Sol through account teams (OpenAI first previewed Ultrafast on GPT-5.6 Sol on August 13), while the recap names GPT-6.1 Sol as next. Neither has a published Ultrafast price.

In ChatGPT, Ultrafast Astra runs in ChatGPT Work and Codex on Pro 500 and Enterprise. That subscription covers the apps, not the API: scripts, CI jobs and agents you build still pay per token with an API key.

Read the speed claim carefully. It’s about token generation, and it says “up to”. The 300 tokens per second figure is for Codex; the API claim is up to 6x. OpenAI doesn’t publish a time-to-first-token (TTFT) figure for Ultrafast, and a tokens-per-second number tells you nothing about how long you wait for the first token.

How to enable service_tier ultrafast

Set model to gpt-6-astra and service_tier to ultrafast on each request. Over HTTP, from OpenAI’s docs:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain why the sky is blue in one sentence.",
    "service_tier": "ultrafast"
  }'

OpenAI strongly recommends WebSockets, especially for agents that make many tool calls in quick succession, because per-request network overhead can eat the gain. Here’s the docs’ Python example, streaming two turns over one connection:

from openai import OpenAI

client = OpenAI()
previous_response_id: str | None = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6-astra",
            service_tier="ultrafast",
            previous_response_id=previous_response_id,
            input=prompt,
        )
        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("Connection closed before the response finished.")

Install with pip install --upgrade "openai[realtime]" and set OPENAI_API_KEY. Our OpenAI WebSocket mode guide covers connection limits and reconnects.

Ultrafast pricing next to Standard, Fast and Batch

Prices per 1M tokens for gpt-6-astra at short context (272K input tokens or fewer):

Above 272K input tokens, Ultrafast rises to $120 input, $12 cached, $150 cache write and $450 output. Fast is the former Priority processing, renamed on July 30, 2026. Note that every input column is multiplied too, so long prompts pay 6x on tokens the speed claim doesn’t target.

Rate limits and data residency

GPT-6 Astra’s default Ultrafast limits are 500,000 tokens per minute on usage Tiers 1-3, 1,000,000 on Tier 4, and 5,000,000 on Tier 5. Ultrafast supports US data residency and global processing only. If your contract routes traffic through an EU or other regional endpoint, Ultrafast isn’t available to that project.

When Ultrafast pays for itself: a break-even model

This is illustrative arithmetic on list prices, not a benchmark. The one speed input is a placeholder: assume your own measurement shows Standard Astra streaming 40 output tokens per second on your prompt. Swap in your number.

A user-facing answer: 5,000 uncached input tokens, 2,000 output tokens.

• Standard: $0.05 input + $0.10 output = $0.15.
• Ultrafast: $0.30 + $0.60 = $0.90, so $0.75 more.
• Generation time: 2,000 / 40 = 50 seconds at Standard, about 8.3 seconds at a full 6x. You save about 41.7 seconds.
• Cost per second saved: $0.75 / 41.7 = $0.018, or $64.80 per hour of waiting removed.

If your measured speedup lands below the ceiling, each saved second costs more:

An agent loop: 20 steps, each with 20,000 input tokens (18,000 cached, 2,000 new) and 500 output tokens, ignoring cache-write charges.

• Standard: $0.018 cached + $0.020 new input + $0.025 output = $0.063 a step, $1.26 a run.
• Ultrafast: $7.56 a run, so $6.30 more.
• Generation time: 250 seconds at Standard, about 41.7 at 6x. You save roughly 208 seconds.
• Cost per second saved: about $0.030, or $109 per hour.

The agent buys seconds at a worse rate because most of its bill is input, which gets the 6x price without the generation speedup. For output alone at a full 6x, each second saved costs about $0.0003 times your Standard output tokens per second; input only raises it.

So the question is concrete: is a person, or something with a dollar value, blocked for those seconds, and is that wait worth more than $65 to $110 an hour? An engineer blocked on your internal coding agent, or a customer staring at a spinner in a paid flow, can clear that bar. A cron job can’t.

Where Ultrafast doesn’t pay

• Nobody is waiting. Nightly evals, backfills and reports belong on the Batch API or Flex at $5 input and $25 output, a twelfth of the Ultrafast rate.
• Background agents. If an agent runs unattended and reports when done, finishing three minutes sooner rarely changes the outcome.
• Short outputs. A 50-token classification has little generation time to cut; connection setup and the wait for the first token dominate, especially over HTTP.
• Long prompts. Input-heavy calls pay 6x on tokens the speed claim doesn’t cover, and above 272K input the rates climb to $120 and $450.
• Regional processing. No EU endpoints.
• TTFT-bound calls. Our GPT-6 Sol latency analysis found that on long reasoning runs, most of the wall clock passed before the first visible token. If your latency lives there, measure whether Ultrafast shortens it before paying for it.

Measure TTFT and total time in Apidog before you switch

Replace the placeholder with your own numbers in about ten minutes.

1. Create an environment in Apidog with OPENAI_API_KEY. Add a POST request to https://api.openai.com/v1/responses with the header Authorization: Bearer {{OPENAI_API_KEY}} and this body:

{
  "model": "gpt-6-astra",
  "input": "<your real production prompt>",
  "service_tier": "ultrafast",
  "stream": true
}

2. Duplicate the request and remove service_tier for the Standard baseline. Keep the prompt identical.
3. Send both. Apidog renders the server-sent events stream event by event. Note when the first response.output_text.delta arrives (TTFT) and when the stream ends (total time), and keep the usage block from the final response.completed event for cost.
4. Repeat each variant at least 10 times and compare medians and p95, not single runs.
5. For agent loops, test the WebSocket path: open a WebSocket request in Apidog to wss://api.openai.com/v1/responses with the same header, send a response.create message with the same fields minus stream, then a second turn with previous_response_id. The WebSocket vs SSE comparison explains why the open connection matters.

Seconds saved is the median total time at Standard minus the median at Ultrafast. Price the usage tokens at both rates, divide, and compare the result with what the wait costs you.

FAQ

What is OpenAI Ultrafast? A Responses API service tier that generates tokens up to 6x faster in the API for 6x the Standard price. You turn it on per request with service_tier: "ultrafast".

Is Ultrafast a smarter model? No. You call the same gpt-6-astra model ID; the tier changes speed and price, not the model.

How much does GPT-6 Astra Ultrafast cost? $60 input, $6 cached input, $75 cache write and $300 output per 1M tokens at short context, against $10, $1, $12.50 and $50 on Standard.

Where does “300 tokens per second” come from? It’s OpenAI’s figure for Ultrafast in Codex, where it claims up to 8x. The API claim is up to 6x.

Does GPT-6.1 Sol support Ultrafast? Not yet. OpenAI says it’s coming soon; the DevDay 2026 roundup tracks what’s live.

Next step

Pick your slowest user-facing request, run it at Standard and Ultrafast ten times each, and set the median seconds saved against the extra cost. Download Apidog to keep both variants, their timings, and their usage numbers in one project.