---
title: Быстрый режим
url: https://platform.claude.com/docs/ru/build-with-claude/fast-mode
description: Получите до 2,5 раза больше выходных токенов в секунду на поддерживаемых моделях Claude.
featureMetadata:
  betaHeader: fast-mode-2026-02-01
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Тот же эндпоинт Messages API с более быстрым инференсом. ZDR применяется независимо от настройки скорости.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
  supportedPlatforms:
    Claude API:
      availability: stable
      note: 'Дата удаления: 30 ноября 2026 г. После удаления запросы к `claude-opus-4-8` с `speed: "fast"` будут возвращать ошибку. Чтобы продолжить использовать быстрый режим, перейдите на Claude Opus 5.5. См. [Переход на Claude Opus 5.5 с Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).'
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry:
      availability: stable
      note: В Microsoft Foundry у быстрого режима свои идентификаторы моделей, которые оканчиваются на `-fast`. Отправляйте запросы в развёртывание модели быстрого режима и не указывайте `speed`.
  details:
    - Быстрый режим находится на этапе исследовательского предварительного просмотра на Claude Opus 5 и объявлен устаревшим на Claude Opus 4.8; на обеих моделях он требует бета-заголовка `fast-mode-2026-02-01`.
---

**Поддержка API**: Использование зависит от продукта.

* **Messages API**: Задайте `speed: "fast"` в запросе.
* **Managed Agents**: Задайте `speed` в объекте модели агента, например `{"id": "claude-opus-5-5", "speed": "fast"}`.

Быстрый режим («fast mode») обеспечивает до 2,5 раза больше выходных токенов в секунду по повышенной цене. Чтобы включить его, укажите в запросе `speed: "fast"`. Быстрый режим доступен на Claude Fable 5.2, Claude Mythos 5.2 и Claude Opus 5.5. Быстрый режим находится на этапе исследовательского предварительного просмотра на Claude Opus 5 и объявлен устаревшим на Claude Opus 4.8.

## Как работает быстрый режим

Быстрый режим запускает ту же модель с более быстрой конфигурацией инференса. Интеллект и возможности модели не меняются.

* До 2,5 раза больше выходных токенов в секунду по сравнению со стандартной скоростью
* Выигрыш в скорости касается количества выходных токенов в секунду, или «output tokens per second» (OTPS), а не времени до первого токена, или «time to first token» (TTFT)
* Совместим со «streaming» ([потоковой передачей](https://platform.claude.com/docs/ru/build-with-claude/streaming)), при которой прирост OTPS наиболее заметен

## Базовое использование

Быстрый режим работает только на поддерживаемых моделях. Подробности, в том числе о том, каким моделям нужен бета-заголовок, см. в разделе [Доступность](https://platform.claude.com/docs/ru/build-with-claude/fast-mode#feature-availability).

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "speed": "fast",
      "messages": [{
        "role": "user",
        "content": "Refactor this module to use dependency injection"
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  speed: fast
  messages:
    - role: user
      content: Refactor this module to use dependency injection
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      speed="fast",
      messages=[
          {"role": "user", "content": "Refactor this module to use dependency injection"}
      ],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    speed: "fast",
    messages: [
      {
        role: "user",
        content: "Refactor this module to use dependency injection"
      }
    ]
  });

  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Speed = Speed.Fast,
      Messages = [
          new UserMessageParam { Content = "Refactor this module to use dependency injection" }
      ],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Refactor this module to use dependency injection")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .speed(MessageCreateParams.Speed.FAST)
          .addUserMessage("Refactor this module to use dependency injection")
          .build());

  response.content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> IO.println(textBlock.text()));
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 4096,
      speed: 'fast',
      messages: [
          ['role' => 'user', 'content' => 'Refactor this module to use dependency injection'],
      ],
  );

  foreach ($response->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    speed: "fast",
    messages: [{ role: "user", content: "Refactor this module to use dependency injection" }]
  )

  response.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

В [Claude в Microsoft Foundry](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry) у быстрого режима есть собственные идентификаторы моделей, а скорость определяется развертыванием. Отправляйте запросы быстрого режима в развертывание модели быстрого режима и не указывайте `speed`:

| Модель            | Идентификатор модели быстрого режима |
| ----------------- | ------------------------------------ |
| Claude Fable 5.2  | `claude-fable-5-2-fast`              |
| Claude Mythos 5.2 | `claude-mythos-5-2-fast`             |
| Claude Opus 5.5   | `claude-opus-5-5-fast`               |

Запрос, в котором задан `speed`, к развертыванию стандартной модели, например `claude-opus-5-5`, возвращает ошибку.

## Ограничения скорости

У быстрого режима есть отдельное «rate limit» (ограничение скорости), не зависящее от стандартных ограничений скорости. При превышении ограничения скорости быстрого режима API возвращает ошибку `429` с заголовком `retry-after`, указывающим, когда снова появится доступная мощность. На [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits) ограничениями скорости и квотами управляет Google Cloud.

Для Claude Fable 5.2, Claude Mythos 5.2 и Claude Opus 5.5 действует ограничение скорости быстрого режима по умолчанию. Ограничение по умолчанию применяется на [уровнях использования](https://platform.claude.com/docs/ru/api/rate-limits) Start, Build и Scale. Вам не нужно запрашивать доступ к быстрому режиму для этих моделей. Организации на ознакомительном уровне смогут использовать быстрый режим с этими моделями после перехода на уровень Start, Build или Scale.

Ответ содержит заголовки, указывающие состояние ограничения скорости быстрого режима:

| Заголовок                                | Описание                                                          |
| ---------------------------------------- | ----------------------------------------------------------------- |
| `anthropic-fast-input-tokens-limit`      | Максимальное количество входных токенов быстрого режима в минуту  |
| `anthropic-fast-input-tokens-remaining`  | Оставшиеся входные токены быстрого режима                         |
| `anthropic-fast-input-tokens-reset`      | Время сброса лимита входных токенов быстрого режима               |
| `anthropic-fast-output-tokens-limit`     | Максимальное количество выходных токенов быстрого режима в минуту |
| `anthropic-fast-output-tokens-remaining` | Оставшиеся выходные токены быстрого режима                        |
| `anthropic-fast-output-tokens-reset`     | Время сброса лимита выходных токенов быстрого режима              |

Чтобы посмотреть свои ограничения скорости быстрого режима, перейдите на страницу [Лимиты запросов](https://platform.claude.com/usage/limits) в Claude Console.

## Проверка использованной скорости

Объект `usage` в ответе содержит поле `speed`, указывающее, какая скорость была использована: `"fast"` или `"standard"`. Запрос `speed: "fast"` к [модели, которая не поддерживает быстрый режим](https://platform.claude.com/docs/ru/build-with-claude/fast-mode#feature-availability), возвращает ошибку; то же происходит при превышении ограничений скорости или мощности быстрого режима (`429` или `529`). Если запрос с `speed: "fast"` выполнен успешно, `usage.speed` равно `"fast"`. Исключение составляет Claude Opus 4.6: вместо ошибки запрос с `speed: "fast"` и бета-заголовком `fast-mode-2026-02-01` выполняется успешно, но на стандартной скорости. В такой ситуации `usage.speed` показывает `"standard"`. На Claude Models on Google Cloud (Anthropic managed) запрос к Claude Opus 4.6 с `speed: "fast"` возвращает ошибку `400` даже при наличии заголовка.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "speed": "fast",
      "messages": [{"role": "user", "content": "Hello"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  speed: fast
  messages:
    - role: user
      content: Hello
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      speed="fast",
      messages=[{"role": "user", "content": "Hello"}],
  )

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

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  });

  console.log(response.usage.speed); // "fast" or "standard"
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Speed = Speed.Fast,
      Messages = [new UserMessageParam { Content = "Hello" }],
  });

  Console.WriteLine(response.Usage.Speed);  // "fast" or "standard"
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.Usage.Speed) // "fast" or "standard"
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024L)
      .speed(MessageCreateParams.Speed.FAST)
      .addUserMessage("Hello")
      .build();

  Message response = client.messages().create(params);
  IO.println(response.usage().speed().orElseThrow());  // "fast" or "standard"
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 1024,
      speed: 'fast',
      messages: [['role' => 'user', 'content' => 'Hello']],
  );

  echo $response->usage->speed;  // "fast" or "standard"
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  )

  puts(response.usage.speed)  # "fast" or "standard"
  ```
</CodeGroup>

```json Output
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  // ...
  "usage": {
    "input_tokens": 8,
    "output_tokens": 12,
    "speed": "fast"
  }
}
```

Чтобы отслеживать использование и затраты быстрого режима в вашей организации, см. [Usage and Cost Analytics API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-analytics-api).

## Повторные попытки и резервные варианты

### Автоматические повторные попытки

SDK по умолчанию автоматически повторяет запросы при ошибках `429` быстрого режима до двух раз (настраивается с помощью `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)), ожидая перед каждой повторной попыткой задержку, указанную в заголовке `retry-after`. Поскольку быстрый режим использует непрерывное пополнение токенов, задержка `retry-after` обычно невелика, и запросы выполняются успешно, как только появляется доступная мощность.

### Переход на стандартную скорость

Если вы предпочитаете перейти на стандартную скорость, а не ждать освобождения мощности быстрого режима, перехватите ошибку ограничения скорости и повторите запрос без `speed: "fast"`. В Claude в Microsoft Foundry скорость определяется развертыванием, поэтому вместо этого повторите запрос к развертыванию стандартной модели. Установите `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) в `0` для первоначального быстрого запроса, чтобы пропустить автоматические повторные попытки и сразу получить ошибку при превышении ограничения скорости.

<Note>
  Переход с быстрой скорости на стандартную приводит к промаху [кэша подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching). Запросы с разными скоростями не используют общие кэшированные префиксы.
</Note>

Поскольку установка `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) в `0` также отключает повторные попытки при других временных ошибках (перегрузка, внутренние ошибки сервера), в следующих примерах запрос отправляется повторно после таких ошибок.

<CodeGroup exclude="shell:cURL, shell:CLI">
  ```python Python
  client = anthropic.Anthropic()


  def create_message_with_fast_fallback(max_retries=0, max_attempts=3, **params):
      try:
          return client.with_options(max_retries=max_retries).messages.create(**params)
      except anthropic.RateLimitError:
          if params.get("speed") == "fast":
              del params["speed"]
              return create_message_with_fast_fallback(max_retries=max_retries, **params)
          raise
      except (
          anthropic.APIStatusError,
          anthropic.APIConnectionError,
      ) as error:
          if isinstance(error, anthropic.APIStatusError) and error.status_code < 500:
              raise
          if max_attempts > 1:
              return create_message_with_fast_fallback(
                  max_retries=max_retries, max_attempts=max_attempts - 1, **params
              )
          raise


  message = create_message_with_fast_fallback(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello"}],
      speed="fast",
      max_retries=0,
  )
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  async function createMessageWithFastFallback(
    params: Anthropic.MessageCreateParamsNonStreaming,
    requestOptions?: Anthropic.RequestOptions,
    maxAttempts: number = 3
  ): Promise<Anthropic.Message> {
    try {
      return await client.messages.create(params, requestOptions);
    } catch (e) {
      if (e instanceof Anthropic.RateLimitError && params.speed === "fast") {
        const { speed, ...rest } = params;
        return createMessageWithFastFallback(rest);
      }
      if (
        e instanceof Anthropic.InternalServerError ||
        e instanceof Anthropic.APIConnectionError
      ) {
        if (maxAttempts > 1) {
          return createMessageWithFastFallback(params, undefined, maxAttempts - 1);
        }
      }
      throw e;
    }
  }

  const message = await createMessageWithFastFallback(
    {
      model: "claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello" }],
      speed: "fast"
    },
    { maxRetries: 0 }
  );
  ```

  ```csharp C#
  AnthropicClient client = new();

  async Task<Message> CreateMessageWithFastFallback(
      MessageCreateParams parameters,
      int? maxRetries = null,
      int maxAttempts = 3)
  {
      try
      {
          var requestClient = maxRetries is int retries
              ? client.WithOptions(options => options with { MaxRetries = retries })
              : client;
          return await requestClient.Messages.Create(parameters);
      }
      catch (AnthropicRateLimitException)
      {
          if (parameters.Speed is not null)
          {
              return await CreateMessageWithFastFallback(
                  parameters with { Speed = null });
          }
          throw;
      }
      catch (Anthropic5xxException)
      {
          if (maxAttempts > 1)
          {
              return await CreateMessageWithFastFallback(
                  parameters, maxAttempts: maxAttempts - 1);
          }
          throw;
      }
  }

  var message = await CreateMessageWithFastFallback(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages = [new UserMessageParam { Content = "Hello" }],
          Speed = Speed.Fast,
      },
      maxRetries: 0);
  ```

  ```go Go
  func createMessageWithFastFallback(
  	ctx context.Context,
  	client *anthropic.Client,
  	params anthropic.MessageNewParams,
  	maxAttempts int,
  	opts ...option.RequestOption,
  ) (*anthropic.Message, error) {
  	message, err := client.Messages.New(ctx, params, opts...)
  	if err != nil {
  		var apierr *anthropic.Error
  		if errors.As(err, &apierr) && apierr.StatusCode == 429 && params.Speed != "" {
  			params.Speed = ""
  			return createMessageWithFastFallback(ctx, client, params, maxAttempts)
  		}
  		if (errors.As(err, &apierr) && apierr.StatusCode >= 500) || !errors.As(err, &apierr) {
  			if maxAttempts > 1 {
  				return createMessageWithFastFallback(ctx, client, params, maxAttempts-1)
  			}
  		}
  		return nil, err
  	}
  	return message, nil
  }

  func main() {
  	client := anthropic.NewClient()
  	message, err := createMessageWithFastFallback(
  		context.TODO(),
  		&client,
  		anthropic.MessageNewParams{
  			Model:     anthropic.ModelClaudeOpus5_5,
  			MaxTokens: 1024,
  			Messages: []anthropic.MessageParam{
  				anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  			},
  			Speed: anthropic.MessageNewParamsSpeedFast,
  		},
  		3,
  		option.WithMaxRetries(0),
  	)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(message)
  }
  ```

  ```java Java
  import com.anthropic.errors.InternalServerException;
  import com.anthropic.errors.RateLimitException;
  // ...
  // Отключаем автоповтор в SDK, чтобы повторы обрабатывала последующая резервная логика
  AnthropicClient client =
      AnthropicOkHttpClient.builder()
          .fromEnv()
          .maxRetries(0)
          .build();

  Message createMessageWithFastFallback(
          MessageCreateParams params, int maxAttempts) {
      try {
          return client.messages().create(params);
      } catch (RateLimitException e) {
          if (params.speed().isPresent()) {
              MessageCreateParams retryParams = params.toBuilder()
                  .speed(Optional.empty())
                  .build();
              return createMessageWithFastFallback(retryParams, maxAttempts);
          }
          throw e;
      } catch (InternalServerException e) {
          if (maxAttempts > 1) {
              return createMessageWithFastFallback(params, maxAttempts - 1);
          }
          throw e;
      }
  }

  void main() {
      Message message = createMessageWithFastFallback(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024L)
              .addUserMessage("Hello")
              .speed(MessageCreateParams.Speed.FAST)
              .build(),
          3);
      message.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Core\Exceptions\APIConnectionException;
  use Anthropic\Core\Exceptions\InternalServerException;
  use Anthropic\Core\Exceptions\RateLimitException;
  use Anthropic\Messages\Model;
  use Anthropic\RequestOptions;

  $client = new Client();

  function createMessageWithFastFallback(
      Client $client,
      array $params,
      ?RequestOptions $requestOptions = null,
      int $maxAttempts = 3,
  ) {
      try {
          return $client->messages->create(
              ...$params,
              requestOptions: $requestOptions,
          );
      } catch (RateLimitException $e) {
          if (isset($params['speed'])) {
              unset($params['speed']);
              return createMessageWithFastFallback($client, $params);
          }
          throw $e;
      } catch (InternalServerException | APIConnectionException $e) {
          if ($maxAttempts > 1) {
              return createMessageWithFastFallback(
                  $client, $params, maxAttempts: $maxAttempts - 1
              );
          }
          throw $e;
      }
  }

  $message = createMessageWithFastFallback(
      $client,
      [
          'model' => Model::CLAUDE_OPUS_5_5,
          'maxTokens' => 1024,
          'messages' => [['role' => 'user', 'content' => 'Hello']],
          'speed' => 'fast',
      ],
      RequestOptions::with(maxRetries: 0),
  );
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  def create_message_with_fast_fallback(client, request_options: {}, max_attempts: 3, **params)
    client.messages.create(**params, request_options: request_options)
  rescue Anthropic::Errors::RateLimitError
    raise unless params[:speed] == "fast"
    params.delete(:speed)
    create_message_with_fast_fallback(client, **params)
  rescue Anthropic::Errors::InternalServerError, Anthropic::Errors::APIConnectionError
    raise unless max_attempts > 1
    create_message_with_fast_fallback(client, max_attempts: max_attempts - 1, **params)
  end

  message = create_message_with_fast_fallback(
    client,
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello" }],
    speed: "fast",
    request_options: { max_retries: 0 }
  )
  ```
</CodeGroup>

## Особенности

* **Batch API:** быстрый режим недоступен с [Batch API](https://platform.claude.com/docs/ru/build-with-claude/batch-processing).
* **Priority Tier:** быстрый режим недоступен при наличии обязательства [Priority Tier](https://platform.claude.com/docs/ru/api/service-tiers).

## Цены

Стоимость быстрого режима рассчитывается с множителем к стандартным тарифам на всё «context window» (контекстное окно), включая запросы длиной более 200 тыс. входных токенов. На Claude Models on Google Cloud (Google managed) цены быстрого режима устанавливает Google Cloud. См. [Цены на облачных платформах](https://platform.claude.com/docs/ru/about-claude/pricing#cloud-platform-pricing).

| Модель                          | Ввод           | Вывод          |
| ------------------------------- | -------------- | -------------- |
| Claude Fable 5.2                | $16 USD / MTok | $80 USD / MTok |
| Claude Mythos 5.2               | $16 USD / MTok | $80 USD / MTok |
| Claude Opus 5.5                 | $8 USD / MTok  | $40 USD / MTok |
| Claude Opus 5 / Claude Opus 4.8 | $10 USD / MTok | $50 USD / MTok |

Цены быстрого режима суммируются с другими ценовыми модификаторами:

* [Множители кэширования подсказок](https://platform.claude.com/docs/ru/about-claude/pricing#prompt-caching) применяются поверх цен быстрого режима.
* Множители [резидентности данных](https://platform.claude.com/docs/ru/manage-claude/data-residency) применяются поверх цен быстрого режима.

Полную информацию о ценах см. на странице [Цены](https://platform.claude.com/docs/ru/about-claude/pricing#fast-mode-pricing).

## Доступность

Быстрый режим находится в доступе или в исследовательской предварительной версии или на стадии вывода из употребления для некоторых моделей и подпадает под нулевое хранение данных и готовность к HIPAA.

### Поддержка API

Быстрый режим доступен только на следующих моделях. Если вы использовали быстрый режим на более ранней модели, [перейдите на модель, поддерживающую быстрый режим](https://platform.claude.com/docs/ru/models/opus-5-5/migration-guide).

Чтобы получить доступ к быстрому режиму на Claude Opus 5, свяжитесь с вашим менеджером по работе с клиентами или [запишитесь в список ожидания](https://claude.com/fast-mode).

#### [Messages API](https://platform.claude.com/docs/ru/build-with-claude/working-with-messages)

* Доступность: Доступно
* Использование: Задайте `speed: "fast"` в запросе.

| Статус                                   | Облачные платформы                                                                                                                                                                                                                                                                                                           | Модели                                                                                                                                                                 |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Доступно                                 | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/ru/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ru/models/mythos-5-2/overview) |
| Доступно<sup>1</sup>                     | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/ru/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ru/models/mythos-5-2/overview) |
| Доступно                                 | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/ru/models/opus-5-5/overview)                                                                                        |
| Доступно<sup>1</sup>                     | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/ru/models/opus-5-5/overview)                                                                                        |
| Исследовательская предварительная версия | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/ru/models/opus-5/overview)                                                                                            |
| Не рекомендуется<sup>2</sup>             | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-4-8/overview)                                                                                        |

1. В Microsoft Foundry у быстрого режима свои идентификаторы моделей, которые оканчиваются на `-fast`. Отправляйте запросы в развёртывание модели быстрого режима и не указывайте `speed`.
2. Дата удаления: 30 ноября 2026 г. После удаления запросы к `claude-opus-4-8` с `speed: "fast"` будут возвращать ошибку. Чтобы продолжить использовать быстрый режим, перейдите на Claude Opus 5.5. См. [Переход на Claude Opus 5.5 с Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

#### [Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview)

* Доступность: Доступно
* Использование: Задайте `speed` в объекте модели агента, например `{"id": "claude-opus-5-5", "speed": "fast"}`.

| Статус                                   | Облачные платформы                                                                                                                                                     | Модели                                                                          |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Доступно                                 | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/ru/models/opus-5-5/overview) |
| Исследовательская предварительная версия | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/ru/models/opus-5/overview)     |
| Не рекомендуется<sup>1</sup>             | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-4-8/overview) |

1. Дата удаления: 30 ноября 2026 г. После удаления запросы к `claude-opus-4-8` с `speed: "fast"` будут возвращать ошибку. Чтобы продолжить использовать быстрый режим, перейдите на Claude Opus 5.5. См. [Переход на Claude Opus 5.5 с Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

### Обязательные бета-заголовки

[Обзор бета-заголовков](https://platform.claude.com/docs/ru/api/beta-headers)

Бета-заголовки позволяют получить доступ к экспериментальным функциям и новым возможностям моделей до того, как они станут частью стандартного API.

| Заголовок              | Модели                                                                                                                                                       |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/ru/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/ru/models/opus-4-8/overview) |

### Обработка данных

[Обзор обработки данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#feature-eligibility)

| Элемент     | Нулевое хранение данных                                                                                                                                        | HIPAA       |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| Статус      | Допускается (кроме [Охватываемые модели](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Допускается |
| Подробности | Тот же эндпоинт Messages API с более быстрым инференсом. ZDR применяется независимо от настройки скорости.                                                     | —           |

Применимые конечные точки:

* `/v1/messages` с `speed: "fast"`

## Дальнейшие шаги

<CardGroup cols={2}>
  <Card title="Структурированные выходные данные" icon="code-brackets" href="https://platform.claude.com/docs/ru/build-with-claude/structured-outputs">
    Получайте проверенные результаты в формате JSON из агентных рабочих процессов.
  </Card>

  <Card title="Цены" icon="calculator" href="https://platform.claude.com/docs/ru/about-claude/pricing#fast-mode-pricing">
    Узнайте о структуре цен Anthropic на модели и функции.
  </Card>

  <Card title="Уровень усилий" icon="gauge" href="https://platform.claude.com/docs/ru/build-with-claude/effort">
    Управляйте тем, сколько токенов Claude использует при ответе, с помощью параметра effort, находя баланс между полнотой ответа и эффективностью использования токенов.
  </Card>

  <Card title="Потоковая передача сообщений" icon="arrow-right" href="https://platform.claude.com/docs/ru/build-with-claude/streaming">
    Получайте ответы Messages API по частям с помощью событий, отправляемых сервером, включая дельты текста, использования инструментов и расширенных размышлений.
  </Card>
</CardGroup>
