---
title: Fast mode
url: https://platform.claude.com/docs/ko/build-with-claude/fast-mode
description: 지원되는 Claude 모델에서 초당 출력 토큰을 최대 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` 요청이 오류를 반환합니다. Fast mode를 계속 사용하려면 Claude Opus 5.5로 마이그레이션하세요. [Claude Opus 4.8에서 Claude Opus 5.5로 마이그레이션](https://platform.claude.com/docs/ko/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 mode에 `-fast`로 끝나는 자체 모델 ID가 있습니다. Fast mode 모델의 배포로 요청을 보내고, `speed`는 생략하세요.
  details:
    - Fast mode는 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"`를 설정하세요. Fast mode는 Claude Fable 5.2, Claude Mythos 5.2 및 Claude Opus 5.5에서 사용할 수 있습니다. Fast mode는 Claude Opus 5에서는 연구 프리뷰 단계이고 Claude Opus 4.8에서는 지원 중단되었습니다.

## Fast mode 작동 방식

Fast mode는 동일한 모델을 더 빠른 추론 구성으로 실행합니다. 지능이나 기능에는 변화가 없습니다.

* 표준 속도 대비 초당 출력 토큰 최대 2.5배 향상
* 속도 이점은 첫 토큰까지의 시간(TTFT)이 아닌 초당 출력 토큰(OTPS)에 집중됩니다
* [스트리밍](https://platform.claude.com/docs/ko/build-with-claude/streaming)과 호환되며, 스트리밍에서 OTPS 향상이 가장 잘 드러납니다

## 기본 사용법

Fast mode는 지원되는 모델에서만 작동합니다. 베타 헤더가 필요한 모델을 포함한 자세한 내용은 [가용성](https://platform.claude.com/docs/ko/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/ko/build-with-claude/claude-in-microsoft-foundry)에서 fast mode에는 자체 모델 ID가 있으며, 배포가 속도를 결정합니다. Fast mode 요청은 fast mode 모델의 배포로 보내고 `speed`는 생략하세요:

| 모델                | Fast mode 모델 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`를 설정한 요청은 오류를 반환합니다.

## 속도 제한

Fast mode에는 표준 속도 제한과 별도인 전용 “rate limit”(속도 제한)이 있습니다. Fast mode 속도 제한을 초과하면 API는 용량을 사용할 수 있게 되는 시점을 나타내는 `retry-after` 헤더와 함께 `429` 오류를 반환합니다. [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ko/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에는 기본 fast mode 속도 제한이 있습니다. 기본 제한은 Start, Build, Scale [사용량 티어](https://platform.claude.com/docs/ko/api/rate-limits)에서 적용됩니다. 이들 모델에 대해 fast mode 액세스를 요청할 필요가 없습니다. 평가 티어의 조직은 Start, Build 또는 Scale 티어로 이동하면 이들 모델로 fast mode를 사용할 수 있습니다.

응답에는 fast mode 속도 제한 상태를 나타내는 헤더가 포함됩니다:

| 헤더                                       | 설명                           |
| ---------------------------------------- | ---------------------------- |
| `anthropic-fast-input-tokens-limit`      | 분당 최대 fast mode 입력 토큰 수      |
| `anthropic-fast-input-tokens-remaining`  | 남은 fast mode 입력 토큰 수         |
| `anthropic-fast-input-tokens-reset`      | Fast mode 입력 토큰 제한이 재설정되는 시간 |
| `anthropic-fast-output-tokens-limit`     | 분당 최대 fast mode 출력 토큰 수      |
| `anthropic-fast-output-tokens-remaining` | 남은 fast mode 출력 토큰 수         |
| `anthropic-fast-output-tokens-reset`     | Fast mode 출력 토큰 제한이 재설정되는 시간 |

Fast mode 속도 제한을 확인하려면 Claude Console의 [속도 제한](https://platform.claude.com/usage/limits) 페이지로 이동하세요.

## 사용된 속도 확인

응답의 `usage` 객체에는 사용된 속도를 나타내는 `speed` 필드가 포함되며, 값은 `"fast"` 또는 `"standard"`입니다. [Fast mode를 지원하지 않는 모델](https://platform.claude.com/docs/ko/build-with-claude/fast-mode#feature-availability)에서 `speed: "fast"`를 요청하면 오류가 반환되며, fast mode의 속도 제한이나 용량을 초과하는 경우(`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"
  }
}
```

조직 전체의 fast mode 사용량과 비용을 추적하려면 [Usage and Cost Analytics API](https://platform.claude.com/docs/ko/manage-claude/usage-cost-analytics-api)를 참조하세요.

## 재시도 및 폴백

### 자동 재시도

SDK는 기본적으로 fast mode `429` 오류를 최대 2회 자동으로 재시도하며(`max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)로 구성 가능), 각 재시도 전에 `retry-after` 헤더의 지연 시간만큼 대기합니다. Fast mode는 연속적인 토큰 보충을 사용하므로 `retry-after` 지연은 일반적으로 짧으며, 용량을 사용할 수 있게 되면 요청이 성공합니다.

### 표준 속도로 폴백

Fast mode 용량을 기다리는 대신 표준 속도로 폴백하려면 속도 제한 오류를 포착하고 `speed: "fast"` 없이 재시도하세요. Microsoft Foundry의 Claude에서는 배포가 속도를 결정하므로, 대신 표준 모델의 배포에서 재시도하세요. 초기 fast 요청에서 `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)를 `0`으로 설정하면 자동 재시도를 건너뛰고 속도 제한 오류 시 즉시 실패합니다.

<Note>
  Fast에서 표준 속도로 폴백하면 [프롬프트 캐시](https://platform.claude.com/docs/ko/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:** Fast mode는 [Batch API](https://platform.claude.com/docs/ko/build-with-claude/batch-processing)와 함께 사용할 수 없습니다.
* **Priority Tier:** Fast mode는 [Priority Tier](https://platform.claude.com/docs/ko/api/service-tiers) 약정과 함께 사용할 수 없습니다.

## 가격

Fast mode는 200k 입력 토큰을 초과하는 요청을 포함하여 전체 컨텍스트 윈도우에 걸쳐 표준 요금에 배수를 적용한 가격으로 책정됩니다. Claude Models on Google Cloud (Google managed)에서는 Google Cloud가 fast mode 가격을 설정합니다. [클라우드 플랫폼 요금](https://platform.claude.com/docs/ko/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 |

Fast mode 가격은 다른 가격 조정 요소와 중첩됩니다:

* [프롬프트 캐싱 배수](https://platform.claude.com/docs/ko/about-claude/pricing#prompt-caching)는 fast mode 가격 위에 추가로 적용됩니다.
* [데이터 레지던시](https://platform.claude.com/docs/ko/manage-claude/data-residency) 배수는 fast mode 가격 위에 추가로 적용됩니다.

전체 가격 세부 정보는 [가격](https://platform.claude.com/docs/ko/about-claude/pricing#fast-mode-pricing) 페이지를 참조하세요.

## 제공 여부

Fast mode은(는) 일부 모델에서 사용 가능 또는 연구 프리뷰 또는 지원 중단 상태이며 제로 데이터 보존 및 HIPAA 대비에 적격합니다.

### API 지원

Fast mode는 다음 모델에서만 사용할 수 있습니다. 이전 모델에서 fast mode를 사용하고 있었다면 [fast mode를 지원하는 모델로 마이그레이션](https://platform.claude.com/docs/ko/models/opus-5-5/migration-guide)하세요.

Claude Opus 5에서 fast mode에 액세스하려면 계정 관리자에게 문의하거나 [대기자 명단에 등록](https://claude.com/fast-mode)하세요.

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

* 제공 여부: 사용 가능
* 사용법: 요청에 `speed: "fast"`를 설정하세요.

| 상태                | 클라우드 플랫폼                                                                                                                                                                                                                                                                                                                     | 모델                                                                                                                                                                     |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 사용 가능             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ko/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ko/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/ko/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ko/models/mythos-5-2/overview) |
| 사용 가능<sup>1</sup> | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/ko/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/ko/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/ko/models/mythos-5-2/overview) |
| 사용 가능             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ko/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/ko/models/opus-5-5/overview)                                                                                        |
| 사용 가능<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/ko/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/ko/models/opus-5-5/overview)                                                                                        |
| 연구 프리뷰            | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/ko/models/opus-5/overview)                                                                                            |
| 지원 중단<sup>2</sup> | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/ko/models/opus-4-8/overview)                                                                                        |

1. Microsoft Foundry에서는 Fast mode에 `-fast`로 끝나는 자체 모델 ID가 있습니다. Fast mode 모델의 배포로 요청을 보내고, `speed`는 생략하세요.
2. 제거 날짜: 2026년 11월 30일. 제거 후에는 `speed: "fast"`를 사용한 `claude-opus-4-8` 요청이 오류를 반환합니다. Fast mode를 계속 사용하려면 Claude Opus 5.5로 마이그레이션하세요. [Claude Opus 4.8에서 Claude Opus 5.5로 마이그레이션](https://platform.claude.com/docs/ko/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8)을 참조하세요.

#### [Managed Agents](https://platform.claude.com/docs/ko/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/ko/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/ko/models/opus-5-5/overview) |
| 연구 프리뷰            | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/ko/models/opus-5/overview)     |
| 지원 중단<sup>1</sup> | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/ko/models/opus-4-8/overview) |

1. 제거 날짜: 2026년 11월 30일. 제거 후에는 `speed: "fast"`를 사용한 `claude-opus-4-8` 요청이 오류를 반환합니다. Fast mode를 계속 사용하려면 Claude Opus 5.5로 마이그레이션하세요. [Claude Opus 4.8에서 Claude Opus 5.5로 마이그레이션](https://platform.claude.com/docs/ko/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8)을 참조하세요.

### 필수 베타 헤더

[베타 헤더 개요](https://platform.claude.com/docs/ko/api/beta-headers)

베타 헤더를 사용하면 실험적 기능과 새로운 모델 기능이 표준 API에 포함되기 전에 액세스할 수 있습니다.

| 헤더                     | 모델                                                                                                                                                           |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/ko/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/ko/models/opus-4-8/overview) |

### 데이터 처리

[데이터 처리 개요](https://platform.claude.com/docs/ko/manage-claude/api-and-data-retention#feature-eligibility)

| 항목    | 제로 데이터 보존                                                                                                                           | HIPAA |
| ----- | ----------------------------------------------------------------------------------------------------------------------------------- | ----- |
| 상태    | 적격([적용 모델](https://platform.claude.com/docs/ko/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/ko/build-with-claude/structured-outputs">
    에이전트 워크플로에서 검증된 JSON 결과를 얻으세요.
  </Card>

  <Card title="가격" icon="calculator" href="https://platform.claude.com/docs/ko/about-claude/pricing#fast-mode-pricing">
    모델 및 기능에 대한 Anthropic의 가격 구조를 알아보세요.
  </Card>

  <Card title="노력 수준" icon="gauge" href="https://platform.claude.com/docs/ko/build-with-claude/effort">
    effort 매개변수로 Claude가 응답할 때 사용하는 토큰 수를 제어하여 응답의 철저함과 토큰 효율성 사이에서 균형을 맞추세요.
  </Card>

  <Card title="메시지 스트리밍" icon="arrow-right" href="https://platform.claude.com/docs/ko/build-with-claude/streaming">
    텍스트, 도구 사용, 확장 사고 델타를 포함하여 서버 전송 이벤트로 Messages API 응답을 점진적으로 스트리밍하세요.
  </Card>
</CardGroup>
