---
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 contrôle 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.
**Automatisez votre migration avec la skill Claude API.** Dans Claude Code, exécutez `/claude-api migrate` pour invoquer la [skill Claude API](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) intégrée. Elle fonctionne avec n'importe quel modèle Claude actuel comme cible :
Laissez Claude Code migrer votre code pour vous
```text
/claude-api migrate ce projet vers claude-opus-5-5
```
La skill applique le remplacement de l'identifiant du modèle et, si nécessaire, les changements de paramètres non rétrocompatibles, le remplacement du préremplissage (prefill) et le calibrage de l'effort pour votre modèle cible dans l'ensemble de votre base de code, puis produit une liste de contrôle des éléments à vérifier manuellement. Elle vous demande de confirmer la portée de la migration (répertoire de travail entier, un sous-répertoire ou une liste de fichiers spécifique) avant de modifier le moindre fichier. La skill détecte également les clients Amazon Bedrock et Claude Platform on AWS, et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour ces plateformes.
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 à la section correspondant à votre modèle actuel : sa première phrase indique les autres sections qui vous concernent. La [liste de contrôle de 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 $ ; 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 prompting 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 de modèle :** Utilisez `claude-opus-5-5`, un ID de modèle fixe sans suffixe de date. Sur Amazon Bedrock, Claude Platform on AWS, Google Cloud 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](https://platform.claude.com/docs/fr/build-with-claude/thinking) » (réflexion adaptative) 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 la 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`, ou laissez-les à leurs valeurs par défaut : toute autre valeur est rejetée. Utilisez le prompting pour orienter le comportement du modèle.
* **Préremplissage :** Ne terminez pas `messages` par un tour assistant prérempli (« prefill », préremplissage) : 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. Sur Amazon Bedrock, les sorties structurées ne sont pas disponibles pour Claude Opus 5.5 ; utilisez donc des instructions dans l'invite système.
* **Utilisation de l'ordinateur :** Sur l'API Claude et Google Cloud, déclarez l'utilisation de l'ordinateur (« computer use ») sous la forme de l'ensemble d'outils (« toolset ») `computer_toolset_20260801` ; l'outil antérieur `computer_20251124` y est rejeté. Consultez le [changement incompatible relatif à 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`. Les onglets SDK qui affichent du texte le sélectionnent par type de bloc, car les blocs `thinking` arrivent en premier.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"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 is Anthropic.TextBlock => block.type === "text"
);
console.log(textBlock?.text);
```
```csharp C#
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() {
Role = Role.User,
Content = "Analyze the trade-offs between microservices and monolithic architectures"
}
],
OutputConfig = new OutputConfig
{
Effort = Effort.Medium
}
};
var message = await client.Messages.Create(parameters);
Console.WriteLine(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: "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 : chaque réponse peut donc commencer par des blocs `thinking`, et `max_tokens` couvre la réflexion plus 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 plus 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 plus texte de réponse : réexaminez-le donc 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 un `max_tokens` élevé afin que le modèle dispose de la marge nécessaire 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, ne fonctionne plus avec ces réponses. Sélectionnez plutôt les blocs de contenu par leur champ `type` : lisez `text` à partir des blocs dont le `type` est `"text"`, et effectuez un branchement sur 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 de « tool use » (utilisation d'outils), renvoyez à l'API les blocs `thinking` de chaque réponse de l'assistant, complets et non modifiés, lorsque vous renvoyez les résultats d'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 avec une erreur 400 les blocs de réflexion modifiés, réordonnés ou partiellement supprimés. 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` vaut `"omitted"` par défaut, 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 en streaming aux utilisateurs, le comportement 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 contrôle de migration par modèle de départ
Parcourez les groupes dans l'ordre et arrêtez-vous après celui qui nomme votre modèle actuel : chaque point jusqu'à ce groupe 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 de 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 d'outils stricte ou aux sorties structurées, ou par `auto` seul sur Amazon Bedrock.
* Si vous recourez à l'utilisation de l'ordinateur sur l'API Claude ou Google Cloud, déclarez `computer_toolset_20260801` (sans en-tête bêta) au lieu de `computer_20251124` et mettez à jour votre boucle d'agent pour l'ensemble d'outils. Sur Amazon Bedrock, conservez `computer_20251124` ; consultez la section [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#compatibility) de l'outil d'utilisation de l'ordinateur pour les autres plateformes.
* 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 Google Cloud, 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 le 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 antérieurs, 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 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, réexaminez `max_tokens`, qui couvre la réflexion plus le texte de réponse ; avec l'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. Réexaminez `max_tokens`, qui reste une limite stricte sur la sortie totale (réflexion plus texte de réponse), et abaissez `effort` là où 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 dispose d'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 correspondances du cache de prompts.
* Vérifiez que votre gestion des raisons d'arrêt lit `stop_details` en cas de refus.
* Si vous souhaitez utiliser le mode rapide, que Claude Opus 4.7 rejette, définissez `speed: "fast"` dans vos requêtes à l'API Claude. Claude Opus 5.5 n'a pas besoin d'en-tête bêta.
### Claude Opus 4.6 ou antérieur
* Supprimez `temperature`, `top_p` et `top_k` des charges utiles de requête.
* Remplacez `thinking: {"type": "enabled", "budget_tokens": N}` par `thinking: {"type": "adaptive"}` associé 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 affiche le contenu de la 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, revoyez 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). Sous-échantillonnez 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îte englobante fournies par le modèle, supprimez toute conversion par facteur d'échelle ; les coordonnées correspondent en 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 un travail de sécurité légitime, postulez au [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) pour bénéficier de restrictions allégées sur le contenu cyber.
### Claude Opus 4.5 ou antérieur
* Supprimez les préremplissages de messages 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 type chaîne des outils.
* Supprimez les anciens en-têtes bêta (`token-efficient-tools-2025-02-19`, `output-128k-2025-02-19`).
* Examinez et mettez à jour vos prompts en suivant les [bonnes pratiques de prompting](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 correspondances du 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
Commencez par traiter [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 contrôle de cette section correspond au premier groupe de la [liste de contrôle de 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, Google Cloud et Microsoft Foundry, utilisez l'identifiant de modèle propre à la plateforme concernée ; consultez [Disponibilité](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#availability).
### Changements incompatibles
Chaque changement est expliqué dans [Nouveautés de Claude Opus 5.5](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#breaking-changes). Cette section indique la modification de code à apporter pour chacun d'eux.
#### 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). Si vous désactiviez la réflexion pour économiser des tokens, choisissez un niveau plus bas. Les réponses commencent alors par des blocs `thinking` : sélectionnez donc les blocs de contenu selon leur `type`, et renvoyez les blocs `thinking` sans modification avec les résultats d'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: 2023-06-01" \
-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() { Role = Role.User, 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 (thinking) est toujours activée ; c'est effort qui sert de réglage.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"output_config": {"effort": "low"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
# la réflexion (thinking) est toujours activée ; c'est effort qui la 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() { Role = Role.User, 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 (thinking) est toujours activée ; c'est le paramètre effort qui la contrôle.
.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 activée ; c'est effort qui la 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 activée ; c'est `effort` qui la 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 de tokens. Utilisez `auto` avec l'[utilisation d'outils stricte](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 d'outils stricte 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). Sur Amazon Bedrock, les sorties structurées, qui incluent l'utilisation d'outils stricte, ne sont pas disponibles pour Claude Opus 5.5. Sur cette plateforme, envoyez `auto` sans `strict`, indiquez dans le prompt quand l'outil s'applique et validez l'entrée de l'outil dans votre code. 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: 2023-06-01" \
-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() { Role = Role.User, 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: 2023-06-01" \
-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 (strict tool use) : 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 (strict tool use) : 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,
// « strict tool use » (utilisation stricte d'outils) : chaque appel respecte le input_schema de l'outil.
tools: tools.map((tool) => ({ ...tool, strict: true })),
tool_choice: { type: "auto" },
messages: [
{
role: "user",
content: "What's the weather in Paris? Use the get_weather tool."
}
]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
// « strict tool use » (utilisation stricte d'outils) : chaque appel respecte le input_schema de l'outil.
Tools = [.. tools.Select(tool => tool with { Strict = true })],
ToolChoice = new ToolChoiceAuto(),
Messages =
[
new()
{
Role = Role.User,
Content = "What's the weather in Paris? Use the get_weather tool.",
},
],
});
```
```go Go
// « strict tool use » (utilisation stricte d'outils) : 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)
// strict tool use (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 (strict tool use) : chaque appel respecte le input_schema de l'outil.
tools: array_map(fn (Tool $tool) => $tool->withStrict(true), $tools),
toolChoice: ToolChoiceAuto::with(),
messages: [
[
'role' => 'user',
'content' => "What's the weather in Paris? Use the get_weather tool.",
],
],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
# « strict tool use » (utilisation stricte d'outils) : 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 Google Cloud, de Claude Sonnet 5.5 et Claude Haiku 5.5, mais pas des modèles Claude Fable ou Claude Mythos. Maintenez la conversation en ajout seul (aucune modification de l'invite `system`, de `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à. L'application de cette règle est identique à celle de Claude Fable 5.1 sur toutes les plateformes : pour les comptes créés le 31 août 2026 à 00:00 UTC ou après, rejouer un bloc de réflexion après une telle modification renvoie par défaut 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).
#### L'outil d'utilisation de l'ordinateur `computer_20251124` n'est pas pris en charge sur l'API Claude et Google Cloud
Sur l'API Claude et Google Cloud, une entrée `tools` de type `computer_20251124` renvoie une erreur 400 (`'claude-opus-5-5' does not support tool types: computer_20251124.`, suivi des types d'outils acceptés par le modèle). Déclarez plutôt l'ensemble d'outils `computer_toolset_20260801` : supprimez l'en-tête bêta et envoyez l'entrée sans `name` ni dimensions d'affichage. Dans votre boucle d'agent, traitez les blocs `tool_use` membres (l'action correspond au `name` du bloc, et non à `input.action`), dont plusieurs peuvent apparaître par tour, et renvoyez `toolset_name` dans chaque résultat. La modification de la requête est présentée ci-dessous ; les modifications de la boucle d'agent sont répertoriées dans [Migrer depuis `computer_20251124`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). Sur Amazon Bedrock, l'ancien outil `computer_20251124` continue de fonctionner sur Claude Opus 5.5 comme sur Claude Opus 5 : aucune modification n'y est donc nécessaire. Pour les autres plateformes, consultez la section [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#compatibility) de l'outil d'utilisation de l'ordinateur. Consultez [L'outil d'utilisation de l'ordinateur `computer_20251124` n'est pas pris en charge sur l'API Claude et Google Cloud](https://platform.claude.com/docs/fr/models/opus-5-5/whats-new-opus-5-5#computer-20251124-is-not-supported).
Avant. Claude Opus 5 accepte cette requête, et sur l'API Claude et Google Cloud, 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: 2023-06-01" \
-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() { Role = Role.User, 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 du toolset 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: 2023-06-01" \
-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 du toolset n'accepte 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 du toolset (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 du toolset 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 du toolset ne prend ni nom ni taille d'affichage
Tools = [new ComputerToolset20260801()],
Messages = [new() { Role = Role.User, 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 du toolset ne prend 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 du toolset 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 du toolset 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 du toolset n'accepte 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 écrit 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), à raison d'un bloc au plus 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 transmet ce texte en streaming à ses utilisateurs sous forme de mises à jour de progression devient silencieuse entre les appels d'outils. Pour rétablir ces mises à jour, lisez-les dans 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 tout en gardant le raisonnement 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 à l'utilisateur](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 le [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 des mesures 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 en `medium`. Baissez le niveau là où la qualité se maintient, et augmentez-le pour les tâches les plus exigeantes. 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 ajustées au comportement de Claude Opus 5 ne sont peut-être plus 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 utilisiez le modèle 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
Commencez par traiter [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 ID 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 l'effort `high` par défaut.
Cette section ajoute ce qui a changé entre Claude Opus 4.8 et Claude Opus 5. Pour une liste de contrôle, consultez les deux premiers groupes de la [liste de contrôle de 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 dispose d'un engagement Priority Tier, planifiez la capacité séparément.
### Modifications recommandées
Ces modifications ne sont pas obligatoires, mais elles amélioreront votre expérience :
1. **Envisagez les budgets de tâche (bêta) :** Pour les charges de travail agentiques, les [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. **Envisagez 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 [cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours antérieurs. Modifier le tableau `tools` lui-même invalide le préfixe mis en cache. Sur l'API Claude, envoyez l'en-tête bêta `inline-tools-2026-09-15`. L'ancien en-tête `mid-conversation-tool-changes-2026-07-01` fonctionne toujours pour les modifications qui désignent un outil par référence, sur l'API Claude, Amazon Bedrock et Google Cloud.
## Migrer vers Claude Opus 5.5 depuis Claude Opus 4.7
Commencez par traiter [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 ID 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 l'effort `high` par défaut 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 est sur 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. La section consacrée à Claude Opus 4.6 ajoute les changements incompatibles entrés en vigueur avec Claude Opus 4.7. Pour une liste de contrôle, consultez les trois premiers groupes de la [liste de contrôle de 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 avoir remplacé l'ID de modèle.
1. **Niveaux d'effort recalibrés :** L'allocation de tokens associée à 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 réglage optimisé 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 [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 l'API Claude, Amazon Bedrock et Google Cloud, Claude Opus 5.5 accepte des 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 des instructions, vous pouvez les simplifier et préserver les correspondances du [cache de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours antérieurs.
4. **Détails d'arrêt en cas de refus :** Lorsque le modèle refuse 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 : ce point ne compte donc 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'est pas possible de le désactiver. 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 refuse dans davantage de catégories ; consultez [Classificateurs de sécurité et 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 [mode rapide](https://platform.claude.com/docs/fr/build-with-claude/fast-mode) sur l'API Claude. 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"` dans 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 :** Sur l'API Claude et Google Cloud, Claude Opus 5.5 prend en charge l'[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 l'[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. Sur ces plateformes, Claude Opus 5.5 n'accepte pas l'outil antérieur `computer_20251124` ; consultez le [changement incompatible relatif à 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 traiter 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), et 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 sur Claude Opus 4.6. Comme Claude Opus 4.7, il accepte `thinking: {"type": "disabled"}`, le choix d'outil forcé et l'outil `computer_20251124`. Il utilise l'effort `high` par défaut 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 également à eux.
Cette section ajoute ce qui a changé avec Claude Opus 4.7, avec `claude-opus-4-6` comme ID de modèle à remplacer. Ses deux sous-sections ajoutent ce qui a changé auparavant, pour les lecteurs sur [Claude Opus 4.5 ou antérieur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-45) et [Claude 4.1 ou antérieur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier). Pour une liste de contrôle, consultez la [liste de contrôle de migration](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migration-checklist) jusqu'au groupe qui nomme 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 à la [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 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: 2023-06-01" \
-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() { Role = Role.User, Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.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ù les lignes de l'ID du modèle, de `thinking` et de `output_config` diffèrent :
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 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() { Role = Role.User, Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.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: '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: "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 prompting et par le [paramètre 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 :** Définir `temperature`, `top_p` ou `top_k` sur une valeur autre que la valeur par défaut sur Claude Opus 4.7 et les modèles ultérieurs, y compris Claude Opus 5.5, renvoie une erreur 400. Le SDK Python (v1.0 et versions ultérieures) ne les définit pas, et les transmettre lève une `TypeError`. La voie de migration la plus sûre consiste à omettre entièrement ces paramètres des charges utiles des requêtes. Le prompting est la méthode recommandée 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 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 le point 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. **Comptage des tokens mis à jour :** Claude Opus 4.7 a introduit un nouveau « tokenizer » (tokeniseur), 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'à \~35 % de plus, selon le contenu).
[`/v1/messages/count_tokens`](https://platform.claude.com/docs/fr/build-with-claude/token-counting) renvoie pour Claude Opus 5.5 un nombre de tokens différent de celui qu'il renvoyait pour Claude Opus 4.6. L'efficacité en tokens peut varier selon la forme 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 comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) pour vérifier. Les interventions par prompting, [`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 à contrôler les coûts ; ces contrôles peuvent se faire au détriment de l'intelligence du modèle.
5. **Suppression du 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. Sur Amazon Bedrock, les sorties structurées ne sont pas disponibles pour Claude Opus 5.5 ; utilisez donc des instructions dans l'invite système.
### Changements de comportement
Claude Opus 4.7 a introduit, par rapport à Claude Opus 4.6, des différences de comportement qui ne sont pas des changements incompatibles de l'API. Les trois suivantes affectent le code ou le « scaffolding » (échafaudage) :
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é un échafaudage pour forcer des messages d'état intermédiaires (« Après chaque série de 3 appels d'outils, résume la progression »), essayez de le 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 façonner leur longueur et leur 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 :** Nouveauté de Claude Opus 4.7, les requêtes impliquant des sujets interdits ou à haut risque peuvent entraîner des refus. Pour un travail de sécurité légitime tel que les tests d'intrusion, la recherche de vulnérabilités ou le red-teaming, postulez au [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) pour demander des restrictions réduites. La procédure de candidature 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 bord long, contre 1 568 pixels sur les modèles précédents. Cela permet des gains sur les charges de travail fortement axées sur la vision et s'avère particulièrement précieux 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 aucun en-tête bêta ni activation côté client. Deux points à 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 par image). Réévaluez le budget `max_tokens` et les attentes de coût pour les charges de travail riches en images, ou sous-échantillonnez avant l'envoi si vous n'avez pas besoin de la fidélité supplémentaire.
* Les coordonnées de pointage et de boîtes englobantes renvoyées par le modèle correspondent 1:1 aux pixels réels de l'image sur Claude Opus 4.7, donc aucune conversion de facteur d'échelle n'est requise.
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 prompting](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Migration depuis Claude Opus 4.5 ou antérieur
Si vous migrez directement de Claude Opus 4.5, de Claude Opus 4.1 ou d'un modèle antérieur vers Claude Opus 5.5, lisez cette page depuis le début : parcourez d'abord chaque section précédente, 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) 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 [Migration 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. **Guillemets des paramètres d'outils :** Claude Opus 4.6 et les modèles ultérieurs peuvent produire un échappement de chaînes JSON légèrement différent dans les arguments d'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'en utilisant un analyseur JSON, vérifiez votre logique d'analyse. Les analyseurs JSON standard (tels que `json.loads()` ou `JSON.parse()`) gèrent ces différences automatiquement.
#### Modifications recommandées
Le premier élément est obligatoire sur Claude Opus 5.5 ; les autres sont recommandés.
1. **Migrez 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. **Supprimez l'en-tête bêta effort :** Le paramètre effort ne nécessite pas d'en-tête bêta. Supprimez l'en-tête bêta `effort-2025-11-24` de vos requêtes.
3. **Supprimez 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 l'en-tête bêta `fine-grained-tool-streaming-2025-05-14` de vos requêtes.
4. **Supprimez 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 chaque modèle qui prend en charge la réflexion adaptative. Supprimez l'en-tête bêta `interleaved-thinking-2025-05-14` de vos requêtes.
5. **Migrez 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 assistants `parse()` et `stream()` reste inchangé.
### Migration depuis Claude 4.1 ou une version antérieure
Si vous migrez directement de Claude Opus 4.1 ou de modèles antérieurs vers Claude Opus 5.5, appliquez d'abord tout ce qui figure dans [Migration depuis Claude Opus 4.5 ou antérieur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#migrating-from-claude-opus-45). La sous-section consacrée à Claude Opus 4.5 commence elle-même 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. **Supprimez les paramètres d'échantillonnage :** Traité dans [Suppression des paramètres d'échantillonnage](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Mettez à jour les versions d'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 :** Sur l'API Claude et Google Cloud, Claude Opus 5.5 n'accepte l'utilisation de l'ordinateur que sous la forme de l'ensemble d'outils `computer_toolset_20260801` : les outils antérieurs `computer_20250124` et `computer_20251124` y sont rejetés. Consultez le [changement incompatible relatif à l'utilisation de l'ordinateur](https://platform.claude.com/docs/fr/models/opus-5-5/migration-guide#computer-use-toolset).
3. **Gérez 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érez 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 a été 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 la limite de la fenêtre de contexte de manière appropriée
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "model_context_window_exceeded") {
// Gérer la limite de la fenêtre de contexte de manière appropriée
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Raw() == "model_context_window_exceeded")
{
// Gérer correctement 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 la limite de la fenêtre de contexte de manière appropriée
}
```
```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 la limite de la fenêtre de contexte de manière appropriée
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'model_context_window_exceeded') {
// Gérer la limite de la fenêtre de contexte de manière appropriée
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :model_context_window_exceeded
# Gérer la limite de la fenêtre de contexte de manière appropriée
end
```
5. **Vérifiez la gestion des paramètres d'outils (sauts de ligne finaux)**
Les modèles Claude 4.5 et ultérieurs conservent les sauts de ligne finaux dans les paramètres de type chaîne des appels d'outils, alors qu'ils é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. **Mettez à jour vos prompts pour les changements de comportement**
Les modèles Claude 4 et ultérieurs ont un style de communication plus concis et plus 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.
#### Modifications recommandées supplémentaires
* **Supprimez les en-têtes bêta hérités :** 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 ID de modèle à remplacer. Cette dernière section s'applique telle quelle au code sur Claude Sonnet 5, car Claude Sonnet 5, comme Claude Opus 5 :
* Fonctionne 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 réglés sur une valeur autre que la valeur par défaut et le préremplissage de l'assistant renvoient une erreur 400 sur les deux modèles ; rien ne change donc à cet égard. 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 l'API Claude, Amazon Bedrock et Google Cloud, 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 de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sur les tours antérieurs.
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 désormais 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 connaître les minimums par modèle.