---
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 instructions 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 correspondant à 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>

<Tip>
  **Automatisez votre migration avec la skill Claude API.** Dans Claude Code, exécutez `/claude-api migrate` pour invoquer la [skill Claude API](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) intégrée. Elle fonctionne avec n'importe quel modèle Claude actuel comme cible :

  Laissez Claude Code migrer votre code pour vous

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

  La skill applique le remplacement de l'identifiant du modèle et, si nécessaire, les changements de paramètres non rétrocompatibles, le remplacement du préremplissage (prefill) et le calibrage de l'effort pour votre modèle cible dans l'ensemble de votre base de code, puis produit une liste de contrôle des éléments à vérifier manuellement. Elle vous demande de confirmer la portée de la migration (répertoire de travail entier, un sous-répertoire ou une liste de fichiers spécifique) avant de modifier le moindre fichier. La skill détecte également les clients Amazon Bedrock et Claude Platform on AWS, et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour ces plateformes.
</Tip>

Claude Sonnet 5.5 a les mêmes tarifs que Claude Sonnet 5, à l'exception des lectures du cache des prompts, qui coûtent 0,10 $ USD par million de tokens, soit la moitié du tarif de Claude Sonnet 5. Consultez [Tarifs de Claude](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 le prompting, 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 les onglets des SDK lisent la réponse par type de bloc. Elle 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: 2023-06-01" \
    -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 is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              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: 'claude-sonnet-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  echo "Stop reason: {$message->stopReason}", PHP_EOL;
  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = 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"
    }
  )

  puts "Stop reason: #{message.stop_reason}"
  message.content.each do |block|
    puts block.text if block.type == :text
  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 nécessite les trois éléments suivants. Le code provenant de Claude Sonnet 5 intègre probablement déjà les 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 et 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"}`. C'est le paramètre de réflexion le plus bas. Ses mises à jour de progression entre les appels d'outils reviennent toujours 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, sans en-tête bêta. Il est accepté aux niveaux d'effort `low`, `medium` et `high`. Aux niveaux `xhigh` ou `max`, il renvoie une erreur 400. Pour utiliser 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é avec lui renvoie 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 se replie sur 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 prompting, 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: 2023-06-01" \
    -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() { Role = Role.User, 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: 2023-06-01" \
    -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() { Role = Role.User, 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 par `type`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-in-responses), et renvoyez les blocs `thinking` sans modification.
* 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 forcée d'outils](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#forced-tool-use) par `auto` et des outils stricts, ou par `auto` seul sur Amazon Bedrock.
* Gardez les conversations en [ajout seul](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#thinking-blocks).
* Sur l'API Claude et Google Cloud, migrez l'utilisation de l'ordinateur vers le [toolset](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`.
* 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 le repli.
* [Relancez votre balayage d'effort](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#recommended-changes), et réétablissez votre 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 les valeurs non par défaut de `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 réévaluez le budget de tokens des images.

### 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.
* Sur Amazon Bedrock, migrez l'utilisation de l'ordinateur de `computer_20250124` vers [`computer_20251124`](https://platform.claude.com/docs/fr/models/sonnet-5-5/migration-guide#computer-use-toolset).
* Définissez `output_config.effort` explicitement.
* Supprimez tout en-tête bêta lié à la 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ût avec le 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 identifiant de modèle par `claude-sonnet-5-5`, qui n'a pas de suffixe de date. Sur les autres plateformes, utilisez l'identifiant indiqué sous [Disponibilité](https://platform.claude.com/docs/fr/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### L'utilisation forcée d'outils 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 `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 d'outils stricte](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). Sur Amazon Bedrock, les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs), qui incluent l'utilisation d'outils stricte, ne sont pas disponibles pour Claude Sonnet 5.5. Sur cette plateforme, envoyez `auto` sans `strict`, indiquez dans le prompt quand appeler l'outil, et validez l'entrée de l'outil dans votre code.

Avant (Claude Sonnet 5) :

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-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?"}]
    }'
  ```

  ```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() { Role = Role.User, 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 le input_schema de l'outil.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-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'\''s 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 le 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 le input_schema de l'outil.
      Tools = [.. tools.Select(tool => tool with { Strict = true })],
      ToolChoice = new ToolChoiceAuto(),
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = "What's the weather in Paris? Use the get_weather tool.",
          },
      ],
  });
  ```

  ```go Go
  // utilisation d'outils stricte : chaque appel respecte le 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 le 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 l'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 strict chaque outil de la liste. Une requête peut comporter au maximum 20 outils stricts, et les entrées de toolset 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, ainsi que, sur l'API Claude et Google Cloud, 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 supprime les blocs que le modèle ne peut pas lire. La requête renvoie tout de même 200, et les blocs supprimés ne sont pas facturés. Consultez [Changer de modèle en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#switching-models).

Chaque bloc de réflexion de Claude Sonnet 5.5 est également signé sur la conversation qui le précède. Pour les comptes créés le 31 août 2026 à 00:00 UTC ou après, l'API applique cette règle par défaut, sur l'API Claude, Amazon Bedrock et Google Cloud. Sur ces comptes, une requête qui rejoue un bloc après une modification de l'historique antérieur renvoie une erreur 400. Gardez les conversations en ajout seul, et modifiez les instructions ou les outils avec des [messages système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages). Les blocs de réflexion produits par 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).

### L'utilisation de l'ordinateur nécessite le toolset sur l'API Claude et Google Cloud

Sur l'API Claude et Google Cloud, Claude Sonnet 5.5 ne prend en charge l'utilisation de l'ordinateur que via le « toolset » (ensemble d'outils) `computer_toolset_20260801`. Sur ces plateformes, `computer_20251124` renvoie une erreur 400. Claude Sonnet 5.5 n'accepte `computer_20250124` sur aucune plateforme. Repérez la version que vous envoyez aujourd'hui :

| Version envoyée aujourd'hui | Modèles de départ qui l'envoient                     | À envoyer sur l'API Claude et Google Cloud | À envoyer sur Amazon Bedrock |
| --------------------------- | ---------------------------------------------------- | ------------------------------------------ | ---------------------------- |
| `computer_20251124`         | Claude Sonnet 5, Claude Sonnet 4.6                   | `computer_toolset_20260801`                | `computer_20251124`          |
| `computer_20250124`         | Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 | `computer_toolset_20260801`                | `computer_20251124`          |

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

Le code qui envoie déjà le toolset ne nécessite aucune modification. [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) répertorie les modifications à apporter à la requête et à la boucle d'agent. Pour les autres plateformes, consultez [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#compatibility).

### L'advisor tool 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 Mythos 5 ou Claude Mythos 5.1. 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 ou deux phrases que le modèle rédige 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 devient silencieuse.

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 son `stop_details` peut 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 informatiques, 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 contribuer 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 bénin 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"`, bêta, API Claude uniquement) 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 de cybersécurité 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 l'API Claude 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 « latency » (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}` en tant que 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: 2023-06-01" \
    -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() { Role = Role.User, 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: 'claude-sonnet-4-6',
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    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: 2023-06-01" \
    -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() { Role = Role.User, 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: '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: "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.** Claude Sonnet 4.6 et les modèles antérieurs, ainsi que Claude Haiku 4.5, acceptent `temperature`, `top_p` et `top_k`. Sur Claude Sonnet 5.5, une valeur non par défaut renvoie une erreur 400. Supprimez-les.

**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 tokenizer 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 :** `xhigh` est nouveau, 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'images haute résolution, jusqu'à 2576 pixels sur le bord le plus long et 4 784 tokens visuels par image. Claude Sonnet 4.6, Claude Sonnet 4.5 et Claude Haiku 4.5 s'arrêtent à 1568 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. Sur Amazon Bedrock, les sorties structurées ne sont pas disponibles pour Claude Sonnet 5.5. Sur cette plateforme, décrivez le format dans le prompt ou utilisez un outil sans `strict`, et validez la sortie dans votre code.
* **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 le [tableau d'utilisation de l'ordinateur](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 un niveau d'effort explicitement, comme le décrit [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, sans en-tête bêta, et d'une limite de sortie plus élevée. Consultez la [page du modèle](https://platform.claude.com/docs/fr/models/sonnet-5-5/overview). Supprimez tout en-tête bêta de 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 est associé à une entrée de toolset 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é et sera supprimé à l'avenir. 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 l'API Claude et reste disponible sur Amazon Bedrock et Google Cloud. 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`. Claude 4.5 et les modèles ultérieurs s'arrêtent également avec `model_context_window_exceeded` lorsque la limite de la fenêtre de contexte est atteinte. Consultez [Gérer les raisons d'arrêt](https://platform.claude.com/docs/fr/build-with-claude/handling-stop-reasons).
* **Sauts de ligne finaux :** Claude 4.5 et les modèles ultérieurs les conservent dans les paramètres de type chaîne des appels d'outils.
* **En-têtes bêta hérités :** supprimez `token-efficient-tools-2025-02-19` et `output-128k-2025-02-19`.
* **Prompts :** révisez-les à l'aide des [bonnes pratiques de prompting](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 :

* **Identifiant 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ût. Consultez [Tarifs de Claude](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, sans en-tête bêta.
* **Routage :** Claude Sonnet 5.5 lit les blocs de réflexion de Claude Haiku 4.5. Une conversation qui passe au modèle supérieur conserve son raisonnement. Une conversation qui redescend vers Claude Haiku 4.5 perd les blocs de Claude Sonnet 5.5.