Claude Fast Mode — Opus at 2.5x Speed Explained

Claude fast mode is a research preview that serves the same Opus model at up to 2.5× higher output tokens per second — for premium pricing. It is not a different model, not a distilled variant, and not smarter or dumber: identical weights, faster inference configuration, bigger bill. This guide covers where fast mode works, how to enable it in Claude Code and the API, what it costs, and the rate-limit fallback pattern you should build before you need it.

TL;DR:

• Fast mode runs Claude Opus at up to 2.5× output tokens per second — same model, same intelligence, faster serving.

• It works on Opus 4.8 at $10/$50 per MTok (2× standard Opus pricing); on Opus 4.7 it is deprecated.

• Enable it with /fast in Claude Code, or on the API via the beta Messages endpoint with betas: ["fast-mode-2026-02-01"] and top-level speed: "fast".

• Fast mode has its own separate rate limit; on 429, retry without speed to fall back to standard — but expect a prompt-cache miss.

• Not available with the Batch API, Priority Tier, or third-party clouds (Bedrock, Google Cloud, Microsoft Foundry).

What Claude fast mode actually is

Fast mode is a serving-level option, currently in research preview on the Claude API. When you request speed: "fast", Anthropic runs your request on a faster inference configuration of the same Opus model. The gains are concentrated in output tokens per second (OTPS) — how quickly generated text streams back — not in time to first token. That distinction matters: fast mode shines on long generated outputs (agent transcripts, large code files, long documents), and does much less for short, snappy exchanges where first-token latency dominates.

Because it is a research preview, access is gated: organizations request it through their Anthropic account manager or a waitlist. The response’s usage.speed field (“fast” or “standard”) tells you which configuration actually served each request — worth logging from day one.

Which models support fast mode

Fast mode works on Claude Opus 4.8 (claude-opus-4-8) — and that is effectively the whole list now. It launched with Opus 4.8 on May 28, 2026, priced at $10/$50 per MTok, three times cheaper than the $30/$150 it cost on Opus 4.7.

Update, late June 2026: Anthropic has deprecated fast mode on Opus 4.7 (as of June 25), with removal scheduled for July 24, 2026 — after that, 4.7 requests with speed: "fast" return an error rather than falling back. The model itself stays available at standard speed. If you are on fast 4.7, migrate to 4.8 now: you get a better model and a 3× price cut in the same change. Sending speed: "fast" to any non-Opus model returns an error. For the rest of the year’s model shuffle, our Claude AI news roundup keeps the timeline straight.

How to enable Claude fast mode

In Claude Code: /fast

In Claude Code, fast mode is a toggle: type /fast to switch it on for the session, and /fast again to switch it off. It applies when you are running an Opus 4.8 session and bills at fast-mode rates for as long as it is enabled. The subjective difference is real — long agentic edits stream back at a pace that keeps you reading instead of waiting — and so is the bill, so treat it as a per-session decision rather than a default.

On the API: beta flag plus speed parameter

On the API, fast mode takes two things: the fast-mode-2026-02-01 beta flag and a top-level speed: "fast" parameter on the Messages request. With cURL, the beta goes in the anthropic-beta header:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "anthropic-beta: fast-mode-2026-02-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-4-8",
    "max_tokens": 4096,
    "speed": "fast",
    "messages": [
      {"role": "user", "content": "Refactor this module to use dependency injection"}
    ]
  }'

In the SDKs, use the beta Messages namespace and pass the flag via betas:

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    speed="fast",
    betas=["fast-mode-2026-02-01"],
    messages=[{"role": "user", "content": "Refactor this module"}],
)

print(response.usage.speed)  # "fast" or "standard"

Fast mode pairs naturally with streaming, which is where the OTPS gain is most visible. If you are new to the Messages API itself, start with our complete Claude API guide and layer fast mode on afterwards.

Fast mode pricing: $10/$50 per MTok

Configuration	Input / MTok	Output / MTok	Output speed
Opus 4.8, standard	$5	$25	Baseline
Opus 4.8, fast mode	$10	$50	Up to 2.5× OTPS
Opus 4.7, fast mode (deprecated)	$30	$150	Up to 2.5× OTPS

Fast Opus 4.8 costs exactly double standard Opus, applied across the full 1M-token context window — including requests past 200K input tokens. Pricing modifiers stack: prompt-caching multipliers apply on top of fast-mode rates, so cached reads stay cheap even in fast mode. For how these multipliers interact across the lineup, see our Claude API pricing breakdown. Full details live in Anthropic’s fast mode documentation.

Rate limits and the 429 fallback pattern

Fast mode has a dedicated rate limit, separate from your standard Opus limits, tracked via its own response headers (anthropic-fast-input-tokens-remaining and friends). When you exceed it, the API returns a 429 with a retry-after header — fast mode does not silently degrade to standard speed on supported models; you get the error instead. The SDKs retry automatically (twice by default), and because fast-mode capacity replenishes continuously, the wait is usually short.

If waiting is worse than slowing down, build the fallback yourself: set max_retries to 0 on the fast request, catch the rate-limit error, and reissue the request without speed: "fast":

try:
    response = client.with_options(max_retries=0).beta.messages.create(
        model="claude-opus-4-8",
        max_tokens=4096,
        speed="fast",
        betas=["fast-mode-2026-02-01"],
        messages=messages,
    )
except anthropic.RateLimitError:
    # Fast-mode capacity exhausted: fall back to standard speed
    response = client.beta.messages.create(
        model="claude-opus-4-8",
        max_tokens=4096,
        betas=["fast-mode-2026-02-01"],
        messages=messages,
    )

One caveat that will bite cache-heavy workloads: requests at different speeds do not share cached prefixes, so falling back from fast to standard is a guaranteed prompt-cache miss. A fallback request re-pays full input price on a prompt you thought was cached — factor that into the economics if your prompts carry large cached system contexts. For the broader mechanics of limits, tiers, and retry-after handling, see our guide to Claude API rate limits.

Where fast mode is not available

• Batch API: not supported — which is logical, since batch is the “cheaper and slower” lane and fast mode is the opposite trade.
• Third-party platforms: fast mode is Claude API only. It is not available on Amazon Bedrock, Google Cloud, or Microsoft Foundry.
• Priority Tier: not compatible with Priority Tier commitments.
• Non-Opus models: Sonnet and Haiku requests with speed: "fast" return an error — they are already the fast lane, economically speaking.

When is fast mode worth paying double for?

The question is never “is 2.5× faster nice?” — it is “is faster output worth 2× per token here?” After a few weeks of using it in real work, my rule of thumb:

• Worth it: interactive agent sessions where a human is watching the stream (Claude Code on a deadline, live debugging), user-facing products where response speed is a feature you charge for, and long single-shot generations that block a pipeline.
• Not worth it: anything asynchronous. Overnight agent runs, evaluation sweeps, and bulk processing do not care about OTPS — that work belongs at standard speed or in the Batch API at a discount, not at a premium.
• Borderline: short-turn chat. Fast mode does little for time to first token, so a chatbot with 100-token replies barely feels different while costing double.

A sanity check that keeps me honest: if nobody is watching the tokens arrive, standard speed is almost always the right call. And remember the pillar rule of API cost control generally — model choice and caching move your bill far more than serving speed does.

FAQ

Bottom line

Claude fast mode is a clean, honest trade: the same Opus 4.8 intelligence, up to 2.5× the output speed, exactly double the price. Enable it where a human or a paying user is watching tokens arrive; skip it everywhere else; and ship the 429 fallback before your first rate-limit surprise, keeping the cache-miss caveat in mind. If you are still weighing which Opus generation to run it on, our Claude Opus 4.8 release coverage makes that decision short.