---
title: Guide de migration vers Claude Opus 5.5
url: https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide
description: Passez à Claude Opus 5.5 depuis des modèles Opus antérieurs ou Claude Sonnet 5 grâce à ce guide de migration. Les instructions pour activer Claude Opus 5.5 couvrent les paramètres de requête qui renvoient des erreurs, les blocs de réflexion présents dans chaque réponse et une liste de vérification pour chaque modèle de départ.
---
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.
Laissez Claude Code migrer votre code pour vous
```text
/claude-api migrate ce projet vers claude-opus-5-5
```
Cette page répertorie les modifications de code nécessaires pour passer à Claude Opus 5.5 depuis [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8), [Claude Opus 4.7](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-47), [Claude Opus 4.6 et les modèles Opus antérieurs](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-46), ou [Claude Sonnet 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-sonnet-5). Tous les lecteurs doivent consulter [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements) et [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response). Rendez-vous ensuite dans la section correspondant à votre modèle actuel : sa première phrase indique les autres sections qui vous concernent. La [liste de vérification de la migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist) répertorie chaque modification par modèle de départ.
Claude Opus 5.5 coûte moins cher que Claude Opus 5 (4 $ / 20 $ USD par million de tokens d’entrée / de sortie, contre 5 $ / 25 $ USD ; consultez la [tarification de Claude](https://platform.claude.com/docs/fr/about-claude/pricing)). Pour la prise en charge des fonctionnalités, consultez [Nouveautés de Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#feature-support). Pour les différences de comportement et les modèles de prompts propres au modèle, consultez [Rédiger des prompts pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).
## Ce que chaque requête à Claude Opus 5.5 doit respecter
Quel que soit le modèle dont vous venez, une requête à `claude-opus-5-5` doit respecter les points suivants. Lorsqu’un point indique qu’un paramètre est rejeté, l’API renvoie une erreur 400.
* **ID du modèle :** Utilisez `claude-opus-5-5`, un ID de modèle fixe sans suffixe de date. Sur Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) et Microsoft Foundry, utilisez l’ID de modèle propre à cette plateforme ; consultez [Disponibilité](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#availability).
* **Réflexion :** N’envoyez aucun champ `thinking`, ou envoyez `thinking: {"type": "adaptive"}`, ce qui est équivalent : l’[« adaptive thinking » (réflexion adaptative)](https://platform.claude.com/docs/fr/build-with-claude/thinking) est toujours activée. `thinking: {"type": "disabled"}` et les budgets de réflexion manuels (`thinking: {"type": "enabled", "budget_tokens": N}`) sont rejetés. Consultez l’[avant/après pour la réflexion](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
* **Effort :** Contrôlez la profondeur de réflexion avec le [paramètre effort](https://platform.claude.com/docs/fr/build-with-claude/effort), le seul paramètre de requête qui la contrôle. Les cinq niveaux (`low`, `medium`, `high`, `xhigh`, `max`) sont pris en charge, et la valeur par défaut est `medium`. Consultez [Niveaux d’effort recommandés pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5).
* **Choix d’outil :** Utilisez `tool_choice` `{"type": "auto"}` (la valeur par défaut) ou `{"type": "none"}`. Forcer un appel d’outil avec `{"type": "any"}` ou `{"type": "tool", "name": "..."}` est rejeté. Consultez l’[avant/après pour le choix d’outil](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#forced-tool-use).
* **Paramètres d’échantillonnage :** Omettez `temperature`, `top_p` et `top_k`. Utilisez le prompting pour guider le comportement du modèle.
* **Préremplissage :** Ne terminez pas `messages` par un tour assistant prérempli : il est rejeté. Utilisez plutôt les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs) ou des instructions dans l’invite système.
* **Utilisation de l’ordinateur :** Déclarez le « computer use » (utilisation de l’ordinateur) en tant que « toolset » (ensemble d’outils) `computer_toolset_20260801`. Sur Amazon Bedrock, `computer_20251124` fonctionne également. Consultez le [changement incompatible concernant l’utilisation de l’ordinateur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#computer-use-toolset).
* **Fenêtre de contexte :** Aucun en-tête bêta de « context window » (fenêtre de contexte) n’est nécessaire. La [fenêtre de contexte de 1M tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows) est la valeur par défaut, et un en-tête envoyé pour des modèles plus anciens n’a aucun effet.
La requête suivante respecte chaque point de la liste : l’effort est défini et il n’y a pas de champ `thinking`. Lorsque l’exemple affiche du texte, il trouve le bloc de texte par son type, car les blocs `thinking` viennent en premier.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Analyze the trade-offs between microservices and monolithic architectures"
}],
"output_config": {
"effort": "medium"
}
}'
```
```bash CLI
ant messages create \
--model claude-opus-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-opus-5-5",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Analyze the trade-offs between microservices and monolithic architectures",
}
],
output_config={"effort": "medium"},
)
for block in response.content:
if block.type == "text":
print(block.text)
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Analyze the trade-offs between microservices and monolithic architectures"
}
],
output_config: {
effort: "medium"
}
});
const textBlock = response.content.find((block) => block.type === "text");
console.log(textBlock?.text);
```
```csharp C#
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_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(message);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_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)
}
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_OPUS_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.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-opus-5-5',
outputConfig: ['effort' => 'medium'],
);
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: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: [
{ role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
],
output_config: {
effort: "medium"
}
)
message.content.each do |block|
puts block.text if block.type == :text
end
```
## Gérer la réflexion dans chaque réponse
La réflexion s’exécute sur chaque requête Claude Opus 5.5, de sorte que chaque réponse peut commencer par des blocs `thinking`, et `max_tokens` couvre la réflexion ainsi que le texte. Si votre code s’exécute déjà avec la réflexion activée, les points 1 à 3 sont probablement déjà en place : vérifiez les points 4 et 5. S’il s’exécutait sans réflexion, sur n’importe quel modèle antérieur, chaque point constitue une modification.
1. **`max_tokens` couvre la réflexion et le texte :** Sur Claude Opus 4.8 et les modèles Opus antérieurs, les requêtes sans champ `thinking` s’exécutent sans réflexion. Claude Opus 5 et Claude Sonnet 5 acceptent `thinking: {"type": "disabled"}`. Sur Claude Opus 5.5, chaque requête s’exécute avec la [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking). `max_tokens` reste une limite stricte sur la sortie totale, réflexion et texte de réponse compris ; revoyez donc cette valeur pour les charges de travail qui s’exécutaient sans réflexion. Les tokens de réflexion sont facturés comme des tokens de sortie même lorsque le texte de réflexion ne vous est pas renvoyé, de sorte qu’une telle charge de travail peut produire davantage de tokens de sortie par requête. Consultez [Contrôle des coûts](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost#cost-control). Pour consacrer moins de tokens à la réflexion, abaissez le niveau d’[effort](https://platform.claude.com/docs/fr/build-with-claude/effort). Si vous utilisez l’effort `xhigh` ou `max`, définissez une valeur `max_tokens` élevée afin que le modèle ait de la marge pour réfléchir et agir ; commencez à 64k tokens et ajustez à partir de là. Si vos prompts ont été optimisés pour une exécution sans réflexion, consultez [Prompts rédigés pour la réflexion désactivée](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
2. **Les réponses commencent par des blocs de réflexion :** Une réponse peut commencer par un ou plusieurs blocs `thinking` avant le premier bloc `text`. Le code qui lit la réponse par position, comme `content[0].text` ou un gestionnaire de streaming qui traite le premier événement `content_block_start` comme du texte, échoue sur ces réponses. Sélectionnez plutôt les blocs de contenu par leur champ `type` : lisez `text` dans les blocs dont le `type` est `"text"`, et effectuez un branchement selon le type de bloc lors du traitement des événements de streaming.
3. **Renvoyez les blocs de réflexion sans modification dans les boucles d’utilisation d’outils :** Si vous exécutez une boucle d’utilisation d’outils, renvoyez à l’API les blocs `thinking` de chaque réponse de l’assistant, complets et sans modification, lorsque vous renvoyez les résultats des outils, y compris les blocs dont le champ `thinking` est vide. Renvoyez le message de l’assistant tel que reçu plutôt que de filtrer ses blocs de contenu par type ou de le reconstruire : l’API rejette les blocs de réflexion modifiés, réordonnés ou partiellement supprimés avec une erreur 400. Consultez [Préserver les blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserving-thinking-blocks).
4. **Le texte de réflexion est omis par défaut :** `thinking.display` a pour valeur par défaut `"omitted"`, de sorte que les blocs `thinking` arrivent avec un champ `thinking` vide accompagné de leur `signature`. Traitez le champ `thinking` uniquement comme du texte d’affichage. Pour recevoir plutôt des résumés lisibles, définissez `thinking.display` sur `"summarized"` :
```python Python
thinking = {
"type": "adaptive",
"display": "summarized",
}
```
```typescript TypeScript
const thinking = {
type: "adaptive",
display: "summarized"
};
```
```csharp C#
var thinking = new ThinkingConfigAdaptive { Display = Display.Summarized };
```
```go Go
thinking := anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized,
},
}
```
```java Java
ThinkingConfigAdaptive thinking = ThinkingConfigAdaptive.builder()
.display(ThinkingConfigAdaptive.Display.SUMMARIZED)
.build();
```
```php PHP
$thinking = ['type' => 'adaptive', 'display' => 'summarized'];
```
```ruby Ruby
thinking = {
type: "adaptive",
display: "summarized"
}
```
Si votre produit diffuse le raisonnement aux utilisateurs en streaming, la valeur par défaut se traduit par une longue pause avant le début de la sortie ; définissez `display: "summarized"` pour rétablir une progression visible pendant la réflexion. Consultez [Contrôler l’affichage de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#controlling-thinking-display).
5. **Le texte entre les appels d’outils arrive dans des blocs de réflexion :** Les courtes notes que le modèle rédige entre les appels d’outils sont renvoyées sous forme de blocs `thinking`, qui sont vides avec l’affichage par défaut. Consultez [Le texte entre les appels d’outils est renvoyé dans des blocs de réflexion](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#text-between-tool-calls).
## Liste de vérification de la 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 actuel : chaque point jusqu’à ce stade vous concerne. Si vous utilisez Claude Opus 5, le premier groupe constitue la liste complète. Si vous utilisez Claude Sonnet 5, appliquez le premier groupe et le dernier.
### Tous les modèles de départ
* Mettez à jour l’ID du modèle vers `claude-opus-5-5`.
* Supprimez `thinking: {"type": "disabled"}` et `thinking: {"type": "enabled", ...}` ; choisissez plutôt un niveau d’effort.
* Définissez `effort` explicitement : la valeur par défaut est `medium`, alors que celle de Claude Opus 5 est `high`.
* Remplacez les types `tool_choice` `any` et `tool` par `auto` associé à l’utilisation stricte d’outils ou aux sorties structurées.
* Si vous utilisez une version antérieure de l’outil d’utilisation de l’ordinateur, déclarez plutôt `computer_toolset_20260801` (sans en-tête bêta) et mettez à jour votre boucle d’agent pour l’ensemble d’outils. Sur Amazon Bedrock, `computer_20251124` fonctionne également.
* Si un routeur ou un mécanisme de repli peut faire passer une conversation de Claude Opus 5.5 à un autre modèle, attendez-vous à ce que ce modèle s’exécute sans les blocs de réflexion de Claude Opus 5.5 (Claude Fable 5.1 et Claude Mythos 5.1 sur l’API Claude font exception et les conservent). Claude Opus 5.5 lui-même lit la réflexion de Claude Opus 5, des modèles Opus, Sonnet et Haiku antérieurs et, sur l’API Claude et Claude Models on Google Cloud (Google managed), de Claude Sonnet 5.5 et Claude Haiku 5.5, mais pas des modèles Claude Fable ou Claude Mythos.
* Lisez les blocs de contenu par `type`, et renvoyez les blocs `thinking` sans modification dans les boucles d’utilisation d’outils.
* Si votre interface affiche du texte entre les appels d’outils, définissez `display: "updates"` (bêta) ou `"summarized"` et affichez les blocs `thinking` non vides.
* Si votre code modifie des tours précédents, l’invite `system` ou `tools` en cours de conversation, suivez [Réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking).
* Gérez `stop_reason: "refusal"` et configurez un mécanisme de repli.
* Réétablissez vos références de coût et de latence au niveau d’effort choisi.
* Si votre code désactivait la réflexion, revoyez `max_tokens`, qui couvre la réflexion plus le texte de réponse ; avec un effort `xhigh` ou `max`, commencez à 64k. Consultez [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response).
### Claude Opus 4.8 ou antérieur
* Examinez les charges de travail qui s’exécutaient sans champ `thinking` : sur Claude Opus 5.5, elles s’exécutent avec la réflexion, et la réflexion ne peut pas être désactivée. Revoyez `max_tokens`, qui reste une limite stricte sur la sortie totale (réflexion et texte de réponse), et abaissez `effort` lorsque vous souhaitez moins de réflexion. Les tokens de réflexion sont facturés comme des tokens de sortie, de sorte que ces charges de travail peuvent produire davantage de tokens de sortie par requête.
* Vérifiez que tout code qui analyse le champ `thinking` le traite uniquement comme du texte d’affichage. Définissez `display: "summarized"` pour recevoir des résumés lisibles.
* Examinez les prompts proches du minimum de mise en cache : les prompts de 512 tokens ou plus peuvent créer des entrées de cache.
* Si votre organisation a un engagement [Priority Tier](https://platform.claude.com/docs/fr/api/service-tiers#supported-models), planifiez la capacité séparément : Priority Tier n’est pas pris en charge sur Claude Opus 5.5.
* Si vous utilisez l’effort `xhigh` ou `max`, augmentez `max_tokens` à au moins 64k comme point de départ.
* Pour les charges de travail agentiques, envisagez les [budgets de tâche](https://platform.claude.com/docs/fr/build-with-claude/task-budgets) (bêta) et les modifications d’outils en cours de conversation (bêta).
### Claude Opus 4.7 ou antérieur
* Effectuez un nouveau balayage des niveaux d’[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) sur vos propres évaluations plutôt que de reprendre un réglage optimisé pour un modèle antérieur.
* Supprimez tout en-tête bêta de fenêtre de contexte.
* Si vous reconstruisez l’historique de conversation pour mettre à jour des instructions, envisagez de passer à un message système en cours de conversation afin de préserver les accès au cache de prompts.
* Vérifiez que votre gestion des raisons d’arrêt lit `stop_details` lors des refus.
* Si vous souhaitez utiliser le mode rapide, que Claude Opus 4.7 rejette, définissez `speed: "fast"` sur vos requêtes à la Claude API. Claude Opus 5.5 ne nécessite pas d’en-tête bêta.
### Claude Opus 4.6 ou antérieur
* Supprimez `temperature`, `top_p` et `top_k` des charges utiles des requêtes.
* Remplacez `thinking: {"type": "enabled", "budget_tokens": N}` par `thinking: {"type": "adaptive"}` combiné au [paramètre effort](https://platform.claude.com/docs/fr/build-with-claude/effort), ou supprimez entièrement le champ `thinking` ; la réflexion adaptative est toujours activée.
* Si votre interface utilisateur affiche le contenu de réflexion, activez explicitement la synthèse de la réflexion.
* Réévaluez le coût et la latence de bout en bout avec la tokenisation mise à jour.
* Réajustez `max_tokens` pour tenir compte de la tokenisation mise à jour, y compris les déclencheurs de compaction.
* Testez à nouveau toute estimation du nombre de tokens côté client.
* Si votre application envoie des images, réévaluez votre budget pour la [prise en charge des images haute résolution](https://platform.claude.com/docs/fr/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) (jusqu’à environ 3 fois plus de tokens d’image par image en pleine résolution). Réduisez la résolution avant l’envoi si vous n’avez pas besoin de la fidélité supplémentaire.
* Si vous exploitez des coordonnées de pointage ou de boîtes englobantes provenant du modèle, supprimez toute conversion par facteur d’échelle ; les coordonnées correspondent 1:1 aux pixels réels de l’image sur Claude Opus 4.7 et les modèles ultérieurs.
* Examinez les [changements de comportement](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#behavior-changes) apparus avec Claude Opus 4.7.
* Si votre produit effectue des travaux de sécurité légitimes, inscrivez-vous au [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) pour bénéficier de restrictions allégées sur le contenu cyber.
### Claude Opus 4.5 ou antérieur
* Supprimez tout préremplissage de message d’assistant ; Claude Opus 4.6 les rejette déjà.
* Vérifiez que l’analyse JSON des appels d’outils utilise un analyseur JSON standard.
* Passez de `client.beta.messages.create()` (csharp: `client.Beta.Messages.Create()`; go: `client.Beta.Messages.New()`; java: `client.beta().messages().create()`; php: `$client->beta->messages->create()`; cli: `ant beta:messages create`) à `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`) : la réflexion adaptative et l’effort ne nécessitent pas d’espace de noms bêta.
* Supprimez l’en-tête bêta `effort-2025-11-24` (le paramètre effort ne le requiert pas).
* Supprimez l’en-tête bêta `fine-grained-tool-streaming-2025-05-14`.
* Supprimez l’en-tête bêta `interleaved-thinking-2025-05-14` (la réflexion adaptative active automatiquement la réflexion entrelacée).
* Migrez `output_format` vers `output_config.format` (le cas échéant).
### Claude 4.1 ou antérieur
* Mettez à jour les versions des outils (`text_editor_20250728`, `code_execution_20260521`).
* Gérez la raison d’arrêt `refusal`.
* Gérez la raison d’arrêt `model_context_window_exceeded`.
* Vérifiez la gestion des sauts de ligne finaux dans les paramètres de chaîne des outils.
* Supprimez les en-têtes bêta `token-efficient-tools-2025-02-19` et `output-128k-2025-02-19`.
* Examinez et mettez à jour vos prompts en suivant les [meilleures pratiques de rédaction de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Claude Sonnet 5 uniquement
* Si vous reconstruisez l’historique de conversation pour mettre à jour des instructions, envisagez de passer à un message système en cours de conversation afin de préserver les accès au cache de prompts.
* Examinez les prompts proches du minimum de mise en cache : les prompts de 512 tokens ou plus peuvent créer des entrées de cache.
## Migrer vers Claude Opus 5.5 depuis Claude Opus 5
Parcourez d’abord [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements) et [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response). Tous les modèles de départ nécessitent les modifications de cette section. Il s’agit des paramètres de requête que Claude Opus 5.5 rejette et des changements de réponse qui l’accompagnent. La liste de vérification de cette section correspond au premier groupe de la [liste de vérification de la migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist).
### Mettre à jour le nom de votre modèle
```python
model = "claude-opus-5" # Before
model = "claude-opus-5-5" # After
```
`claude-opus-5-5` est un identifiant de modèle fixe sans suffixe de date, selon le même schéma que `claude-opus-5`. Sur Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) et Microsoft Foundry, utilisez l’identifiant de modèle propre à cette plateforme ; consultez [Disponibilité](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#availability).
### Changements incompatibles
Chaque changement est expliqué sous [Changements incompatibles](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#breaking-changes) dans Nouveautés de Claude Opus 5.5 ; cette section indique la modification de code pour chacun.
#### La réflexion ne peut pas être désactivée
`thinking: {"type": "disabled"}` et `thinking: {"type": "enabled", "budget_tokens": N}` renvoient tous deux une erreur 400 (`"thinking.type.disabled" is not supported for this model.` ou `"thinking.type.enabled" is not supported for this model.`). Supprimez le champ `thinking` et choisissez un niveau d’[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) ; là où vous désactiviez la réflexion pour économiser des tokens, utilisez un niveau plus bas. Les réponses commencent alors par des blocs `thinking` ; sélectionnez donc les blocs de contenu par `type` et renvoyez les blocs `thinking` sans modification avec les résultats des outils. Consultez [La réflexion ne peut pas être désactivée](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#thinking-cant-be-disabled).
Avant. Claude Opus 5 accepte cette requête, et Claude Opus 5.5 la rejette avec une erreur 400 :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 16000,
"thinking": {"type": "disabled"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5 \
--max-tokens 16000 \
--thinking '{type: disabled}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5",
max_tokens=16000,
thinking={"type": "disabled"},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5",
max_tokens: 16000,
thinking: { type: "disabled" },
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 16000,
Thinking = new ThinkingConfigDisabled(),
Messages = [new UserMessageParam { Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(16000L)
.thinking(ThinkingConfigDisabled.builder().build())
.addUserMessage("...")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 16000,
thinking: ThinkingConfigDisabled::with(),
messages: [['role' => 'user', 'content' => '...']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 16000,
thinking: Anthropic::ThinkingConfigDisabled.new,
messages: [{ role: "user", content: "..." }]
)
```
Après :
```bash cURL
# la réflexion est toujours active ; l'effort sert de réglage
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"output_config": {"effort": "low"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
# la réflexion est toujours active ; effort sert de contrôle
ant messages create \
--model claude-opus-5-5 \
--max-tokens 16000 \
--output-config '{effort: low}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
output_config={"effort": "low"}, # thinking is always on; effort is the control
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
output_config: { effort: "low" }, // thinking is always on; effort is the control
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
OutputConfig = new() { Effort = Effort.Low }, // thinking is always on; effort is the control
Messages = [new UserMessageParam { Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortLow, // thinking is always on; effort is the control
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
// la réflexion est toujours activée ; l'effort sert de réglage
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.LOW)
.build())
.addUserMessage("...")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 16000,
// la réflexion est toujours active ; l'effort sert de contrôle.
outputConfig: OutputConfig::with(effort: Effort::LOW),
messages: [['role' => 'user', 'content' => '...']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 16000,
# la réflexion est toujours active ; l'effort sert de contrôle
output_config: { effort: Anthropic::OutputConfig::Effort::LOW },
messages: [{ role: "user", content: "..." }]
)
```
#### L’utilisation forcée d’outils n’est pas prise en charge
Les types `tool_choice` `any` et `tool` renvoient une erreur 400 (`tool_choice: type "tool" and "any" are not supported for this model.`), y compris sur le point de terminaison de comptage des tokens. Utilisez `auto` avec l’[utilisation stricte d’outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/strict-tool-use) ou les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs), et indiquez dans le prompt quand l’outil s’applique. L’utilisation stricte d’outils accepte un sous-ensemble de JSON Schema ; vérifiez donc le `input_schema` de chaque outil avant d’ajouter `strict: true`. Chaque objet du schéma doit définir `additionalProperties: false` ; consultez [Limitations de JSON Schema](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs#json-schema-limitations). Consultez [L’utilisation forcée d’outils n’est pas prise en charge](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#forced-tool-use-is-not-supported).
Avant. Claude Opus 5 accepte cette requête, et Claude Opus 5.5 la rejette avec une erreur 400 :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"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-opus-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-opus-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-opus-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.ClaudeOpus5,
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.ModelClaudeOpus5,
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_OPUS_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_OPUS_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_OPUS_5,
max_tokens: 1024,
tools: tools,
tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
messages: [{ role: "user", content: "What's the weather in Paris?" }]
)
```
Après :
```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: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-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-opus-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 le 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-opus-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-opus-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.ClaudeOpus5_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.ModelClaudeOpus5_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_OPUS_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_OPUS_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_OPUS_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." }
]
)
```
#### Les blocs de réflexion sont liés au modèle et à la conversation
Sur l’API Claude, Claude Fable 5.1 et Claude Mythos 5.1 lisent les blocs de réflexion de Claude Opus 5.5 ; aucun autre modèle ne le fait. Un routeur ou un mécanisme de repli qui fait passer une conversation de Claude Opus 5.5 à n’importe quel autre modèle exécute ces tours sans eux. Dans l’autre sens, Claude Opus 5.5 lit les blocs de réflexion de Claude Opus 5, des modèles Opus, Sonnet et Haiku antérieurs et, sur l’API Claude et Claude Models on Google Cloud (Google managed), de Claude Sonnet 5.5 et Claude Haiku 5.5, mais pas des modèles Claude Fable ou Claude Mythos. Conservez la conversation en ajout seul (aucune modification de l’invite `system`, des `tools` ou des messages antérieurs en cours de conversation) afin que les blocs restent valides ; Claude Code, claude.ai, Claude Managed Agents et le Claude Agent SDK le font déjà. Sur les comptes créés le 31 août 2026 à 00:00 UTC ou après, sur l’API Claude et sur les plateformes cloud, une requête qui rejoue un bloc de réflexion après une telle modification et qui laisse `thinking.block_binding.prefix_mismatch_behavior` non défini reçoit une erreur 400. Aucune modification de code n’est nécessaire pour les intégrations en ajout seul. Consultez [Les blocs de réflexion sont liés au modèle et à la conversation](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#thinking-blocks-are-tied-to-the-model-that-produced-them) et [Réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking).
#### Certaines versions de l’outil d’utilisation de l’ordinateur ne sont pas prises en charge
Claude Opus 5.5 prend en charge l’utilisation de l’ordinateur via l’ensemble d’outils `computer_toolset_20260801`. Sur Amazon Bedrock, Claude Opus 5.5 accepte également l’outil `computer_20251124` avec l’en-tête bêta `computer-use-2025-11-24`. Claude Opus 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. Sur l’API Claude, le message d’erreur commence par `'claude-opus-5-5' does not support tool types: computer_20251124.` puis liste les types d’outils que le modèle accepte.
Les intégrations qui utilisent l’ensemble d’outils ne nécessitent aucune modification. Pour faire passer une intégration `computer_20251124` à l’ensemble d’outils, supprimez l’en-tête bêta et envoyez l’entrée `computer_toolset_20260801` sans `name` ni dimensions d’affichage. Dans votre boucle d’agent, traitez chaque bloc `tool_use` membre d’un tour et renvoyez `toolset_name` dans chaque résultat. Lisez l’action à partir du `name` de chaque bloc, et non à partir de `input.action`. [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) liste les modifications de la boucle d’agent.
Avant. Claude Opus 5 accepte cette requête, et Claude Opus 5.5 la rejette avec une erreur 400 sur l’API Claude :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: computer-use-2025-11-24" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 4096,
"tools": [{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768
}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
ant beta:messages create \
--model claude-opus-5 \
--max-tokens 4096 \
--beta computer-use-2025-11-24 \
--tool '{
type: computer_20251124,
name: computer,
display_width_px: 1024,
display_height_px: 768
}' \
--message '{role: user, content: "Open the display settings."}'
```
```python Python
client.beta.messages.create(
model="claude-opus-5",
max_tokens=4096,
betas=["computer-use-2025-11-24"],
tools=[
{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768,
}
],
messages=[{"role": "user", "content": "Open the display settings."}],
)
```
```typescript TypeScript
await client.beta.messages.create({
model: "claude-opus-5",
max_tokens: 4096,
betas: ["computer-use-2025-11-24"],
tools: [
{
type: "computer_20251124",
name: "computer",
display_width_px: 1024,
display_height_px: 768
}
],
messages: [{ role: "user", content: "Open the display settings." }]
});
```
```csharp C#
await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 4096,
Betas = [AnthropicBeta.ComputerUse2025_11_24],
Tools =
[
new BetaToolComputerUse20251124
{
DisplayWidthPx = 1024,
DisplayHeightPx = 768,
},
],
Messages = [new BetaUserMessageParam { Content = "Open the display settings." }],
});
```
```go Go
client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 4096,
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaComputerUse2025_11_24},
Tools: []anthropic.BetaToolUnionParam{
{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
DisplayWidthPx: 1024,
DisplayHeightPx: 768,
}},
},
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Open the display settings.")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(4096L)
.addBeta(AnthropicBeta.COMPUTER_USE_2025_11_24)
.addTool(BetaToolComputerUse20251124.builder()
.displayWidthPx(1024L)
.displayHeightPx(768L)
.build())
.addUserMessage("Open the display settings.")
.build();
client.beta().messages().create(params);
```
```php PHP
$client->beta->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 4096,
betas: [AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
BetaToolComputerUse20251124::with(
displayWidthPx: 1024,
displayHeightPx: 768,
),
],
messages: [['role' => 'user', 'content' => 'Open the display settings.']],
);
```
```ruby Ruby
client.beta.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 4096,
betas: [Anthropic::AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
Anthropic::Beta::BetaToolComputerUse20251124.new(
name: :computer,
display_width_px: 1024,
display_height_px: 768
)
],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
Après :
```bash cURL
# pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"tools": [{"type": "computer_toolset_20260801"}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
# pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage
ant messages create \
--model claude-opus-5-5 \
--max-tokens 4096 \
--tool '{type: computer_toolset_20260801}' \
--message '{role: user, content: "Open the display settings."}'
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
# pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
tools=[{"type": "computer_toolset_20260801"}],
messages=[{"role": "user", "content": "Open the display settings."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
// pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
tools: [{ type: "computer_toolset_20260801" }],
messages: [{ role: "user", content: "Open the display settings." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
// pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
Tools = [new ComputerToolset20260801()],
Messages = [new UserMessageParam { Content = "Open the display settings." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
// pas d'en-tête bêta ; l'entrée de l'ensemble d'outils n'accepte ni nom ni taille d'affichage
Tools: []anthropic.ToolUnionParam{
{OfComputerToolset20260801: &anthropic.ComputerToolset20260801Param{}},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Open the display settings.")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
// pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
.addTool(ComputerToolset20260801.builder().build())
.addUserMessage("Open the display settings.")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 4096,
// pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage.
tools: [ComputerToolset20260801::with()],
messages: [['role' => 'user', 'content' => 'Open the display settings.']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
# pas d'en-tête bêta ; l'entrée de l'ensemble d'outils ne prend ni nom ni taille d'affichage
tools: [Anthropic::ComputerToolset20260801.new],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
### Le texte entre les appels d’outils est renvoyé dans des blocs de réflexion
Sur Claude Opus 5, le texte que le modèle rédige entre les appels d’outils est renvoyé sous forme de blocs `text`. Sur Claude Opus 5.5, comme sur Claude Fable 5.1, cette narration est renvoyée sous forme de [blocs `thinking` de mise à jour de progression](https://platform.claude.com/docs/fr/build-with-claude/thinking#progress-updates), au plus un avant chaque appel d’outil. Avec la valeur par défaut `"omitted"` de `thinking.display`, leur champ `thinking` est vide. Aucune requête n’échoue, mais une application qui diffuse ce texte en streaming à ses utilisateurs sous forme de mises à jour de progression devient silencieuse entre les appels d’outils. Pour rétablir les mises à jour, lisez-les depuis les blocs `thinking` et définissez une valeur `display` qui renvoie leur texte : `"updates"` (bêta, en-tête `thinking-display-updates-2026-08-18`) renvoie les mises à jour de progression tandis que le raisonnement reste masqué, et `"summarized"` renvoie les deux, mélangés. Affichez ensuite chaque bloc `thinking` non vide avant le bloc `tool_use` qu’il précède, et renvoyez les blocs sans modification avec le reste du tour de l’assistant. Consultez [Mises à jour de progression destinées aux utilisateurs](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
### Classificateurs de sécurité et repli
Claude Opus 5.5 peut renvoyer `stop_reason: "refusal"` avec une catégorie `stop_details`. Ses classificateurs couvrent un ensemble de catégories plus large que ceux de Claude Opus 5 ; attendez-vous donc à des valeurs `stop_details.category` telles que `"bio"` en plus de `"cyber"` et `"reasoning_extraction"` ; consultez le [tableau des catégories de refus](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#refusal-response). Gérez les refus et configurez un [repli côté serveur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback) ou votre propre nouvelle tentative (le repli côté serveur ne relance pas les requêtes refusées avec `"reasoning_extraction"` ; ce refus vous est renvoyé) ; consultez [Refus et repli](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback) et [Refus de protection](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#safeguard-refusals).
### Modifications recommandées
1. **Relancez votre balayage des niveaux d’effort.** L’effort est le seul contrôle de la réflexion sur Claude Opus 5.5, et sa valeur par défaut est `medium` alors que celle de Claude Opus 5 est `high` ; une requête qui omet `effort` s’exécute donc désormais à `medium`. Descendez d’un niveau là où la qualité se maintient, et montez d’un niveau pour les travaux les plus exigeants. Consultez [Effort](https://platform.claude.com/docs/fr/build-with-claude/effort).
2. **Réévaluez les instructions de prompt propres au modèle.** Les instructions optimisées pour le comportement de Claude Opus 5 pourraient ne plus être nécessaires ; consultez [Rédiger des prompts pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5). Si vous exécutiez avec la réflexion désactivée, consultez également [Prompts rédigés pour la réflexion désactivée](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
3. **Testez dans un environnement de développement** avant de basculer le trafic de production.
## Migrer vers Claude Opus 5.5 depuis Claude Opus 4.8
Parcourez d’abord [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements), [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response) et [Migrer vers Claude Opus 5.5 depuis Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-5). Utilisez `claude-opus-4-8` comme identifiant de modèle à remplacer. Cette dernière section s’applique telle quelle au code sur Claude Opus 4.8, car Claude Opus 4.8, comme Claude Opus 5 :
* Accepte `thinking: {"type": "disabled"}`, le choix d’outil forcé et l’outil `computer_20251124`.
* Renvoie le texte entre les appels d’outils sous forme de blocs `text`.
* Utilise par défaut l’effort `high`.
Cette section ajoute ce qui a changé entre Claude Opus 4.8 et Claude Opus 5. Pour une liste de vérification, consultez les deux premiers groupes de la [liste de vérification de la migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist).
### Ce qui a changé
1. **La réflexion s’exécute sur les requêtes qui l’omettaient :** Sur Claude Opus 4.8, la réflexion est désactivée sauf si vous la demandez. Sur Claude Opus 5.5, une requête sans champ `thinking` s’exécute avec la réflexion ; chaque point de [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response) constitue donc une modification pour ce code. Si votre code n’a jamais envoyé de champ `thinking`, il n’y a rien à supprimer dans l’[avant/après pour la réflexion](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
2. **Minimum de mise en cache des prompts abaissé :** La longueur minimale de prompt pouvant être mise en cache sur Claude Opus 5.5 est de 512 tokens, contre 1 024 tokens sur Claude Opus 4.8. Les prompts trop courts pour être mis en cache sur Claude Opus 4.8 peuvent créer des entrées de cache, sans aucune modification de code. Consultez [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-limitations) pour les minimums par modèle.
3. **Priority Tier n’est pas pris en charge :** [Priority Tier](https://platform.claude.com/docs/fr/api/service-tiers#supported-models) n’est pas pris en charge sur Claude Opus 5.5, alors que Claude Opus 4.8 le conserve. Si votre organisation a un engagement Priority Tier, planifiez la capacité séparément.
### Modifications recommandées
Ces modifications ne sont pas obligatoires mais amélioreront votre expérience :
1. **Envisager les budgets de tâche (bêta) :** Pour les charges de travail agentiques, les [« task budgets » (budgets de tâche)](https://platform.claude.com/docs/fr/build-with-claude/task-budgets) indiquent au modèle de combien de tokens il dispose pour une boucle agentique complète. Ils nécessitent l’en-tête bêta `task-budgets-2026-03-13`.
2. **Envisager les modifications d’outils en cours de conversation (bêta) :** Les modifications d’outils en cours de conversation vous permettent d’ajouter ou de supprimer des outils entre les tours d’une conversation sans invalider les correspondances du [« prompt cache » (cache des prompts)](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours précédents. Modifier le tableau `tools` lui-même invalide le préfixe mis en cache. Sur la Claude API, Claude Platform on AWS et Claude Models on Google Cloud (Anthropic managed), envoyez l’en-tête bêta `inline-tools-2026-09-15`. L’en-tête `mid-conversation-tool-changes-2026-07-01` fonctionne pour les modifications qui désignent un outil par référence, sur la Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) et Claude Models on Google Cloud (Google managed).
## Migrer vers Claude Opus 5.5 depuis Claude Opus 4.7
Parcourez d’abord [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements), [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response), [Migrer vers Claude Opus 5.5 depuis Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-5) et [Migrer vers Claude Opus 5.5 depuis Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8). Utilisez `claude-opus-4-7` comme identifiant de modèle à remplacer. Ces sections s’appliquent telles quelles au code sur Claude Opus 4.7. Comme Claude Opus 4.8, il accepte `thinking: {"type": "disabled"}`, le choix d’outil forcé et l’outil `computer_20251124`. Il utilise par défaut l’effort `high` et s’exécute sans réflexion sauf si vous la demandez.
Cette section ajoute ce qui a changé après Claude Opus 4.7. Si votre code utilise Claude Opus 4.6 ou antérieur, poursuivez avec [Migrer vers Claude Opus 5.5 depuis Claude Opus 4.6 et les modèles Opus antérieurs](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-46) après cette section. Elle ajoute les changements incompatibles entrés en vigueur avec Claude Opus 4.7. Pour une liste de vérification, consultez les trois premiers groupes de la [liste de vérification de la migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist).
### Ce qui a changé
Aucun de ces points n’ajoute de changement incompatible à ceux des sections précédentes ; ils méritent d’être vérifiés après le remplacement de l’identifiant du modèle.
1. **Niveaux d’effort recalibrés :** L’allocation de tokens derrière chaque niveau d’effort change sur Claude Opus 5.5 par rapport à Claude Opus 4.7. La valeur par défaut est `medium`, alors que celle de Claude Opus 4.7 est `high`. Effectuez un nouveau balayage des niveaux d’effort sur vos propres évaluations plutôt que de reprendre un paramètre ajusté pour Claude Opus 4.7. Consultez [Effort](https://platform.claude.com/docs/fr/build-with-claude/effort).
2. **La fenêtre de contexte de 1M est la valeur par défaut :** Claude Opus 5.5 fournit par défaut la [« context window » (fenêtre de contexte)](https://platform.claude.com/docs/fr/build-with-claude/context-windows) complète de 1M tokens, sans en-tête bêta. Si votre client transmet un en-tête bêta de fenêtre de contexte pour assurer la compatibilité avec des modèles plus anciens, supprimez-le.
3. **Messages système en cours de conversation :** Sur la Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) et Claude Models on Google Cloud (Google managed), Claude Opus 5.5 accepte les messages `role: "system"` immédiatement après un tour utilisateur dans le tableau `messages` (sous réserve des [règles de placement](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#limitations)). Utilisez le champ `system` de premier niveau pour les instructions qui s’appliquent dès le début. Claude Opus 4.7 rejette `role: "system"` dans `messages` avec une erreur 400. Si vous maintenez des chemins de code qui reconstruisent l’historique complet des messages pour mettre à jour les instructions, vous pouvez les simplifier et préserver les correspondances du [cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours précédents.
4. **Détails d’arrêt en cas de refus :** Lorsque le modèle décline une requête, Claude Opus 5.5 renvoie un objet `stop_details` qui nomme la catégorie du refus, en plus de la raison d’arrêt `refusal`. Claude Opus 4.7 renvoie le même objet, cela n’a donc d’importance que si votre gestion des raisons d’arrêt ne le lit pas encore. Aucun en-tête bêta n’est requis, et il n’y a pas de possibilité de désactivation. Si votre gestion des raisons d’arrêt ne le lit pas encore, consultez [Gérer les raisons d’arrêt](https://platform.claude.com/docs/fr/build-with-claude/handling-stop-reasons). Claude Opus 5.5 décline des requêtes dans davantage de catégories ; consultez [Classificateurs de sécurité et solution de repli](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#safety-classifiers-and-fallback).
5. **Mode rapide :** Claude Opus 5.5 prend en charge le [« fast mode » (mode rapide)](https://platform.claude.com/docs/fr/build-with-claude/fast-mode) sur la Claude API. Le mode rapide n’est pas disponible sur Claude Opus 4.7, où les requêtes avec `speed: "fast"` renvoient une erreur. Définissez `speed: "fast"` sur vos requêtes. Claude Opus 5.5 n’a pas besoin d’en-tête bêta.
6. **Ensemble d’outils d’utilisation de l’ordinateur et outil d’utilisation du navigateur :** Claude Opus 5.5 prend en charge le [« computer use » (utilisation de l’ordinateur)](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool) sous la forme de l’ensemble d’outils `computer_toolset_20260801` ainsi que le [« browser use tool » (outil d’utilisation du navigateur)](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool) pour les tâches au sein de pages web. Claude Opus 4.7 ne prend en charge ni l’un ni l’autre. Pour migrer une intégration `computer_20251124` vers l’ensemble d’outils, consultez le [changement incompatible concernant l’utilisation de l’ordinateur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#computer-use-toolset).
## Migrer vers Claude Opus 5.5 depuis Claude Opus 4.6 et les modèles Opus antérieurs
Commencez par parcourir chacune des sections précédentes, dans l’ordre de la page. Il s’agit de [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements), [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response), ainsi que des sections consacrées à [Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8) et [Claude Opus 4.7](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-47). Ces sections s’appliquent telles quelles au code utilisant Claude Opus 4.6. Comme Claude Opus 4.7, ce modèle accepte `thinking: {"type": "disabled"}`, le choix d’outil forcé et l’outil `computer_20251124`. Il utilise par défaut l’effort `high` et s’exécute sans réflexion, sauf si vous la demandez. Claude Opus 4.5 et les modèles Opus antérieurs acceptent également `thinking: {"type": "disabled"}` et le choix d’outil forcé, et s’exécutent sans réflexion sauf si vous la demandez ; ces sections s’appliquent donc aussi à eux.
Cette section ajoute ce qui a changé dans Claude Opus 4.7, avec `claude-opus-4-6` comme identifiant de modèle à remplacer. Ses deux sous-sections ajoutent ce qui a changé auparavant, pour les lecteurs utilisant [Claude Opus 4.5 ou une version antérieure](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-45) et [Claude 4.1 ou une version antérieure](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier). Pour une liste de vérification, consultez la [liste de vérification de la migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist) jusqu’au groupe qui mentionne votre modèle.
### Changements incompatibles
1. **Suppression de l’« extended thinking » (réflexion étendue) :** `thinking: {"type": "enabled", "budget_tokens": N}` n’est plus pris en charge sur Claude Opus 4.7 et les modèles ultérieurs, et renvoie une erreur 400. Passez à l’[« adaptive thinking » (réflexion adaptative)](https://platform.claude.com/docs/fr/build-with-claude/thinking) (`thinking: {"type": "adaptive"}`) et utilisez le [paramètre effort](https://platform.claude.com/docs/fr/build-with-claude/effort) pour contrôler la profondeur de la réflexion. Sur Claude Opus 5.5, la réflexion adaptative est toujours activée : `thinking: {"type": "adaptive"}` est valide et équivaut à omettre entièrement le champ `thinking`.
Avant (Claude Opus 4.6) :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-4-6",
"max_tokens": 16000,
"thinking": {
"type": "enabled",
"budget_tokens": 10000
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-4-6
max_tokens: 16000
thinking:
type: enabled
budget_tokens: 10000
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-4-6",
max_tokens=16000,
thinking={"type": "enabled", "budget_tokens": 10000},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-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.ClaudeOpus4_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.ModelClaudeOpus4_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_OPUS_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-opus-4-6',
thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
);
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: "claude-opus-4-6",
max_tokens: 16000,
thinking: {
type: "enabled",
budget_tokens: 10000
},
messages: [
{ role: "user", content: "..." }
]
)
```
Après (Claude Opus 5.5), où l’identifiant du modèle et les lignes `thinking` et `output_config` diffèrent :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"output_config": {
"effort": "high"
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
thinking:
type: adaptive
output_config:
effort: high
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-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-opus-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.ClaudeOpus5_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.ModelClaudeOpus5_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_OPUS_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_OPUS_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_OPUS_5_5,
max_tokens: 16000,
thinking: {
type: "adaptive"
},
output_config: {
effort: "high" # or "max", "xhigh", "medium", "low"
},
messages: [
{ role: "user", content: "..." }
]
)
```
La réflexion adaptative peut être orientée par le prompt et par le [paramètre d’effort](https://platform.claude.com/docs/fr/build-with-claude/effort), qui remplace le budget de réflexion comme moyen de contrôler la quantité de raisonnement du modèle. Effectuez un balayage des niveaux d’effort sur vos propres évaluations plutôt que de convertir une valeur `budget_tokens`. Le [tableau des niveaux d’effort](https://platform.claude.com/docs/fr/build-with-claude/effort#effort-levels) décrit quand utiliser chaque niveau, et [Niveaux d’effort recommandés pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5) couvre ce modèle.
2. **Suppression des paramètres d’échantillonnage :** Omettez `temperature`, `top_p` et `top_k`. Le prompt est le moyen recommandé pour orienter le comportement du modèle sur Claude Opus 5.5. Si vous utilisiez `temperature = 0` pour obtenir un comportement déterministe, notez que cela n’a jamais garanti des sorties identiques sur les modèles précédents.
3. **Contenu de la réflexion omis par défaut :** Les blocs de réflexion apparaissent toujours dans le flux de réponse sur Claude Opus 4.7 et les modèles ultérieurs, mais leur champ `thinking` est vide, sauf si vous l’activez explicitement. Il s’agit d’un changement silencieux par rapport à Claude Opus 4.6, où le comportement par défaut consistait à renvoyer un texte de réflexion résumé. Pour le rétablir, consultez l’élément 4 de [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response).
4. **Mise à jour du décompte des tokens :** Claude Opus 4.7 a introduit un nouveau « tokenizer » (analyseur en tokens), que les modèles Opus ultérieurs, y compris Claude Opus 5.5, utilisent également. Il contribue à l’amélioration des performances sur un large éventail de tâches, et il peut utiliser environ 1x à 1,35x plus de tokens lors du traitement de texte par rapport aux modèles antérieurs à Claude Opus 4.7 (jusqu’à environ 35 pour cent de plus, selon le contenu).
[`/v1/messages/count_tokens`](https://platform.claude.com/docs/fr/build-with-claude/token-counting) renvoie un nombre de tokens différent pour Claude Opus 5.5 de celui qu’il renvoyait pour Claude Opus 4.6. L’efficacité en tokens peut varier selon la nature de la charge de travail.
Mettez à jour vos paramètres `max_tokens` pour prévoir une marge supplémentaire, y compris pour les déclencheurs de compaction, et testez à nouveau tout chemin de code qui estime les tokens côté client ou suppose un ratio fixe entre tokens et caractères. Utilisez le point de terminaison de [décompte des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) pour vérifier. Les interventions dans le prompt, [`task_budget`](https://platform.claude.com/docs/fr/build-with-claude/task-budgets) et [`effort`](https://platform.claude.com/docs/fr/build-with-claude/effort) peuvent aider à maîtriser les coûts ; ces contrôles peuvent se faire au détriment de l’intelligence du modèle.
5. **Suppression du « prefill » (pré-remplissage) (déjà en vigueur sur Claude Opus 4.6) :** Le pré-remplissage des messages de l’assistant renvoie une erreur 400 sur Claude Opus 4.6 et les modèles Opus ultérieurs, y compris Claude Opus 5.5 ; il ne s’agit donc d’un changement que si vous venez de Claude Opus 4.5 ou d’une version antérieure. Utilisez plutôt les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs) ou des instructions dans l’invite système.
### Changements de comportement
Claude Opus 4.7 a introduit des différences de comportement par rapport à Claude Opus 4.6 qui ne constituent pas des changements incompatibles de l’API. Les trois suivantes affectent le code ou l’infrastructure d’encadrement :
1. **Mises à jour de progression intégrées dans les traces agentiques :** Claude Opus 4.7 fournit à l’utilisateur des mises à jour plus régulières et de meilleure qualité tout au long des longues traces agentiques. Si vous avez ajouté une infrastructure d’encadrement pour forcer des messages d’état intermédiaires (« Après chaque série de 3 appels d’outils, résume la progression »), essayez de la supprimer. Sur Claude Opus 5.5, ces mises à jour arrivent dans des blocs `thinking`, qui sont vides avec la valeur par défaut de `thinking.display`. Pour les recevoir, consultez [Le texte entre les appels d’outils est renvoyé dans des blocs de réflexion](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#text-between-tool-calls). Pour en façonner la longueur et le contenu, consultez [Mises à jour de progression destinées à l’utilisateur](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
2. **Protections de cybersécurité en temps réel :** Ces protections sont nouvelles dans Claude Opus 4.7 : les requêtes portant sur des sujets interdits ou à haut risque peuvent entraîner des refus. Pour des travaux de sécurité légitimes tels que les tests d’intrusion, la recherche de vulnérabilités ou le red-teaming, faites une demande auprès du [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) pour obtenir des restrictions allégées. La procédure de demande dépend de la manière dont vous accédez à Claude.
3. **Prise en charge des images haute résolution :** Claude Opus 4.7 est le premier modèle Claude à prendre en charge les images haute résolution. La résolution maximale des images est de 2 576 pixels sur le côté le plus long, contre 1 568 pixels sur les modèles précédents. Cela apporte des gains sur les charges de travail fortement axées sur la vision et s’avère particulièrement utile pour l’utilisation de l’ordinateur, la compréhension de captures d’écran et l’analyse de documents.
La prise en charge de la haute résolution est automatique et ne nécessite ni en-tête bêta ni activation côté client. Deux points sont à prévoir :
* Les images en pleine résolution peuvent utiliser jusqu’à environ 3x plus de tokens d’image que sur les modèles précédents (jusqu’à 4 784 tokens par image, contre un plafond précédent d’environ 1 600 tokens). Réévaluez le budget `max_tokens` et vos prévisions de coûts pour les charges de travail riches en images, ou réduisez la résolution avant l’envoi si vous n’avez pas besoin de la fidélité supplémentaire.
* Les coordonnées de pointage et de cadres de délimitation renvoyées par le modèle correspondent en 1:1 aux pixels réels de l’image sur Claude Opus 4.7 ; aucune conversion par facteur d’échelle n’est donc nécessaire.
Consultez [Prise en charge des images haute résolution sur Claude Opus 4.7](https://platform.claude.com/docs/fr/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) pour plus de détails.
Pour les différences côté prompt, consultez [Rédiger des prompts pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5) et [Bonnes pratiques de rédaction de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Migrer depuis Claude Opus 4.5 ou une version antérieure
Si vous migrez directement vers Claude Opus 5.5 depuis Claude Opus 4.5, Claude Opus 4.1 ou un modèle antérieur, lisez cette page depuis le début : commencez par parcourir chacune des sections précédentes, dans l’ordre de la page. Parcourez ensuite les [changements incompatibles pour la migration depuis Claude Opus 4.6](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#opus-46-breaking-changes) présentés plus haut dans cette section. Appliquez ensuite les changements cumulatifs suivants, entrés en vigueur entre Claude Opus 4.5 et Claude Opus 4.7. Si vous utilisez Claude Opus 4.1 ou une version antérieure, poursuivez avec [Migrer depuis Claude 4.1 ou une version antérieure](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier) après cette sous-section.
#### Changements incompatibles
1. La **suppression du pré-remplissage** est traitée dans les [changements incompatibles pour la migration depuis Claude Opus 4.6](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Échappement des paramètres d’outils :** Claude Opus 4.6 et les modèles ultérieurs peuvent produire un échappement légèrement différent des chaînes JSON dans les arguments des appels d’outils (par exemple, une gestion différente des échappements Unicode ou de l’échappement des barres obliques). Si vous analysez l’`input` des appels d’outils comme une chaîne brute plutôt qu’avec un analyseur JSON, vérifiez votre logique d’analyse. Les analyseurs JSON standard (tels que `json.loads()` ou `JSON.parse()`) gèrent automatiquement ces différences.
#### Changements recommandés
Le premier élément est obligatoire sur Claude Opus 5.5 ; les autres sont recommandés.
1. **Migrer vers la réflexion adaptative (obligatoire) :** `thinking: {"type": "enabled", "budget_tokens": N}` renvoie une erreur 400 sur Claude Opus 4.7 et les modèles ultérieurs. L’avant/après correspond à l’élément 1 des [changements incompatibles pour la migration depuis Claude Opus 4.6](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#opus-46-breaking-changes). La migration fait également passer de `client.beta.messages.create()` (csharp: `client.Beta.Messages.Create()`; go: `client.Beta.Messages.New()`; java: `client.beta().messages().create()`; php: `$client->beta->messages->create()`; cli: `ant beta:messages create`) à `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`) : la réflexion adaptative et l’effort ne nécessitent ni l’espace de noms bêta du SDK ni aucun en-tête bêta.
2. **Supprimer l’en-tête bêta de l’effort :** Le paramètre d’effort ne nécessite pas d’en-tête bêta. Supprimez la bêta `effort-2025-11-24` de vos requêtes.
3. **Supprimer l’en-tête bêta du streaming d’outils à granularité fine :** Le « streaming » d’outils à granularité fine ne nécessite pas d’en-tête bêta. Supprimez la bêta `fine-grained-tool-streaming-2025-05-14` de vos requêtes.
4. **Supprimer l’en-tête bêta de la réflexion entrelacée :** Avec la réflexion adaptative, la réflexion entrelacée est automatique sur tous les modèles qui prennent en charge la réflexion adaptative. Supprimez la bêta `interleaved-thinking-2025-05-14` de vos requêtes.
5. **Migrer vers output\_config.format :** Si vous utilisez les sorties structurées, remplacez `output_format={...}` par `output_config={"format": {...}}`. 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. Le SDK Python (v1.0 et versions ultérieures) n’accepte pas `output_format={...}` sur `client.beta.messages.create()` ni sur `count_tokens()`. L’argument `output_format=Model` des fonctions utilitaires `parse()` et `stream()` reste inchangé.
### Migrer depuis Claude 4.1 ou une version antérieure
Si vous migrez directement vers Claude Opus 5.5 depuis Claude Opus 4.1 ou des modèles antérieurs, appliquez d’abord l’ensemble de [Migrer depuis Claude Opus 4.5 ou une version antérieure](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-45). Cette sous-section commence par toutes les sections précédentes ; en pratique, vous lisez donc cette page depuis le début. Appliquez ensuite les changements supplémentaires de cette sous-section.
#### Changements incompatibles supplémentaires
1. **Supprimer les paramètres d’échantillonnage :** Traité dans [Paramètres d’échantillonnage supprimés](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Mettre à jour les versions des outils**
Il s’agit d’un changement incompatible lors de la migration depuis les modèles Claude 3.x.
Passez aux versions actuelles des outils. Supprimez tout code utilisant la commande `undo_edit`.
```python Python
# Avant
tools = [{"type": "text_editor_20250124", "name": "str_replace_editor"}]
# Après
tools = [{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}]
```
```typescript TypeScript
// Avant
const legacyTools = [{ type: "text_editor_20250124", name: "str_replace_editor" }];
// Après
const tools = [{ type: "text_editor_20250728", name: "str_replace_based_edit_tool" }];
```
```csharp C#
var parameters = new MessageCreateParams
{
// Avant : {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Après :
Tools = [new ToolTextEditor20250728()],
// ...
};
```
```go Go
params := anthropic.MessageNewParams{
// Avant : {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Après :
Tools: []anthropic.ToolUnionParam{
{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
},
// ...
}
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
// Avant : {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Après :
.addTool(ToolTextEditor20250728.builder().build())
// ...
.build();
```
```php PHP
$message = $client->messages->create(
// Avant : ['type' => 'text_editor_20250124', 'name' => 'str_replace_editor']
// Après :
tools: [new ToolTextEditor20250728()],
// ...
);
```
```ruby Ruby
# Avant
legacy_tools = [{type: "text_editor_20250124", name: "str_replace_editor"}]
# Après
tools = [{type: "text_editor_20250728", name: "str_replace_based_edit_tool"}]
```
* **Éditeur de texte :** Utilisez `text_editor_20250728` et `str_replace_based_edit_tool`. Consultez la documentation de l’[outil d’édition de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool) pour plus de détails.
* **Exécution de code :** Passez à `code_execution_20260521`. Consultez la documentation de 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) pour les instructions de migration.
* **Utilisation de l’ordinateur :** Utilisez l’ensemble d’outils `computer_toolset_20260801` à la place de `computer_20250124`, que Claude Opus 5.5 n’accepte pas. Sur Amazon Bedrock, `computer_20251124` fonctionne également. Consultez le [changement incompatible concernant l’utilisation de l’ordinateur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#computer-use-toolset).
3. **Gérer la raison d’arrêt `refusal`**
Mettez à jour votre application pour [gérer les raisons d’arrêt `refusal`](https://platform.claude.com/docs/fr/test-and-evaluate/strengthen-guardrails/handle-streaming-refusals) :
```python Python
response = client.messages.create(...)
if response.stop_reason == "refusal":
# Gérer le refus de manière appropriée.
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "refusal") {
// Gérer le refus de manière appropriée.
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Value() == StopReason.Refusal)
{
// Gérer le refus de manière appropriée.
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == anthropic.StopReasonRefusal {
// Gérer le refus de manière appropriée.
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.REFUSAL)) {
// Gérer le refus de manière appropriée.
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'refusal') {
// Gérer le refus de manière appropriée.
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :refusal
# Gérer le refus de manière appropriée.
end
```
4. **Gérer la raison d’arrêt `model_context_window_exceeded`**
Les modèles Claude 4.5 et ultérieurs renvoient une raison d’arrêt `model_context_window_exceeded` lorsque la génération s’arrête parce que la limite de la fenêtre de contexte est atteinte, plutôt que la limite `max_tokens` demandée. Mettez à jour votre application pour gérer cette nouvelle raison d’arrêt :
```python Python
response = client.messages.create(...)
if response.stop_reason == "model_context_window_exceeded":
# Gérer de manière appropriée la limite de la fenêtre de contexte.
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "model_context_window_exceeded") {
// Gérer de manière appropriée la limite de la fenêtre de contexte.
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Raw() == "model_context_window_exceeded")
{
// Gérer de manière appropriée la limite de la fenêtre de contexte.
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == "model_context_window_exceeded" {
// Gérer de manière appropriée la limite de la fenêtre de contexte.
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.of("model_context_window_exceeded"))) {
// Gérer de manière appropriée la limite de la fenêtre de contexte.
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'model_context_window_exceeded') {
// Gérer correctement la limite de la fenêtre de contexte.
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :model_context_window_exceeded
# Gérer de manière appropriée la limite de la fenêtre de contexte.
end
```
5. **Vérifier la gestion des paramètres d’outils (sauts de ligne finaux)**
Les modèles Claude 4.5 et ultérieurs préservent les sauts de ligne finaux dans les paramètres de type chaîne des appels d’outils, qui étaient auparavant supprimés. Si vos outils reposent sur une correspondance exacte de chaînes avec les paramètres des appels d’outils, vérifiez que votre logique gère correctement les sauts de ligne finaux.
6. **Mettre à jour vos prompts en fonction des changements de comportement**
Les modèles Claude 4 et ultérieurs ont un style de communication plus concis et direct, et nécessitent des instructions explicites. Consultez les [bonnes pratiques de prompting](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices) pour obtenir des conseils d’optimisation.
#### Changements recommandés supplémentaires
* **En-têtes bêta :** Supprimez `token-efficient-tools-2025-02-19` et `output-128k-2025-02-19`. Tous les modèles Claude 4 et ultérieurs intègrent une utilisation d’outils économe en tokens, et ces en-têtes n’ont aucun effet.
## Migrer vers Claude Opus 5.5 depuis Claude Sonnet 5
Parcourez [Ce que chaque requête à Claude Opus 5.5 doit respecter](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#request-requirements), [Gérer la réflexion dans chaque réponse](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#thinking-in-every-response) et [Migrer vers Claude Opus 5.5 depuis Claude Opus 5](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-5). Utilisez `claude-sonnet-5` comme identifiant de modèle à remplacer. Cette dernière section s’applique telle quelle au code utilisant Claude Sonnet 5, car Claude Sonnet 5, comme Claude Opus 5 :
* S’exécute avec la réflexion activée par défaut et accepte `thinking: {"type": "disabled"}`, dans son cas à n’importe quel niveau d’effort.
* Accepte le choix d’outil forcé et l’outil `computer_20251124`.
* Renvoie le texte entre les appels d’outils sous forme de blocs `text`.
* Utilise par défaut l’effort `high`.
La réflexion étendue manuelle, les paramètres d’échantillonnage et le préremplissage de l’assistant renvoient une erreur 400 sur les deux modèles ; rien ne change donc à ce niveau. Aucun des changements obligatoires des sections consacrées à Claude Opus 4.8, Claude Opus 4.7 et Claude Opus 4.6 ne vous concerne.
### Ce qui a changé
1. **Messages système en cours de conversation :** Sur la Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) et Claude Models on Google Cloud (Google managed), Claude Opus 5.5 accepte les messages `role: "system"` immédiatement après un tour utilisateur dans le tableau `messages` (sous réserve des [règles de placement](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#limitations)). Cette fonctionnalité n’est pas disponible sur Claude Sonnet 5. Si vous maintenez des chemins de code qui reconstruisent l’historique complet des messages pour mettre à jour les instructions, vous pouvez les simplifier et préserver les correspondances du [cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours précédents.
2. **Minimum de mise en cache des prompts abaissé :** La longueur minimale de prompt pouvant être mise en cache sur Claude Opus 5.5 est de 512 tokens, contre 1 024 tokens sur Claude Sonnet 5. Les prompts qui étaient trop courts pour être mis en cache sur Claude Sonnet 5 peuvent créer des entrées de cache, sans aucune modification de code requise. Consultez [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-limitations) pour les minimums par modèle.