GPT-6.1 Sol Ultrafast Mode: Responses API Latency and Pricing

Learn how the 2026-10-08 Ultrafast mode release for GPT-6.1 Sol works in the Responses API, including WebSocket setup, rate limits, and pricing tiers.

By ailog · Published Oct 12, 2026 · 5 min read · How we work
In short
  • OpenAI introduced Ultrafast mode for gpt-6.1-sol in the Responses API on 2026-10-08 to reduce output token generation latency.
  • Ultrafast mode costs 6x Standard pricing, charging $12.00 input and $60.00 output per 1M tokens for short context.
  • Persistent WebSocket connections are recommended over HTTP to prevent network overhead from eroding token throughput speedups.
  • Default rate limits provide 1,000,000 TPM for Build tier, scaling to 4,000,000 TPM for Launch and 40,000,000 TPM for Grow.
  • Data residency covers US and EU regions alongside global processing, with regional endpoints subject to a 10% premium.

OpenAI Releases Ultrafast Mode for GPT-6.1 Sol

On 2026-10-08, OpenAI expanded its fastest service tier by introducing Ultrafast mode for gpt-6.1-sol in the Responses API (v1/responses). Prior to this update, Ultrafast throughput was accessible on gpt-6-astra. By extending this tier to gpt-6.1-sol, developers can now pair near-Astra reasoning capabilities with minimized generation delay between sequential output tokens. The feature is open to all API usage tiers, governed by dedicated Ultrafast token allocations.

The release is configured directly within request parameters using service_tier: "ultrafast". This mode specifically targets the interval separating generated output tokens rather than model reasoning depth. Teams deploying interactive coding assistants, UI-driven generative workflows, and chained tool loops can access this capability while retaining standard gpt-6.1-sol operational bounds, such as a 1,050,000 token context window and knowledge cutoff of Apr 30, 2026.

Connection Protocols: WebSockets Versus HTTP Transport

Although the Responses API allows Ultrafast execution across standard HTTP requests, official guidance strongly advises using persistent WebSocket sessions. When agentic routines execute rapid sequences of automated tools, standard HTTP handshakes add connection latency that negates the mechanical output gains delivered by the Ultrafast infrastructure. Reusing a single WebSocket connection across conversational turns ensures intermediate tokens stream without connection setup penalties.

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.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.")

Developers electing to send standard HTTP requests may continue using standard client calls with the Responses API, passing service_tier: "ultrafast" alongside the chosen model identifier. Detailed protocol event architectures for handling streamed payloads can be reviewed in streaming response schemas.

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

Pricing Multipliers and Context Thresholds

Ultrafast mode carries a cost multiplier of 6x relative to Standard service rates. For gpt-6.1-sol, short context is defined as prompts containing less than or equal to 272K input tokens. When input lengths cross this 272K threshold, long context pricing applies at double the baseline input and cache rates, alongside a 1.5x multiplier on output tokens.

Context Tier Input (1M tokens) Cached Input (1M tokens) Cache Writes (1M tokens) Output (1M tokens)
Standard Short (<=272K) $2.00 $0.10 $2.50 $10.00
Standard Long (>272K) $4.00 $0.20 $5.00 $15.00
Ultrafast Short (<=272K) $12.00 $0.60 $15.00 $60.00
Ultrafast Long (>272K) $24.00 $1.20 $30.00 $90.00

Within the Standard tier, cached inputs are billed at 5% of uncached input costs, and cache writes incur a 1.25x fee over uncached inputs. These proportional structures carry into Ultrafast pricing. If regional processing endpoints are specified for compliance, OpenAI adds a 10% premium over base token prices. For interactive budgetary evaluation across production workloads, consult the LLM API cost calculator and review the updated model pricing catalog.

Throughput and Rate Limit Allocations

Rate limits for Ultrafast execution are maintained separately from an organization’s existing Standard and Fast quotas. This design isolates rapid interactive traffic from lower-priority batch operations, ensuring spikes in background queues do not throttle latency-sensitive customer sessions.

Model Usage Tier Ultrafast TPM Standard TPM
gpt-6.1-sol Build 1,000,000 1,000,000
gpt-6.1-sol Launch 4,000,000 4,000,000
gpt-6.1-sol Grow 40,000,000 40,000,000
gpt-6-astra Build 500,000 -
gpt-6-astra Launch 1,000,000 -
gpt-6-astra Grow 5,000,000 -

As outlined above, gpt-6.1-sol provides notably higher default Ultrafast throughput caps than gpt-6-astra. Under the Grow tier, gpt-6.1-sol supports 40,000,000 tokens per minute (TPM), compared to 5,000,000 TPM for gpt-6-astra. For standard operations, requests per minute limits scale from 5,000 RPM in Build, to 10,000 RPM in Launch, and 15,000 RPM in Grow.

Architectural Boundaries and Implementation Constraints

While gpt-6.1-sol supports extensive tooling and reasoning controls, several operational boundaries apply when moving to production:

  • Endpoint constraints: Ultrafast mode is supported exclusively via the Responses API (v1/responses). It cannot be enabled through the legacy Completions endpoint or Chat Completions (v1/chat/completions).
  • Reasoning configuration: reasoning.effort supports low, medium (default), high, xhigh, and max. Settings for none and minimal are unsupported.
  • Tool support: Tool calling requires the Responses API. Supported tools include web_search, file_search, code_interpreter, hosted_shell, computer_use, apply_patch, skills, mcp, and tool_search.
  • Token context bounds: Context window is capped at 1,050,000 tokens, with a maximum of 922,000 input tokens and 128,000 max output tokens.
  • Data residency: GPT-6.1 Sol supports US and EU data residency and global processing, differing from GPT-6 Astra Ultrafast which supports US residency and global processing only.
  • Unsupported capabilities: Fine-tuning and predicted outputs are not supported on gpt-6.1-sol.

Workflows requiring specialized tool calls or external context integration should review multi-provider function calling conventions to align parameter schemas effectively.

Production Migration Checklist

Before migrating standard gpt-6.1-sol traffic to Ultrafast mode, verify the following configuration requirements:

  • Target the Responses endpoint: Verify all request routing directs to v1/responses rather than v1/chat/completions.
  • Configure service tier: Set service_tier: "ultrafast" alongside model: "gpt-6.1-sol" in request payloads.
  • Implement connection pooling: Establish persistent WebSocket connections for interactive, multi-turn agent sessions using previous_response_id chaining.
  • Evaluate token expense: Confirm that application throughput justifies the 6x expense over Standard tier pricing.
  • Inspect token rate limits: Check organizational usage tier limits against required concurrency (1,000,000 TPM Build, 4,000,000 TPM Launch, or 40,000,000 TPM Grow).
  • Validate compliance routing: If utilizing EU or US regional residency endpoints, incorporate the 10% premium into cost tracking.
Sources
  1. OpenAI API changelog — 2026-10-08
  2. Ultrafast mode
  3. GPT-6.1 Sol
  4. Pricing

Related