---
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.
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). Même point de terminaison de la Messages API avec une inférence plus rapide. La ZDR s’applique quel que soit le paramètre de vitesse.
  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: 'Date de suppression : 30 novembre 2026. Après le retrait, les requêtes vers `claude-opus-4-8` avec `speed: "fast"` renverront une erreur. Pour continuer à utiliser le mode rapide, migrez vers Claude Opus 5.5. Consultez [Migrer de Claude Opus 4.8 vers Claude Opus 5.5](https://platform.claude.com/docs/fr/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: Sur Microsoft Foundry, le mode rapide dispose de ses propres ID de modèle, qui se terminent par `-fast`. Envoyez les requêtes à un déploiement du modèle en mode rapide, et omettez `speed`.
  details:
    - Le mode rapide est en aperçu de recherche sur Claude Opus 5 et déprécié sur Claude Opus 4.8, et nécessite l'en-tête bêta `fast-mode-2026-02-01` sur ces deux modèles.
---

**Prise en charge de l’API** : L’utilisation varie selon le produit.

* **Messages API** : Définissez `speed: "fast"` dans la requête.
* **Managed Agents** : Définissez `speed` sur l’objet modèle de l’agent, par exemple `{"id": "claude-opus-5-5", "speed": "fast"}`.

Le « fast mode » (mode rapide) offre jusqu’à 2,5 fois plus de « output tokens » (tokens de sortie) par seconde, à un tarif premium. Définissez `speed: "fast"` dans votre requête pour l’activer. Le mode rapide est disponible sur Claude Fable 5.2, Claude Mythos 5.2 et Claude Opus 5.5. Le mode rapide est en aperçu de recherche sur Claude Opus 5 et déprécié sur Claude Opus 4.8.

## Fonctionnement du mode rapide

Le mode rapide exécute le même modèle avec une configuration d’inférence plus rapide. L’intelligence et les capacités restent inchangées.

* 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
* 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

Le mode rapide fonctionne uniquement sur les modèles pris en charge. Consultez [Disponibilité](https://platform.claude.com/docs/fr/build-with-claude/fast-mode#feature-availability) pour plus de détails, notamment pour savoir quels modèles nécessitent un en-tête bêta.

<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>

Sur [Claude dans Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry), le mode rapide dispose de ses propres ID de modèle, et c’est le déploiement qui définit la vitesse. Envoyez les requêtes en mode rapide à un déploiement du modèle en mode rapide, et omettez `speed` :

| Modèle            | ID du modèle en mode rapide |
| ----------------- | --------------------------- |
| 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`      |

Une requête qui définit `speed` sur un déploiement du modèle standard, tel que `claude-opus-5-5`, renvoie une erreur.

## 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. Lorsque vous dépassez votre limite de débit du mode rapide, l’API renvoie une erreur `429` avec un en-tête `retry-after` indiquant quand de la capacité est disponible. Sur [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits), Google Cloud gère les limites de débit et les quotas.

Claude Fable 5.2, Claude Mythos 5.2 et Claude Opus 5.5 disposent d’une limite de débit par défaut pour le mode rapide. La limite par défaut s’applique dans les [niveaux d’utilisation](https://platform.claude.com/docs/fr/api/rate-limits) Start, Build et Scale. Vous n’avez pas besoin de demander l’accès au mode rapide pour ces modèles. Les organisations du niveau d’évaluation peuvent utiliser le mode rapide avec ces modèles 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 restants en mode rapide                                  |
| `anthropic-fast-input-tokens-reset`      | Moment où la limite de tokens d’entrée du 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 restants en mode rapide                                 |
| `anthropic-fast-output-tokens-reset`     | Moment où la limite de tokens de sortie du mode rapide est réinitialisée |

Pour consulter vos limites de débit du mode rapide, rendez-vous sur la page [Limites de débit](https://platform.claude.com/usage/limits) de 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#feature-availability) 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. Dans cette situation, `usage.speed` affiche `"standard"`. Sur Claude Models on Google Cloud (Anthropic managed), une requête Claude Opus 4.6 avec `speed: "fast"` renvoie une erreur `400`, même avec l’en-tête.

<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"
  }
}
```

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

## Nouvelles tentatives et solutions de repli

### Nouvelles tentatives automatiques

Le SDK réessaie automatiquement les erreurs `429` du mode rapide jusqu’à deux fois par défaut (configurable avec `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)), en attendant le délai indiqué dans l’en-tête `retry-after` 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 sur la vitesse standard

Si vous préférez vous replier sur la vitesse standard plutôt que d’attendre de la capacité en mode rapide, interceptez l’erreur de limite de débit et réessayez sans `speed: "fast"`. Sur Claude dans Microsoft Foundry, c’est le déploiement qui définit la vitesse ; réessayez donc plutôt sur un déploiement du modèle standard. Définissez `max_retries` (typescript, php: `maxRetries`; java: `.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 de la vitesse rapide vers la vitesse standard entraîne un échec de la [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) (cache miss). Les requêtes à des vitesses différentes ne partagent pas les préfixes mis en cache.
</Note>

Comme définir `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) sur `0` désactive également les nouvelles tentatives pour les autres erreurs transitoires (surcharge, erreurs internes du serveur), les exemples suivants renvoient la requête après ces erreurs.

<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;
  // ...
  // Désactive les nouvelles tentatives automatiques du SDK pour que la logique de repli qui suit 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\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>

## Considérations

* **Batch API :** le mode rapide n’est pas disponible avec la [Batch API](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).

## Tarification

Le mode rapide est facturé selon un multiplicateur appliqué aux tarifs standard sur l’ensemble de la « context window » (fenêtre de contexte), y compris pour les requêtes de plus de 200k tokens d’entrée. Sur Claude Models on Google Cloud (Google managed), Google Cloud fixe les tarifs du mode rapide. Consultez [Tarification des plateformes cloud](https://platform.claude.com/docs/fr/about-claude/pricing#cloud-platform-pricing).

| Modèle                          | Entrée          | Sortie          |
| ------------------------------- | --------------- | --------------- |
| 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 |

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

* 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 tous les détails de tarification, consultez la page [Tarification](https://platform.claude.com/docs/fr/about-claude/pricing#fast-mode-pricing).

## Disponibilité

Mode rapide est disponible ou en aperçu de recherche ou au statut déprécié sur certains modèles et éligible aux dispositifs suivants : zéro conservation des données et préparation HIPAA.

### Prise en charge de l’API

Le mode rapide est disponible uniquement sur les modèles suivants. 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).

Pour accéder au mode rapide sur Claude Opus 5, contactez votre gestionnaire de compte ou [inscrivez-vous sur la liste d’attente](https://claude.com/fast-mode).

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

* Disponibilité : Disponible
* Utilisation : Définissez `speed: "fast"` dans la requête.

| Statut                 | Plateformes cloud                                                                                                                                                                                                                                                                                                            | Modèles                                                                                                                                                                |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Disponible             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/fr/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/fr/models/mythos-5-2/overview) |
| Disponible<sup>1</sup> | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/fr/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/fr/models/mythos-5-2/overview) |
| Disponible             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/overview)                                                                                        |
| Disponible<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/overview)                                                                                        |
| Aperçu de recherche    | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5/overview)                                                                                            |
| Déprécié<sup>2</sup>   | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-4-8/overview)                                                                                        |

1. Sur Microsoft Foundry, le mode rapide dispose de ses propres ID de modèle, qui se terminent par `-fast`. Envoyez les requêtes à un déploiement du modèle en mode rapide, et omettez `speed`.
2. Date de suppression : 30 novembre 2026. Après le retrait, les requêtes vers `claude-opus-4-8` avec `speed: "fast"` renverront une erreur. Pour continuer à utiliser le mode rapide, migrez vers Claude Opus 5.5. Consultez [Migrer de Claude Opus 4.8 vers Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

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

* Disponibilité : Disponible
* Utilisation : Définissez `speed` sur l’objet modèle de l’agent, par exemple `{"id": "claude-opus-5-5", "speed": "fast"}`.

| Statut               | Plateformes cloud                                                                                                                                                      | Modèles                                                                         |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Disponible           | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/overview) |
| Aperçu de recherche  | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5/overview)     |
| Déprécié<sup>1</sup> | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-4-8/overview) |

1. Date de suppression : 30 novembre 2026. Après le retrait, les requêtes vers `claude-opus-4-8` avec `speed: "fast"` renverront une erreur. Pour continuer à utiliser le mode rapide, migrez vers Claude Opus 5.5. Consultez [Migrer de Claude Opus 4.8 vers Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

### En-têtes bêta requis

[Présentation des en-têtes bêta](https://platform.claude.com/docs/fr/api/beta-headers)

Les en-têtes bêta vous permettent d’accéder à des fonctionnalités expérimentales et à de nouvelles capacités des modèles avant qu’elles ne fassent partie de l’API standard.

| En-tête                | Modèles                                                                                                                                                      |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-4-8/overview) |

### Traitement des données

[Présentation du traitement des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#feature-eligibility)

| Élément | Zéro conservation des données                                                                                                                             | HIPAA    |
| ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| Statut  | Éligible (exclut [Modèles couverts](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Éligible |
| Détails | Même point de terminaison de la Messages API avec une inférence plus rapide. La ZDR s’applique quel que soit le paramètre de vitesse.                     | —        |

Points de terminaison concernés :

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

## É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 workflows 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é des réponses et l’efficacité en tokens.
  </Card>

  <Card title="Streaming de messages" 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 les événements envoyés par le serveur, y compris les deltas de texte, d’utilisation d’outils et de réflexion étendue.
  </Card>
</CardGroup>
