GPT Fast Mode Explained: What OpenAI Fast Mode Is, 2× Price, and When It's Worth It

TL;DR

• OpenAI Fast mode is a paid speed tier, formerly called Priority processing (renamed July 30, 2026): up to 2.5× faster on gpt-5.6-sol and steadier latency, with the same model and the same output quality.
• It costs 2× the Standard token rate. OpenAI list price for GPT-5.6 Sol: $8 / $40 per million input / output tokens in Fast mode vs $4 / $20 Standard (promotional, at least through November 21, 2026); GPT-6 Astra Fast is $20 / $100.
• Turn it on with service_tier: "fast" (the old "priority" still works) on the Responses or Chat Completions API, or /fast in Codex CLI. It pays off when a person waits on every response; skip it for batch jobs.
• On Moyi API, Fast mode works on gpt-5.6-sol, gpt-5.6-terra and gpt-6-astra, billed at 2× the Standard list price with your discount unchanged. Get an API key.

Quick Answer

GPT 5.6 Sol Fast mode is OpenAI's paid latency upgrade for its flagship model. For twice the price, requests tagged service_tier: "fast" run at up to 2.5x the speed of Standard processing, with no change in output intelligence. OpenAI renamed its "Priority Processing" offering to Fast mode on July 30, 2026, but the API is fully backward compatible — the legacy value "priority" still works. You can enable it per-request, or set it as a project default. If you use GPT 5.6 Sol through a gateway like Moyi API, Fast mode is available with the same one-key setup.

What Actually Changed on July 30, 2026

OpenAI quietly retired the "Priority processing" brand and replaced it with Fast mode. Same underlying mechanism, new name, better pricing clarity. The core promise:

• Up to 2.5x faster than Standard for gpt-5.6-sol
• 2x the Standard price ($8 / $40 vs $4 / $20 per million tokens for GPT-5.6 Sol at OpenAI list price)
• Zero intelligence change — this is purely a speed/consistency upgrade. Same model, same outputs, less latency.

On service levels, OpenAI's Fast mode guide says Fast mode for GPT-5.6 and earlier models gets the same SLA treatment as Scale Tier (eligible Enterprise agreements may provide service credits when latency targets are missed), while Fast mode for GPT-6 Astra has no latency SLA. For GPT-6 Astra and GPT-6.1 Sol there is also a faster and pricier Ultrafast mode.

For interactive tools — live coding assistants, agent loops where you wait on each step, chat UIs — steady latency is what decides whether a product feels instant or sluggish.

How to Enable Fast Mode

Fast mode is a per-request opt-in via the service_tier parameter. It works on both the Chat Completions API and the Responses API, and OpenAI lists Fast prices for the whole GPT-5.6 family (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna), the GPT-6 line and older GPT-5.x models. Fine-tuned models and embeddings are not supported.

curl

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer sk-your-key" \
  -H "content-type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "input": "Explain how Fast mode routing works, briefly.",
    "service_tier": "fast"
  }'

Python (openai SDK)

from openai import OpenAI

client = OpenAI(api_key="sk-your-key")

resp = client.responses.create(
    model="gpt-5.6-sol",
    input="Summarize the three most important trade-offs of Fast mode.",
    service_tier="fast",
)
print(resp.output_text)

Node.js

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "sk-your-key" });

const resp = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "What latency does Fast mode target?",
  service_tier: "fast",
});
console.log(resp.output_text);

Setting a Project Default

If you want everything in a project to use Fast mode without touching every request, set the default service tier in the OpenAI Platform project settings. Every request from that project then carries Fast mode automatically (OpenAI moves the project over gradually), and you can still override per request by passing service_tier explicitly. This is an OpenAI project setting, so it doesn't apply when you call through a gateway.

The Legacy Value Still Works

OpenAI deliberately kept the old spelling alive. Requests tagged:

"service_tier": "priority"

are still accepted and route to the same Fast mode path. This matters if you have old integrations or third-party tools that hardcode "priority" — they keep working after the rename. Note that for GPT-5.6 and earlier models, the service_tier field in the response object may still echo back "priority" even when you sent "fast". That is expected and harmless.

How Fast Is It, Really?

OpenAI's claim is up to 2.5x Standard. In our own small set of streaming tests through Moyi API on July 31, 2026, Fast mode on gpt-5.6-sol was about 1.5x faster on average, with steadier time to first token — still substantial, but the 2.5x figure is a ceiling, not a guarantee. Realized speedup depends on:

• Request size. Long outputs benefit more, because output speed is the binding constraint.
• Queue depth. Fast mode buys you queue priority, so the benefit is largest when the Standard queue is congested.
• Server load. During peak times Fast mode holds the line; off-peak, Standard may already be fast.

The honest framing: you're not paying for a faster model, you're paying for consistently low latency under load. If your traffic is light and off-peak, you may not notice the difference — and you're paying 2x for nothing. If your product has interactive latency targets during business hours, Fast mode is how you hit them.

Pricing: What "2x" Means in Dollars

OpenAI's list price for GPT-5.6 Sol (short context; promotional pricing, available at least through November 21, 2026, per OpenAI's pricing page):

Cached input is $0.40 per million at Standard, and cached-input discounts still apply in Fast mode. Long-context Fast requests cost $16 / $60 per million input / output tokens. Fast mode bills tokens at exactly 2x the Standard rate, so a request that costs $1.00 at Standard costs $2.00 on Fast.

For the GPT-6 line, OpenAI's Fast prices are also 2x Standard: GPT-6 Astra $20 / $100, GPT-6.1 Sol $4 / $20, GPT-6.1 Terra $2 / $10 and GPT-6 Luna $0.20 / $1.00 per million input / output tokens.

At GPT-5.6 Sol's price tier, Fast mode is a significant premium. This is exactly why the cost-conscience routing question matters: you want Fast mode on the interactive path and Standard (or a cheaper model) everywhere else.

When Fast Mode Is Worth It

Pay for Fast mode when:

• A human is waiting on every request. Live coding assistants (Codex, IDE agents, terminal tools), chatbots, and pair-programming UIs. Latency is user experience.
• You run sequential agent loops. If each agent step waits on the previous one, latency compounds across the whole run. A 2x speedup on a 20-step agent is not 2x faster — it's potentially 5-10x faster wall-clock for the full task.
• You have latency targets to hit. On GPT-5.6, Fast mode gets the same SLA treatment as Scale Tier; on GPT-6 Astra it has no latency SLA.
• Traffic spikes are the norm. Fast mode protects interactive throughput when your users all hit at the same time.

Skip Fast mode when:

• You run batch jobs, evals, or offline generation. These are explicitly not the target use case. OpenAI can downgrade fast traffic that looks like batch (see the caveat below) and bill it at Standard.
• Cost is the binding constraint. At 2x, a high-volume background workload would rather use a cheaper model entirely — DeepSeek V4.1 Flash at an official $0.15 / $0.60 off-peak, for example, is more than 50x cheaper than GPT-5.6 Sol in Fast mode.
• You're already off-peak and latency is fine. Don't pay for priority you don't need.

The Downgrade Caveat You Need to Know

OpenAI reserves the right to downgrade Fast mode requests to Standard when traffic ramps too quickly. Specifically: if aggregate traffic climbs past 1M TPM with more than a 50% increase within 15 minutes, some Fast/Priority requests may be processed at Standard priority and billed at the Standard rate. The response will show service_tier: "default" so you can detect it programmatically.

This is an anti-batch-burst guard, not a penalty on legitimate interactive use. But if your product has viral moments that spike 2-3x in a quarter-hour, expect some of your "fast" requests to silently downgrade. Build for it: monitor the returned service_tier and alert when it flips to "default".

Codex and the "pi" Extensions

One of the most visible Fast mode use cases is OpenAI Codex. For ChatGPT-subscription (OAuth) users, third-party "pi" extensions (e.g., pi-openai-fast, pi-codex-fast) inject { "service_tier": "priority" } into eligible Codex request payloads, enabling Fast mode for gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna on ChatGPT-auth. Injection only triggers when the provider is openai-codex, the API is the Responses path, the model is a supported GPT-5.x variant, and the payload doesn't already carry service_tier.

If you're on API-key auth rather than ChatGPT OAuth, you don't need an extension — just pass service_tier yourself.

Using Fast Mode Through Moyi API

Moyi API's OpenAI-compatible endpoint takes the same parameter, so your code only changes the base URL and key:

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-key-here",
    base_url="https://api.moyi-api.com/v1",
)

resp = client.responses.create(
    model="gpt-5.6-sol",
    input="Write a Fast mode activation check for our agent pipeline.",
    service_tier="fast",
)
print(resp.output_text)

Same for Chat Completions:

resp = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Give me a one-line summary of Fast mode."}],
    service_tier="fast",
)
print(resp.choices[0].message.content)

How Fast mode behaves on Moyi API:

• Models. Fast mode works on gpt-5.6-sol, gpt-5.6-terra and gpt-6-astra (listed with "(fast)" in the model list). On other models the request runs and is billed at Standard.
• Values. Send service_tier: "fast" or "priority"; the gateway forwards it upstream as "priority". OpenAI project defaults don't apply, so set the tier on each request.
• Billing. A request processed in Fast mode is billed at 2x the Standard list price, and your account discount stays the same (see Billing). If the upstream processes a request at Standard speed, for example after a ramp-rate downgrade, it is billed at Standard.
• Codex. In Codex CLI, type /fast to toggle it for the session, or add service_tier = "fast" at the top of ~/.codex/config.toml to keep it on (see Codex setup).

You can also route GPT-5.6 Sol side by side with Claude, Gemini and DeepSeek under one key. That combination is what makes the "Fast mode for interactive, Standard or Flash for everything else" strategy practical: a router picks the tier per request instead of you editing code.

A Sane Routing Strategy

The most cost-effective pattern in 2026 is tiered, not all-Fast:

With one Moyi API key you pick the model and the service_tier on each request, so Fast mode only runs where a person is actually waiting. One integration, one bill.

Bottom Line

GPT 5.6 Sol Fast mode is a clean, well-priced answer to a real problem: interactive AI latency. It's not a smarter model — it's the same model with a priority lane and a 2x price tag. Use it where humans wait, skip it where they don't, and route the volume work to cheaper models. Through Moyi API the same service_tier values work on gpt-5.6-sol, gpt-5.6-terra and gpt-6-astra, billed at 2x the Standard list price with your discount unchanged — one key for the fast lane and the cheap lane alike.

FAQ

What is the difference between Priority and Fast mode?

Nothing functionally. OpenAI renamed "Priority processing" to "Fast mode" on July 30, 2026. Both map to the same service tier; the legacy value service_tier: "priority" is still accepted.

How much does Fast mode cost?

Exactly 2x the Standard token rate. At OpenAI list price, GPT-5.6 Sol is $4 / $20 per million input / output tokens at Standard (promotional, at least through November 21, 2026) and $8 / $40 in Fast mode; long-context Fast requests are $16 / $60. On Moyi API, Fast requests are billed at 2x the Standard list price with your discount unchanged.

Does Fast mode change output quality?

No. It is a latency/priority upgrade only — same model, same intelligence, same outputs.

Is Fast mode worth it for Codex?

For interactive coding where you wait on each agent step, yes — our own tests showed about 1.5x on average, and the benefit compounds across multi-step agent runs. For batch work, no. In Codex CLI, /fast toggles it.

Can I use Fast mode through Moyi API?

Yes, on gpt-5.6-sol, gpt-5.6-terra and gpt-6-astra. Pass service_tier: "fast" (or "priority") to Moyi API's OpenAI-compatible endpoint (https://api.moyi-api.com/v1); on other models the request runs and is billed at Standard.