---
title: Mode rapide
url: https://platform.claude.com/docs/fr/build-with-claude/fast-mode
description: Obtenez jusqu'à 2,5 fois plus de tokens de sortie par seconde avec les modèles Claude pris en charge.
---

Le « fast mode » (mode rapide) offre jusqu'à 2,5 fois plus de tokens de sortie par seconde avec Claude Opus 5.5, Claude Opus 5, et Claude Opus 4.8, à un tarif premium. Définissez `speed: "fast"` dans votre requête pour l'activer.

<Note>
  Le mode rapide pour Claude Opus 5.5 ne nécessite ni l'en-tête bêta `fast-mode-2026-02-01` ni demande d'accès. Les requêtes qui envoient encore l'en-tête continuent de fonctionner. Le mode rapide pour Claude Opus 5 et Claude Opus 4.8 est en aperçu de recherche : contactez votre gestionnaire de compte ou [inscrivez-vous sur la liste d'attente](https://claude.com/fast-mode) pour demander l'accès, et envoyez l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) dans vos requêtes.
</Note>

<Note>
  Pour savoir comment la « zero data retention » (rétention zéro des données), ou ZDR, s'applique à cette fonctionnalité, consultez [API et rétention des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
</Note>

## Modèles et plateformes pris en charge

Le mode rapide est pris en charge sur les modèles et plateformes suivants :

| Modèle pris en charge             | Plateformes prises en charge                                                                                                                                                                                                                                                 |
| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Claude Opus 5.5 (claude-opus-5-5) | API Claude, y compris [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview)<br />[Claude dans Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry), pour les déploiements hébergés sur Azure |
| Claude Opus 5 (claude-opus-5)     | API Claude, y compris [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview)                                                                                                                                                                   |
| Claude Opus 4.8 (claude-opus-4-8) | API Claude, y compris [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview)                                                                                                                                                                   |

Si vous utilisiez le mode rapide sur un modèle antérieur, [migrez vers un modèle qui prend en charge le mode rapide](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide).

Le mode rapide n'est pas disponible pour les déploiements de Claude dans Microsoft Foundry [hébergés sur Anthropic](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#hosting-options).

## Fonctionnement du mode rapide

Le mode rapide exécute le même modèle avec une configuration d'inférence plus rapide. Il n'y a aucun changement en matière d'intelligence ou de capacités.

* Jusqu'à 2,5 fois plus de tokens de sortie par seconde par rapport à la vitesse standard
* Les gains de vitesse portent sur les « output tokens per second » (tokens de sortie par seconde), ou OTPS, et non sur le « time to first token » (délai avant le premier token), ou TTFT
* Mêmes poids de modèle et même comportement (il ne s'agit pas d'un modèle différent)
* Compatible avec le [streaming](https://platform.claude.com/docs/fr/build-with-claude/streaming), où le gain en OTPS est le plus visible

## Utilisation de base

Les modèles en aperçu de recherche nécessitent également l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `fast-mode-2026-02-01`.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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 is Anthropic.TextBlock => 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() { Role = Role.User, 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: '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: "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.type == :text
  end
  ```
</CodeGroup>

## Tarification

Le mode rapide est facturé selon un multiplicateur appliqué aux tarifs standard sur l'ensemble de la fenêtre de contexte, y compris pour les requêtes dépassant 200 000 tokens d'entrée. Le tableau suivant présente la tarification du mode rapide pour les modèles pris en charge :

| Modèle                          | Entrée          | Sortie          |
| ------------------------------- | --------------- | --------------- |
| Claude Opus 5.5                 | 8 $ USD / MTok  | 40 $ USD / MTok |
| Claude Opus 5 / Claude Opus 4.8 | 10 $ USD / MTok | 50 $ USD / MTok |

La tarification du mode rapide se cumule avec les autres modificateurs de prix :

* Les [multiplicateurs de mise en cache des prompts](https://platform.claude.com/docs/fr/about-claude/pricing#prompt-caching) s'appliquent en plus de la tarification du mode rapide
* Les multiplicateurs de [résidence des données](https://platform.claude.com/docs/fr/manage-claude/data-residency) s'appliquent en plus de la tarification du mode rapide

Pour obtenir tous les détails sur la tarification, consultez la page [Tarification](https://platform.claude.com/docs/fr/about-claude/pricing#fast-mode-pricing).

## Limites de débit

Le mode rapide dispose d'une « rate limit » (limite de débit) dédiée, distincte des limites de débit standard d'Opus. Lorsque votre limite de débit du mode rapide est dépassée, l'API renvoie une erreur `429` avec un en-tête `retry-after` indiquant quand la capacité sera disponible.

Claude Opus 5.5 dispose d'une limite de débit par défaut pour le mode rapide dans les [niveaux d'utilisation](https://platform.claude.com/docs/fr/api/rate-limits) Start, Build et Scale ; vous n'avez donc pas besoin de demander l'accès pour utiliser le mode rapide avec ce modèle. Les organisations du niveau Evaluation peuvent utiliser le mode rapide avec Claude Opus 5.5 dès qu'elles passent au niveau Start, Build ou Scale.

La réponse inclut des en-têtes qui indiquent l'état de votre limite de débit du mode rapide :

| En-tête                                  | Description                                                                     |
| ---------------------------------------- | ------------------------------------------------------------------------------- |
| `anthropic-fast-input-tokens-limit`      | Nombre maximal de tokens d'entrée en mode rapide par minute                     |
| `anthropic-fast-input-tokens-remaining`  | Tokens d'entrée en mode rapide restants                                         |
| `anthropic-fast-input-tokens-reset`      | Heure à laquelle la limite de tokens d'entrée en mode rapide est réinitialisée  |
| `anthropic-fast-output-tokens-limit`     | Nombre maximal de tokens de sortie en mode rapide par minute                    |
| `anthropic-fast-output-tokens-remaining` | Tokens de sortie en mode rapide restants                                        |
| `anthropic-fast-output-tokens-reset`     | Heure à laquelle la limite de tokens de sortie en mode rapide est réinitialisée |

Pour consulter vos limites de débit du mode rapide, accédez à la page [Limites de débit](https://platform.claude.com/usage/limits) dans la Claude Console.

## Vérifier quelle vitesse a été utilisée

L'objet `usage` de la réponse inclut un champ `speed` qui indique quelle vitesse a été utilisée, soit `"fast"`, soit `"standard"`. Demander `speed: "fast"` sur un [modèle qui ne prend pas en charge le mode rapide](https://platform.claude.com/docs/fr/build-with-claude/fast-mode#supported-models-and-platforms) renvoie une erreur, tout comme le dépassement des limites de débit ou de la capacité du mode rapide (une erreur `429` ou `529`). Lorsqu'une requête avec `speed: "fast"` réussit, `usage.speed` vaut `"fast"`. Claude Opus 4.6 constitue une exception : au lieu de renvoyer une erreur, une requête avec `speed: "fast"` et l'en-tête bêta `fast-mode-2026-02-01` réussit, mais s'exécute à la vitesse standard. Ce comportement est correctement reflété dans `usage.speed`, qui indique `"standard"` dans cette situation.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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 \
    --transform usage.speed \
    --raw-output <<'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() { Role = Role.User, 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: '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: "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"
  }
}
```

Pour suivre l'utilisation et les coûts du mode rapide dans l'ensemble de votre organisation, consultez l'[API d'utilisation et de coûts](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api).

## Nouvelles tentatives et repli

### Nouvelles tentatives automatiques

Lorsque les limites de débit du mode rapide sont dépassées, l'API renvoie une erreur `429` avec un en-tête `retry-after`. Le SDK relance automatiquement ces requêtes jusqu'à 2 fois par défaut (configurable avec `max_retries` (typescript, java, php: `maxRetries`; csharp: `MaxRetries`; go: `option.WithMaxRetries`)), en attendant le délai spécifié par le serveur avant chaque nouvelle tentative. Comme le mode rapide utilise un réapprovisionnement continu des tokens, le délai `retry-after` est généralement court et les requêtes réussissent dès que de la capacité est disponible.

### Repli vers la vitesse standard

Si vous préférez basculer vers la vitesse standard plutôt que d'attendre que de la capacité du mode rapide se libère, interceptez l'erreur de limite de débit et relancez la requête sans `speed: "fast"`. Définissez `max_retries` (typescript, java, php: `maxRetries`; csharp: `MaxRetries`; go: `option.WithMaxRetries`) sur `0` pour la requête rapide initiale afin d'ignorer les nouvelles tentatives automatiques et d'échouer immédiatement en cas d'erreur de limite de débit.

<Note>
  Le repli du mode rapide vers la vitesse standard entraînera un échec du [cache de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching). Les requêtes à des vitesses différentes ne partagent pas les préfixes mis en cache.
</Note>

Comme définir `max_retries` (typescript, java, php: `maxRetries`; csharp: `MaxRetries`; go: `option.WithMaxRetries`) sur `0` désactive également les nouvelles tentatives pour d'autres erreurs transitoires (surcharge, erreurs internes du serveur), les exemples suivants relancent la requête d'origine avec les nouvelles tentatives par défaut dans ces cas.

<CodeGroup exclude="shell:cURL">
  ```bash CLI
  # `ant` relance automatiquement les 429/5xx et n'offre aucune surcharge
  # max_retries par requête ; ainsi, sur un 429 en mode rapide, le repli s'exécute après
  # épuisement des relances intégrées. --transform-error expose error.type pour le branchement.
  create_message_with_fast_fallback() {
    local speed="$1" max_attempts="${2:-3}" body out
    body=${3:-$(cat)}
    out=$(
      ant messages create \
        ${speed:+--speed "$speed"} \
        --transform-error error.type --format-error yaml <<<"$body" 2>/dev/null
    ) && { printf '%s\n' "$out"; return; }
    case "$out" in
      rate_limit_error)
        if [[ -n "$speed" ]]; then
          create_message_with_fast_fallback "" "$max_attempts" "$body"
          return
        fi ;;
      overloaded_error | api_error | "")
        if (( max_attempts > 1 )); then
          create_message_with_fast_fallback "$speed" $((max_attempts - 1)) "$body"
          return
        fi ;;
    esac
    printf '%s\n' "${out:-connection_error}" >&2
    return 1
  }

  MESSAGE=$(
    create_message_with_fast_fallback fast <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content: Hello
  YAML
  )
  ```

  ```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() { Role = Role.User, 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;
  // ...
  // Désactivez les nouvelles tentatives automatiques du SDK afin que la logique de repli ci-dessous s'en charge.
  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\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' => '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: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello" }],
    speed: "fast",
    request_options: { max_retries: 0 }
  )
  ```
</CodeGroup>

## Points à prendre en compte

* **Mise en cache des prompts :** le passage de la vitesse rapide à la vitesse standard, ou inversement, invalide le cache de prompts. Les requêtes exécutées à des vitesses différentes ne partagent pas les préfixes mis en cache.
* **TTFT :** les avantages du mode rapide portent sur les tokens de sortie par seconde (OTPS), et non sur le délai avant le premier token (TTFT).
* **API Batch :** le mode rapide n'est pas disponible avec l'[API Batch](https://platform.claude.com/docs/fr/build-with-claude/batch-processing).
* **Priority Tier :** le mode rapide n'est pas disponible avec un engagement [Priority Tier](https://platform.claude.com/docs/fr/api/service-tiers).
* **Claude Platform on AWS :** le mode rapide n'est actuellement pas disponible sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws).

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Sorties structurées" icon="code-brackets" href="https://platform.claude.com/docs/fr/build-with-claude/structured-outputs">
    Obtenez des résultats JSON validés à partir de flux de travail d'agents.
  </Card>

  <Card title="Tarification" icon="calculator" href="https://platform.claude.com/docs/fr/about-claude/pricing#fast-mode-pricing">
    Découvrez la structure tarifaire d'Anthropic pour les modèles et les fonctionnalités.
  </Card>

  <Card title="Effort" icon="gauge" href="https://platform.claude.com/docs/fr/build-with-claude/effort">
    Contrôlez le nombre de tokens que Claude utilise pour répondre grâce au paramètre effort, en arbitrant entre l'exhaustivité de la réponse et l'efficacité en tokens.
  </Card>

  <Card title="Messages en streaming" icon="arrow-right" href="https://platform.claude.com/docs/fr/build-with-claude/streaming">
    Diffusez les réponses de l'API Messages de manière incrémentale avec des événements envoyés par le serveur, y compris le texte, l'utilisation d'outils et les deltas de réflexion étendue.
  </Card>
</CardGroup>