---
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 Anfrageeinstellungen, 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.
**Automatisiere deine Migration mit dem Claude API Skill.** Führe in Claude Code `/claude-api migrate` aus, um den mitgelieferten [Claude API Skill](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) aufzurufen. Er funktioniert mit jedem aktuellen Claude-Modell als Ziel:
Lass Claude Code deinen Code für dich migrieren
```text
/claude-api migrate dieses Projekt zu claude-opus-5-5
```
Der Skill wendet den Austausch der Modell-ID sowie bei Bedarf Breaking Changes bei Parametern, den Ersatz von Prefills und die Effort-Kalibrierung für dein Zielmodell in deiner gesamten Codebasis an und erstellt anschließend eine Checkliste mit Punkten, die manuell zu überprüfen sind. Er bittet dich, den Migrationsumfang (gesamtes Arbeitsverzeichnis, ein Unterverzeichnis oder eine bestimmte Dateiliste) zu bestätigen, bevor Dateien bearbeitet werden. Der Skill erkennt außerdem Clients für Amazon Bedrock und Claude Platform auf AWS und passt Modell-ID-Formate und Feature-Änderungen für diese Plattformen an.
Diese Seite listet die Codeänderungen für den Wechsel zu Claude Opus 5.5 auf, ausgehend 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). Alle Leser benötigen [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 $ USD pro Million Input-/Output-Token, verglichen mit 5 $ / 25 $; siehe [Claude-Preise](https://platform.claude.com/docs/de/about-claude/pricing)). Informationen zur Feature-Unterstützung findest du unter [Neuerungen in Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#feature-support). Verhaltensunterschiede und modellspezifische Prompting-Muster findest du unter [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` die folgenden Punkte 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. Verwende auf Amazon Bedrock, Claude Platform on AWS, Google Cloud und Microsoft Foundry 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).
* **Nachdenken:** Sende kein `thinking`-Feld oder sende `thinking: {"type": "adaptive"}`, was gleichwertig ist: [„adaptive thinking“ (adaptives Nachdenken)](https://platform.claude.com/docs/de/build-with-claude/thinking) ist immer aktiv. `thinking: {"type": "disabled"}` und manuelle Denkbudgets (`thinking: {"type": "enabled", "budget_tokens": N}`) werden abgelehnt. Siehe das [Vorher-Nachher-Beispiel für das Nachdenken](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#thinking-cant-be-disabled).
* **Effort:** Steuere die Denktiefe mit dem [„effort parameter“ (Effort-Parameter)](https://platform.claude.com/docs/de/build-with-claude/effort), dem einzigen Anfrageparameter, der sie steuert. Alle fünf Stufen (`low`, `medium`, `high`, `xhigh`, `max`) werden unterstützt, und der Standardwert ist `medium`. Siehe [Empfohlene Effort-Level 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-Auswahl:** Verwende `tool_choice` `{"type": "auto"}` (der Standard) oder `{"type": "none"}`. Das Erzwingen eines Tool-Aufrufs mit `{"type": "any"}` oder `{"type": "tool", "name": "..."}` wird abgelehnt. Siehe das [Vorher-Nachher-Beispiel 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 oder belasse sie bei ihren Standardwerten: Jeder andere Wert wird abgelehnt. Nutze Prompting, um das Verhalten des Modells zu steuern.
* **Prefill:** Beende `messages` nicht mit einem vorausgefüllten Assistant-Turn: Er wird abgelehnt. Verwende stattdessen [strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) oder Anweisungen im System-Prompt. Auf Amazon Bedrock sind strukturierte Ausgaben für Claude Opus 5.5 nicht verfügbar, verwende dort also Anweisungen im System-Prompt.
* **Computer Use:** Deklariere „computer use“ (Computernutzung) auf der Claude API und Google Cloud als Toolset `computer_toolset_20260801`; das frühere Tool `computer_20251124` wird dort abgelehnt. Siehe den [Breaking Change zu 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. Die SDK-Tabs, die Text ausgeben, wählen ihn nach Blocktyp aus, 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: 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
```
## Nachdenken in jeder Antwort behandeln
Das Nachdenken läuft bei jeder Anfrage an Claude Opus 5.5, daher kann jede Antwort mit `thinking`-Blöcken beginnen, und `max_tokens` umfasst Nachdenken plus Text. Wenn dein Code bereits mit aktiviertem Nachdenken läuft, sind die Punkte 1 bis 3 wahrscheinlich bereits umgesetzt: Prüfe die Punkte 4 und 5. Wenn er auf einem beliebigen früheren Modell ohne Nachdenken lief, ist jeder Punkt eine Änderung.
1. **`max_tokens` umfasst Nachdenken plus Text:** Bei 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"}`. Bei Claude Opus 5.5 läuft jede Anfrage mit [adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking). `max_tokens` bleibt ein hartes Limit für die gesamte Ausgabe, Nachdenken plus Antworttext, überprüfe es also für Workloads, die ohne Nachdenken liefen. Denk-Token werden als Output-Token abgerechnet, auch wenn der Denktext 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 das 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 Denken und Handeln hat; beginne bei 64k Token und passe von dort aus an. Wenn deine Prompts für den Betrieb ohne Nachdenken abgestimmt wurden, 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, funktioniert bei diesen Antworten nicht mehr. 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 Schleife mit „tool use“ (Tool-Nutzung) ausführst, übergib 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 du sie erhalten hast, anstatt ihre Content-Blöcke nach Typ zu filtern oder sie neu aufzubauen: Die API lehnt bearbeitete, neu angeordnete 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. **Denktext wird standardmäßig weggelassen:** `thinking.display` ist standardmäßig `"omitted"`, daher kommen `thinking`-Blöcke mit einem leeren `thinking`-Feld neben ihrer `signature` an. Behandle das `thinking`-Feld nur 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 per Streaming an Nutzer ausgibt, 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 durch und höre nach derjenigen 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 Standard 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, oder auf Amazon Bedrock durch `auto` allein.
* Wenn du Computer Use auf der Claude API oder Google Cloud verwendest, deklariere `computer_toolset_20260801` (ohne Beta-Header) anstelle von `computer_20251124` und aktualisiere deine Agent-Schleife für das Toolset. Behalte auf Amazon Bedrock `computer_20251124` bei; für andere Plattformen prüfe den Abschnitt [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#compatibility) des Computer-Use-Tools.
* 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 das Nachdenken von Claude Opus 5, von früheren Opus-, Sonnet- und Haiku-Modellen und, auf der Claude API und Google Cloud, von Claude Sonnet 5.5 und Claude Haiku 5.5, aber nicht von Claude Fable- oder Claude Mythos-Modellen.
* Lies Content-Blöcke nach `type` und übergib `thinking`-Blöcke in Tool-Nutzungs-Schleifen unverändert zurück.
* Wenn deine Oberfläche Text zwischen Tool-Aufrufen darstellt, setze `display: "updates"` (Beta) oder `"summarized"` und stelle die nicht leeren `thinking`-Blöcke dar.
* Wenn dein Code frühere Turns, den `system`-Prompt oder `tools` mitten in der Konversation bearbeitet, folge [Erhaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking).
* Behandle `stop_reason: "refusal"` und konfiguriere einen Fallback.
* Ermittle Kosten und Latenz auf deiner gewählten Effort-Stufe als neue Baseline.
* Wenn dein Code das Nachdenken deaktiviert hat, überprüfe `max_tokens`, das Nachdenken plus Antworttext umfasst; beginne bei `xhigh`- oder `max`-Effort 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 das Nachdenken kann nicht deaktiviert werden. Überprüfe `max_tokens`, das ein hartes Limit für die gesamte Ausgabe bleibt (Nachdenken plus Antworttext), und senke `effort`, wo du weniger Nachdenken möchtest. Denk-Token werden als Output-Token abgerechnet, daher können diese Workloads mehr Output-Token pro Anfrage erzeugen.
* Stelle sicher, dass jeder Code, der das `thinking`-Feld parst, es nur als Anzeigetext behandelt. Setze `display: "summarized"`, um lesbare Zusammenfassungen zu erhalten.
* Überprüfe Prompts nahe dem Caching-Minimum: Prompts ab 512 Token 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 mit deinen eigenen Evals durch, anstatt eine für ein früheres Modell abgestimmte Einstellung zu übernehmen.
* Entferne jeden Kontextfenster-Beta-Header.
* 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 „fast mode“ (Schnellmodus) nutzen möchtest, den Claude Opus 4.7 ablehnt, setze `speed: "fast"` in deinen Anfragen an die Claude API. Claude Opus 5.5 benötigt keinen Beta-Header.
### Claude Opus 4.6 oder früher
* Entferne `temperature`, `top_p` und `top_k` aus Anfrage-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 das zusammengefasste Nachdenken explizit.
* Führe erneut Benchmarks für End-to-End-Kosten und -Latenz unter der aktualisierten Tokenisierung durch.
* Passe `max_tokens` neu an, um die aktualisierte Tokenisierung zu berücksichtigen, einschließlich Compaction-Triggern.
* Teste alle clientseitigen Schätzungen der Token-Anzahl erneut.
* Wenn deine Anwendung Bilder sendet, plane das Budget für [hochauflösende Bildunterstützung](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). Verkleinere Bilder vor dem Senden, wenn du die zusätzliche Detailtreue nicht benötigst.
* Wenn du Zeige- oder Bounding-Box-Koordinaten vom Modell verwendest, entferne jede Umrechnung per Skalierungsfaktor; Koordinaten entsprechen bei 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 JSON-Parsing 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 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 nachgestellte Zeilenumbrüche.
* Entferne veraltete Beta-Header (`token-efficient-tools-2025-02-19`, `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 ab 512 Token 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 damit einhergehenden Änderungen an den Antworten. 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).
### Modellnamen aktualisieren
```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`. Verwende auf Amazon Bedrock, Claude Platform on AWS, Google Cloud und Microsoft Foundry 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 [Neuerungen in Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#breaking-changes) erklärt; dieser Abschnitt zeigt die jeweils erforderliche 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.` bzw. `"thinking.type.enabled" is not supported for this model.`). Entferne das Feld `thinking` und wähle eine [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe; wo du das Nachdenken deaktiviert hast, um Token zu sparen, verwende eine niedrigere Stufe. Antworten beginnen dann mit `thinking`-Blöcken. Wähle Inhaltsblöcke daher anhand von `type` aus und gib `thinking`-Blöcke zusammen mit Tool-Ergebnissen unverändert 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: 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: "..." }]
)
```
Nachher:
```bash cURL
# Thinking ist immer aktiv; gesteuert wird über effort
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
# Thinking ist immer aktiv; gesteuert wird über effort
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)
// Thinking ist immer aktiv; gesteuert wird über effort
.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,
// Thinking ist immer aktiv; gesteuert wird über effort
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,
# Thinking ist immer aktiv; gesteuert wird über effort
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 Endpunkt zur Token-Zählung. 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 zum Einsatz kommt. 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 [JSON-Schema-Einschränkungen](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#json-schema-limitations). Auf Amazon Bedrock sind strukturierte Ausgaben, zu denen auch die strikte Tool-Nutzung gehört, für Claude Opus 5.5 nicht verfügbar. Sende dort `auto` ohne `strict`, gib im Prompt an, wann das Tool zum Einsatz kommt, und validiere die Tool-Eingabe in deinem Code. 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: 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?" }]
)
```
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: 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
# 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()
{
Role = Role.User,
Content = "What's the weather in Paris? Use the get_weather tool.",
},
],
});
```
```go Go
// strict tool use (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
Auf 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 dies. 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 und, auf der Claude API und Google Cloud, von Claude Sonnet 5.5 und Claude Haiku 5.5, aber nicht von Claude Fable- oder Claude Mythos-Modellen. Halte die Konversation append-only (keine Bearbeitungen 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 dies bereits. Die Durchsetzung entspricht der von Claude Fable 5.1 auf jeder Plattform: Für Konten, die am oder nach dem 31. August 2026, 00:00 UTC, erstellt wurden, gibt das erneute Senden eines Thinking-Blocks nach einer solchen Bearbeitung standardmäßig einen 400-Fehler zurück. 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 [Erhaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking).
#### Das Computer-Use-Tool `computer_20251124` wird auf der Claude API und Google Cloud nicht unterstützt
Auf der Claude API und Google Cloud gibt ein `tools`-Eintrag vom Typ `computer_20251124` einen 400-Fehler zurück (`'claude-opus-5-5' does not support tool types: computer_20251124.`, gefolgt von den Tool-Typen, die das Modell akzeptiert). Deklariere stattdessen das Toolset `computer_toolset_20260801`: Lass den Beta-Header weg und sende den Eintrag ohne `name` oder Anzeigeabmessungen. Verarbeite in deiner Agent-Schleife die `tool_use`-Blöcke der Toolset-Mitglieder (die Aktion ist der `name` des Blocks, nicht `input.action`), mehrere davon pro Turn, und gib bei jedem Ergebnis `toolset_name` zurück. Die Änderung an der Anfrage ist unten dargestellt; die Änderungen an der Agent-Schleife sind unter [Von `computer_20251124` migrieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) aufgeführt. Auf Amazon Bedrock funktioniert das frühere Tool `computer_20251124` auf Claude Opus 5.5 weiterhin wie auf Claude Opus 5, dort ist also keine Änderung erforderlich; für andere Plattformen siehe den Abschnitt [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#compatibility) des Computer-Use-Tools. Siehe [Das Computer-Use-Tool `computer_20251124` wird auf der Claude API und Google Cloud nicht unterstützt](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5#computer-20251124-is-not-supported).
Vorher. Claude Opus 5 akzeptiert diese Anfrage, und auf der Claude API und Google Cloud lehnt Claude Opus 5.5 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: 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." }]
)
```
Nachher:
```bash cURL
# kein Beta-Header; der Toolset-Eintrag hat keinen Namen und keine Anzeigegröße
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
# 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 keinen Namen und keine 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 weder Namen noch 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 hat keinen Namen und keine Anzeigegröße
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,
// kein Beta-Header; der Toolset-Eintrag hat weder Namen noch Anzeigegröße
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 hat keinen Namen und keine Anzeigegröße
.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 weder Namen noch 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 hat keinen Namen und keine 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 wird Text, den das Modell zwischen Tool-Aufrufen schreibt, als `text`-Blöcke zurückgegeben. Auf Claude Opus 5.5 wird dieser begleitende Text, wie bei Claude Fable 5.1, als [`thinking`-Blöcke mit Fortschrittsmeldungen](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) zurückgegeben, 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 Fortschrittsmeldungen an ihre Nutzer streamt, bleibt zwischen Tool-Aufrufen stumm. Um die Meldungen wiederherzustellen, lies sie aus den `thinking`-Blöcken und setze einen `display`-Wert, der ihren Text zurückgibt: `"updates"` (Beta, Header `thinking-display-updates-2026-08-18`) gibt die Fortschrittsmeldungen zurück, während das Reasoning verborgen bleibt, und `"summarized"` gibt beides vermischt zurück. Rendere dann jeden nicht leeren `thinking`-Block vor dem `tool_use`-Block, dem er vorausgeht, und gib die Blöcke zusammen mit dem Rest des Assistant-Turns unverändert zurück. Siehe [Fortschrittsmeldungen für Benutzer](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 Retry (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 [Safeguard-Ablehnungen](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 für das Nachdenken auf Claude Opus 5.5, und der Standardwert ist `medium`, während er bei Claude Opus 5 `high` ist. Eine Anfrage ohne `effort` läuft jetzt also mit `medium`. Gehe eine Stufe herunter, wo die Qualität erhalten bleibt, und eine Stufe hinauf für die anspruchsvollsten Aufgaben. Siehe [Effort](https://platform.claude.com/docs/de/build-with-claude/effort).
2. **Überprüfe modellspezifische Prompt-Anweisungen.** Anweisungen, die auf das Verhalten von Claude Opus 5 abgestimmt sind, werden möglicherweise nicht mehr benötigt; 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 unverändert für Code auf Claude Opus 4.8, weil Claude Opus 4.8, wie Claude Opus 5:
* `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das Tool `computer_20251124` 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. **Das Nachdenken läuft bei Anfragen, die es weggelassen haben:** Bei Claude Opus 4.8 ist das Nachdenken deaktiviert, sofern du es nicht anforderst. Bei 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 im [Vorher-Nachher-Beispiel für das 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 beträgt bei Claude Opus 5.5 512 Token, gegenüber 1.024 Token bei Claude Opus 4.8. Prompts, die bei Claude Opus 4.8 zu kurz zum Cachen waren, können Cache-Einträge erstellen, ohne dass Codeänderungen erforderlich sind. Die Mindestwerte pro Modell findest du unter [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-limitations).
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 weiterhin bietet. Wenn deine Organisation eine Priority-Tier-Verpflichtung hat, plane die Kapazität separat.
### Empfohlene Änderungen
Diese sind nicht erforderlich, verbessern aber deine Erfahrung:
1. **Ziehe Task-Budgets (Beta) in Betracht:** 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 hat. Sie erfordern den Beta-Header `task-budgets-2026-03-13`.
2. **Ziehe Tool-Änderungen mitten in der Konversation in Betracht (Beta):** Mit Tool-Änderungen mitten in der Konversation kannst du zwischen den Turns einer Konversation Tools hinzufügen oder entfernen, ohne [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)-Treffer bei früheren Turns ungültig zu machen. Eine Änderung des `tools`-Arrays selbst macht das gecachte Präfix ungültig. Sende auf der Claude API den Beta-Header `inline-tools-2026-09-15`. Der ältere Header `mid-conversation-tool-changes-2026-07-01` funktioniert weiterhin für Änderungen, die ein Tool per Referenz benennen, auf der Claude API, Amazon Bedrock und Google Cloud.
## 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 unverändert für Code auf Claude Opus 4.7. Wie Claude Opus 4.8 akzeptiert es `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das Tool `computer_20251124`. 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. Jener Abschnitt ergänzt die Breaking Changes, die mit Claude Opus 4.7 in Kraft traten. 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 einen weiteren 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 Standard ist `medium`, während er bei Claude Opus 4.7 `high` ist. Führe einen neuen Effort-Sweep 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 volle [Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows) mit 1M Token ohne Beta-Header bereit. Wenn dein Client aus Kompatibilitätsgründen mit älteren Modellen einen Kontextfenster-Beta-Header übergibt, entferne ihn.
3. **System-Nachrichten mitten in der Konversation:** Auf der Claude API, Amazon Bedrock und Google Cloud akzeptiert Claude Opus 5.5 `role: "system"`-Nachrichten unmittelbar nach einem User-Turn 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 [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)-Treffer bei früheren Turns erhalten.
4. **Stop-Details bei Ablehnungen:** Wenn das Modell eine Anfrage ablehnt, gibt Claude Opus 5.5 neben dem Stop-Reason `refusal` ein `stop_details`-Objekt zurück, das die Kategorie der Ablehnung nennt. Claude Opus 4.7 gibt dasselbe Objekt zurück, daher ist dies nur relevant, wenn deine Stop-Reason-Behandlung es noch nicht liest. Es ist kein Beta-Header erforderlich, und es gibt keine Opt-out-Möglichkeit. Wenn deine Stop-Reason-Behandlung es noch nicht liest, siehe [Umgang mit Stop-Reasons](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 [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, wo Anfragen mit `speed: "fast"` einen Fehler zurückgeben. Setze `speed: "fast"` in deinen Anfragen. Claude Opus 5.5 benötigt keinen Beta-Header.
6. **Computer-Use-Toolset und Browser-Use-Tool:** Auf der Claude API und Google Cloud unterstützt Claude Opus 5.5 [Computer Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool) als Toolset `computer_toolset_20260801` 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. Auf diesen Plattformen akzeptiert Claude Opus 5.5 das frühere Tool `computer_20251124` nicht; siehe den [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 für [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 unverändert für Code auf Claude Opus 4.6. Wie Claude Opus 4.7 akzeptiert es `thinking: {"type": "disabled"}`, erzwungene Tool-Auswahl und das Tool `computer_20251124`. Es verwendet standardmäßig `high`-Effort 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 Denktiefe 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: 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: "..." }
]
)
```
Nachher (Claude Opus 5.5), wobei sich die Zeilen für die 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: 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: "..." }
]
)
```
Adaptives Nachdenken lässt sich über Prompting und den [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort) steuern, der das Denkbudget als Mittel ersetzt, um festzulegen, wie viel das Modell nachdenkt. Führe einen Effort-Sweep mit deinen eigenen Evals durch, anstatt einen `budget_tokens`-Wert umzurechnen. Die [Tabelle der Effort-Level](https://platform.claude.com/docs/de/build-with-claude/effort#effort-levels) beschreibt, wann welche Stufe zu verwenden ist, und [Empfohlene Effort-Level 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:** Das Setzen von `temperature`, `top_p` oder `top_k` auf einen beliebigen Nicht-Standardwert gibt auf Claude Opus 4.7 und späteren Modellen, einschließlich Claude Opus 5.5, einen 400-Fehler zurück. Das Python SDK (v1.0 und später) definiert sie nicht, und ihre Übergabe löst einen `TypeError` aus. Der sicherste Migrationspfad ist, diese Parameter vollständig aus den Anfrage-Payloads wegzulassen. Prompting ist der empfohlene Weg, 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 `thinking`-Feld ist leer, sofern du dich nicht ausdrücklich dafür entscheidest. Dies ist eine stille Änderung gegenüber Claude Opus 4.6, bei dem standardmäßig zusammengefasster Denktext zurückgegeben wurde. Um ihn 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 1- bis 1,35-mal so viele Token verwenden wie Modelle vor Claude Opus 4.7 (bis zu \~35 % 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.
Passe deine `max_tokens`-Parameter an, um zusätzlichen Spielraum zu schaffen, einschließlich der Compaction-Trigger, und teste jeden Codepfad erneut, der Token clientseitig schätzt oder ein festes Verhältnis von Token zu Zeichen annimmt. Verwende zur Überprüfung den [Token-Counting-Endpunkt](https://platform.claude.com/docs/de/build-with-claude/token-counting). 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. Dies ist also nur dann 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. Auf Amazon Bedrock sind strukturierte Ausgaben für Claude Opus 5.5 nicht verfügbar, verwende dort also Anweisungen im System-Prompt.
### Verhaltensänderungen
Claude Opus 4.7 hat gegenüber Claude Opus 4.6 Verhaltensunterschiede eingeführt, die keine Breaking Changes der API sind. Diese drei betreffen Code oder Scaffolding:
1. **Integrierte Fortschrittsupdates in agentischen Traces:** Claude Opus 4.7 liefert dem Benutzer während langer agentischer Traces 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 Standardwert von `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 [Fortschrittsmeldungen für Benutzer](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates).
2. **Echtzeit-Schutzmaßnahmen für Cybersicherheit:** 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 kannst du dich beim [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet) bewerben, um gelockerte Einschränkungen zu beantragen. Der Bewerbungsweg hängt davon ab, wie du auf Claude zugreifst.
3. **Unterstützung für hochauflösende 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 bildintensiven Workloads und ist besonders wertvoll für Computer Use, das Verständnis von Screenshots und die Dokumentenanalyse.
Die Unterstützung hoher Auflösung ist automatisch und erfordert keinen Beta-Header oder clientseitiges Opt-in. Zwei Dinge, die du einplanen solltest:
* Bilder in voller Auflösung können bis zu etwa 3x 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 pro Bild). Plane `max_tokens` und Kostenerwartungen für bildlastige Workloads neu, oder skaliere vor dem Senden herunter, wenn du die zusätzliche Detailtreue nicht benötigst.
* Vom Modell zurückgegebene Zeige- und Bounding-Box-Koordinaten entsprechen auf Claude Opus 4.7 1:1 den tatsächlichen Bildpixeln, sodass keine Skalierungsfaktor-Umrechnung erforderlich ist.
Siehe [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 Details.
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 in Kraft getreten sind. 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 leicht unterschiedliches JSON-String-Escaping in Tool-Aufruf-Argumenten erzeugen (zum Beispiel unterschiedliche Behandlung von Unicode-Escapes oder Escaping von Schrägstrichen). Wenn du den `input` von Tool-Aufrufen als rohen 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. **Migration zu adaptivem Nachdenken (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 den Beta-Header `effort-2025-11-24` aus deinen Anfragen.
3. **Beta-Header für feingranulares Tool-Streaming entfernen:** Feingranulares Tool-Streaming erfordert keinen Beta-Header. Entferne den Beta-Header `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 den Beta-Header `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 neuer) 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 aus [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. Jener 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 unter [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 ein 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).
* **Codeausführung:** Aktualisiere auf `code_execution_20260521`. Migrationsanweisungen findest du in der Dokumentation zum [Codeausführungs-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Computer Use:** Auf der Claude API und Google Cloud akzeptiert Claude Opus 5.5 Computer Use nur als Toolset `computer_toolset_20260801`: Die früheren Tools `computer_20250124` und `computer_20251124` werden dort abgelehnt. Siehe den [Breaking Change zu Computer Use](https://platform.claude.com/docs/de/models/opus-5-5/migration-guide#computer-use-toolset).
3. **Den Stop-Reason `refusal` behandeln**
Aktualisiere deine Anwendung, um [`refusal`-Stop-Reasons 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":
# Ablehnung angemessen behandeln
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "refusal") {
// Ablehnung angemessen behandeln
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Value() == StopReason.Refusal)
{
// Ablehnung angemessen behandeln
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == anthropic.StopReasonRefusal {
// Ablehnung angemessen behandeln
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.REFUSAL)) {
// Ablehnung angemessen behandeln
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'refusal') {
// Ablehnung angemessen behandeln
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :refusal
# Ablehnung angemessen behandeln
end
```
4. **Den Stop-Reason `model_context_window_exceeded` behandeln**
Claude 4.5 und spätere Modelle geben den Stop-Reason `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 Stop-Reason zu behandeln:
```python Python
response = client.messages.create(...)
if response.stop_reason == "model_context_window_exceeded":
# Kontextfenster-Limit angemessen behandeln
pass
```
```typescript TypeScript
const response = await client.messages.create(/* ... */);
if (response.stop_reason === "model_context_window_exceeded") {
// Kontextfenster-Limit angemessen behandeln
}
```
```csharp C#
var response = await client.Messages.Create(...);
if (response.StopReason?.Raw() == "model_context_window_exceeded")
{
// Kontextfenster-Limit angemessen behandeln
}
```
```go Go
response, _ := client.Messages.New(ctx, params) // your existing request
if response.StopReason == "model_context_window_exceeded" {
// Kontextfenster-Limit angemessen behandeln
}
```
```java Java
Message response = client.messages().create(...);
StopReason reason = response.stopReason().orElse(StopReason.END_TURN);
if (reason.equals(StopReason.of("model_context_window_exceeded"))) {
// Kontextfenster-Limit angemessen behandeln
}
```
```php PHP
$response = $client->messages->create(...);
if ($response->stopReason === 'model_context_window_exceeded') {
// Kontextfenster-Limit angemessen behandeln
}
```
```ruby Ruby
response = client.messages.create(...)
if response.stop_reason == :model_context_window_exceeded
# Kontextfenster-Limit angemessen behandeln
end
```
5. **Behandlung von Tool-Parametern überprüfen (abschließende Zeilenumbrüche)**
Claude 4.5 und spätere Modelle behalten abschließende Zeilenumbrüche in String-Parametern von Tool-Aufrufen bei, die zuvor entfernt wurden. Wenn deine Tools auf einem exakten String-Abgleich mit Tool-Aufruf-Parametern beruhen, überprüfe, ob deine Logik abschließende Zeilenumbrüche korrekt behandelt.
6. **Deine Prompts für Verhaltensänderungen aktualisieren**
Claude 4 und spätere Modelle haben einen prägnanteren, direkteren Kommunikationsstil und erfordern explizite Anweisungen. Hinweise zur Optimierung findest du in den [Best Practices für Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices).
#### Zusätzliche empfohlene Änderungen
* **Veraltete Beta-Header entfernen:** 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 unverändert für Code auf Claude Sonnet 5, denn für Claude Sonnet 5 gilt wie für 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, nicht standardmäßige 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 für Claude Opus 4.8, Claude Opus 4.7 und Claude Opus 4.6 betrifft dich.
### Was sich geändert hat
1. **System-Nachrichten mitten in der Konversation:** Auf der Claude API, Amazon Bedrock und Google Cloud akzeptiert Claude Opus 5.5 `role: "system"`-Nachrichten unmittelbar nach einem User-Turn 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 [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)-Treffer bei früheren Turns erhalten.
2. **Niedrigeres Minimum für Prompt-Caching:** Die minimale cachebare Prompt-Länge beträgt auf Claude Opus 5.5 512 Token, gegenüber 1.024 Token auf Claude Sonnet 5. Prompts, die auf Claude Sonnet 5 zu kurz zum Cachen waren, können Cache-Einträge erstellen, ohne dass Codeänderungen erforderlich sind. Die Mindestwerte pro Modell findest du unter [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-limitations).