fast-mode changedbuild-with-claude/fast-mode
Nearest release: v2.1.301, published 5 hours before this site recorded the change. Shown because the two are within 24 hours of each other. Nothing here says the release caused the edit.
Recorded here
Lines+56added
Lines−81removed
From line
1
where the diff opens
First seen
14 Aug 2026
this site's first read of the page
Recorded edits17to this page, all time
The whole hunk
from line 1, old and new numbered
/
from line 1
11---
2title: Fast mode (research preview)
2title: Fast mode
33url: https://platform.claude.com/docs/en/build-with-claude/fast-mode
4description: Get up to 2.5x higher output tokens per second from supported Claude Opus models.
4description: Get up to 2.5x higher output tokens per second from supported Claude models.
55---
66
7Fast mode delivers up to 2.5x higher output tokens per second from Claude Opus 5.5, Claude Opus 5, and Claude Opus 4.8 at premium pricing. Set `speed: "fast"` with the `fast-mode-2026-02-01` beta header on your request to opt in.
7Fast mode delivers up to 2.5x higher output tokens per second from Claude Opus 5.5, Claude Opus 5, and Claude Opus 4.8 at premium pricing. Set `speed: "fast"` on your request to opt in.
88
99<Note>
10 Fast mode is in research preview. Contact your account manager to request access. If you do not have an account manager, [join the waitlist](https://claude.com/fast-mode) for fast mode.
10 Fast mode for Claude Opus 5.5 doesn't need the `fast-mode-2026-02-01` beta header or an access request. Requests that still send the header keep working. Fast mode for Claude Opus 5 and Claude Opus 4.8 is in research preview: contact your account manager or [join the waitlist](https://claude.com/fast-mode) to request access, and send the [beta header](https://platform.claude.com/docs/en/api/beta-headers) on your requests.
1111</Note>
1212
1313<Note>
from line 23
2323* Claude Opus 4.8 (claude-opus-4-8)
2424
2525<Note>
26 Fast mode for Claude Opus 5.5, Claude Opus 5, and Claude Opus 4.8 is available as a research preview on the Claude API, including [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview), only. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud, or Microsoft Foundry.
26 Fast mode is available on the Claude API, including [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview), only. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud, or Microsoft Foundry.
2727</Note>
2828
2929<Note>
from line 31
3131</Note>
3232
3333<Note>
34 Fast mode is not available on Claude Opus 4.6. Requests to `claude-opus-4-6` with `speed: "fast"` do not return an error: they run at standard speed and are billed at [standard rates](https://platform.claude.com/docs/en/about-claude/pricing) rather than fast mode's premium rates, and the response reports [`usage.speed: "standard"`](https://platform.claude.com/docs/en/build-with-claude/fast-mode#checking-which-speed-was-used). To continue using fast mode, see [Migrating to Claude Opus 5.5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/models/opus-5-5/migration-guide#migrating-from-claude-opus-46).
34 Fast mode is not available on Claude Opus 4.6. Requests to `claude-opus-4-6` that set `speed` need the `fast-mode-2026-02-01` beta header; without it, they return a `400` error. With the header, requests with `speed: "fast"` run at standard speed and are billed at [standard rates](https://platform.claude.com/docs/en/about-claude/pricing) rather than fast mode's premium rates, and the response reports [`usage.speed: "standard"`](https://platform.claude.com/docs/en/build-with-claude/fast-mode#checking-which-speed-was-used). To continue using fast mode, see [Migrating to Claude Opus 5.5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/models/opus-5-5/migration-guide#migrating-from-claude-opus-46).
3535</Note>
3636
3737## How fast mode works
from line 45
4545
4646## Basic usage
4747
48Models in research preview also need the `fast-mode-2026-02-01` [beta header](https://platform.claude.com/docs/en/api/beta-headers).
49
4850<CodeGroup>
4951 ```bash cURL
5052 curl https://api.anthropic.com/v1/messages \
5153 -H "x-api-key: $ANTHROPIC_API_KEY" \
5254 -H "anthropic-version: 2023-06-01" \
53 -H "anthropic-beta: fast-mode-2026-02-01" \
5455 -H "content-type: application/json" \
5556 -d '{
5657 "model": "claude-opus-5-5",
from line 65
6465 ```
6566
6667 ```bash CLI
67 ant beta:messages create \
68 --beta fast-mode-2026-02-01 \
69 --transform 'content.#(type=="text").text' \
70 --raw-output <<'YAML'
68 ant messages create <<'YAML'
7169 model: claude-opus-5-5
7270 max_tokens: 4096
7371 speed: fast
from line 78
8078 ```python Python
8179 client = anthropic.Anthropic()
8280
83 response = client.beta.messages.create(
81 response = client.messages.create(
8482 model="claude-opus-5-5",
8583 max_tokens=4096,
8684 speed="fast",
87 betas=["fast-mode-2026-02-01"],
8885 messages=[
8986 {"role": "user", "content": "Refactor this module to use dependency injection"}
9087 ],
from line 95
9895 ```typescript TypeScript
9996 const client = new Anthropic();
10097
101 const response = await client.beta.messages.create({
98 const response = await client.messages.create({
10299 model: "claude-opus-5-5",
103100 max_tokens: 4096,
104101 speed: "fast",
105 betas: ["fast-mode-2026-02-01"],
106102 messages: [
107103 {
108104 role: "user",
from line 108
112108 });
113109
114110 const textBlock = response.content.find(
115 (block): block is Anthropic.Beta.Messages.BetaTextBlock => block.type === "text"
111 (block): block is Anthropic.TextBlock => block.type === "text"
116112 );
117113 console.log(textBlock?.text);
118114 ```
from line 116
120116 ```csharp C#
121117 AnthropicClient client = new();
122118
123 var response = await client.Beta.Messages.Create(new MessageCreateParams
119 var response = await client.Messages.Create(new MessageCreateParams
124120 {
125121 Model = "claude-opus-5-5",
126122 MaxTokens = 4096,
127123 Speed = Speed.Fast,
128 Betas = ["fast-mode-2026-02-01"],
129124 Messages = [
130125 new() { Role = Role.User, Content = "Refactor this module to use dependency injection" }
131126 ],
from line 138
143138 ```go Go
144139 client := anthropic.NewClient()
145140
146 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
141 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
147142 Model: anthropic.ModelClaudeOpus5_5,
148143 MaxTokens: 4096,
149 Speed: anthropic.BetaMessageNewParamsSpeedFast,
150 Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaFastMode2026_02_01},
151 Messages: []anthropic.BetaMessageParam{
152 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Refactor this module to use dependency injection")),
144 Speed: anthropic.MessageNewParamsSpeedFast,
145 Messages: []anthropic.MessageParam{
146 anthropic.NewUserMessage(anthropic.NewTextBlock("Refactor this module to use dependency injection")),
153147 },
154148 })
155149 if err != nil {
from line 150
156150 log.Fatal(err)
157151 }
158152 for _, block := range response.Content {
159 if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
153 if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
160154 fmt.Println(textBlock.Text)
161155 }
162156 }
from line 159
165159 ```java Java
166160 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
167161
168 BetaMessage response = client.beta().messages().create(
162 Message response = client.messages().create(
169163 MessageCreateParams.builder()
170164 .model(Model.CLAUDE_OPUS_5_5)
171165 .maxTokens(4096L)
172166 .speed(MessageCreateParams.Speed.FAST)
173 .addBeta(AnthropicBeta.FAST_MODE_2026_02_01)
174167 .addUserMessage("Refactor this module to use dependency injection")
175168 .build());
176169
from line 175
182175 ```php PHP
183176 $client = new Client();
184177
185 $response = $client->beta->messages->create(
178 $response = $client->messages->create(
186179 model: 'claude-opus-5-5',
187180 maxTokens: 4096,
188181 speed: 'fast',
189 betas: ['fast-mode-2026-02-01'],
190182 messages: [
191183 ['role' => 'user', 'content' => 'Refactor this module to use dependency injection'],
192184 ],
from line 194
202194 ```ruby Ruby
203195 client = Anthropic::Client.new
204196
205 response = client.beta.messages.create(
197 response = client.messages.create(
206198 model: "claude-opus-5-5",
207199 max_tokens: 4096,
208200 speed: "fast",
209 betas: ["fast-mode-2026-02-01"],
210201 messages: [{role: "user", content: "Refactor this module to use dependency injection"}]
211202 )
212203
from line 227
236227
237228Fast mode has a dedicated rate limit that is separate from standard Opus rate limits. When your fast mode rate limit is exceeded, the API returns a `429` error with a `retry-after` header indicating when capacity will be available.
238229
230Claude Opus 5.5 has a default fast mode rate limit in every [usage tier](https://platform.claude.com/docs/en/api/rate-limits), so you don't need to request access to use fast mode with it.
231
239232The response includes headers that indicate your fast mode rate limit status:
240233
241234| Header | Description |
from line 240
247240| `anthropic-fast-output-tokens-remaining` | Remaining fast mode output tokens |
248241| `anthropic-fast-output-tokens-reset` | Time when the fast mode output token limit resets |
249242
250For tier-specific rate limits, see the [Rate limits](https://platform.claude.com/docs/en/api/rate-limits) page.
243To see your fast mode rate limits, go to the [Rate limits](https://platform.claude.com/usage/limits) page in the Claude Console.
251244
252245## Checking which speed was used
253246
254The response `usage` object includes a `speed` field that indicates which speed was used, either `"fast"` or `"standard"`. Requesting `speed: "fast"` on a [model that doesn't support fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#supported-models) returns an error, and so does exceeding fast mode's rate limits or capacity (a `429` or `529`). When a request with `speed: "fast"` succeeds, `usage.speed` is `"fast"`. If you are using Claude Opus 4.6 and request fast mode, its behavior is unique. Instead of returning an error like other models that don't support fast mode, it silently switches to standard speed. Though there is no error with Opus 4.6, the `speed` field accurately shows `"standard"`.
247The response `usage` object includes a `speed` field that indicates which speed was used, either `"fast"` or `"standard"`. Requesting `speed: "fast"` on a [model that doesn't support fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#supported-models) returns an error, and so does exceeding fast mode's rate limits or capacity (a `429` or `529`). When a request with `speed: "fast"` succeeds, `usage.speed` is `"fast"`. Claude Opus 4.6 is an exception: a request with `speed: "fast"` and the `fast-mode-2026-02-01` beta header does not return an error but runs at standard speed, and `usage.speed` shows `"standard"`. Without the header, the request returns a `400` error.
255248
256249<CodeGroup>
257250 ```bash cURL
from line 251
258251 curl https://api.anthropic.com/v1/messages \
259252 -H "x-api-key: $ANTHROPIC_API_KEY" \
260253 -H "anthropic-version: 2023-06-01" \
261 -H "anthropic-beta: fast-mode-2026-02-01" \
262254 -H "content-type: application/json" \
263255 -d '{
264256 "model": "claude-opus-5-5",
from line 261
269261 ```
270262
271263 ```bash CLI
272 ant beta:messages create \
273 --beta fast-mode-2026-02-01 \
264 ant messages create \
274265 --transform usage.speed \
275266 --raw-output <<'YAML'
276267 model: claude-opus-5-5
from line 276
285276 ```python Python
286277 client = anthropic.Anthropic()
287278
288 response = client.beta.messages.create(
279 response = client.messages.create(
289280 model="claude-opus-5-5",
290281 max_tokens=1024,
291282 speed="fast",
292 betas=["fast-mode-2026-02-01"],
293283 messages=[{"role": "user", "content": "Hello"}],
294284 )
295285
from line 289
299289 ```typescript TypeScript
300290 const client = new Anthropic();
301291
302 const response = await client.beta.messages.create({
292 const response = await client.messages.create({
303293 model: "claude-opus-5-5",
304294 max_tokens: 1024,
305295 speed: "fast",
306 betas: ["fast-mode-2026-02-01"],
307296 messages: [{ role: "user", content: "Hello" }]
308297 });
309298
from line 302
313302 ```csharp C#
314303 AnthropicClient client = new();
315304
316 var response = await client.Beta.Messages.Create(new MessageCreateParams
305 var response = await client.Messages.Create(new MessageCreateParams
317306 {
318307 Model = "claude-opus-5-5",
319308 MaxTokens = 1024,
320309 Speed = Speed.Fast,
321 Betas = ["fast-mode-2026-02-01"],
322310 Messages = [new() { Role = Role.User, Content = "Hello" }],
323311 });
324312
from line 316
328316 ```go Go
329317 client := anthropic.NewClient()
330318
331 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
319 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
332320 Model: anthropic.ModelClaudeOpus5_5,
333321 MaxTokens: 1024,
334 Speed: anthropic.BetaMessageNewParamsSpeedFast,
335 Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaFastMode2026_02_01},
336 Messages: []anthropic.BetaMessageParam{
337 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
322 Speed: anthropic.MessageNewParamsSpeedFast,
323 Messages: []anthropic.MessageParam{
324 anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
338325 },
339326 })
340327 if err != nil {
from line 337
350337 .model(Model.CLAUDE_OPUS_5_5)
351338 .maxTokens(1024L)
352339 .speed(MessageCreateParams.Speed.FAST)
353 .addBeta(AnthropicBeta.FAST_MODE_2026_02_01)
354340 .addUserMessage("Hello")
355341 .build();
356342
357 BetaMessage response = client.beta().messages().create(params);
343 Message response = client.messages().create(params);
358344 IO.println(response.usage().speed().orElseThrow()); // "fast" or "standard"
359345 ```
360346
from line 347
361347 ```php PHP
362348 $client = new Client();
363349
364 $response = $client->beta->messages->create(
350 $response = $client->messages->create(
365351 model: 'claude-opus-5-5',
366352 maxTokens: 1024,
367353 speed: 'fast',
368 betas: ['fast-mode-2026-02-01'],
369354 messages: [['role' => 'user', 'content' => 'Hello']],
370355 );
371356
from line 360
375360 ```ruby Ruby
376361 client = Anthropic::Client.new
377362
378 response = client.beta.messages.create(
363 response = client.messages.create(
379364 model: "claude-opus-5-5",
380365 max_tokens: 1024,
381366 speed: "fast",
382 betas: ["fast-mode-2026-02-01"],
383367 messages: [{ role: "user", content: "Hello" }]
384368 )
385369
from line 396
412396### Falling back to standard speed
413397
414398<Note>
415 This section covers an opt-in client-side fallback when fast mode is rate limited. It is separate from the behavior on [Claude Opus 4.6](https://platform.claude.com/docs/en/build-with-claude/fast-mode#supported-models), where fast mode is not available and requests run at standard speed automatically.
399 This section covers an opt-in client-side fallback when fast mode is rate limited. It is separate from the behavior on [Claude Opus 4.6](https://platform.claude.com/docs/en/build-with-claude/fast-mode#supported-models), where fast mode is not available.
416400</Note>
417401
418402If you'd prefer to fall back to standard speed rather than wait for fast mode capacity, catch the rate limit error and retry without `speed: "fast"`. Set `max_retries` (typescript, java, php: `maxRetries`; csharp: `MaxRetries`; go: `option.WithMaxRetries`) to `0` on the initial fast request to skip automatic retries and fail immediately on rate limit errors.
from line 416
432416 local speed="$1" max_attempts="${2:-3}" body out
433417 body=${3:-$(cat)}
434418 out=$(
435 ant beta:messages create --beta fast-mode-2026-02-01 \
419 ant messages create \
436420 ${speed:+--speed "$speed"} \
437421 --transform-error error.type --format-error yaml <<<"$body" 2>/dev/null
438422 ) && { printf '%s\n' "$out"; return; }
from line 453
469453
470454 def create_message_with_fast_fallback(max_retries=0, max_attempts=3, **params):
471455 try:
472 return client.with_options(max_retries=max_retries).beta.messages.create(
473 **params
474 )
456 return client.with_options(max_retries=max_retries).messages.create(**params)
475457 except anthropic.RateLimitError:
476458 if params.get("speed") == "fast":
477459 del params["speed"]
from line 476
494476 model="claude-opus-5-5",
495477 max_tokens=1024,
496478 messages=[{"role": "user", "content": "Hello"}],
497 betas=["fast-mode-2026-02-01"],
498479 speed="fast",
499480 max_retries=0,
500481 )
from line 485
504485 const client = new Anthropic();
505486
506487 async function createMessageWithFastFallback(
507 params: Anthropic.Beta.MessageCreateParamsNonStreaming,
488 params: Anthropic.MessageCreateParamsNonStreaming,
508489 requestOptions?: Anthropic.RequestOptions,
509490 maxAttempts: number = 3
510 ): Promise<Anthropic.Beta.Messages.BetaMessage> {
491 ): Promise<Anthropic.Message> {
511492 try {
512 return await client.beta.messages.create(params, requestOptions);
493 return await client.messages.create(params, requestOptions);
513494 } catch (e) {
514495 if (e instanceof Anthropic.RateLimitError && params.speed === "fast") {
515496 const { speed, ...rest } = params;
from line 513
532513 model: "claude-opus-5-5",
533514 max_tokens: 1024,
534515 messages: [{ role: "user", content: "Hello" }],
535 betas: ["fast-mode-2026-02-01"],
536516 speed: "fast"
537517 },
538518 { maxRetries: 0 }
from line 522
542522 ```csharp C#
543523 AnthropicClient client = new();
544524
545 async Task<BetaMessage> CreateMessageWithFastFallback(
525 async Task<Message> CreateMessageWithFastFallback(
546526 MessageCreateParams parameters,
547527 int? maxRetries = null,
548528 int maxAttempts = 3)
from line 532
552532 var requestClient = maxRetries is int retries
553533 ? client.WithOptions(options => options with { MaxRetries = retries })
554534 : client;
555 return await requestClient.Beta.Messages.Create(parameters);
535 return await requestClient.Messages.Create(parameters);
556536 }
557537 catch (AnthropicRateLimitException)
558538 {
from line 560
580560 Model = "claude-opus-5-5",
581561 MaxTokens = 1024,
582562 Messages = [new() { Role = Role.User, Content = "Hello" }],
583 Betas = ["fast-mode-2026-02-01"],
584563 Speed = Speed.Fast,
585564 },
586565 maxRetries: 0);
from line 569
590569 func createMessageWithFastFallback(
591570 ctx context.Context,
592571 client *anthropic.Client,
593 params anthropic.BetaMessageNewParams,
572 params anthropic.MessageNewParams,
594573 maxAttempts int,
595574 opts ...option.RequestOption,
596 ) (*anthropic.BetaMessage, error) {
597 message, err := client.Beta.Messages.New(ctx, params, opts...)
575 ) (*anthropic.Message, error) {
576 message, err := client.Messages.New(ctx, params, opts...)
598577 if err != nil {
599578 var apierr *anthropic.Error
600579 if errors.As(err, &apierr) && apierr.StatusCode == 429 && params.Speed != "" {
from line 595
616595 message, err := createMessageWithFastFallback(
617596 context.TODO(),
618597 &client,
619 anthropic.BetaMessageNewParams{
598 anthropic.MessageNewParams{
620599 Model: anthropic.ModelClaudeOpus5_5,
621600 MaxTokens: 1024,
622 Messages: []anthropic.BetaMessageParam{
623 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
601 Messages: []anthropic.MessageParam{
602 anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
624603 },
625 Speed: anthropic.BetaMessageNewParamsSpeedFast,
626 Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaFastMode2026_02_01},
604 Speed: anthropic.MessageNewParamsSpeedFast,
627605 },
628606 3,
629607 option.WithMaxRetries(0),
from line 621
643621 AnthropicClient client =
644622 AnthropicOkHttpClient.builder().fromEnv().maxRetries(0).build();
645623
646 BetaMessage createMessageWithFastFallback(
624 Message createMessageWithFastFallback(
647625 MessageCreateParams params, int maxAttempts) {
648626 try {
649 return client.beta().messages().create(params);
627 return client.messages().create(params);
650628 } catch (RateLimitException e) {
651629 if (params.speed().isPresent()) {
652630 MessageCreateParams retryParams = params.toBuilder()
from line 642
664642 }
665643
666644 void main() {
667 BetaMessage message = createMessageWithFastFallback(
645 Message message = createMessageWithFastFallback(
668646 MessageCreateParams.builder()
669647 .model(Model.CLAUDE_OPUS_5_5)
670648 .maxTokens(1024L)
671649 .addUserMessage("Hello")
672 .addBeta(AnthropicBeta.FAST_MODE_2026_02_01)
673650 .speed(MessageCreateParams.Speed.FAST)
674651 .build(),
675652 3);
from line 671
694671 int $maxAttempts = 3,
695672 ) {
696673 try {
697 return $client->beta->messages->create(
674 return $client->messages->create(
698675 ...$params,
699676 requestOptions: $requestOptions,
700677 );
from line 697
720697 'model' => 'claude-opus-5-5',
721698 'maxTokens' => 1024,
722699 'messages' => [['role' => 'user', 'content' => 'Hello']],
723 'betas' => ['fast-mode-2026-02-01'],
724700 'speed' => 'fast',
725701 ],
726702 RequestOptions::with(maxRetries: 0),
from line 707
731707 client = Anthropic::Client.new
732708
733709 def create_message_with_fast_fallback(client, request_options: {}, max_attempts: 3, **params)
734 client.beta.messages.create(**params, request_options: request_options)
710 client.messages.create(**params, request_options: request_options)
735711 rescue Anthropic::Errors::RateLimitError
736712 raise unless params[:speed] == "fast"
737713 params.delete(:speed)
from line 722
746722 model: "claude-opus-5-5",
747723 max_tokens: 1024,
748724 messages: [{ role: "user", content: "Hello" }],
749 betas: ["fast-mode-2026-02-01"],
750725 speed: "fast",
751726 request_options: { max_retries: 0 }
752727 )
No line in this hunk matches that.