How to Use GPT-6.1 Sol Ultrafast Mode in the OpenAI Responses API (2026)

Introduction

A coding assistant that pauses mid-answer, or an agent that stalls between tool calls, feels broken even when the final output is correct. OpenAI added Ultrafast mode for GPT-6.1 Sol on October 8, 2026, as a per-request speed tier for exactly that problem. This tutorial shows how to turn it on in the Responses API, when the premium is worth paying, and how to avoid the three expensive mistakes teams make with it: paying for speed on background work, hitting a separate rate limit, and losing the latency gain to connection overhead.

Quick answer

Set model="gpt-6.1-sol" and service_tier="ultrafast" on a Responses API request. Use it only where a person or process is actively waiting, and use a persistent WebSocket connection for tool-heavy agents.

Evidence

OpenAI describes the tier in one sentence that frames the whole decision: “Ultrafast mode is the fastest service tier in the OpenAI API. It is broadly available for GPT-6 Astra and GPT-6.1 Sol. Use it when speed justifies the higher cost.” The official Ultrafast mode guide adds the second key warning: “We strongly recommend WebSockets, especially for agentic applications that make many tool calls in quick succession. Without a persistent connection, network overhead can reduce the latency gains.”

The price premium is steep and exact. As of October 2026, the official OpenAI API pricing page lists GPT-6.1 Sol Standard at $2.00 per million input tokens and $10.00 per million output tokens. Ultrafast is $12.00 input and $60.00 output per million tokens, with $0.60 cached input and $15.00 cache writes, which is six times Standard across the board. A request with one million input tokens and 250,000 output tokens costs $4.50 on Standard and $27.00 on Ultrafast, so the tier decision is worth about $22.50 per million-token-scale request.

Rate limits are a separate budget, not a shared one. The Ultrafast guide publishes default Ultrafast token-per-minute limits for GPT-6.1 Sol of 1,000,000 for Build tier organizations, 4,000,000 for Launch, and 40,000,000 for Grow. Ultrafast “has separate rate limits from Standard and Fast modes,” so a workflow that is healthy on Standard can still be throttled on Ultrafast. Check your organization’s limits before moving traffic, and contact your account team if you need higher ones.

Prerequisites

• An OpenAI API key with access to GPT-6.1 Sol. Ultrafast in the Responses API is available to all API users, subject to rate limits.
• Python 3.10 or later, with the OpenAI Python SDK installed. The WebSocket example needs the realtime extra.
• A way to watch spend: the OpenAI usage dashboard, or a wrapper that logs input and output tokens per request.
• A workload where latency matters: an interactive coding assistant, a voice-adjacent interface, a customer-facing agent, or an agent chain with many sequential tool calls.

Step-by-step guide

Step 1: Install the SDK with WebSocket support

The HTTP example works with the base SDK, but the agent example in Step 3 needs the realtime extra, so install it once:

pip install --upgrade "openai[realtime]"
export OPENAI_API_KEY="sk-your-key-here"

Keep the key in an environment variable or a secrets manager, never in source code.

Step 2: Send a one-shot Ultrafast request over HTTP

Enabling Ultrafast is a one-line change to a normal Responses API call. This is the exact pattern from the official guide, switched to GPT-6.1 Sol:

from openai import OpenAI

client = OpenAI()
response = client.responses.create(
    model="gpt-6.1-sol",
    input="Give a one-line status update: deployment succeeded, no errors.",
    service_tier="ultrafast",
)
print(response.output_text)

Two things matter here. First, service_tier is set per request, not per account, so the same client can send Standard requests and Ultrafast requests side by side. Second, nothing else about the call changes: same model, same input format, same response object. If you remove the service_tier argument, the request falls back to Standard pricing and Standard rate limits.

Step 3: Use a persistent WebSocket connection for agents

For an agent that makes many tool calls in quick succession, open one connection and reuse it across turns. This is the official pattern, adapted to GPT-6.1 Sol, with previous_response_id chaining each turn to the last:

from openai import OpenAI

client = OpenAI()
previous_response_id = 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.1-sol",
            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.")

The loop prints each token as it arrives, which is the behavior users actually feel: time to first token, then a steady stream. Reusing the connection also removes the per-request handshake overhead that would otherwise blunt the tier’s advantage. To display output as it arrives over plain HTTP instead, enable streaming on the HTTP call, but prefer the WebSocket form for multi-turn agents.

Step 4: Route each request to the cheapest tier that fits

Do not flip your whole application to Ultrafast. Put the tier choice in one helper, and call it with intent, not habit:

def choose_tier(user_is_waiting: bool, tool_calls_expected: int) -> str:
    if user_is_waiting or tool_calls_expected >= 3:
        return "ultrafast"
    return "standard"

tier = choose_tier(user_is_waiting=True, tool_calls_expected=5)
response = client.responses.create(
    model="gpt-6.1-sol",
    input="Summarize this pull request for the reviewer waiting in chat.",
    service_tier=tier,
)

A practical split: interactive chat, live review, and multi-tool agent loops go to Ultrafast; nightly reports, batch enrichment, document pipelines, and retries go to Standard or Batch. The 6x multiplier makes a careless default expensive fast. At the Step 2 scale, 1,000 background requests at one million input tokens and 250,000 output tokens each would cost $4,500 on Standard and $27,000 on Ultrafast.

Step 5: Verify limits and spend before scaling traffic

Before moving a production workload, confirm two numbers in your own account:

1. Your organization’s Ultrafast tokens-per-minute limit, on the limits page of the API dashboard. Compare it against the published defaults (Build 1,000,000, Launch 4,000,000, Grow 40,000,000 TPM for GPT-6.1 Sol) and against your peak traffic, not your average.
2. The cost of one representative request, from the usage dashboard, after running Steps 2 and 3 once. Confirm the $12/$60 Ultrafast rate appears, not the $2/$10 Standard rate, so a silent fallback cannot hide in your bill.

If you need more Ultrafast headroom and you work with an OpenAI account team, ask them directly; the guide points organizations with an account team at that route rather than at a self-serve form.

Step 6: Handle data residency explicitly

If your workload must stay in the EU, GPT-6.1 Sol is the right model for Ultrafast: it supports US and EU data residency plus global processing, including in Fast and Ultrafast modes. GPT-6 Astra Ultrafast supports US data residency and global processing only. Choose the model after the residency requirement, not before, and test one EU-residency request end to end before committing a pipeline to it. Regional processing endpoints carry a 10% uplift for models released on or after March 5, 2026, so budget that on top of the Ultrafast rate when residency applies.

Troubleshooting

429 errors on Ultrafast while Standard requests succeed

This is the most confusing failure, and it is by design. Ultrafast has separate rate limits from Standard and Fast, so Standard headroom says nothing about Ultrafast headroom. Fix it by checking your Ultrafast TPM limit, adding a retry with backoff that falls back to Fast or Standard for non-urgent requests, and requesting a higher limit through your account team if the workload genuinely needs it. Do not hammer the endpoint: a retry storm on a throttled tier burns budget without moving work.

Latency barely improves after enabling Ultrafast

If the tier flag is set but the user experience is unchanged, the bottleneck is usually connection overhead, not the model. Switch tool-heavy, multi-turn flows to the WebSocket pattern in Step 3, and keep the connection open across turns instead of reconnecting per request. Also check that you are measuring the right metric: Ultrafast reduces the time between generated output tokens and time to first token, not the model’s reasoning time, so a long chain-of-thought task will still take a while end to end.

The bill jumps 6x after a deploy

A single flipped default can do this overnight. Audit for service_tier="ultrafast" in your codebase and confirm every call site passes through the Step 4 helper or an equivalent gate. Watch for two quiet multipliers: very long-context requests, which fall into a higher Ultrafast rate band on the published rate card, and regional processing endpoints, which add a 10% uplift. Set a spend alert at the level of one day of expected Ultrafast traffic, not one month, so a bad deploy surfaces within hours.

EU residency requests fail or route unexpectedly

If an EU-residency workload behaves oddly on Ultrafast, check the model first. GPT-6 Astra Ultrafast does not support EU residency, while GPT-6.1 Sol does. Switching the model to gpt-6.1-sol with the same service_tier="ultrafast" flag is the fix, and it keeps the speed tier intact. If the requirement is strict, confirm the residency behavior on one request before scaling, rather than assuming the flag alone guarantees routing.

FAQ

The FAQ front matter at the top of this page covers the most common questions. The short version: Ultrafast is a per-request speed flag, not a different model; it costs six times Standard; it is available to all API users subject to its own rate limits; WebSockets are the right transport for agents; and GPT-6.1 Sol, not Astra, is the choice for EU data residency.

Conclusion

Ultrafast mode earns its premium in exactly one situation: a person or another process is waiting, and every token of delay costs something real. Enable it with one argument, service_tier="ultrafast", route it through a helper that defaults to Standard, run agents over a persistent WebSocket connection, and verify your separate Ultrafast rate limit before production traffic arrives. Used that way, it turns a sluggish agent into a responsive one without turning the monthly bill into a surprise.

For the next step, read our guide to building agents on the same API family in OpenAI Agents API tutorial, and if your automations live in n8n rather than raw API calls, the complete n8n guide covers the workflow side of the same latency problem.

Frequently asked questions