---
title: Guide de migration vers Claude Sonnet 5.5
url: https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide
description: Passez à Claude Sonnet 5.5 depuis des modèles Sonnet antérieurs ou Claude Haiku 4.5 grâce à ce guide de migration. Les indications pour activer Claude Sonnet 5.5 couvrent les paramètres qui renvoient des erreurs, les changements liés à la réflexion et une liste de vérification pour chaque modèle de départ.
---

Ce guide répertorie les modifications de code nécessaires pour passer à Claude Sonnet 5.5 depuis Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet ou Claude Haiku 4.5. Lisez les deux premières sections, puis poursuivez jusqu’à la section consacrée à votre modèle actuel. La [liste de vérification de migration](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migration-checklist) répertorie chaque modification par modèle de départ.

<Note>
  Ce guide couvre la migration du code de la [Messages API](https://platform.claude.com/docs/fr/build-with-claude/working-with-messages). Si vous utilisez [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview), aucune modification n’est requise au-delà de la mise à jour du nom du modèle.
</Note>

Laissez Claude Code migrer votre code pour vous

```text
/claude-api migrate ce projet vers claude-sonnet-5-5
```

Claude Sonnet 5.5 a les mêmes tarifs que Claude Sonnet 5, à l’exception des lectures du cache de prompts, qui coûtent 0,10 $ USD par million de tokens, soit la moitié du tarif de Claude Sonnet 5. Consultez [Tarification](https://platform.claude.com/docs/fr/about-claude/pricing). Pour sa « context window » (fenêtre de contexte) et ses limites de sortie, consultez la page du modèle [Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/overview). Pour les fonctionnalités et la rédaction de prompts, consultez [Nouveautés de Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) et [Rédiger des prompts pour Claude Sonnet 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Envoyer une requête à Claude Sonnet 5.5

Cette requête fonctionne telle quelle sur Claude Sonnet 5.5. Elle définit un niveau d’effort et omet cinq paramètres qui renvoient une erreur 400 : les [budgets de réflexion](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), les [paramètres d’échantillonnage](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), le [préremplissage de l’assistant](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), le [choix d’outil forcé](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#forced-tool-use) et [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

<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-sonnet-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}'
  ```

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

  response = client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  print(f"Stop reason: {response.stop_reason}")
  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-sonnet-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  console.log(`Stop reason: ${response.stop_reason}`);
  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 4096,
      Messages = [
          new UserMessageParam
          {
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine($"Stop reason: {message.StopReason?.Raw()}");
  foreach (var block in message.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.ModelClaudeSonnet5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println("Stop reason:", response.StopReason)
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.OutputConfig;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.stopReason().ifPresent(reason -> IO.println("Stop reason: " + reason));
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: Model::CLAUDE_SONNET_5_5,
      outputConfig: ['effort' => 'medium'],
  );

  echo "Stop reason: {$message->stopReason}", PHP_EOL;
  foreach ($message->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  puts "Stop reason: #{message.stop_reason}"
  message.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

## La réflexion s’exécute par défaut

Sur Claude Sonnet 5.5, une requête sans champ `thinking` s’exécute avec l’« [adaptive thinking](https://platform.claude.com/docs/fr/build-with-claude/thinking) » (réflexion adaptative), tout comme `thinking: {"type": "adaptive"}`. Sur Claude Sonnet 4.6 et les modèles antérieurs, ainsi que sur Claude Haiku 4.5, cette requête s’exécutait sans réflexion. Pour continuer à fonctionner sans réflexion préalable, consultez [Désactiver la réflexion préalable](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Modèle                                | Réflexion sans champ `thinking` | Valeurs `thinking.type` acceptées                  | `display` par défaut |
| ------------------------------------- | ------------------------------- | -------------------------------------------------- | -------------------- |
| Claude Sonnet 5.5                     | Activée                         | `"adaptive"`, `"between_tools"`                    | `"omitted"`          |
| Claude Sonnet 5                       | Activée                         | `"adaptive"`, `"disabled"`                         | `"omitted"`          |
| Claude Sonnet 4.6                     | Désactivée                      | `"adaptive"`, `"disabled"`, `"enabled"` (déprécié) | `"summarized"`       |
| Claude Sonnet 4.5 et Claude Haiku 4.5 | Désactivée                      | `"disabled"`, `"enabled"`                          | `"summarized"`       |

### Gérer la réflexion dans les réponses

Le code qui s’exécutait sans réflexion a besoin des trois éléments. Le code provenant de Claude Sonnet 5 dispose probablement déjà des deux premiers.

* **Lisez les blocs de contenu par `type`.** Une réponse peut commencer par des blocs `thinking`, de sorte que le code qui lit `content[0].text` ne fonctionne plus.
* **Renvoyez les blocs `thinking` sans modification** dans les boucles d’utilisation d’outils, y compris les blocs vides. Consultez [Préserver les blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserving-thinking-blocks).
* **Réexaminez `max_tokens`.** Il couvre la réflexion plus le texte, et les tokens de réflexion sont facturés comme des tokens de sortie. Consultez [Contrôle des coûts](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost#cost-control).

Le texte de réflexion est omis par défaut. Les blocs `thinking` arrivent avec un champ `thinking` vide et une `signature`. Pour obtenir des résumés lisibles, définissez `display: "summarized"`, la valeur par défaut sur Claude Sonnet 4.6 et les modèles antérieurs, ainsi que sur Claude Haiku 4.5. Consultez [Contrôler l’affichage de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#controlling-thinking-display).

### Désactiver la réflexion préalable

Pour désactiver la réflexion préalable sur Claude Sonnet 5.5, envoyez `thinking: {"type": "between_tools"}`. Il s’agit du paramètre de réflexion le plus bas. Ses mises à jour de progression entre les appels d’outils sont toujours renvoyées sous forme de blocs `thinking` avec leur texte de résumé. Sans outils, la réponse ne contient que du texte. Claude Sonnet 5 désactive plutôt la réflexion avec `thinking: {"type": "disabled"}`, et les modèles antérieurs s’exécutent sans réflexion par défaut. Sur Claude Sonnet 5.5, `disabled` renvoie une erreur 400 `invalid_request_error` :

```text wrap
To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.
```

`between_tools` fonctionne sur toutes les plateformes qui proposent Claude Sonnet 5.5. Il est accepté aux niveaux d’effort `low`, `medium` et `high`. Aux niveaux `xhigh` ou `max`, il renvoie une erreur 400. Pour fonctionner à ces niveaux, utilisez la réflexion adaptative : omettez le champ `thinking` ou envoyez `thinking: {"type": "adaptive"}`. `between_tools` n’accepte aucun autre champ : `display`, `budget_tokens` ou `block_binding` envoyés avec lui renvoient une erreur 400. Avec le [repli côté serveur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback), une requête `between_tools` qui bascule vers Claude Sonnet 5 s’y exécute avec `thinking: {"type": "disabled"}`.

Avec `between_tools`, l’effort ne peut pas changer en cours de conversation : un `output_config.effort` par message qui diffère du niveau en vigueur renvoie une erreur 400. Pour faire varier l’effort à chaque tour, utilisez la réflexion adaptative. Pour des conseils de rédaction de prompts, consultez [Fonctionner sans réflexion préalable](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Avant (Claude Sonnet 5) :

<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-sonnet-5",
      "max_tokens": 16000,
      "thinking": {"type": "disabled"},
      "output_config": {"effort": "xhigh"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5 \
    --max-tokens 16000 \
    --thinking '{type: disabled}' \
    --output-config '{effort: xhigh}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=16000,
      thinking={"type": "disabled"},
      output_config={"effort": "xhigh"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 16000,
    thinking: { type: "disabled" },
    output_config: { effort: "xhigh" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigDisabled(),
      OutputConfig = new() { Effort = Effort.Xhigh },
      Messages = [new UserMessageParam { Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortXhigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigDisabled.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.XHIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 16000,
      thinking: ThinkingConfigDisabled::with(),
      outputConfig: OutputConfig::with(effort: Effort::XHIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigDisabled.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::XHIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

Après (Claude Sonnet 5.5) :

<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-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {"type": "between_tools"},
      "output_config": {"effort": "high"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 16000 \
    --thinking '{type: between_tools}' \
    --output-config '{effort: high}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "between_tools"},
      output_config={"effort": "high"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "between_tools" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigBetweenTools(),
      OutputConfig = new() { Effort = Effort.High },
      Messages = [new UserMessageParam { Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfBetweenTools: &anthropic.ThinkingConfigBetweenToolsParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigBetweenTools.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5_5,
      maxTokens: 16000,
      thinking: ThinkingConfigBetweenTools::with(),
      outputConfig: OutputConfig::with(effort: Effort::HIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigBetweenTools.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::HIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

## Liste de vérification de migration par modèle de départ

Parcourez les groupes dans l’ordre et arrêtez-vous après celui qui mentionne votre modèle. Sur Claude Haiku 4.5, appliquez tous les groupes sauf « Claude Sonnet 4 ou antérieur », en terminant par « Claude Haiku 4.5 uniquement ».

### Tous les modèles de départ

* Remplacez l’ID du modèle par `claude-sonnet-5-5`.
* [Lisez les blocs de contenu selon leur `type`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-in-responses), et renvoyez les blocs `thinking` sans les modifier.
* Pour continuer à fonctionner sans réflexion préalable, envoyez le [paramètre de réflexion le plus bas](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) avec un effort `high` ou inférieur.
* Remplacez l’[utilisation d’outils forcée](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#forced-tool-use) par `auto` et des outils stricts.
* Gardez les conversations en [ajout seul](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-blocks).
* Déplacez l’utilisation de l’ordinateur vers le [« toolset » (ensemble d’outils)](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#computer-use-toolset), sans l’en-tête bêta `fine-grained-tool-streaming-2025-05-14`. Sur Amazon Bedrock, `computer_20251124` fonctionne également.
* [Associez l’outil advisor](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#advisor-tool) à un conseiller pris en charge, et attendez-vous à des conseils chiffrés.
* Lisez le [texte entre les appels d’outils](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#text-between-tool-calls) à partir des blocs `thinking`.
* [Gérez les refus](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback), et configurez une solution de repli.
* [Relancez votre balayage d’effort](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#recommended-changes), et réétablissez la référence de coût.

### Claude Sonnet 4.6 ou antérieur

* Attendez-vous à de la [réflexion sur les requêtes sans champ `thinking`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-on-by-default), et réexaminez `max_tokens`.
* Remplacez les [budgets de réflexion](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) par un niveau d’effort.
* Supprimez `temperature`, `top_p` et `top_k`.
* Si vous [affichez le texte de réflexion](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-in-responses), définissez `display: "summarized"`.
* [Recomptez les tokens](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6), et revoyez le budget des tokens d’image.

### Claude Sonnet 4.5 ou antérieur

* Remplacez les [préremplissages de l’assistant](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45).
* Analysez l’entrée des appels d’outils avec un analyseur JSON standard.
* Définissez `output_config.effort` explicitement.
* Supprimez tout en-tête bêta de fenêtre de contexte.
* Supprimez `interleaved-thinking-2025-05-14`, et remplacez `fine-grained-tool-streaming-2025-05-14` par `eager_input_streaming`.
* Déplacez `output_format` vers `output_config.format`.

### Claude Sonnet 4 ou antérieur

* Mettez à jour les [versions des outils](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) vers `text_editor_20250728` et `code_execution_20260521`.
* Gérez les raisons d’arrêt `refusal` et `model_context_window_exceeded`.
* Vérifiez la présence de sauts de ligne finaux dans les paramètres de type chaîne des outils.
* Supprimez `token-efficient-tools-2025-02-19` et `output-128k-2025-02-19`.
* Révisez vos prompts.

### Claude Haiku 4.5 uniquement

* Remplacez [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) ou son alias.
* Réétablissez votre référence de coûts au prix par token plus élevé.
* Révisez les prompts qui étaient trop courts pour être mis en cache sur Claude Haiku 4.5.

## Migrer vers Claude Sonnet 5.5 depuis Claude Sonnet 5

Tous les modèles de départ nécessitent les modifications de cette section. Remplacez votre ID de modèle par `claude-sonnet-5-5`, qui n’a pas de suffixe de date. Sur les autres plateformes, utilisez l’ID indiqué sous [Disponibilité](https://platform.claude.com/docs/fr/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### L’utilisation d’outils forcée n’est pas prise en charge

Tous les modèles antérieurs de cette page acceptent un `tool_choice` de type `any` ou `tool`. Claude Sonnet 5.5 rejette les deux avec une erreur 400, y compris sur le point de terminaison de [comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) :

```text wrap
tool_choice: type "tool" and "any" are not supported for this model.
```

Envoyez `tool_choice: {"type": "auto"}`, et marquez l’outil avec `strict: true` afin que son entrée corresponde au schéma. Le modèle peut alors répondre sans appeler l’outil ; indiquez donc dans le prompt quand l’utiliser. L’[utilisation stricte des outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/strict-tool-use) prend en charge un sous-ensemble de JSON Schema et nécessite `additionalProperties: false` sur chaque objet. Consultez [Limitations de JSON Schema](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs#json-schema-limitations).

Avant (Claude Sonnet 5) :

<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-sonnet-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        }
      }],
      "tool_choice": {"type": "tool", "name": "get_weather"},
      "messages": [{"role": "user", "content": "What is the weather in Paris?"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
  tool_choice:
    type: tool
    name: get_weather
  messages:
    - role: user
      content: What's the weather in Paris?
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=1024,
      tools=tools,
      tool_choice={"type": "tool", "name": "get_weather"},
      messages=[{"role": "user", "content": "What's the weather in Paris?"}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    tools,
    tool_choice: { type: "tool", name: "get_weather" },
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 1024,
      Tools = [.. tools],
      ToolChoice = new ToolChoiceTool { Name = "get_weather" },
      Messages = [new UserMessageParam { Content = "What's the weather in Paris?" }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeSonnet5,
  	MaxTokens:  1024,
  	Tools:      tools,
  	ToolChoice: anthropic.ToolChoiceParamOfTool("get_weather"),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in Paris?")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(1024L)
      .tools(tools)
      .toolChoice(ToolChoiceTool.of("get_weather"))
      .addUserMessage("What's the weather in Paris?")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 1024,
      tools: $tools,
      toolChoice: ToolChoiceTool::with(name: 'get_weather'),
      messages: [['role' => 'user', 'content' => "What's the weather in Paris?"]],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 1024,
    tools: tools,
    tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  )
  ```
</CodeGroup>

Après (Claude Sonnet 5.5) :

<CodeGroup>
  ```bash cURL
  # utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil
  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-sonnet-5-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        },
        "strict": true
      }],
      "tool_choice": {"type": "auto"},
      "messages": [{
        "role": "user",
        "content": "What is the weather in Paris? Use the get_weather tool."
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
      # utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil.
      strict: true
  tool_choice:
    type: auto
  messages:
    - role: user
      content: What's the weather in Paris? Use the get_weather tool.
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=1024,
      # utilisation d'outils stricte : chaque appel respecte le input_schema de l'outil
      tools=[{**tool, "strict": True} for tool in tools],
      tool_choice={"type": "auto"},
      messages=[
          {
              "role": "user",
              "content": "What's the weather in Paris? Use the get_weather tool.",
          }
      ],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 1024,
    // utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil
    tools: tools.map((tool) => ({ ...tool, strict: true })),
    tool_choice: { type: "auto" },
    messages: [
      {
        role: "user",
        content: "What's the weather in Paris? Use the get_weather tool."
      }
    ]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 1024,
      // utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil.
      Tools = [.. tools.Select(tool => tool with { Strict = true })],
      ToolChoice = new ToolChoiceAuto(),
      Messages =
      [
          new UserMessageParam
          {
              Content = "What's the weather in Paris? Use the get_weather tool.",
          },
      ],
  });
  ```

  ```go Go
  // utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil
  var strictTools []anthropic.ToolUnionParam
  for _, tool := range tools {
  	strictTool := *tool.OfTool
  	strictTool.Strict = anthropic.Bool(true)
  	strictTools = append(strictTools, anthropic.ToolUnionParam{OfTool: &strictTool})
  }
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeSonnet5_5,
  	MaxTokens:  1024,
  	Tools:      strictTools,
  	ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("What's the weather in Paris? Use the get_weather tool."),
  		),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(1024L)
      // utilisation d'outils stricte : chaque appel respecte l'input_schema de l'outil.
      .tools(tools.stream()
          .map(tool -> tool.tool()
              .map(customTool -> customTool.toBuilder()
                  .strict(true)
                  .build())
              .map(ToolUnion::ofTool)
              .orElse(tool))
          .toList())
      .toolChoice(ToolChoiceAuto.builder().build())
      .addUserMessage("What's the weather in Paris? Use the get_weather tool.")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5_5,
      maxTokens: 1024,
      // utilisation d'outils stricte : chaque appel respecte le input_schema de l'outil.
      tools: array_map(fn (Tool $tool) => $tool->withStrict(true), $tools),
      toolChoice: ToolChoiceAuto::with(),
      messages: [
          [
              'role' => 'user',
              'content' => "What's the weather in Paris? Use the get_weather tool.",
          ],
      ],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 1024,
    # utilisation d'outils stricte : chaque appel respecte le input_schema de l'outil
    tools: tools.map { |tool| tool.merge(strict: true) },
    tool_choice: Anthropic::ToolChoiceAuto.new,
    messages: [
      { role: "user", content: "What's the weather in Paris? Use the get_weather tool." }
    ]
  )
  ```
</CodeGroup>

L’exemple marque comme stricts tous les outils de la liste. Une requête peut comporter au maximum 20 outils stricts, et les entrées d’ensemble d’outils MCP, d’utilisation de l’ordinateur et d’utilisation du navigateur n’acceptent pas `strict`. Dans une liste d’outils plus longue, ne marquez que les outils qui en ont besoin.

### Les blocs de réflexion sont liés au modèle et à la conversation

Claude Sonnet 5.5 lit les blocs de réflexion de Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 et des [modèles antérieurs](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#earlier-models). Sur la Claude API et Claude Models on Google Cloud (Google managed), il lit également ceux de Claude Haiku 5.5. Il ne lit pas les blocs de Claude Opus 5, Claude Opus 5.5 ni d’aucun modèle Claude Fable ou Claude Mythos.

L’API écarte les blocs que le modèle ne peut pas lire. La requête renvoie 200, et les blocs écartés ne sont pas facturés. Consultez [Changer de modèle puis revenir](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#switching-models).

Gardez les conversations en ajout seul, afin que les blocs de réflexion réussissent la [vérification du préfixe](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check). Pour modifier les instructions ou les outils, consultez [Messages système et modifications d’outils en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages).

Échouer à la [« prefix check » (vérification du préfixe)](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check) peut entraîner ou non une [erreur 400](https://platform.claude.com/docs/fr/api/errors#thinking-block-conversation-mismatch). Pour identifier et gérer ces deux cas, consultez [Vérifications du préfixe sur les blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks).

La vérification du préfixe s’exécute sur la Claude API et sur [certaines plateformes cloud](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#feature-availability).

Les blocs de réflexion de Claude Sonnet 5.5 ne fonctionnent que dans le compte qui les a produits ou dans un compte qui lui est lié. Consultez [Réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#account-bound-thinking).

### Certaines versions de l’outil d’utilisation de l’ordinateur ne sont pas prises en charge

Claude Sonnet 5.5 prend en charge l’utilisation de l’ordinateur via l’ensemble d’outils `computer_toolset_20260801`. Sur Amazon Bedrock, Claude Sonnet 5.5 accepte également l’outil `computer_20251124` avec l’en-tête bêta `computer-use-2025-11-24`. Claude Sonnet 5.5 renvoie une erreur 400 pour toute version de l’outil d’utilisation de l’ordinateur qu’il n’accepte pas, comme `computer_20251124` sur l’API Claude. Il n’accepte `computer_20250124` sur aucune plateforme.

Les intégrations qui utilisent l’ensemble d’outils ne nécessitent aucune modification. Pour passer à l’ensemble d’outils, remplacez `computer_20251124` ou `computer_20250124` par `computer_toolset_20260801`, et supprimez l’en-tête bêta de cette version. Pour les modifications à apporter à la requête et à la boucle d’agent, consultez [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).

Si vous envoyez l’en-tête bêta `fine-grained-tool-streaming-2025-05-14`, supprimez-le lorsque vous passez à l’ensemble d’outils. Accompagné d’une entrée d’ensemble d’outils, il renvoie une erreur 400. Définissez plutôt `eager_input_streaming: true` sur chaque outil qui en a besoin.

### L’outil advisor accepte moins de conseillers

Avec l’[outil advisor](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/advisor-tool), un exécuteur Claude Sonnet 5.5 nécessite l’un de ces conseillers : Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5, Claude Fable 5.1, Claude Fable 5.2, Claude Mythos 5, Claude Mythos 5.1 ou Claude Mythos 5.2. Les conseillers Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6 et Claude Haiku 5.5 renvoient une erreur 400. Le conseil est renvoyé chiffré sous forme de bloc `advisor_redacted_result`, de sorte que son texte n’est pas lisible dans la réponse. Consultez [Compatibilité des modèles](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### Le texte entre les appels d’outils est renvoyé dans des blocs de réflexion

Sur Claude Sonnet 5.5, les notes de plus d’une phrase ou deux que le modèle écrit entre les appels d’outils sont renvoyées sous forme de [blocs `thinking` de mise à jour de progression](https://platform.claude.com/docs/fr/build-with-claude/thinking#progress-updates), vides avec le `display` par défaut. Les remarques plus courtes restent du `text`. Sur Claude Sonnet 5 et les modèles antérieurs, tout le texte entre les appels d’outils est renvoyé sous forme de blocs `text`. Aucune requête n’échoue, mais une interface qui affiche ces notes cesse de les afficher.

Avec la réflexion adaptative, définissez `display` sur `"updates"` (bêta, en-tête `thinking-display-updates-2026-08-18`) pour obtenir uniquement les mises à jour, ou sur `"summarized"` pour les obtenir mêlées au raisonnement. Affichez chaque bloc `thinking` non vide avant le bloc `tool_use` qui le suit. Avec [`between_tools`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), le texte est renvoyé sans `display`. Consultez [Mises à jour de progression destinées à l’utilisateur](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Classificateurs de sécurité et repli

Claude Sonnet 5.5 refuse dans davantage de catégories que Claude Sonnet 5. Un refus renvoie `stop_reason: "refusal"`, et ses `stop_details` peuvent indiquer l’une de ces [catégories](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#refusal-response) :

* **`"cyber"` :** La requête pourrait permettre des dommages cyber, comme le développement de logiciels malveillants ou d’exploits.
* **`"bio"` :** La requête pourrait permettre des dommages biologiques, comme des méthodes de laboratoire dangereuses.
* **`"frontier_llm"` :** La requête pourrait aider au développement de modèles d’IA concurrents.
* **`"reasoning_extraction"` :** La requête demande au modèle de reproduire son raisonnement interne dans le texte de la réponse.
* **`"general_harms"` :** La requête relève d’un autre domaine de la politique d’utilisation. Un travail inoffensif peut également déclencher cette catégorie.

Le [repli côté serveur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`), en bêta sur la Claude API et sur [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed), relance les refus `"cyber"` et `"frontier_llm"` sur Claude Sonnet 5. Il ne relance pas les refus `"bio"`, `"reasoning_extraction"` ou `"general_harms"`. Consultez [Refus et repli](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback) et [Facturation des refus](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Les protections cyber en temps réel sont nouvelles pour le code provenant de Claude Sonnet 4.6, Claude Sonnet 4.5 et Claude Haiku 4.5. Pour un travail de sécurité légitime, postulez au [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Autres changements

* **« Prompt caching » (mise en cache des prompts) :** Le prompt minimal pouvant être mis en cache est de 512 tokens, contre 1 024 sur Claude Sonnet 5, Claude Sonnet 4.6 et Claude Sonnet 4.5. Consultez [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-limitations).
* **Nouvelles fonctionnalités :** Pour les messages système en cours de conversation, les modifications d’outils en cours de conversation et l’effort par message, consultez [Nouveautés de Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). Avec [`between_tools`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), l’effort ne peut pas changer en cours de conversation.

### Modifications recommandées

Relancez votre balayage des niveaux d’effort. Claude Sonnet 5.5 dispose de cinq niveaux d’effort : `low`, `medium`, `high`, `xhigh` et `max`. La valeur par défaut sur la Claude API est `high`. Les niveaux ont été recalibrés, de sorte qu’un niveau ne produit pas la même quantité de réflexion que sur Claude Sonnet 5. Commencez à `high`, sauf si votre charge de travail est agentique ou sensible à la latence. Pour le codage agentique et l’utilisation d’outils en plusieurs étapes, commencez à `medium` pour les tâches bien spécifiées et passez à `high` pour les tâches plus difficiles ou plus longues. Pour le chat et les autres travaux sensibles à la latence, commencez à `medium` ou `low`. Définissez le niveau dans `output_config.effort`. Consultez [Niveaux d’effort recommandés pour Claude Sonnet 5.5](https://platform.claude.com/docs/fr/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Réévaluez ensuite les instructions de prompt propres au modèle à l’aide de [Rédiger des prompts pour Claude Sonnet 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Migrer vers Claude Sonnet 5.5 depuis Claude Sonnet 4.6 et les modèles Sonnet antérieurs

Appliquez d’abord toutes les sections précédentes, en remplaçant `claude-sonnet-4-6`. Effectuez ensuite ces modifications. Sur Claude Sonnet 4.5 ou antérieur, poursuivez avec les sous-sections qui suivent.

### Changements incompatibles

**La réflexion s’exécute sur les requêtes qui l’omettaient.** Consultez [La réflexion s’exécute par défaut](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-on-by-default) et [Désactiver la réflexion préalable](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**Les budgets de réflexion renvoient une erreur.** Claude Sonnet 4.6 accepte `thinking: {"type": "enabled", "budget_tokens": N}` comme paramètre déprécié. Claude Sonnet 4.5 et Claude Haiku 4.5 l’utilisent pour toute réflexion. Claude Sonnet 5.5 renvoie une erreur 400 :

```text wrap
"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.
```

Supprimez le budget et définissez un niveau d’[effort](https://platform.claude.com/docs/fr/build-with-claude/effort). Il n’existe pas de correspondance fixe entre un budget et un niveau d’effort ; exécutez donc vos évaluations à deux ou trois niveaux.

Avant (Claude Sonnet 4.6) :

<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-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages = [new UserMessageParam { Content = "..." }]
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

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

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_4_6)
      .maxTokens(16000L)
      .enabledThinking(10000L)
      .addUserMessage("...")
      .build();

  Message response = client.messages().create(params);
  IO.println(response);
  ```

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

  $message = $client->messages->create(
      maxTokens: 16000,
      messages: [['role' => 'user', 'content' => '...']],
      model: Model::CLAUDE_SONNET_4_6,
      thinking: ['type' => 'enabled', 'budgetTokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_4_6,
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

Après (Claude Sonnet 5.5) :

<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-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {
        "type": "adaptive"
      },
      "output_config": {
        "effort": "high"
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
  output_config:
    effort: high
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive"},
      output_config={"effort": "high"},  # or "max", "xhigh", "medium", "low"
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" }, // or "max", "xhigh", "medium", "low"
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive(),
      OutputConfig = new OutputConfig { Effort = Effort.High }, // or Max, Xhigh, Medium, Low
      Messages = [new UserMessageParam { Content = "..." }]
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh, // or Max, Xhigh, Medium, Low
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

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

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigAdaptive.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH) // or MAX, XHIGH, MEDIUM, LOW
          .build())
      .addUserMessage("...")
      .build();

  Message response = client.messages().create(params);
  IO.println(response);
  ```

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

  $message = $client->messages->create(
      maxTokens: 16000,
      messages: [['role' => 'user', 'content' => '...']],
      model: Model::CLAUDE_SONNET_5_5,
      thinking: ['type' => 'adaptive'],
      outputConfig: ['effort' => 'high'], // or 'max', 'xhigh', 'medium', 'low'
  );
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 16000,
    thinking: {
      type: "adaptive"
    },
    output_config: {
      effort: "high" # or "max", "xhigh", "medium", "low"
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

**Les paramètres d’échantillonnage renvoient une erreur.** Supprimez `temperature`, `top_p` et `top_k`.

**Le texte de réflexion est omis par défaut.** Consultez [Gérer la réflexion dans les réponses](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Autres changements

* **Environ 30 % de tokens en plus :** Claude Sonnet 5.5 utilise le tokeniseur de Claude Sonnet 5. Par rapport à Claude Sonnet 4.6, Claude Sonnet 4.5 et Claude Haiku 4.5, le même texte produit environ 30 % de tokens en plus, selon le contenu. Recomptez avec le [comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting), et réexaminez `max_tokens` et les coûts.
* **Effort :** Claude Sonnet 5.5 prend en charge `xhigh`, et les niveaux ont été recalibrés. Consultez [Modifications recommandées](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#recommended-changes).
* **Images :** Claude Sonnet 5.5 utilise le niveau d’image haute résolution, jusqu’à 2 576 pixels sur le bord le plus long et jusqu’à 4 784 tokens visuels par image. Claude Sonnet 4.6, Claude Sonnet 4.5 et Claude Haiku 4.5 s’arrêtent à 1 568 pixels et 1 568 tokens. Une image de 2000×1500 coûte environ 2,5 fois plus de tokens sur Claude Sonnet 5.5. Consultez [Résolution et coût en tokens](https://platform.claude.com/docs/fr/build-with-claude/vision#evaluate-image-size).

### Migrer depuis Claude Sonnet 4.5 ou antérieur

Sur Claude Sonnet 4.5, Claude Sonnet 4 ou Claude 3.7 Sonnet, appliquez d’abord toutes les sections précédentes, puis ces modifications.

**Le préremplissage renvoie une erreur.** Claude Sonnet 5.5 rejette un dernier tour d’assistant prérempli avec une erreur 400, comme le font Claude Sonnet 4.6 et Claude Sonnet 5. Claude Sonnet 4.5, Claude Haiku 4.5 et les modèles plus anciens l’acceptent. L’erreur indique :

```text wrap
This model does not support assistant message prefill. The conversation must end with a user message.
```

Remplacez chaque préremplissage selon son objectif :

* **Format de sortie :** utilisez les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs), ou des outils avec des champs enum pour la classification.
* **Préambules :** demandez une réponse directe dans l’invite système.
* **Refus indésirables :** des instructions claires dans le message utilisateur suffisent généralement.
* **Continuations :** déplacez-les dans le message utilisateur, par exemple « Votre réponse précédente a été interrompue et se terminait par `[previous_response]`. Reprenez là où vous vous êtes arrêté. »
* **Rappels de contexte :** placez-les dans le tour de l’utilisateur.

**Échappement de l’entrée des outils.** L’échappement dans les arguments des appels d’outils peut différer. Analysez `input` avec un analyseur JSON standard.

**Utilisation de l’ordinateur.** Claude Sonnet 5.5 n’accepte pas `computer_20250124`. Consultez [Certaines versions de l’outil d’utilisation de l’ordinateur ne sont pas prises en charge](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Effort.** Claude Sonnet 4.5 n’a pas de paramètre d’effort. Définissez explicitement un niveau d’effort (consultez [Modifications recommandées](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#recommended-changes)).

**Contexte et sortie.** Claude Sonnet 5.5 dispose d’une fenêtre de contexte plus grande et d’une limite de sortie plus élevée. Consultez la page du modèle [Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/overview). Supprimez tout en-tête bêta relatif à la fenêtre de contexte.

**En-têtes bêta.** Supprimez `interleaved-thinking-2025-05-14`, car la réflexion adaptative s’entrelace automatiquement. Remplacez `fine-grained-tool-streaming-2025-05-14` par `eager_input_streaming: true` sur chaque outil qui en a besoin. Cet en-tête renvoie une erreur 400 lorsqu’il accompagne une entrée d’ensemble d’outils d’utilisation de l’ordinateur ou d’utilisation du navigateur. Consultez [Streaming d’outils à granularité fine](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Sorties structurées.** Le paramètre `output_format` est déprécié. Pour l’utiliser malgré tout, ajoutez l’en-tête bêta `structured-outputs-2025-11-13`. Sans celui-ci, l’API renvoie une erreur 400. Utilisez plutôt `output_config.format`.

### Migrer depuis Claude Sonnet 4 ou antérieur

Claude Sonnet 4 est retiré sur la Claude API, mais disponible sur Claude Models on Google Cloud (Google managed) et Amazon Bedrock. Claude 3.7 Sonnet est retiré. Depuis l’un ou l’autre de ces modèles, appliquez d’abord toutes les sections précédentes, puis ces modifications :

* **Versions des outils :** Utilisez `text_editor_20250728`, avec le nom d’outil `str_replace_based_edit_tool` et sans commande `undo_edit`. Utilisez `code_execution_20260521`. Consultez l’[outil d’édition de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool) et l’[outil d’exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Raisons d’arrêt :** Gérez `refusal`. Les modèles Claude 4.5 et ultérieurs s’arrêtent également avec `model_context_window_exceeded` à la limite de la fenêtre de contexte. Consultez [Raisons d’arrêt et repli](https://platform.claude.com/docs/fr/build-with-claude/handling-stop-reasons).
* **Sauts de ligne finaux :** Les modèles Claude 4.5 et ultérieurs les conservent dans les paramètres de type chaîne des appels d’outils.
* **En-têtes bêta :** Supprimez `token-efficient-tools-2025-02-19` et `output-128k-2025-02-19`.
* **Prompts :** Révisez-les à l’aide des [bonnes pratiques de rédaction de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Migrer vers Claude Sonnet 5.5 depuis Claude Haiku 4.5

Appliquez d’abord toutes les sections jusqu’à [Migrer depuis Claude Sonnet 4.5 ou antérieur](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45) incluse, en ignorant la sous-section Claude Sonnet 4. Effectuez ensuite ces modifications :

* **ID du modèle :** Remplacez `claude-haiku-4-5-20251001`, ou l’alias `claude-haiku-4-5`, par `claude-sonnet-5-5`.
* **Coût :** Le prix par token est plus élevé, et le même texte produit davantage de tokens. Recomptez les tokens et réétablissez votre référence de coûts. Consultez [Tarification](https://platform.claude.com/docs/fr/about-claude/pricing).
* **Mise en cache des prompts :** Le prompt minimal pouvant être mis en cache passe de 4 096 tokens au [minimum de Claude Sonnet 5.5](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Réflexion entrelacée :** La réflexion adaptative s’exécute automatiquement entre les appels d’outils.
* **Routage :** Claude Sonnet 5.5 lit les blocs de réflexion de Claude Haiku 4.5. Une conversation qui monte en gamme conserve son raisonnement. Une conversation qui redescend vers Claude Haiku 4.5 écarte les blocs de Claude Sonnet 5.5.