---
title: Migrationsleitfaden für Claude Opus 5.5
url: https://platform.claude.com/docs/de/models/opus-5-5/migration-guide
description: Wechsle mit diesem Migrationsleitfaden von früheren Opus-Modellen oder Claude Sonnet 5 zu Claude Opus 5.5. Die Anleitung zur Aktivierung von Claude Opus 5.5 umfasst Request-Einstellungen, die Fehler zurückgeben, Thinking-Blöcke in jeder Antwort und eine Checkliste für jedes Ausgangsmodell.
---
Dieser Leitfaden behandelt die Migration von [Messages API](https://platform.claude.com/docs/de/build-with-claude/working-with-messages)-Code. Wenn du [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) verwendest, sind außer der Aktualisierung des Modellnamens keine Änderungen erforderlich.
Lass Claude Code deinen Code für dich migrieren
```text
/claude-api migrate dieses Projekt zu claude-opus-5-5
```
Diese Seite listet die Codeänderungen für den Wechsel zu Claude Opus 5.5 von [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8), [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-47), [Claude Opus 4.6 und früheren Opus-Modellen](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-46) oder [Claude Sonnet 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-sonnet-5) auf. Jede Leserin und jeder Leser braucht [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements) und [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response). Gehe dann zum Abschnitt für dein aktuelles Modell: Sein erster Satz nennt die anderen Abschnitte, die für dich gelten. Die [Migrations-Checkliste](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migration-checklist) listet jede Änderung nach Ausgangsmodell auf.
Claude Opus 5.5 kostet weniger als Claude Opus 5 (4 $ / 20 $ pro Million Eingabe-/Ausgabe-Token, verglichen mit 5 $ / 25 $; siehe [Claude-Preise](https://platform.claude.com/docs/de/about-claude/pricing)). Zur Funktionsunterstützung siehe [Neuerungen in Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#feature-support). Zu Verhaltensunterschieden und modellspezifischen Prompting-Mustern siehe [Prompting für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).
## Was jede Anfrage an Claude Opus 5.5 erfüllen muss
Unabhängig davon, von welchem Modell du kommst, muss eine Anfrage an `claude-opus-5-5` Folgendes erfüllen. Wenn ein Punkt besagt, dass eine Einstellung abgelehnt wird, gibt die API einen 400-Fehler zurück.
* **Modell-ID:** Verwende `claude-opus-5-5`, eine feste Modell-ID ohne Datumssuffix. Auf Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) und Microsoft Foundry verwendest du die Modell-ID der jeweiligen Plattform; siehe [Verfügbarkeit](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#availability).
* **Thinking (Nachdenken):** Sende kein `thinking`-Feld oder sende `thinking: {"type": "adaptive"}`, was gleichwertig ist: [Adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) ist immer aktiv. `thinking: {"type": "disabled"}` und manuelle Thinking-Budgets (`thinking: {"type": "enabled", "budget_tokens": N}`) werden abgelehnt. Siehe [Vorher und Nachher für Nachdenken](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
* **Effort (Aufwand):** Steuere die Tiefe des Nachdenkens mit dem [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort), dem einzigen Request-Parameter, der sie steuert. Alle fünf Stufen (`low`, `medium`, `high`, `xhigh`, `max`) werden unterstützt, und der Standardwert ist `medium`. Siehe [Empfohlene Effort-Stufen für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5).
* **Tool choice (Tool-Auswahl):** Verwende `tool_choice` `{"type": "auto"}` (den Standardwert) oder `{"type": "none"}`. Das Erzwingen eines Tool-Aufrufs mit `{"type": "any"}` oder `{"type": "tool", "name": "..."}` wird abgelehnt. Siehe [Vorher und Nachher für die Tool-Auswahl](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#forced-tool-use).
* **Sampling-Parameter:** Lass `temperature`, `top_p` und `top_k` weg. Verwende Prompting, um das Verhalten des Modells zu steuern.
* **Prefill (Vorausfüllen):** Beende `messages` nicht mit einem vorausgefüllten Assistant-Turn: Dies wird abgelehnt. Verwende stattdessen [strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) oder Anweisungen im System-Prompt.
* **Computer Use:** Deklariere Computer Use als Toolset `computer_toolset_20260801`. Auf Amazon Bedrock funktioniert auch `computer_20251124`. Siehe die [Breaking Change bei Computer Use](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#computer-use-toolset).
* **Kontextfenster:** Es ist kein Beta-Header für das „context window“ (Kontextfenster) erforderlich. Das [Kontextfenster mit 1M Token](https://platform.claude.com/docs/de/build-with-claude/context-windows) ist der Standard, und ein für ältere Modelle gesendeter Header hat keine Wirkung.
Die folgende Anfrage erfüllt jeden Punkt der Liste: Effort ist gesetzt, und es gibt kein `thinking`-Feld. Wo das Beispiel Text ausgibt, findet es den Textblock anhand seines Typs, weil `thinking`-Blöcke zuerst kommen.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Analyze the trade-offs between microservices and monolithic architectures"
}],
"output_config": {
"effort": "medium"
}
}'
```
```bash CLI
ant messages create \
--model claude-opus-5-5 \
--max-tokens 4096 \
--output-config '{effort: medium}' \
--message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}'
```
```python Python
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Analyze the trade-offs between microservices and monolithic architectures",
}
],
output_config={"effort": "medium"},
)
for block in response.content:
if block.type == "text":
print(block.text)
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Analyze the trade-offs between microservices and monolithic architectures"
}
],
output_config: {
effort: "medium"
}
});
const textBlock = response.content.find((block) => block.type === "text");
console.log(textBlock?.text);
```
```csharp C#
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new UserMessageParam
{
Content = "Analyze the trade-offs between microservices and monolithic architectures"
}
],
OutputConfig = new OutputConfig
{
Effort = Effort.Medium
}
};
var message = await client.Messages.Create(parameters);
Console.WriteLine(message);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
},
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortMedium,
},
})
if err != nil {
log.Fatal(err)
}
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
fmt.Println(textBlock.Text)
}
}
```
```java Java
import com.anthropic.models.messages.OutputConfig;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.MEDIUM)
.build())
.build();
Message response = client.messages().create(params);
response.content().stream()
.flatMap(block -> block.text().stream())
.forEach(textBlock -> IO.println(textBlock.text()));
}
```
```php PHP
$client = new Client();
$message = $client->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
],
model: 'claude-opus-5-5',
outputConfig: ['effort' => 'medium'],
);
foreach ($message->content as $block) {
if ($block->type === 'text') {
echo $block->text, PHP_EOL;
}
}
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: [
{ role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
],
output_config: {
effort: "medium"
}
)
message.content.each do |block|
puts block.text if block.type == :text
end
```
## Nachdenken in jeder Antwort behandeln
Nachdenken läuft bei jedem Claude Opus 5.5-Request, daher kann jede Antwort mit `thinking`-Blöcken beginnen, und `max_tokens` deckt Nachdenken plus Text ab. Wenn dein Code bereits mit aktiviertem Nachdenken läuft, sind die Punkte 1 bis 3 wahrscheinlich schon umgesetzt: Prüfe die Punkte 4 und 5. Wenn er auf einem früheren Modell ohne Nachdenken lief, ist jeder Punkt eine Änderung.
1. **`max_tokens` deckt Nachdenken plus Text ab:** Auf Claude Opus 4.8 und früheren Opus-Modellen laufen Anfragen ohne `thinking`-Feld ohne Nachdenken. Claude Opus 5 und Claude Sonnet 5 akzeptieren `thinking: {"type": "disabled"}`. Auf Claude Opus 5.5 läuft jede Anfrage mit [adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking). `max_tokens` bleibt eine harte Grenze für die gesamte Ausgabe, Nachdenken plus Antworttext, überprüfe es also für Workloads, die ohne Nachdenken liefen. Thinking-Token werden als Output-Token abgerechnet, auch wenn der Thinking-Text nicht an dich zurückgegeben wird, sodass ein solcher Workload mehr Output-Token pro Anfrage erzeugen kann. Siehe [Kostenkontrolle](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#cost-control). Um weniger Token für Nachdenken aufzuwenden, senke die [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe. Wenn du mit `xhigh`- oder `max`-Effort arbeitest, setze ein großes `max_tokens`, damit das Modell Raum zum Nachdenken und Handeln hat; beginne bei 64k Token und passe von dort aus an. Wenn deine Prompts für den Betrieb ohne Nachdenken abgestimmt waren, siehe [Prompts, die für deaktiviertes Nachdenken geschrieben wurden](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
2. **Antworten beginnen mit Thinking-Blöcken:** Eine Antwort kann vor dem ersten `text`-Block mit einem oder mehreren `thinking`-Blöcken beginnen. Code, der die Antwort nach Position liest, etwa `content[0].text` oder ein Stream-Handler, der das erste `content_block_start`-Event als Text behandelt, bricht bei diesen Antworten. Wähle Content-Blöcke stattdessen anhand ihres `type`-Felds aus: Lies `text` aus den Blöcken, deren `type` `"text"` ist, und verzweige beim Verarbeiten von Stream-Events nach dem Blocktyp.
3. **Thinking-Blöcke in Tool-Nutzungs-Schleifen unverändert zurückgeben:** Wenn du eine Tool-Nutzungs-Schleife betreibst, gib die `thinking`-Blöcke aus jeder Assistant-Antwort vollständig und unverändert an die API zurück, wenn du Tool-Ergebnisse zurückgibst, einschließlich Blöcken, deren `thinking`-Feld leer ist. Gib die Assistant-Nachricht so zurück, wie sie empfangen wurde, statt ihre Content-Blöcke nach Typ zu filtern oder sie neu aufzubauen: Die API lehnt bearbeitete, umsortierte oder teilweise entfernte Thinking-Blöcke mit einem 400-Fehler ab. Siehe [Thinking-Blöcke beibehalten](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks).
4. **Thinking-Text wird standardmäßig weggelassen:** `thinking.display` hat standardmäßig den Wert `"omitted"`, daher kommen `thinking`-Blöcke mit einem leeren `thinking`-Feld neben ihrer `signature` an. Behandle das `thinking`-Feld ausschließlich als Anzeigetext. Um stattdessen lesbare Zusammenfassungen zu erhalten, setze `thinking.display` auf `"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"
}
```
Wenn dein Produkt das Reasoning an Nutzer streamt, erscheint der Standard als lange Pause, bevor die Ausgabe beginnt; setze `display: "summarized"`, um während des Nachdenkens wieder sichtbaren Fortschritt anzuzeigen. Siehe [Anzeige des Nachdenkens steuern](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display).
5. **Text zwischen Tool-Aufrufen kommt in Thinking-Blöcken an:** Die kurzen Notizen, die das Modell zwischen Tool-Aufrufen schreibt, kommen als `thinking`-Blöcke zurück, die bei der Standardanzeige leer sind. Siehe [Text zwischen Tool-Aufrufen wird in Thinking-Blöcken zurückgegeben](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#text-between-tool-calls).
## Migrations-Checkliste nach Ausgangsmodell
Arbeite die Gruppen von oben nach unten ab und höre nach der Gruppe auf, die dein aktuelles Modell nennt: Jeder Punkt bis dahin gilt für dich. Wenn du Claude Opus 5 verwendest, ist die erste Gruppe die gesamte Liste. Wenn du Claude Sonnet 5 verwendest, wende die erste und die letzte Gruppe an.
### Jedes Ausgangsmodell
* Aktualisiere die Modell-ID auf `claude-opus-5-5`.
* Entferne `thinking: {"type": "disabled"}` und `thinking: {"type": "enabled", ...}`; wähle stattdessen eine Effort-Stufe.
* Setze `effort` explizit: Der Standardwert ist `medium`, während er bei Claude Opus 5 `high` ist.
* Ersetze die `tool_choice`-Typen `any` und `tool` durch `auto` plus strikte Tool-Nutzung oder strukturierte Ausgaben.
* Wenn du eine frühere Version des Computer-Use-Tools verwendest, deklariere stattdessen `computer_toolset_20260801` (ohne Beta-Header) und passe deine Agent-Schleife an das Toolset an. Auf Amazon Bedrock funktioniert auch `computer_20251124`.
* Wenn ein Router oder Fallback eine Konversation von Claude Opus 5.5 zu einem anderen Modell verschieben kann, rechne damit, dass dieses Modell ohne die Thinking-Blöcke von Claude Opus 5.5 läuft (Claude Fable 5.1 und Claude Mythos 5.1 auf der Claude API sind die Ausnahme und behalten sie). Claude Opus 5.5 selbst liest Nachdenken von Claude Opus 5, von früheren Opus-, Sonnet- und Haiku-Modellen sowie, auf der Claude API und Claude Models on Google Cloud (Google managed), von Claude Sonnet 5.5 und Claude Haiku 5.5, aber nicht von Claude Fable- oder Claude Mythos-Modellen.
* Lies Content-Blöcke anhand ihres `type` und gib `thinking`-Blöcke in Tool-Nutzungs-Schleifen unverändert zurück.
* Wenn deine Oberfläche Text zwischen Tool-Aufrufen rendert, setze `display: "updates"` (Beta) oder `"summarized"` und rendere die nicht leeren `thinking`-Blöcke.
* Wenn dein Code frühere Turns, den `system`-Prompt oder `tools` mitten in der Konversation bearbeitet, folge [Bewahrtes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking).
* Behandle `stop_reason: "refusal"` und konfiguriere einen Fallback.
* Ermittle Kosten und Latenz bei deiner gewählten Effort-Stufe neu als Baseline.
* Wenn dein Code das Nachdenken deaktiviert hat, überprüfe `max_tokens`, das Nachdenken plus Antworttext abdeckt; beginne bei Effort `xhigh` oder `max` mit 64k. Siehe [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response).
### Claude Opus 4.8 oder früher
* Überprüfe Workloads, die ohne `thinking`-Feld liefen: Auf Claude Opus 5.5 laufen sie mit Nachdenken, und Nachdenken kann nicht deaktiviert werden. Überprüfe `max_tokens`, das eine harte Grenze für die gesamte Ausgabe bleibt (Nachdenken plus Antworttext), und senke `effort` dort, wo du weniger Nachdenken möchtest. Thinking-Token werden als Output-Token abgerechnet, sodass diese Workloads mehr Output-Token pro Anfrage erzeugen können.
* Stelle sicher, dass jeder Code, der das `thinking`-Feld parst, es ausschließlich als Anzeigetext behandelt. Setze `display: "summarized"`, um lesbare Zusammenfassungen zu erhalten.
* Überprüfe Prompts nahe dem Caching-Minimum: Prompts mit 512 Token oder mehr können Cache-Einträge erstellen.
* Wenn deine Organisation eine [Priority Tier](https://platform.claude.com/docs/de/api/service-tiers#supported-models)-Verpflichtung hat, plane die Kapazität separat: Priority Tier wird auf Claude Opus 5.5 nicht unterstützt.
* Wenn du mit `xhigh`- oder `max`-Effort arbeitest, erhöhe `max_tokens` als Ausgangspunkt auf mindestens 64k.
* Ziehe für agentische Workloads [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets) (Beta) und Tool-Änderungen mitten in der Konversation (Beta) in Betracht.
### Claude Opus 4.7 oder früher
* Führe einen neuen [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Sweep auf deinen eigenen Evals durch, statt eine für ein früheres Modell abgestimmte Einstellung zu übernehmen.
* Entferne jeden Beta-Header für das Kontextfenster.
* Wenn du den Konversationsverlauf neu aufbaust, um Anweisungen zu aktualisieren, erwäge den Wechsel zu einer System-Nachricht mitten in der Konversation, um Prompt-Cache-Treffer zu erhalten.
* Stelle sicher, dass deine Stop-Reason-Behandlung bei Ablehnungen `stop_details` liest.
* Wenn du den Fast Mode möchtest, den Claude Opus 4.7 ablehnt, setze `speed: "fast"` in deinen Claude API-Anfragen. Claude Opus 5.5 benötigt keinen Beta-Header.
### Claude Opus 4.6 oder früher
* Entferne `temperature`, `top_p` und `top_k` aus den Request-Payloads.
* Ersetze `thinking: {"type": "enabled", "budget_tokens": N}` durch `thinking: {"type": "adaptive"}` plus den [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort) oder entferne das `thinking`-Feld vollständig; adaptives Nachdenken ist immer aktiv.
* Wenn deine UI Thinking-Inhalte anzeigt, aktiviere die Zusammenfassung des Nachdenkens explizit.
* Führe ein neues Benchmarking der End-to-End-Kosten und -Latenz unter der aktualisierten Tokenisierung durch.
* Passe `max_tokens` an die aktualisierte Tokenisierung an, einschließlich der Compaction-Auslöser.
* Teste alle clientseitigen Token-Zählungsschätzungen erneut.
* Wenn deine Anwendung Bilder sendet, plane das Budget für die [Unterstützung hochauflösender Bilder](https://platform.claude.com/docs/de/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7) neu (bis zu etwa 3x mehr Bild-Token pro Bild in voller Auflösung). Reduziere die Auflösung vor dem Senden, wenn du die zusätzliche Detailtreue nicht benötigst.
* Wenn du Zeige- oder Bounding-Box-Koordinaten vom Modell verwendest, entferne jede Skalierungsfaktor-Umrechnung; die Koordinaten entsprechen auf Claude Opus 4.7 und späteren Modellen 1:1 den tatsächlichen Bildpixeln.
* Überprüfe die [Verhaltensänderungen](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#behavior-changes), die mit Claude Opus 4.7 begonnen haben.
* Wenn dein Produkt legitime Sicherheitsarbeit leistet, bewirb dich für das [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet), um Zugang zu geringeren Einschränkungen bei Cyber-Inhalten zu erhalten.
### Claude Opus 4.5 oder früher
* Entferne alle Prefills von Assistant-Nachrichten; Claude Opus 4.6 lehnt sie bereits ab.
* Stelle sicher, dass das Parsen des JSON von Tool-Aufrufen einen Standard-JSON-Parser verwendet.
* Wechsle von `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`) zu `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`): Adaptives Nachdenken und Effort benötigen keinen Beta-Namespace.
* Entferne den Beta-Header `effort-2025-11-24` (der Effort-Parameter benötigt ihn nicht).
* Entferne den Beta-Header `fine-grained-tool-streaming-2025-05-14`.
* Entferne den Beta-Header `interleaved-thinking-2025-05-14` (adaptives Nachdenken aktiviert verschachteltes Nachdenken automatisch).
* Migriere `output_format` zu `output_config.format` (falls zutreffend).
### Claude 4.1 oder früher
* Aktualisiere die Tool-Versionen (`text_editor_20250728`, `code_execution_20260521`).
* Behandle den Stop-Reason `refusal`.
* Behandle den Stop-Reason `model_context_window_exceeded`.
* Überprüfe die Behandlung von String-Parametern in Tools auf abschließende Zeilenumbrüche.
* Entferne die Beta-Header `token-efficient-tools-2025-02-19` und `output-128k-2025-02-19`.
* Überprüfe und aktualisiere Prompts gemäß den [Best Practices für Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Nur Claude Sonnet 5
* Wenn du den Konversationsverlauf neu aufbaust, um Anweisungen zu aktualisieren, erwäge den Wechsel zu einer System-Nachricht mitten in der Konversation, um Prompt-Cache-Treffer zu erhalten.
* Überprüfe Prompts nahe dem Caching-Minimum: Prompts mit 512 Token oder mehr können Cache-Einträge erstellen.
## Migration zu Claude Opus 5.5 von Claude Opus 5
Arbeite zuerst [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements) und [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response) durch. Jedes Ausgangsmodell benötigt die Änderungen in diesem Abschnitt. Es handelt sich um die Anfrageeinstellungen, die Claude Opus 5.5 ablehnt, und die Änderungen an den Antworten, die damit einhergehen. Die Checkliste für diesen Abschnitt ist die erste Gruppe der [Migrations-Checkliste](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migration-checklist).
### Aktualisiere deinen Modellnamen
```python
model = "claude-opus-5" # Before
model = "claude-opus-5-5" # After
```
`claude-opus-5-5` ist eine feste Modell-ID ohne Datumssuffix, nach demselben Schema wie `claude-opus-5`. Auf Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) und Microsoft Foundry verwendest du die Modell-ID der jeweiligen Plattform; siehe [Verfügbarkeit](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#availability).
### Breaking Changes
Jede Änderung wird unter [Breaking Changes](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#breaking-changes) in „Neuerungen in Claude Opus 5.5“ erklärt; dieser Abschnitt zeigt die jeweilige Codeänderung.
#### Nachdenken kann nicht deaktiviert werden
`thinking: {"type": "disabled"}` und `thinking: {"type": "enabled", "budget_tokens": N}` geben beide einen 400-Fehler zurück (`"thinking.type.disabled" is not supported for this model.` oder `"thinking.type.enabled" is not supported for this model.`). Entferne das `thinking`-Feld und wähle eine [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe; wo du Nachdenken deaktiviert hast, um Token zu sparen, verwende eine niedrigere. Antworten beginnen dann mit `thinking`-Blöcken, wähle Content-Blöcke also nach `type` aus und gib `thinking`-Blöcke unverändert mit den Tool-Ergebnissen zurück. Siehe [Nachdenken kann nicht deaktiviert werden](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#thinking-cant-be-disabled).
Vorher. Claude Opus 5 akzeptiert diese Anfrage, und Claude Opus 5.5 lehnt sie mit einem 400-Fehler ab:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 16000,
"thinking": {"type": "disabled"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5 \
--max-tokens 16000 \
--thinking '{type: disabled}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5",
max_tokens=16000,
thinking={"type": "disabled"},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5",
max_tokens: 16000,
thinking: { type: "disabled" },
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 16000,
Thinking = new ThinkingConfigDisabled(),
Messages = [new UserMessageParam { Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(16000L)
.thinking(ThinkingConfigDisabled.builder().build())
.addUserMessage("...")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 16000,
thinking: ThinkingConfigDisabled::with(),
messages: [['role' => 'user', 'content' => '...']],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 16000,
thinking: Anthropic::ThinkingConfigDisabled.new,
messages: [{ role: "user", content: "..." }]
)
```
Nachher:
```bash cURL
# Nachdenken ist immer aktiv; effort ist die Steuerung
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"output_config": {"effort": "low"},
"messages": [{"role": "user", "content": "..."}]
}'
```
```bash CLI
# Nachdenken ist immer aktiv; effort ist die Steuerung
ant messages create \
--model claude-opus-5-5 \
--max-tokens 16000 \
--output-config '{effort: low}' \
--message '{role: user, content: "..."}'
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
output_config={"effort": "low"}, # thinking is always on; effort is the control
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
output_config: { effort: "low" }, // thinking is always on; effort is the control
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
OutputConfig = new() { Effort = Effort.Low }, // thinking is always on; effort is the control
Messages = [new UserMessageParam { Content = "..." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortLow, // thinking is always on; effort is the control
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
// Nachdenken ist immer aktiv; effort ist die Steuerung
.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,
// Nachdenken ist immer aktiv; effort ist die Steuerung
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,
# Nachdenken ist immer aktiv; effort dient zur Steuerung
output_config: { effort: Anthropic::OutputConfig::Effort::LOW },
messages: [{ role: "user", content: "..." }]
)
```
#### Erzwungene Tool-Nutzung wird nicht unterstützt
Die `tool_choice`-Typen `any` und `tool` geben einen 400-Fehler zurück (`tool_choice: type "tool" and "any" are not supported for this model.`), auch am Token-Counting-Endpunkt. Verwende `auto` mit [strikter Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/strict-tool-use) oder [strukturierten Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) und gib im Prompt an, wann das Tool zutrifft. Strikte Tool-Nutzung akzeptiert eine Teilmenge von JSON Schema, prüfe also das `input_schema` jedes Tools, bevor du `strict: true` hinzufügst. Jedes Objekt im Schema muss `additionalProperties: false` setzen; siehe [Einschränkungen von JSON Schema](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#json-schema-limitations). Siehe [Erzwungene Tool-Nutzung wird nicht unterstützt](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#forced-tool-use-is-not-supported).
Vorher. Claude Opus 5 akzeptiert diese Anfrage, und Claude Opus 5.5 lehnt sie mit einem 400-Fehler ab:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 1024,
"tools": [{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
}
},
"required": ["location"],
"additionalProperties": false
}
}],
"tool_choice": {"type": "tool", "name": "get_weather"},
"messages": [{"role": "user", "content": "What'\''s the weather in Paris?"}]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 1024
tools:
- name: get_weather
description: Get the current weather in a given location
input_schema:
type: object
properties:
location:
type: string
description: The city and state, e.g. San Francisco, CA
required: [location]
additionalProperties: false
tool_choice:
type: tool
name: get_weather
messages:
- role: user
content: What's the weather in Paris?
YAML
```
```python Python
client.messages.create(
model="claude-opus-5",
max_tokens=1024,
tools=tools,
tool_choice={"type": "tool", "name": "get_weather"},
messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5",
max_tokens: 1024,
tools,
tool_choice: { type: "tool", name: "get_weather" },
messages: [{ role: "user", content: "What's the weather in Paris?" }]
});
```
```csharp C#
await client.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 1024,
Tools = [.. tools],
ToolChoice = new ToolChoiceTool { Name = "get_weather" },
Messages = [new UserMessageParam { Content = "What's the weather in Paris?" }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 1024,
Tools: tools,
ToolChoice: anthropic.ToolChoiceParamOfTool("get_weather"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in Paris?")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(1024L)
.tools(tools)
.toolChoice(ToolChoiceTool.of("get_weather"))
.addUserMessage("What's the weather in Paris?")
.build();
client.messages().create(params);
```
```php PHP
$client->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 1024,
tools: $tools,
toolChoice: ToolChoiceTool::with(name: 'get_weather'),
messages: [['role' => 'user', 'content' => "What's the weather in Paris?"]],
);
```
```ruby Ruby
client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 1024,
tools: tools,
tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
messages: [{ role: "user", content: "What's the weather in Paris?" }]
)
```
Nachher:
```bash cURL
# strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"tools": [{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
}
},
"required": ["location"],
"additionalProperties": false
},
"strict": true
}],
"tool_choice": {"type": "auto"},
"messages": [{
"role": "user",
"content": "What'\''s the weather in Paris? Use the get_weather tool."
}]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
tools:
- name: get_weather
description: Get the current weather in a given location
input_schema:
type: object
properties:
location:
type: string
description: The city and state, e.g. San Francisco, CA
required: [location]
additionalProperties: false
# strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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,
# strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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,
// strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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,
// strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
Tools = [.. tools.Select(tool => tool with { Strict = true })],
ToolChoice = new ToolChoiceAuto(),
Messages =
[
new UserMessageParam { Content = "What's the weather in Paris? Use the get_weather tool." },
],
});
```
```go Go
// strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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)
// Strikte Tool-Nutzung: Jeder Aufruf entspricht dem input_schema des Tools
.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,
// strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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,
# strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
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." }
]
)
```
#### Thinking-Blöcke sind an das Modell und die Konversation gebunden
In der Claude API lesen Claude Fable 5.1 und Claude Mythos 5.1 die Thinking-Blöcke von Claude Opus 5.5; kein anderes Modell tut das. Ein Router oder Fallback, der eine Konversation von Claude Opus 5.5 zu einem anderen Modell verschiebt, führt diese Turns ohne sie aus. In umgekehrter Richtung liest Claude Opus 5.5 Thinking-Blöcke von Claude Opus 5, von früheren Opus-, Sonnet- und Haiku-Modellen sowie, in der Claude API und bei Claude Models on Google Cloud (Google managed), von Claude Sonnet 5.5 und Claude Haiku 5.5, jedoch nicht von Claude Fable- oder Claude Mythos-Modellen. Halte die Konversation „append-only“ (nur anhängend; keine Änderungen am `system`-Prompt, an `tools` oder an früheren Nachrichten mitten in der Konversation), damit die Blöcke gültig bleiben; Claude Code, claude.ai, Claude Managed Agents und das Claude Agent SDK tun das bereits. Bei Konten, die am oder nach dem 31. August 2026, 00:00 UTC, erstellt wurden, erhält in der Claude API und auf Cloud-Plattformen eine Anfrage, die nach einer solchen Änderung einen Thinking-Block erneut mitsendet und `thinking.block_binding.prefix_mismatch_behavior` nicht setzt, einen 400-Fehler. Für append-only-Integrationen ist keine Codeänderung erforderlich. Siehe [Thinking-Blöcke sind an das Modell und die Konversation gebunden](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#thinking-blocks-are-tied-to-the-model-that-produced-them) und [Beibehaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking).
#### Einige Versionen des Computer-Use-Tools werden nicht unterstützt
Claude Opus 5.5 unterstützt Computer Use über das Toolset `computer_toolset_20260801`. Auf Amazon Bedrock akzeptiert Claude Opus 5.5 außerdem das Tool `computer_20251124` mit dem Beta-Header `computer-use-2025-11-24`. Claude Opus 5.5 gibt einen 400-Fehler für jede Version des Computer-Use-Tools zurück, die es nicht akzeptiert, etwa `computer_20251124` auf der Claude API. Es akzeptiert `computer_20250124` auf keiner Plattform. Auf der Claude API beginnt die Fehlermeldung mit `'claude-opus-5-5' does not support tool types: computer_20251124.` und listet dann die Tool-Typen auf, die das Modell akzeptiert.
Integrationen, die das Toolset verwenden, benötigen keine Änderung. Um eine `computer_20251124`-Integration auf das Toolset umzustellen, entferne den Beta-Header und sende den Eintrag `computer_toolset_20260801` ohne `name` oder Display-Abmessungen. Behandle in deiner Agent-Schleife jeden `tool_use`-Block eines Members in einem Turn und gib bei jedem Ergebnis `toolset_name` zurück. Lies die Aktion aus dem `name` jedes Blocks, nicht aus `input.action`. [Von `computer_20251124` migrieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) listet die Änderungen an der Agent-Schleife auf.
Vorher. Claude Opus 5 akzeptiert diese Anfrage, und Claude Opus 5.5 lehnt sie auf der Claude API mit einem 400-Fehler ab:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: computer-use-2025-11-24" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5",
"max_tokens": 4096,
"tools": [{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768
}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
ant beta:messages create \
--model claude-opus-5 \
--max-tokens 4096 \
--beta computer-use-2025-11-24 \
--tool '{
type: computer_20251124,
name: computer,
display_width_px: 1024,
display_height_px: 768
}' \
--message '{role: user, content: "Open the display settings."}'
```
```python Python
client.beta.messages.create(
model="claude-opus-5",
max_tokens=4096,
betas=["computer-use-2025-11-24"],
tools=[
{
"type": "computer_20251124",
"name": "computer",
"display_width_px": 1024,
"display_height_px": 768,
}
],
messages=[{"role": "user", "content": "Open the display settings."}],
)
```
```typescript TypeScript
await client.beta.messages.create({
model: "claude-opus-5",
max_tokens: 4096,
betas: ["computer-use-2025-11-24"],
tools: [
{
type: "computer_20251124",
name: "computer",
display_width_px: 1024,
display_height_px: 768
}
],
messages: [{ role: "user", content: "Open the display settings." }]
});
```
```csharp C#
await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeOpus5,
MaxTokens = 4096,
Betas = [AnthropicBeta.ComputerUse2025_11_24],
Tools =
[
new BetaToolComputerUse20251124
{
DisplayWidthPx = 1024,
DisplayHeightPx = 768,
},
],
Messages = [new BetaUserMessageParam { Content = "Open the display settings." }],
});
```
```go Go
client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: 4096,
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaComputerUse2025_11_24},
Tools: []anthropic.BetaToolUnionParam{
{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
DisplayWidthPx: 1024,
DisplayHeightPx: 768,
}},
},
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Open the display settings.")),
},
})
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(4096L)
.addBeta(AnthropicBeta.COMPUTER_USE_2025_11_24)
.addTool(BetaToolComputerUse20251124.builder()
.displayWidthPx(1024L)
.displayHeightPx(768L)
.build())
.addUserMessage("Open the display settings.")
.build();
client.beta().messages().create(params);
```
```php PHP
$client->beta->messages->create(
model: Model::CLAUDE_OPUS_5,
maxTokens: 4096,
betas: [AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
BetaToolComputerUse20251124::with(
displayWidthPx: 1024,
displayHeightPx: 768,
),
],
messages: [['role' => 'user', 'content' => 'Open the display settings.']],
);
```
```ruby Ruby
client.beta.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5,
max_tokens: 4096,
betas: [Anthropic::AnthropicBeta::COMPUTER_USE_2025_11_24],
tools: [
Anthropic::Beta::BetaToolComputerUse20251124.new(
name: :computer,
display_width_px: 1024,
display_height_px: 768
)
],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
Nachher:
```bash cURL
# kein Beta-Header; der Toolset-Eintrag hat weder Namen noch Anzeigegröße
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"tools": [{"type": "computer_toolset_20260801"}],
"messages": [{"role": "user", "content": "Open the display settings."}]
}'
```
```bash CLI
# kein Beta-Header; der Toolset-Eintrag hat keinen Namen und keine Anzeigegröße
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,
# kein Beta-Header; der Toolset-Eintrag hat weder Namen noch Anzeigegröße
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,
// kein Beta-Header; der Toolset-Eintrag hat keinen Namen und keine Anzeigegröße
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,
// kein Beta-Header; der Toolset-Eintrag nimmt weder Namen noch Anzeigegröße an
Tools = [new ComputerToolset20260801()],
Messages = [new UserMessageParam { Content = "Open the display settings." }],
});
```
```go Go
client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
// kein Beta-Header; der Toolset-Eintrag nimmt keinen Namen und keine Anzeigegröße an
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)
// kein Beta-Header; der Toolset-Eintrag nimmt weder Namen noch Anzeigegröße an
.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,
// kein Beta-Header; der Toolset-Eintrag hat keinen Namen und keine Anzeigegröße
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,
# kein Beta-Header; der Toolset-Eintrag erhält weder Namen noch Anzeigegröße
tools: [Anthropic::ComputerToolset20260801.new],
messages: [{ role: "user", content: "Open the display settings." }]
)
```
### Text zwischen Tool-Aufrufen wird in Thinking-Blöcken zurückgegeben
Auf Claude Opus 5 kommt Text, den das Modell zwischen Tool-Aufrufen schreibt, als `text`-Blöcke zurück. Auf Claude Opus 5.5 kommt diese Erzählung, wie bei Claude Fable 5.1, als [Fortschritts-Update-`thinking`-Blöcke](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) zurück, höchstens einer vor jedem Tool-Aufruf. Beim Standardwert `"omitted"` für `thinking.display` ist ihr `thinking`-Feld leer. Keine Anfrage schlägt fehl, aber eine Anwendung, die diesen Text als Fortschritts-Updates an ihre Nutzer streamt, wird zwischen Tool-Aufrufen still. Um die Updates wiederherzustellen, lies sie aus `thinking`-Blöcken und setze einen `display`-Wert, der ihren Text zurückgibt: `"updates"` (Beta, Header `thinking-display-updates-2026-08-18`) gibt die Fortschritts-Updates zurück, während das Reasoning verborgen bleibt, und `"summarized"` gibt beides gemischt zurück. Stelle dann jeden nicht leeren `thinking`-Block vor dem `tool_use`-Block dar, dem er vorausgeht, und gib die Blöcke unverändert mit dem Rest des Assistant-Turns zurück. Siehe [Nutzerseitige Fortschritts-Updates](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
### Sicherheitsklassifikatoren und Fallback
Claude Opus 5.5 kann `stop_reason: "refusal"` mit einer `stop_details`-Kategorie zurückgeben. Seine Klassifikatoren decken eine breitere Menge an Kategorien ab als die von Claude Opus 5, rechne also mit `stop_details.category`-Werten wie `"bio"` zusätzlich zu `"cyber"` und `"reasoning_extraction"`; siehe die [Tabelle der Ablehnungskategorien](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#refusal-response). Behandle Ablehnungen und konfiguriere einen [serverseitigen Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) oder deinen eigenen Wiederholungsversuch (der serverseitige Fallback wiederholt keine Anfragen, die mit `"reasoning_extraction"` abgelehnt wurden; diese Ablehnung wird an dich zurückgegeben); siehe [Ablehnungen und Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback) und [Ablehnungen durch Schutzmaßnahmen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#safeguard-refusals).
### Empfohlene Änderungen
1. **Führe deinen Effort-Sweep erneut durch.** Effort ist die einzige Steuerung des Nachdenkens auf Claude Opus 5.5, und sein Standardwert ist `medium`, während er bei Claude Opus 5 `high` ist; eine Anfrage, die `effort` weglässt, läuft jetzt also mit `medium`. Geh eine Stufe herunter, wo die Qualität erhalten bleibt, und eine Stufe höher für die anspruchsvollsten Aufgaben. Siehe [Effort](https://platform.claude.com/docs/de/build-with-claude/effort).
2. **Bewerte modellspezifische Prompt-Anweisungen neu.** Anweisungen, die auf das Verhalten von Claude Opus 5 abgestimmt waren, sind möglicherweise nicht mehr nötig; siehe [Prompting für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5). Wenn du mit deaktiviertem Nachdenken gearbeitet hast, siehe auch [Prompts, die für deaktiviertes Nachdenken geschrieben wurden](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#prompts-written-for-thinking-disabled).
3. **Teste in einer Entwicklungsumgebung**, bevor du den Produktions-Traffic umstellst.
## Migration zu Claude Opus 5.5 von Claude Opus 4.8
Arbeite zuerst [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements), [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response) und [Migration zu Claude Opus 5.5 von Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-5) durch. Verwende `claude-opus-4-8` als die Modell-ID, die du ersetzt. Der letztgenannte Abschnitt gilt für Code auf Claude Opus 4.8 unverändert, weil Claude Opus 4.8, wie Claude Opus 5:
* `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das `computer_20251124`-Tool akzeptiert.
* Den Text zwischen Tool-Aufrufen als `text`-Blöcke zurückgibt.
* Standardmäßig `high`-Effort verwendet.
Dieser Abschnitt ergänzt, was sich zwischen Claude Opus 4.8 und Claude Opus 5 geändert hat. Eine Checkliste findest du in den ersten beiden Gruppen der [Migrations-Checkliste](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migration-checklist).
### Was sich geändert hat
1. **Nachdenken läuft bei Anfragen, die es weggelassen haben:** Auf Claude Opus 4.8 ist Nachdenken deaktiviert, sofern du es nicht anforderst. Auf Claude Opus 5.5 läuft eine Anfrage ohne `thinking`-Feld mit Nachdenken, daher ist jeder Punkt in [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response) eine Änderung für diesen Code. Wenn dein Code nie ein `thinking`-Feld gesendet hat, gibt es unter dem [Vorher und Nachher für Nachdenken](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-cant-be-disabled) nichts zu entfernen.
2. **Niedrigeres Minimum für Prompt-Caching:** Die minimale cachebare Prompt-Länge auf Claude Opus 5.5 beträgt 512 Token, gegenüber 1.024 Token auf Claude Opus 4.8. Prompts, die auf Claude Opus 4.8 zu kurz zum Cachen waren, können Cache-Einträge erstellen, ohne dass Codeänderungen erforderlich sind. Siehe [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-limitations) für die Minima pro Modell.
3. **Priority Tier wird nicht unterstützt:** [Priority Tier](https://platform.claude.com/docs/de/api/service-tiers#supported-models) wird auf Claude Opus 5.5 nicht unterstützt, während Claude Opus 4.8 es beibehält. Wenn deine Organisation eine Priority Tier-Verpflichtung hat, plane die Kapazität separat.
### Empfohlene Änderungen
Diese sind nicht erforderlich, verbessern aber deine Erfahrung:
1. **Task-Budgets in Betracht ziehen (Beta):** Für agentische Workloads teilen [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets) dem Modell mit, wie viele Token es für eine vollständige agentische Schleife zur Verfügung hat. Sie erfordern den Beta-Header `task-budgets-2026-03-13`.
2. **Tool-Änderungen während der Konversation in Betracht ziehen (Beta):** Mit „mid-conversation tool changes“ (Tool-Änderungen während der Konversation) kannst du zwischen den Runden einer Konversation Tools hinzufügen oder entfernen, ohne Treffer im [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) bei früheren Runden ungültig zu machen. Eine Änderung des `tools`-Arrays selbst macht das gecachte Präfix ungültig. Sende auf der Claude API, Claude Platform on AWS und Claude Models on Google Cloud (Anthropic managed) den Beta-Header `inline-tools-2026-09-15`. Der Header `mid-conversation-tool-changes-2026-07-01` funktioniert für Änderungen, die ein Tool per Referenz benennen, und zwar auf der Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) und Claude Models on Google Cloud (Google managed).
## Migration zu Claude Opus 5.5 von Claude Opus 4.7
Arbeite zuerst [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements), [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response), [Migration zu Claude Opus 5.5 von Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-5) und [Migration zu Claude Opus 5.5 von Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8) durch. Verwende `claude-opus-4-7` als die Modell-ID, die du ersetzt. Diese Abschnitte gelten für Code auf Claude Opus 4.7 unverändert. Wie Claude Opus 4.8 akzeptiert es `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das `computer_20251124`-Tool. Es verwendet standardmäßig `high`-Effort und läuft ohne Nachdenken, sofern du es nicht anforderst.
Dieser Abschnitt ergänzt, was sich nach Claude Opus 4.7 geändert hat. Wenn dein Code auf Claude Opus 4.6 oder früher läuft, fahre nach diesem Abschnitt mit [Migration zu Claude Opus 5.5 von Claude Opus 4.6 und früheren Opus-Modellen](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-46) fort. Dieser ergänzt die Breaking Changes, die mit Claude Opus 4.7 in Kraft getreten sind. Eine Checkliste findest du in den ersten drei Gruppen der [Migrations-Checkliste](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migration-checklist).
### Was sich geändert hat
Keiner dieser Punkte fügt den Breaking Changes aus den früheren Abschnitten eine weitere hinzu; es lohnt sich aber, sie nach dem Austausch der Modell-ID zu prüfen.
1. **Effort-Stufen neu kalibriert:** Die Token-Zuteilung hinter jeder Effort-Stufe ändert sich bei Claude Opus 5.5 im Vergleich zu Claude Opus 4.7. Der Standardwert ist `medium`, während er bei Claude Opus 4.7 `high` ist. Führe einen neuen Effort-Durchlauf mit deinen eigenen Evals durch, anstatt eine für Claude Opus 4.7 abgestimmte Einstellung zu übernehmen. Siehe [Effort](https://platform.claude.com/docs/de/build-with-claude/effort).
2. **1M-Kontextfenster ist der Standard:** Claude Opus 5.5 stellt standardmäßig das vollständige „context window“ (Kontextfenster) mit 1M Token ([Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows)) ohne Beta-Header bereit. Wenn dein Client aus Kompatibilitätsgründen mit älteren Modellen einen Kontextfenster-Beta-Header übergibt, entferne ihn.
3. **System-Nachrichten während der Konversation:** Auf der Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) und Claude Models on Google Cloud (Google managed) akzeptiert Claude Opus 5.5 `role: "system"`-Nachrichten unmittelbar nach einer Benutzerrunde im `messages`-Array (vorbehaltlich der [Platzierungsregeln](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#limitations)). Verwende das `system`-Feld auf oberster Ebene für Anweisungen, die von Anfang an gelten. Claude Opus 4.7 lehnt `role: "system"` in `messages` mit einem 400-Fehler ab. Wenn du Codepfade pflegst, die den gesamten Nachrichtenverlauf neu aufbauen, um Anweisungen zu aktualisieren, kannst du sie vereinfachen und Treffer im [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) bei früheren Runden beibehalten.
4. **Details zum Ablehnungs-Stopp:** Wenn das Modell eine Anfrage ablehnt, gibt Claude Opus 5.5 neben dem Stop-Grund `refusal` ein `stop_details`-Objekt zurück, das die Kategorie der Ablehnung benennt. Claude Opus 4.7 gibt dasselbe Objekt zurück, daher ist dies nur relevant, wenn deine Behandlung von Stop-Gründen es noch nicht ausliest. Es ist kein Beta-Header erforderlich, und es gibt keine Opt-out-Möglichkeit. Wenn deine Behandlung von Stop-Gründen es noch nicht ausliest, siehe [Umgang mit Stop-Gründen](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons). Claude Opus 5.5 lehnt in mehr Kategorien ab; siehe [Sicherheitsklassifikatoren und Fallback](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#safety-classifiers-and-fallback).
5. **Fast Mode:** Claude Opus 5.5 unterstützt den [Fast Mode](https://platform.claude.com/docs/de/build-with-claude/fast-mode) auf der Claude API. Fast Mode ist auf Claude Opus 4.7 nicht verfügbar; dort geben Anfragen mit `speed: "fast"` einen Fehler zurück. Setze `speed: "fast"` in deinen Anfragen. Claude Opus 5.5 benötigt keinen Beta-Header.
6. **Computer-Use-Toolset und Browser-Use-Tool:** Claude Opus 5.5 unterstützt [Computer Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool) als `computer_toolset_20260801`-Toolset sowie das [Browser-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool) für Aufgaben innerhalb von Webseiten. Claude Opus 4.7 unterstützt keines von beiden. Um eine `computer_20251124`-Integration auf das Toolset umzustellen, siehe die [Breaking Change zu Computer Use](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#computer-use-toolset).
## Migration zu Claude Opus 5.5 von Claude Opus 4.6 und früheren Opus-Modellen
Arbeite zuerst alle vorherigen Abschnitte in der Reihenfolge der Seite durch. Das sind [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements), [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response) sowie die Abschnitte zu [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-5), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8) und [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-47). Diese Abschnitte gelten für Code auf Claude Opus 4.6 so, wie sie geschrieben sind. Wie Claude Opus 4.7 akzeptiert es `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das Tool `computer_20251124`. Es verwendet standardmäßig den Effort `high` und läuft ohne Nachdenken, sofern du es nicht anforderst. Claude Opus 4.5 und frühere Opus-Modelle akzeptieren ebenfalls `thinking: {"type": "disabled"}` und erzwungene Tool-Auswahl und laufen ohne Nachdenken, sofern du es nicht anforderst, daher gelten diese Abschnitte auch für sie.
Dieser Abschnitt ergänzt, was sich in Claude Opus 4.7 geändert hat, mit `claude-opus-4-6` als der Modell-ID, die du ersetzt. Seine beiden Unterabschnitte ergänzen, was sich davor geändert hat, für Leser auf [Claude Opus 4.5 oder früher](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-45) und [Claude 4.1 oder früher](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier). Eine Checkliste findest du in der [Migrations-Checkliste](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migration-checklist) bis zu der Gruppe, die dein Modell nennt.
### Breaking Changes
1. **Erweitertes Nachdenken entfernt:** `thinking: {"type": "enabled", "budget_tokens": N}` wird auf Claude Opus 4.7 und späteren Modellen nicht mehr unterstützt und gibt einen 400-Fehler zurück. Wechsle zu [adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) (`thinking: {"type": "adaptive"}`) und verwende den [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort), um die Tiefe des Nachdenkens zu steuern. Auf Claude Opus 5.5 ist adaptives Nachdenken immer aktiv: `thinking: {"type": "adaptive"}` ist gültig und gleichbedeutend damit, das Feld `thinking` ganz wegzulassen.
Vorher (Claude Opus 4.6):
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-4-6",
"max_tokens": 16000,
"thinking": {
"type": "enabled",
"budget_tokens": 10000
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-4-6
max_tokens: 16000
thinking:
type: enabled
budget_tokens: 10000
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-4-6",
max_tokens=16000,
thinking={"type": "enabled", "budget_tokens": 10000},
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-4-6",
max_tokens: 16000,
thinking: { type: "enabled", budget_tokens: 10000 },
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus4_6,
MaxTokens = 16000,
Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
Messages = [new UserMessageParam { Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus4_6,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamOfEnabled(10000),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_4_6)
.maxTokens(16000L)
.enabledThinking(10000L)
.addUserMessage("...")
.build();
Message response = client.messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$message = $client->messages->create(
maxTokens: 16000,
messages: [['role' => 'user', 'content' => '...']],
model: 'claude-opus-4-6',
thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
);
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: "claude-opus-4-6",
max_tokens: 16000,
thinking: {
type: "enabled",
budget_tokens: 10000
},
messages: [
{ role: "user", content: "..." }
]
)
```
Nachher (Claude Opus 5.5), wobei sich die Zeilen für Modell-ID, `thinking` und `output_config` unterscheiden:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"output_config": {
"effort": "high"
},
"messages": [
{
"role": "user",
"content": "..."
}
]
}'
```
```bash CLI
ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
thinking:
type: adaptive
output_config:
effort: high
messages:
- role: user
content: "..."
YAML
```
```python Python
client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={"type": "adaptive"},
output_config={"effort": "high"}, # or "max", "xhigh", "medium", "low"
messages=[{"role": "user", "content": "..."}],
)
```
```typescript TypeScript
await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: { type: "adaptive" },
output_config: { effort: "high" }, // or "max", "xhigh", "medium", "low"
messages: [{ role: "user", content: "..." }]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new ThinkingConfigAdaptive(),
OutputConfig = new OutputConfig { Effort = Effort.High }, // or Max, Xhigh, Medium, Low
Messages = [new UserMessageParam { Content = "..." }]
};
var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
},
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortHigh, // or Max, Xhigh, Medium, Low
},
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(ThinkingConfigAdaptive.builder().build())
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.HIGH) // or MAX, XHIGH, MEDIUM, LOW
.build())
.addUserMessage("...")
.build();
Message response = client.messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$message = $client->messages->create(
maxTokens: 16000,
messages: [['role' => 'user', 'content' => '...']],
model: Model::CLAUDE_OPUS_5_5,
thinking: ['type' => 'adaptive'],
outputConfig: ['effort' => 'high'], // or 'max', 'xhigh', 'medium', 'low'
);
```
```ruby Ruby
client = Anthropic::Client.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 16000,
thinking: {
type: "adaptive"
},
output_config: {
effort: "high" # or "max", "xhigh", "medium", "low"
},
messages: [
{ role: "user", content: "..." }
]
)
```
Adaptives Nachdenken lässt sich über Prompting und den [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort) steuern, der das Thinking-Budget als Mittel ersetzt, um zu steuern, wie viel das Modell überlegt. Führe einen Effort-Sweep mit deinen eigenen Evals durch, anstatt einen `budget_tokens`-Wert zu übertragen. Die [Tabelle der Effort-Stufen](https://platform.claude.com/docs/de/build-with-claude/effort#effort-levels) beschreibt, wann welche Stufe zu verwenden ist, und [Empfohlene Effort-Stufen für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/effort#recommended-effort-levels-for-claude-opus-5-5) behandelt dieses Modell.
2. **Sampling-Parameter entfernt:** Lass `temperature`, `top_p` und `top_k` weg. Prompting ist der empfohlene Weg, um das Modellverhalten auf Claude Opus 5.5 zu steuern. Falls du `temperature = 0` für Determinismus verwendet hast, beachte, dass dies auch bei früheren Modellen nie identische Ausgaben garantiert hat.
3. **Thinking-Inhalt standardmäßig ausgelassen:** Thinking-Blöcke erscheinen auf Claude Opus 4.7 und späteren Modellen weiterhin im Antwort-Stream, aber ihr Feld `thinking` ist leer, sofern du dich nicht ausdrücklich dafür entscheidest. Dies ist eine stille Änderung gegenüber Claude Opus 4.6, wo standardmäßig zusammengefasster Thinking-Text zurückgegeben wurde. Um dies wiederherzustellen, siehe Punkt 4 von [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response).
4. **Aktualisierte Token-Zählung:** Claude Opus 4.7 hat einen neuen Tokenizer eingeführt, den auch spätere Opus-Modelle, einschließlich Claude Opus 5.5, verwenden. Er trägt zu einer verbesserten Leistung bei einer Vielzahl von Aufgaben bei und kann bei der Verarbeitung von Text etwa das 1- bis 1,35-Fache an Token im Vergleich zu Modellen vor Claude Opus 4.7 verbrauchen (bis zu etwa 35 Prozent mehr, je nach Inhalt).
[`/v1/messages/count_tokens`](https://platform.claude.com/docs/de/build-with-claude/token-counting) gibt für Claude Opus 5.5 eine andere Anzahl von Token zurück als für Claude Opus 4.6. Die Token-Effizienz kann je nach Art der Workload variieren.
Aktualisiere deine `max_tokens`-Parameter, um zusätzlichen Spielraum zu schaffen, einschließlich Compaction-Triggern, und teste jeden Codepfad erneut, der Token clientseitig schätzt oder ein festes Verhältnis von Token zu Zeichen annimmt. Verwende den Endpunkt [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) zur Überprüfung. Prompting-Maßnahmen, [`task_budget`](https://platform.claude.com/docs/de/build-with-claude/task-budgets) und [`effort`](https://platform.claude.com/docs/de/build-with-claude/effort) können helfen, die Kosten zu kontrollieren; diese Steuerungen können zulasten der Modellintelligenz gehen.
5. **Entfernung von Prefill (bereits auf Claude Opus 4.6 wirksam):** Das Vorausfüllen von Assistant-Nachrichten gibt auf Claude Opus 4.6 und späteren Opus-Modellen, einschließlich Claude Opus 5.5, einen 400-Fehler zurück, daher ist dies nur eine Änderung, wenn du von Claude Opus 4.5 oder früher kommst. Verwende stattdessen [strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) oder Anweisungen im System-Prompt.
### Verhaltensänderungen
Claude Opus 4.7 hat Verhaltensunterschiede gegenüber Claude Opus 4.6 eingeführt, die keine Breaking Changes der API sind. Diese drei betreffen Code oder Scaffolding:
1. **Integrierte Fortschrittsupdates in agentischen Abläufen:** Claude Opus 4.7 liefert dem Benutzer während langer agentischer Abläufe regelmäßigere und hochwertigere Updates. Wenn du Scaffolding hinzugefügt hast, um Zwischenstatusmeldungen zu erzwingen („Fasse nach jeweils 3 Tool-Aufrufen den Fortschritt zusammen“), versuche, es zu entfernen. Auf Claude Opus 5.5 kommen diese Updates in `thinking`-Blöcken an, die beim standardmäßigen `thinking.display` leer sind. Um sie zu erhalten, siehe [Text zwischen Tool-Aufrufen wird in Thinking-Blöcken zurückgegeben](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#text-between-tool-calls). Um ihre Länge und ihren Inhalt zu gestalten, siehe [Fortschrittsupdates für Benutzer](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
2. **Cybersicherheits-Schutzmaßnahmen in Echtzeit:** Diese Schutzmaßnahmen sind neu in Claude Opus 4.7: Anfragen, die verbotene oder risikoreiche Themen betreffen, können zu Ablehnungen führen. Für legitime Sicherheitsarbeit wie Penetrationstests, Schwachstellenforschung oder Red-Teaming bewirb dich beim [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet), um gelockerte Einschränkungen zu beantragen. Der Bewerbungsweg hängt davon ab, wie du auf Claude zugreifst.
3. **Unterstützung hochauflösender Bilder:** Claude Opus 4.7 ist das erste Claude-Modell mit Unterstützung für hochauflösende Bilder. Die maximale Bildauflösung beträgt 2.576 Pixel an der langen Kante, gegenüber 1.568 Pixeln bei früheren Modellen. Dies ermöglicht Verbesserungen bei bildlastigen Workloads und ist besonders wertvoll für Computer Use, das Verstehen von Screenshots und die Dokumentenanalyse.
Die Unterstützung hoher Auflösungen erfolgt automatisch und erfordert weder einen Beta-Header noch eine clientseitige Aktivierung. Zwei Dinge solltest du einplanen:
* Bilder in voller Auflösung können bis zu etwa 3-mal mehr Bild-Token verbrauchen als bei früheren Modellen (bis zu 4.784 Token pro Bild, verglichen mit der bisherigen Obergrenze von etwa 1.600 Token). Plane `max_tokens` und die Kostenerwartungen für bildlastige Workloads neu, oder verkleinere die Bilder vor dem Senden, wenn du die zusätzliche Detailtreue nicht benötigst.
* Zeige- und Bounding-Box-Koordinaten, die das Modell zurückgibt, entsprechen auf Claude Opus 4.7 1:1 den tatsächlichen Bildpixeln, sodass keine Umrechnung mit Skalierungsfaktor erforderlich ist.
Details findest du unter [Unterstützung hochauflösender Bilder auf Claude Opus 4.7](https://platform.claude.com/docs/de/build-with-claude/vision#high-resolution-image-support-on-claude-opus-4-7).
Für Unterschiede auf der Prompt-Seite siehe [Prompting für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5) und [Best Practices für Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Migration von Claude Opus 4.5 oder früher
Wenn du von Claude Opus 4.5, Claude Opus 4.1 oder einem früheren Modell direkt zu Claude Opus 5.5 migrierst, lies diese Seite von Anfang an: Arbeite zuerst alle vorherigen Abschnitte in der Reihenfolge der Seite durch. Arbeite dann die [Breaking Changes für die Migration von Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#opus-46-breaking-changes) weiter oben in diesem Abschnitt durch. Wende anschließend die folgenden kumulativen Änderungen an, die zwischen Claude Opus 4.5 und Claude Opus 4.7 wirksam wurden. Wenn du Claude Opus 4.1 oder früher verwendest, fahre nach diesem Unterabschnitt mit [Migration von Claude 4.1 oder früher](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-4-1-or-earlier) fort.
#### Breaking Changes
1. **Die Entfernung von Prefill** wird in den [Breaking Changes für die Migration von Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#opus-46-breaking-changes) behandelt.
2. **Quoting von Tool-Parametern:** Claude Opus 4.6 und spätere Modelle können in Tool-Aufruf-Argumenten ein leicht abweichendes Escaping von JSON-Strings erzeugen (zum Beispiel eine andere Behandlung von Unicode-Escapes oder dem Escaping von Schrägstrichen). Wenn du das `input` eines Tool-Aufrufs als Roh-String parst, anstatt einen JSON-Parser zu verwenden, überprüfe deine Parsing-Logik. Standard-JSON-Parser (wie `json.loads()` oder `JSON.parse()`) behandeln diese Unterschiede automatisch.
#### Empfohlene Änderungen
Der erste Punkt ist auf Claude Opus 5.5 erforderlich; die übrigen werden empfohlen.
1. **Zu adaptivem Nachdenken migrieren (erforderlich):** `thinking: {"type": "enabled", "budget_tokens": N}` gibt auf Claude Opus 4.7 und späteren Modellen einen 400-Fehler zurück. Das Vorher und Nachher findest du in Punkt 1 der [Breaking Changes für die Migration von Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#opus-46-breaking-changes). Die Migration wechselt außerdem von `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`) zu `client.messages.create()` (csharp: `client.Messages.Create()`; go: `client.Messages.New()`; java: `client.messages().create()`; php: `$client->messages->create()`; cli: `ant messages create`): Adaptives Nachdenken und Effort erfordern weder den Beta-SDK-Namespace noch Beta-Header.
2. **Effort-Beta-Header entfernen:** Der Effort-Parameter erfordert keinen Beta-Header. Entferne die Beta `effort-2025-11-24` aus deinen Anfragen.
3. **Beta-Header für feingranulares Tool-Streaming entfernen:** Feingranulares Tool-Streaming erfordert keinen Beta-Header. Entferne die Beta `fine-grained-tool-streaming-2025-05-14` aus deinen Anfragen.
4. **Beta-Header für verschachteltes Nachdenken entfernen:** Mit adaptivem Nachdenken erfolgt verschachteltes Nachdenken (interleaved thinking) automatisch auf jedem Modell, das adaptives Nachdenken unterstützt. Entferne die Beta `interleaved-thinking-2025-05-14` aus deinen Anfragen.
5. **Zu output\_config.format migrieren:** Wenn du strukturierte Ausgaben verwendest, ändere `output_format={...}` zu `output_config={"format": {...}}`. Der Parameter `output_format` ist abgekündigt und wird in Zukunft entfernt. Um ihn dennoch zu verwenden, füge den Beta-Header `structured-outputs-2025-11-13` hinzu. Ohne ihn gibt die API einen 400-Fehler zurück. Das Python SDK (v1.0 und später) akzeptiert `output_format={...}` nicht bei `client.beta.messages.create()` oder `count_tokens()`. Das Argument `output_format=Model` der Helfer `parse()` und `stream()` bleibt unverändert.
### Migration von Claude 4.1 oder früher
Wenn du von Claude Opus 4.1 oder früheren Modellen direkt zu Claude Opus 5.5 migrierst, wende zuerst alles unter [Migration von Claude Opus 4.5 oder früher](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-45) an. Dieser Unterabschnitt beginnt mit allen vorherigen Abschnitten, sodass du diese Seite effektiv von Anfang an liest. Wende dann die zusätzlichen Änderungen in diesem Unterabschnitt an.
#### Zusätzliche Breaking Changes
1. **Sampling-Parameter entfernen:** Behandelt in [Sampling-Parameter entfernt](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#opus-46-breaking-changes).
2. **Tool-Versionen aktualisieren**
Dies ist eine Breaking Change bei der Migration von Claude-3.x-Modellen.
Aktualisiere auf die aktuellen Tool-Versionen. Entferne jeglichen Code, der den Befehl `undo_edit` verwendet.
```python Python
# Vorher
tools = [{"type": "text_editor_20250124", "name": "str_replace_editor"}]
# Nachher
tools = [{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}]
```
```typescript TypeScript
// Vorher
const legacyTools = [{ type: "text_editor_20250124", name: "str_replace_editor" }];
// Nachher
const tools = [{ type: "text_editor_20250728", name: "str_replace_based_edit_tool" }];
```
```csharp C#
var parameters = new MessageCreateParams
{
// Vorher: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Nachher:
Tools = [new ToolTextEditor20250728()],
// ...
};
```
```go Go
params := anthropic.MessageNewParams{
// Vorher: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Nachher:
Tools: []anthropic.ToolUnionParam{
{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
},
// ...
}
```
```java Java
MessageCreateParams params = MessageCreateParams.builder()
// Vorher: {"type": "text_editor_20250124", "name": "str_replace_editor"}
// Nachher:
.addTool(ToolTextEditor20250728.builder().build())
// ...
.build();
```
```php PHP
$message = $client->messages->create(
// Vorher: ['type' => 'text_editor_20250124', 'name' => 'str_replace_editor']
// Nachher:
tools: [new ToolTextEditor20250728()],
// ...
);
```
```ruby Ruby
# Vorher
legacy_tools = [{type: "text_editor_20250124", name: "str_replace_editor"}]
# Nachher
tools = [{type: "text_editor_20250728", name: "str_replace_based_edit_tool"}]
```
* **Texteditor:** Verwende `text_editor_20250728` und `str_replace_based_edit_tool`. Details findest du in der Dokumentation zum [Texteditor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool).
* **Code-Ausführung:** Aktualisiere auf `code_execution_20260521`. Migrationsanweisungen findest du in der Dokumentation zum [Code-Ausführungs-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Computer Use:** Verwende das Toolset `computer_toolset_20260801` anstelle von `computer_20250124`, das Claude Opus 5.5 nicht akzeptiert. Auf Amazon Bedrock funktioniert auch `computer_20251124`. Siehe die [Breaking Change bei Computer Use](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#computer-use-toolset).
3. **Den Stoppgrund `refusal` behandeln**
Aktualisiere deine Anwendung, um [`refusal`-Stoppgründe zu behandeln](https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/handle-streaming-refusals):
```python Python
response = client.messages.create(...)
if response.stop_reason == "refusal":
# Behandle die Ablehnung angemessen
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "refusal") {
// Behandle die Ablehnung angemessen
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Value() == StopReason.Refusal)
{
// Behandle die Ablehnung angemessen
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == anthropic.StopReasonRefusal {
// Behandle die Ablehnung angemessen
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.REFUSAL)) {
// Behandle die Ablehnung angemessen
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'refusal') {
// Behandle die Ablehnung angemessen
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :refusal
# Behandle die Ablehnung angemessen
end
```
4. **Den Stoppgrund `model_context_window_exceeded` behandeln**
Claude 4.5 und neuere Modelle geben einen Stoppgrund `model_context_window_exceeded` zurück, wenn die Generierung stoppt, weil das Limit des Kontextfensters erreicht wurde, und nicht das angeforderte `max_tokens`-Limit. Aktualisiere deine Anwendung, um diesen neuen Stoppgrund zu behandeln:
```python Python
response = client.messages.create(...)
if response.stop_reason == "model_context_window_exceeded":
# Behandle das Limit des Kontextfensters angemessen
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "model_context_window_exceeded") {
// Behandle das Limit des Kontextfensters angemessen
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Raw() == "model_context_window_exceeded")
{
// Behandle das Limit des Kontextfensters angemessen
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == "model_context_window_exceeded" {
// Behandle das Limit des Kontextfensters angemessen
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.of("model_context_window_exceeded"))) {
// Behandle das Limit des Kontextfensters angemessen
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'model_context_window_exceeded') {
// Behandle das Limit des Kontextfensters angemessen
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :model_context_window_exceeded
# Behandle das Limit des Kontextfensters angemessen
end
```
5. **Behandlung von Tool-Parametern überprüfen (abschließende Zeilenumbrüche)**
Claude 4.5 und neuere Modelle behalten abschließende Zeilenumbrüche in String-Parametern von Tool-Aufrufen bei, die zuvor entfernt wurden. Wenn deine Tools auf exaktem String-Abgleich mit Parametern von Tool-Aufrufen beruhen, überprüfe, ob deine Logik abschließende Zeilenumbrüche korrekt behandelt.
6. **Prompts an Verhaltensänderungen anpassen**
Claude 4 und neuere Modelle haben einen prägnanteren, direkteren Kommunikationsstil und erfordern explizite Anweisungen. Lies die [Best Practices für Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices) für Hinweise zur Optimierung.
#### Zusätzliche empfohlene Änderungen
* **Beta-Header:** Entferne `token-efficient-tools-2025-02-19` und `output-128k-2025-02-19`. Alle Claude 4- und späteren Modelle verfügen über eine integrierte token-effiziente Tool-Nutzung, und diese Header haben keine Wirkung.
## Migration zu Claude Opus 5.5 von Claude Sonnet 5
Arbeite [Was jede Anfrage an Claude Opus 5.5 erfüllen muss](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#request-requirements), [Nachdenken in jeder Antwort behandeln](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-in-every-response) und [Migration zu Claude Opus 5.5 von Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#migrating-from-claude-opus-5) durch. Verwende `claude-sonnet-5` als die Modell-ID, die du ersetzt. Der letzte dieser Abschnitte gilt für Code auf Claude Sonnet 5 so, wie er geschrieben ist, denn Claude Sonnet 5 verhält sich wie Claude Opus 5:
* Es läuft standardmäßig mit aktiviertem Nachdenken und akzeptiert `thinking: {"type": "disabled"}`, in seinem Fall bei jeder Effort-Stufe.
* Es akzeptiert erzwungene Tool-Auswahl und das Tool `computer_20251124`.
* Es gibt den Text zwischen Tool-Aufrufen als `text`-Blöcke zurück.
* Es verwendet standardmäßig den Effort `high`.
Manuelles erweitertes Nachdenken, Sampling-Parameter und Assistant-Prefill geben auf beiden Modellen einen 400-Fehler zurück, daher ändert sich dort nichts. Keine der erforderlichen Änderungen in den Abschnitten zu Claude Opus 4.8, Claude Opus 4.7 und Claude Opus 4.6 betrifft dich.
### Was sich geändert hat
1. **System-Nachrichten während der Konversation:** Auf der Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) und Claude Models on Google Cloud (Google managed) akzeptiert Claude Opus 5.5 `role: "system"`-Nachrichten unmittelbar nach einer Benutzerrunde im `messages`-Array (vorbehaltlich der [Platzierungsregeln](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#limitations)). Diese Funktion ist auf Claude Sonnet 5 nicht verfügbar. Wenn du Codepfade pflegst, die den gesamten Nachrichtenverlauf neu aufbauen, um Anweisungen zu aktualisieren, kannst du sie vereinfachen und Treffer im [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) bei früheren Runden beibehalten.
2. **Niedrigeres Minimum für Prompt-Caching:** Die minimale cachebare Prompt-Länge beträgt bei Claude Opus 5.5 512 Token, gegenüber 1.024 Token bei Claude Sonnet 5. Prompts, die bei Claude Sonnet 5 zu kurz zum Cachen waren, können Cache-Einträge erstellen, ohne dass Codeänderungen erforderlich sind. Siehe [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-limitations) für die Mindestwerte pro Modell.