---
title: 高速モード
url: https://platform.claude.com/docs/ja/build-with-claude/fast-mode
description: サポートされているClaudeモデルで、1秒あたりの出力トークン数を最大2.5倍に向上させます。
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: '削除日：2026年11月30日。削除後は、`speed: "fast"`を指定した`claude-opus-4-8`へのリクエストはエラーを返します。高速モードを引き続き使用するには、Claude Opus 5.5に移行してください。[Claude Opus 4.8からClaude Opus 5.5への移行](https://platform.claude.com/docs/ja/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`で終わる独自のモデルIDがあります。高速モードモデルのデプロイメントにリクエストを送信し、`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」（高速モード）は、プレミアム価格で1秒あたりの出力トークン数を最大2.5倍に向上させます。オプトインするには、リクエストで`speed: "fast"`を設定します。高速モードはClaude Fable 5.2、Claude Mythos 5.2、およびClaude Opus 5.5で利用可能です。高速モードはClaude Opus 5ではリサーチプレビュー段階、Claude Opus 4.8では非推奨です。

## 高速モードの仕組み

高速モードは、同じモデルをより高速な推論構成で実行します。知能や機能に変更はありません。

* 標準速度と比較して、1秒あたりの出力トークン数が最大2.5倍に向上
* 速度の向上は、最初のトークンまでの時間（TTFT）ではなく、1秒あたりの出力トークン数（OTPS）に重点を置いています
* 「streaming」（[ストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming)）と互換性があり、OTPSの向上が最も顕著に現れます

## 基本的な使い方

高速モードはサポートされているモデルでのみ動作します。ベータヘッダーが必要なモデルを含む詳細については、[利用可能性](https://platform.claude.com/docs/ja/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>

[Microsoft FoundryのClaude](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)では、高速モードには独自のモデルIDがあり、デプロイメントが速度を決定します。高速モードのリクエストは高速モードのモデルのデプロイメントに送信し、`speed`は省略してください：

| モデル               | 高速モードのモデルID              |
| ----------------- | ------------------------ |
| 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`   |

`claude-opus-5-5`のような標準モデルのデプロイメントで`speed`を設定したリクエストはエラーを返します。

## レート制限

高速モードには、標準のレート制限とは別の専用の「rate limit」（レート制限）があります。高速モードのレート制限を超えると、APIは`429`エラーを返し、容量が利用可能になる時期を示す`retry-after`ヘッダーを含めます。[Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ja/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には、デフォルトの高速モードのレート制限があります。デフォルトの制限は、Start、Build、Scaleの[使用量ティア](https://platform.claude.com/docs/ja/api/rate-limits)で適用されます。これらのモデルについて、高速モードへのアクセスをリクエストする必要はありません。評価ティアの組織は、Start、Build、またはScaleティアに移行すると、これらのモデルで高速モードを使用できるようになります。

レスポンスには、高速モードのレート制限のステータスを示すヘッダーが含まれます：

| ヘッダー                                     | 説明                       |
| ---------------------------------------- | ------------------------ |
| `anthropic-fast-input-tokens-limit`      | 1分あたりの高速モードの最大入力トークン数    |
| `anthropic-fast-input-tokens-remaining`  | 残りの高速モードの入力トークン数         |
| `anthropic-fast-input-tokens-reset`      | 高速モードの入力トークン制限がリセットされる時刻 |
| `anthropic-fast-output-tokens-limit`     | 1分あたりの高速モードの最大出力トークン数    |
| `anthropic-fast-output-tokens-remaining` | 残りの高速モードの出力トークン数         |
| `anthropic-fast-output-tokens-reset`     | 高速モードの出力トークン制限がリセットされる時刻 |

高速モードのレート制限を確認するには、Claude Consoleの[レート制限](https://platform.claude.com/usage/limits)ページにアクセスしてください。

## 使用された速度の確認

レスポンスの`usage`オブジェクトには、使用された速度（`"fast"`または`"standard"`）を示す`speed`フィールドが含まれます。[高速モードをサポートしていないモデル](https://platform.claude.com/docs/ja/build-with-claude/fast-mode#feature-availability)で`speed: "fast"`をリクエストするとエラーが返されます。高速モードのレート制限や容量を超えた場合も同様です（`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)では、`speed: "fast"`を指定したClaude Opus 4.6のリクエストは、ヘッダーがあっても`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/ja/manage-claude/usage-cost-analytics-api)を参照してください。

## リトライとフォールバック

### 自動リトライ

SDKは、高速モードの`429`エラーをデフォルトで最大2回自動的にリトライします（`max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)で設定可能）。各リトライの前に、`retry-after`ヘッダーで示された遅延時間だけ待機します。高速モードは継続的なトークン補充を使用するため、`retry-after`の遅延は通常短く、容量が利用可能になるとリクエストは成功します。

### 標準速度へのフォールバック

高速モードの容量を待つのではなく標準速度にフォールバックしたい場合は、レート制限エラーをキャッチし、`speed: "fast"`なしでリトライします。Microsoft FoundryのClaudeでは、デプロイメントが速度を決定するため、代わりに標準モデルのデプロイメントでリトライしてください。最初の高速リクエストで`max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)を`0`に設定すると、自動リトライをスキップし、レート制限エラー時に即座に失敗させることができます。

<Note>
  高速から標準速度へのフォールバックは、[プロンプトキャッシュ](https://platform.claude.com/docs/ja/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/ja/build-with-claude/batch-processing)では利用できません。
* **Priority Tier：** 高速モードは[Priority Tier](https://platform.claude.com/docs/ja/api/service-tiers)のコミットメントでは利用できません。

## 料金

高速モードの価格は、200kを超える入力トークンのリクエストを含め、「context window」（コンテキストウィンドウ）全体にわたって標準料金に乗数を適用したものです。Claude Models on Google Cloud (Google managed)では、Google Cloudが高速モードの価格を設定します。[クラウドプラットフォームの料金](https://platform.claude.com/docs/ja/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/ja/about-claude/pricing#prompt-caching)は、高速モードの価格に上乗せして適用されます。
* [データレジデンシー](https://platform.claude.com/docs/ja/manage-claude/data-residency)の乗数は、高速モードの価格に上乗せして適用されます。

価格の詳細については、[価格](https://platform.claude.com/docs/ja/about-claude/pricing#fast-mode-pricing)ページを参照してください。

## 利用可能状況

高速モードは一部のモデルで利用可能またはリサーチプレビューまたは非推奨であり、ゼロデータ保持とHIPAAレディネスの対象です。

### APIサポート

高速モードは以下のモデルでのみ利用できます。以前のモデルで高速モードを使用していた場合は、[高速モードをサポートするモデルに移行](https://platform.claude.com/docs/ja/models/opus-5-5/migration-guide)してください。

Claude Opus 5で高速モードにアクセスするには、アカウントマネージャーに連絡するか、[ウェイトリストに登録](https://claude.com/fast-mode)してください。

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

* 利用可能状況：利用可能
* 使用方法：リクエストで`speed: "fast"`を設定します。

| ステータス            | クラウドプラットフォーム                                                                                                                                                                                                                                                                                                                 | モデル                                                                                                                                                                    |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 利用可能             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ja/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ja/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/ja/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ja/models/mythos-5-2/overview) |
| 利用可能<sup>1</sup> | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/ja/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ja/models/mythos-5-2/overview) |
| 利用可能             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ja/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/ja/models/opus-5-5/overview)                                                                                        |
| 利用可能<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/ja/models/opus-5-5/overview)                                                                                        |
| リサーチプレビュー        | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/ja/models/opus-5/overview)                                                                                            |
| 非推奨<sup>2</sup>  | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/ja/models/opus-4-8/overview)                                                                                        |

1. Microsoft Foundryでは、高速モードには`-fast`で終わる独自のモデルIDがあります。高速モードモデルのデプロイメントにリクエストを送信し、`speed`は省略してください。
2. 削除日：2026年11月30日。削除後は、`speed: "fast"`を指定した`claude-opus-4-8`へのリクエストはエラーを返します。高速モードを引き続き使用するには、Claude Opus 5.5に移行してください。[Claude Opus 4.8からClaude Opus 5.5への移行](https://platform.claude.com/docs/ja/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8)を参照してください。

#### [Managed Agents](https://platform.claude.com/docs/ja/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/ja/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/ja/models/opus-5-5/overview) |
| リサーチプレビュー       | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/ja/models/opus-5/overview)     |
| 非推奨<sup>1</sup> | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/ja/models/opus-4-8/overview) |

1. 削除日：2026年11月30日。削除後は、`speed: "fast"`を指定した`claude-opus-4-8`へのリクエストはエラーを返します。高速モードを引き続き使用するには、Claude Opus 5.5に移行してください。[Claude Opus 4.8からClaude Opus 5.5への移行](https://platform.claude.com/docs/ja/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8)を参照してください。

### 必須のベータヘッダー

[ベータヘッダーの概要](https://platform.claude.com/docs/ja/api/beta-headers)

ベータヘッダーを使用すると、実験的な機能や新しいモデル機能が標準APIに組み込まれる前にアクセスできます。

| ヘッダー                   | モデル                                                                                                                                                          |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/ja/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/ja/models/opus-4-8/overview) |

### データの取り扱い

[データの取り扱いの概要](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention#feature-eligibility)

| 項目    | ゼロデータ保持                                                                                                                             | HIPAA |
| ----- | ----------------------------------------------------------------------------------------------------------------------------------- | ----- |
| ステータス | 対象（[対象モデル](https://platform.claude.com/docs/ja/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/ja/build-with-claude/structured-outputs">
    エージェントワークフローから検証済みのJSON結果を取得します。
  </Card>

  <Card title="価格" icon="calculator" href="https://platform.claude.com/docs/ja/about-claude/pricing#fast-mode-pricing">
    モデルと機能に関するAnthropicの価格体系について学びます。
  </Card>

  <Card title="エフォート" icon="gauge" href="https://platform.claude.com/docs/ja/build-with-claude/effort">
    effortパラメータを使用して、Claudeが応答時に使用するトークン数を制御し、応答の網羅性とトークン効率のバランスを取ります。
  </Card>

  <Card title="メッセージのストリーミング" icon="arrow-right" href="https://platform.claude.com/docs/ja/build-with-claude/streaming">
    テキスト、ツール使用、拡張思考のデルタを含め、サーバー送信イベントを使用してMessages APIのレスポンスを段階的にストリーミングします。
  </Card>
</CardGroup>
