---
title: Migrationsleitfaden für Claude Sonnet 5.5
url: https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide
description: Wechsle mit diesem Migrationsleitfaden von früheren Sonnet-Modellen oder Claude Haiku 4.5 zu Claude Sonnet 5.5. Die Anleitung zur Aktivierung von Claude Sonnet 5.5 umfasst Einstellungen, die Fehler zurückgeben, Änderungen beim Nachdenken und eine Checkliste für jedes Ausgangsmodell.
---

Dieser Leitfaden listet die Codeänderungen für den Wechsel von Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet oder Claude Haiku 4.5 zu Claude Sonnet 5.5 auf. Lies die ersten beiden Abschnitte und dann weiter bis zum Abschnitt für dein aktuelles Modell. Die [Migrations-Checkliste](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migration-checklist) listet jede Änderung nach Ausgangsmodell auf.

<Note>
  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.
</Note>

<Tip>
  **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-sonnet-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.
</Tip>

Claude Sonnet 5.5 hat dieselben Preise wie Claude Sonnet 5, mit Ausnahme von Lesevorgängen aus dem Prompt-Cache, die 0,10 $ USD pro Million Token kosten, die Hälfte des Tarifs von Claude Sonnet 5. Siehe [Claude-Preise](https://platform.claude.com/docs/de/about-claude/pricing). Informationen zum „context window" (Kontextfenster) und zu den Ausgabelimits findest du auf der [Modellseite von Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview). Zu Funktionen und Prompting siehe [Neuerungen in Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) und [Prompting für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Eine Anfrage an Claude Sonnet 5.5 senden

Diese Anfrage funktioniert auf Claude Sonnet 5.5 so, wie sie geschrieben ist. Sie legt eine Effort-Stufe fest, und die SDK-Tabs lesen die Antwort nach Blocktyp aus. Sie lässt fünf Einstellungen weg, die einen 400-Fehler zurückgeben: [Thinking-Budgets](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [Sampling-Parameter](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [Assistant-Prefill](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), [erzwungene Tool-Auswahl](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#forced-tool-use) und [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}'
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  print(f"Stop reason: {response.stop_reason}")
  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  console.log(`Stop reason: ${response.stop_reason}`);
  const textBlock = response.content.find(
    (block): block is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine($"Stop reason: {message.StopReason?.Raw()}");
  foreach (var block in message.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println("Stop reason:", response.StopReason)
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.OutputConfig;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.stopReason().ifPresent(reason -> IO.println("Stop reason: " + reason));
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: 'claude-sonnet-5-5',
      outputConfig: ['effort' => 'medium'],
  );

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

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

  message = client.messages.create(
    model: "claude-sonnet-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  puts "Stop reason: #{message.stop_reason}"
  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

## Nachdenken läuft standardmäßig

Auf Claude Sonnet 5.5 läuft eine Anfrage ohne `thinking`-Feld mit [„adaptive thinking" (adaptivem Nachdenken)](https://platform.claude.com/docs/de/build-with-claude/thinking), ebenso wie `thinking: {"type": "adaptive"}`. Auf Claude Sonnet 4.6 und früheren Modellen sowie auf Claude Haiku 4.5 lief diese Anfrage ohne Nachdenken. Um weiterhin ohne vorgelagertes Nachdenken zu arbeiten, siehe [Vorgelagertes Nachdenken ausschalten](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Modell                                 | Nachdenken ohne `thinking`-Feld | Akzeptierte `thinking.type`-Werte                     | Standard-`display` |
| -------------------------------------- | ------------------------------- | ----------------------------------------------------- | ------------------ |
| Claude Sonnet 5.5                      | An                              | `"adaptive"`, `"between_tools"`                       | `"omitted"`        |
| Claude Sonnet 5                        | An                              | `"adaptive"`, `"disabled"`                            | `"omitted"`        |
| Claude Sonnet 4.6                      | Aus                             | `"adaptive"`, `"disabled"`, `"enabled"` (abgekündigt) | `"summarized"`     |
| Claude Sonnet 4.5 und Claude Haiku 4.5 | Aus                             | `"disabled"`, `"enabled"`                             | `"summarized"`     |

### Nachdenken in Antworten verarbeiten

Code, der ohne Nachdenken lief, braucht alle drei Punkte. Code von Claude Sonnet 5 hat wahrscheinlich bereits die ersten beiden.

* **Lies Content-Blöcke nach `type`.** Eine Antwort kann mit `thinking`-Blöcken beginnen, daher bricht Code, der `content[0].text` liest.
* **Gib `thinking`-Blöcke unverändert zurück** in Schleifen mit Tool-Nutzung, einschließlich leerer Blöcke. Siehe [Thinking-Blöcke beibehalten](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks).
* **Überprüfe `max_tokens`.** Es umfasst Nachdenken plus Text, und Thinking-Token werden als Ausgabe-Token abgerechnet. Siehe [Kostenkontrolle](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#cost-control).

Der Thinking-Text wird standardmäßig weggelassen. `thinking`-Blöcke kommen mit einem leeren `thinking`-Feld und einer `signature` an. Um lesbare Zusammenfassungen zu erhalten, setze `display: "summarized"`, den Standard auf Claude Sonnet 4.6 und früheren Modellen sowie auf Claude Haiku 4.5. Siehe [Anzeige des Nachdenkens steuern](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display).

### Vorgelagertes Nachdenken ausschalten

Um vorgelagertes Nachdenken auf Claude Sonnet 5.5 auszuschalten, sende `thinking: {"type": "between_tools"}`. Das ist die niedrigste Thinking-Einstellung. Ihre Fortschrittsmeldungen zwischen Tool-Aufrufen kommen weiterhin als `thinking`-Blöcke mit ihrem Zusammenfassungstext zurück. Ohne Tools enthält die Antwort nur Text. Claude Sonnet 5 schaltet das Nachdenken stattdessen mit `thinking: {"type": "disabled"}` aus, und frühere Modelle laufen standardmäßig ohne Nachdenken. Auf Claude Sonnet 5.5 gibt `disabled` einen 400-`invalid_request_error` zurück:

```text wrap
To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.
```

`between_tools` funktioniert auf jeder Plattform, die Claude Sonnet 5.5 anbietet, ohne Beta-Header. Es wird bei Effort `low`, `medium` und `high` akzeptiert. Bei `xhigh` oder `max` gibt es einen 400-Fehler zurück. Um auf diesen Stufen zu arbeiten, verwende adaptives Nachdenken: Lass das `thinking`-Feld weg oder sende `thinking: {"type": "adaptive"}`. `between_tools` akzeptiert kein weiteres Feld: `display`, `budget_tokens` oder `block_binding` zusammen damit gesendet gibt einen 400-Fehler zurück. Mit [serverseitigem Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) läuft eine `between_tools`-Anfrage, die auf Claude Sonnet 5 zurückfällt, dort mit `thinking: {"type": "disabled"}`.

Mit `between_tools` kann sich der Effort nicht mitten im Gespräch ändern: Ein nachrichtenspezifisches `output_config.effort`, das von der aktuell geltenden Stufe abweicht, gibt einen 400-Fehler zurück. Um den Effort pro Runde zu variieren, verwende adaptives Nachdenken. Hinweise zum Prompting findest du unter [Ausführung ohne vorgelagertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Vorher (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 16000,
      "thinking": {"type": "disabled"},
      "output_config": {"effort": "xhigh"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5 \
    --max-tokens 16000 \
    --thinking '{type: disabled}' \
    --output-config '{effort: xhigh}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=16000,
      thinking={"type": "disabled"},
      output_config={"effort": "xhigh"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 16000,
    thinking: { type: "disabled" },
    output_config: { effort: "xhigh" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigDisabled(),
      OutputConfig = new() { Effort = Effort.Xhigh },
      Messages = [new() { Role = Role.User, Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortXhigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigDisabled.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.XHIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 16000,
      thinking: ThinkingConfigDisabled::with(),
      outputConfig: OutputConfig::with(effort: Effort::XHIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigDisabled.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::XHIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

Nachher (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {"type": "between_tools"},
      "output_config": {"effort": "high"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 16000 \
    --thinking '{type: between_tools}' \
    --output-config '{effort: high}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "between_tools"},
      output_config={"effort": "high"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "between_tools" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigBetweenTools(),
      OutputConfig = new() { Effort = Effort.High },
      Messages = [new() { Role = Role.User, Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfBetweenTools: &anthropic.ThinkingConfigBetweenToolsParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigBetweenTools.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5_5,
      maxTokens: 16000,
      thinking: ThinkingConfigBetweenTools::with(),
      outputConfig: OutputConfig::with(effort: Effort::HIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigBetweenTools.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::HIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

## Migrations-Checkliste nach Ausgangsmodell

Arbeite die Gruppen von oben nach unten ab und höre nach der Gruppe auf, die dein Modell nennt. Wende auf Claude Haiku 4.5 jede Gruppe außer „Claude Sonnet 4 oder früher" an und ende mit „Nur Claude Haiku 4.5".

### Jedes Ausgangsmodell

* Ändere die Modell-ID zu `claude-sonnet-5-5`.
* [Lies Content-Blöcke nach `type` aus](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-in-responses) und gib `thinking`-Blöcke unverändert zurück.
* Um weiterhin ohne vorgelagertes Nachdenken zu arbeiten, sende [die niedrigste Thinking-Einstellung](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) bei Aufwand `high` oder darunter.
* Ersetze [erzwungene Tool-Nutzung](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#forced-tool-use) durch `auto` und strikte Tools, oder auf Amazon Bedrock nur durch `auto`.
* Halte Gespräche [append-only](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-blocks) (nur anhängend).
* Verlagere Computer Use auf der Claude API und Google Cloud auf das [Toolset](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#computer-use-toolset), ohne den Beta-Header `fine-grained-tool-streaming-2025-05-14`.
* Kombiniere das [Advisor-Tool](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#advisor-tool) mit einem unterstützten Advisor und rechne mit verschlüsselten Ratschlägen.
* Lies [Text zwischen Tool-Aufrufen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#text-between-tool-calls) aus `thinking`-Blöcken.
* [Verarbeite Ablehnungen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback) und konfiguriere einen Fallback.
* [Führe deinen Effort-Sweep erneut durch](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#recommended-changes) und lege eine neue Kostenbasis fest.

### Claude Sonnet 4.6 oder früher

* Rechne mit [Nachdenken bei Anfragen ohne `thinking`-Feld](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-on-by-default) und überprüfe `max_tokens`.
* Ersetze [Thinking-Budgets](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) durch eine Effort-Stufe.
* Entferne nicht standardmäßige Werte für `temperature`, `top_p` und `top_k`.
* Wenn du [Thinking-Text anzeigst](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-in-responses), setze `display: "summarized"`.
* [Zähle Token neu](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6) und plane das Budget für Bild-Token neu.

### Claude Sonnet 4.5 oder früher

* Ersetze [Assistant-Prefills](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45).
* Parse Tool-Aufruf-Eingaben mit einem Standard-JSON-Parser.
* Verlagere Computer Use auf Amazon Bedrock von `computer_20250124` auf [`computer_20251124`](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#computer-use-toolset).
* Setze `output_config.effort` explizit.
* Entferne jeden Kontextfenster-Beta-Header.
* Entferne `interleaved-thinking-2025-05-14` und ersetze `fine-grained-tool-streaming-2025-05-14` durch `eager_input_streaming`.
* Verschiebe `output_format` nach `output_config.format`.

### Claude Sonnet 4 oder früher

* Aktualisiere die [Tool-Versionen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) auf `text_editor_20250728` und `code_execution_20260521`.
* Behandle die Stop-Gründe `refusal` und `model_context_window_exceeded`.
* Prüfe String-Parameter von Tools auf abschließende Zeilenumbrüche.
* Entferne `token-efficient-tools-2025-02-19` und `output-128k-2025-02-19`.
* Überprüfe deine Prompts.

### Nur Claude Haiku 4.5

* Ersetze [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) oder seinen Alias.
* Lege die Kostenbasis beim höheren Preis pro Token neu fest.
* Überprüfe Prompts, die auf Claude Haiku 4.5 zu kurz zum Cachen waren.

## Migration zu Claude Sonnet 5.5 von Claude Sonnet 5

Jedes Ausgangsmodell benötigt die Änderungen in diesem Abschnitt. Ersetze deine Modell-ID durch `claude-sonnet-5-5`, die kein Datumssuffix hat. Auf anderen Plattformen verwende die ID, die unter [Verfügbarkeit](https://platform.claude.com/docs/de/models/sonnet-5-5/whats-new-sonnet-5-5#availability) aufgeführt ist.

### Erzwungene Tool-Nutzung wird nicht unterstützt

Jedes frühere Modell auf dieser Seite akzeptiert eine `tool_choice` vom Typ `any` oder `tool`. Claude Sonnet 5.5 lehnt beide mit einem 400-Fehler ab, auch am Endpunkt für [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting):

```text wrap
tool_choice: type "tool" and "any" are not supported for this model.
```

Sende `tool_choice: {"type": "auto"}` und markiere das Tool mit `strict: true`, damit seine Eingabe dem Schema entspricht. Das Modell kann dann antworten, ohne das Tool aufzurufen, also gib im Prompt an, wann es verwendet werden soll. [Strikte Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/strict-tool-use) unterstützt eine Teilmenge von JSON Schema und benötigt `additionalProperties: false` bei jedem Objekt. Siehe [Einschränkungen von JSON Schema](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#json-schema-limitations). Auf Amazon Bedrock sind [strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs), zu denen die strikte Tool-Nutzung gehört, für Claude Sonnet 5.5 nicht verfügbar. Sende dort `auto` ohne `strict`, gib im Prompt an, wann das Tool aufgerufen werden soll, und validiere die Tool-Eingabe in deinem Code.

Vorher (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        }
      }],
      "tool_choice": {"type": "tool", "name": "get_weather"},
      "messages": [{"role": "user", "content": "What'\''s the weather in Paris?"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
  tool_choice:
    type: tool
    name: get_weather
  messages:
    - role: user
      content: What's the weather in Paris?
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=1024,
      tools=tools,
      tool_choice={"type": "tool", "name": "get_weather"},
      messages=[{"role": "user", "content": "What's the weather in Paris?"}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    tools,
    tool_choice: { type: "tool", name: "get_weather" },
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 1024,
      Tools = [.. tools],
      ToolChoice = new ToolChoiceTool { Name = "get_weather" },
      Messages = [new() { Role = Role.User, Content = "What's the weather in Paris?" }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeSonnet5,
  	MaxTokens:  1024,
  	Tools:      tools,
  	ToolChoice: anthropic.ToolChoiceParamOfTool("get_weather"),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in Paris?")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(1024L)
      .tools(tools)
      .toolChoice(ToolChoiceTool.of("get_weather"))
      .addUserMessage("What's the weather in Paris?")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 1024,
      tools: $tools,
      toolChoice: ToolChoiceTool::with(name: 'get_weather'),
      messages: [['role' => 'user', 'content' => "What's the weather in Paris?"]],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 1024,
    tools: tools,
    tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  )
  ```
</CodeGroup>

Nachher (Claude Sonnet 5.5):

<CodeGroup>
  ```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-sonnet-5-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        },
        "strict": true
      }],
      "tool_choice": {"type": "auto"},
      "messages": [{
        "role": "user",
        "content": "What'\''s the weather in Paris? Use the get_weather tool."
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
      # 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-sonnet-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-sonnet-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.ClaudeSonnet5_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
  // 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.ModelClaudeSonnet5_5,
  	MaxTokens:  1024,
  	Tools:      strictTools,
  	ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("What's the weather in Paris? Use the get_weather tool."),
  		),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(1024L)
      // 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_SONNET_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_SONNET_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." }
    ]
  )
  ```
</CodeGroup>

Das Beispiel markiert jedes Tool in der Liste als strikt. Eine Anfrage kann höchstens 20 strikte Tools enthalten, und die Toolset-Einträge für MCP, Computer Use und Browser Use akzeptieren kein `strict`. Markiere in einer längeren Tool-Liste nur die Tools, die es benötigen.

### Thinking-Blöcke sind an das Modell und das Gespräch gebunden

Claude Sonnet 5.5 liest Thinking-Blöcke von Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 und früheren Modellen sowie, auf der Claude API und Google Cloud, von Claude Haiku 5.5. Es liest keine Blöcke von Claude Opus 5, Claude Opus 5.5 oder einem Claude Fable- oder Claude Mythos-Modell. Die API verwirft Blöcke, die das Modell nicht lesen kann. Die Anfrage gibt trotzdem 200 zurück, und verworfene Blöcke werden nicht abgerechnet. Siehe [Modellwechsel mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#switching-models).

Jeder Thinking-Block von Claude Sonnet 5.5 ist außerdem über das vorangehende Gespräch signiert. Für Konten, die am oder nach dem 31. August 2026, 00:00 UTC, erstellt wurden, erzwingt die API dies standardmäßig auf der Claude API, Amazon Bedrock und Google Cloud. Bei diesen Konten gibt eine Anfrage, die einen Block nach einer Bearbeitung des früheren Verlaufs erneut sendet, einen 400-Fehler zurück. Halte Gespräche append-only und ändere Anweisungen oder Tools mit [System-Nachrichten mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages). Thinking-Blöcke, die Claude Sonnet 5.5 erzeugt, funktionieren nur in dem Konto, das sie erzeugt hat, oder in einem damit verknüpften Konto. Siehe [Beibehaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#account-bound-thinking).

### Computer Use benötigt das Toolset auf der Claude API und Google Cloud

Auf der Claude API und Google Cloud unterstützt Claude Sonnet 5.5 „computer use" (Computernutzung) nur über das Toolset `computer_toolset_20260801`. Dort gibt `computer_20251124` einen 400-Fehler zurück. Claude Sonnet 5.5 akzeptiert `computer_20250124` auf keiner Plattform. Finde die Version, die du heute sendest:

| Version, die du heute sendest | Ausgangsmodelle, die sie senden                      | Auf der Claude API und Google Cloud senden | Auf Amazon Bedrock senden |
| ----------------------------- | ---------------------------------------------------- | ------------------------------------------ | ------------------------- |
| `computer_20251124`           | Claude Sonnet 5, Claude Sonnet 4.6                   | `computer_toolset_20260801`                | `computer_20251124`       |
| `computer_20250124`           | Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 | `computer_toolset_20260801`                | `computer_20251124`       |

Wenn du den Beta-Header `fine-grained-tool-streaming-2025-05-14` sendest, entferne ihn beim Wechsel zum Toolset. Zusammen mit einem Toolset-Eintrag gibt er einen 400-Fehler zurück. Setze stattdessen `eager_input_streaming: true` für jedes Tool, das es benötigt.

Code, der das Toolset bereits sendet, benötigt keine Änderung. [Migration von `computer_20251124`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) listet die Änderungen an der Anfrage und der Agent-Schleife auf. Für andere Plattformen siehe [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#compatibility).

### Das Advisor-Tool akzeptiert weniger Advisors

Mit dem [Advisor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool) benötigt ein Claude Sonnet 5.5-Executor einen dieser Advisors: Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5, Claude Fable 5.1, Claude Mythos 5 oder Claude Mythos 5.1. Advisors vom Typ Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6 und Claude Haiku 5.5 geben einen 400-Fehler zurück. Der Ratschlag kommt verschlüsselt als `advisor_redacted_result`-Block zurück, sodass sein Text in der Antwort nicht lesbar ist. Siehe [Modellkompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### Text zwischen Tool-Aufrufen wird in Thinking-Blöcken zurückgegeben

Auf Claude Sonnet 5.5 kommen Notizen, die länger als ein oder zwei Sätze sind und die das Modell zwischen Tool-Aufrufen schreibt, als [`thinking`-Blöcke mit Fortschrittsupdates](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) zurück, die beim Standard-`display` leer sind. Kürzere Bemerkungen bleiben `text`. Auf Claude Sonnet 5 und früheren Modellen kommt sämtlicher Text zwischen Tool-Aufrufen als `text`-Blöcke zurück. Keine Anfrage schlägt fehl, aber eine Oberfläche, die diese Notizen anzeigt, wird still.

Setze bei adaptivem Nachdenken `display` auf `"updates"` (Beta, Header `thinking-display-updates-2026-08-18`), um nur die Updates zu erhalten, oder auf `"summarized"`, um sie gemischt mit dem Reasoning zu erhalten. Rendere jeden nicht leeren `thinking`-Block vor dem darauffolgenden `tool_use`-Block. Mit [`between_tools`](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) kommt der Text ohne `display` zurück. Siehe [Fortschrittsupdates für Nutzer](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Sicherheitsklassifikatoren und Fallback

Claude Sonnet 5.5 lehnt in mehr Kategorien ab als Claude Sonnet 5. Eine Ablehnung gibt `stop_reason: "refusal"` zurück, und ihre `stop_details` können eine dieser [Kategorien](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#refusal-response) nennen:

* **`"cyber"`:** Die Anfrage könnte Cyberschäden ermöglichen, etwa die Entwicklung von Malware oder Exploits.
* **`"bio"`:** Die Anfrage könnte biologische Schäden ermöglichen, etwa gefährliche Labormethoden.
* **`"frontier_llm"`:** Die Anfrage könnte die Entwicklung konkurrierender KI-Modelle unterstützen.
* **`"reasoning_extraction"`:** Die Anfrage fordert das Modell auf, sein internes Reasoning im Antworttext wiederzugeben.
* **`"general_harms"`:** Die Anfrage fällt unter einen anderen Bereich der Nutzungsrichtlinien. Auch harmlose Arbeit kann diese Kategorie auslösen.

[Serverseitiger Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`, Beta, nur Claude API) wiederholt `"cyber"`- und `"frontier_llm"`-Ablehnungen auf Claude Sonnet 5. Ablehnungen vom Typ `"bio"`, `"reasoning_extraction"` oder `"general_harms"` wiederholt er nicht. Siehe [Ablehnungen und Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback) und [Wie Ablehnungen abgerechnet werden](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Echtzeit-Cyber-Schutzmaßnahmen sind neu für Code von Claude Sonnet 4.6, Claude Sonnet 4.5 und Claude Haiku 4.5. Bewirb dich für legitime Sicherheitsarbeit beim [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Weitere Änderungen

* **Prompt-Caching:** Der minimale Prompt, der sich für „prompt caching" (Prompt-Caching) eignet, beträgt 512 Token, gegenüber 1.024 auf Claude Sonnet 5, Claude Sonnet 4.6 und Claude Sonnet 4.5. Siehe [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-limitations).
* **Neue Funktionen:** Zu System-Nachrichten mitten im Gespräch, Tool-Änderungen mitten im Gespräch und Effort pro Nachricht siehe [Neuerungen in Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). Mit [`between_tools`](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) kann sich der Effort nicht mitten im Gespräch ändern.

### Empfohlene Änderungen

Führe deinen Effort-Sweep erneut durch. Claude Sonnet 5.5 hat fünf Effort-Stufen: `low`, `medium`, `high`, `xhigh` und `max`. Der Standard auf der Claude API ist `high`. Die Stufen sind neu kalibriert, sodass eine Stufe nicht dieselbe Menge an Nachdenken erzeugt wie auf Claude Sonnet 5. Beginne mit `high`, es sei denn, deine Workload ist agentisch oder latenzempfindlich. Für agentisches Coding und mehrstufige Tool-Nutzung beginne bei klar spezifizierten Aufgaben mit `medium` und wechsle bei schwierigeren oder längeren Aufgaben zu `high`. Für Chat und andere latenzempfindliche Arbeit beginne mit `medium` oder `low`. Lege die Stufe in `output_config.effort` fest. Siehe [Empfohlene Effort-Level für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Bewerte anschließend modellspezifische Prompt-Anweisungen anhand von [Prompting für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5) neu.

## Migration zu Claude Sonnet 5.5 von Claude Sonnet 4.6 und früheren Sonnet-Modellen

Wende zuerst jeden vorangehenden Abschnitt an und ersetze dabei `claude-sonnet-4-6`. Nimm dann diese Änderungen vor. Fahre bei Claude Sonnet 4.5 oder früher mit den folgenden Unterabschnitten fort.

### Breaking Changes

**Nachdenken läuft bei Anfragen, die es weggelassen haben.** Siehe [Nachdenken läuft standardmäßig](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-on-by-default) und [Vorgelagertes Nachdenken ausschalten](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**Thinking-Budgets geben einen Fehler zurück.** Claude Sonnet 4.6 akzeptiert `thinking: {"type": "enabled", "budget_tokens": N}` als abgekündigte Einstellung. Claude Sonnet 4.5 und Claude Haiku 4.5 verwenden es für jedes Nachdenken. Claude Sonnet 5.5 gibt einen 400-Fehler zurück:

```text wrap
"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.
```

Entferne das Budget und lege eine [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe fest. Es gibt keine feste Zuordnung von einem Budget zu einer Effort-Stufe, also führe deine Evaluierungen auf zwei oder drei Stufen durch.

Vorher (Claude Sonnet 4.6):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages = [new() { Role = Role.User, Content = "..." }]
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_4_6)
      .maxTokens(16000L)
      .enabledThinking(10000L)
      .addUserMessage("...")
      .build();

  Message response = client.messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 16000,
      messages: [['role' => 'user', 'content' => '...']],
      model: 'claude-sonnet-4-6',
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

Nachher (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {
        "type": "adaptive"
      },
      "output_config": {
        "effort": "high"
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
  output_config:
    effort: high
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive"},
      output_config={"effort": "high"},  # or "max", "xhigh", "medium", "low"
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" }, // or "max", "xhigh", "medium", "low"
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive(),
      OutputConfig = new OutputConfig { Effort = Effort.High }, // or Max, Xhigh, Medium, Low
      Messages = [new() { Role = Role.User, Content = "..." }]
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh, // or Max, Xhigh, Medium, Low
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigAdaptive.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH) // or MAX, XHIGH, MEDIUM, LOW
          .build())
      .addUserMessage("...")
      .build();

  Message response = client.messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 16000,
      messages: [['role' => 'user', 'content' => '...']],
      model: 'claude-sonnet-5-5',
      thinking: ['type' => 'adaptive'],
      outputConfig: ['effort' => 'high'], // or 'max', 'xhigh', 'medium', 'low'
  );
  ```

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

  message = client.messages.create(
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: {
      type: "adaptive"
    },
    output_config: {
      effort: "high" # or "max", "xhigh", "medium", "low"
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

**Sampling-Parameter geben einen Fehler zurück.** Claude Sonnet 4.6 und frühere Modelle sowie Claude Haiku 4.5 akzeptieren `temperature`, `top_p` und `top_k`. Auf Claude Sonnet 5.5 gibt ein nicht standardmäßiger Wert einen 400-Fehler zurück. Entferne sie.

**Thinking-Text wird standardmäßig weggelassen.** Siehe [Nachdenken in Antworten verarbeiten](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Weitere Änderungen

* **Etwa 30 % mehr Token:** Claude Sonnet 5.5 verwendet den Tokenizer von Claude Sonnet 5. Im Vergleich zu Claude Sonnet 4.6, Claude Sonnet 4.5 und Claude Haiku 4.5 erzeugt derselbe Text je nach Inhalt etwa 30 % mehr Token. Zähle mit [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) neu und überprüfe `max_tokens` und die Kosten.
* **Effort:** `xhigh` ist neu, und die Stufen sind neu kalibriert. Siehe [Empfohlene Änderungen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#recommended-changes).
* **Bilder:** Claude Sonnet 5.5 verwendet die hochauflösende Bildstufe mit bis zu 2576 Pixeln an der langen Kante und 4.784 visuellen Token pro Bild. Claude Sonnet 4.6, Claude Sonnet 4.5 und Claude Haiku 4.5 enden bei 1568 Pixeln und 1.568 Token. Ein Bild mit 2000×1500 kostet auf Claude Sonnet 5.5 etwa 2,5-mal so viele Token. Siehe [Auflösung und Token-Kosten](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size).

### Migration von Claude Sonnet 4.5 oder früher

Bei Claude Sonnet 4.5, Claude Sonnet 4 oder Claude 3.7 Sonnet wende zuerst jeden vorangehenden Abschnitt an, dann diese Änderungen.

**Prefill gibt einen Fehler zurück.** Claude Sonnet 5.5 lehnt einen vorausgefüllten letzten Assistant-Turn mit einem 400-Fehler ab, wie es auch Claude Sonnet 4.6 und Claude Sonnet 5 tun. Claude Sonnet 4.5, Claude Haiku 4.5 und ältere Modelle akzeptieren einen. Der Fehler lautet:

```text wrap
This model does not support assistant message prefill. The conversation must end with a user message.
```

Ersetze jedes Prefill entsprechend seinem Zweck:

* **Ausgabeformat:** Verwende [strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) oder Tools mit Enum-Feldern für die Klassifizierung. Auf Amazon Bedrock sind strukturierte Ausgaben für Claude Sonnet 5.5 nicht verfügbar. Beschreibe dort das Format im Prompt oder verwende ein Tool ohne `strict` und validiere die Ausgabe in deinem Code.
* **Präambeln:** Bitte im System-Prompt um eine direkte Antwort.
* **Unerwünschte Ablehnungen:** Klare Anweisungen in der Nutzernachricht reichen in der Regel aus.
* **Fortsetzungen:** Verschiebe sie in die Nutzernachricht, zum Beispiel „Deine vorherige Antwort wurde unterbrochen und endete mit `[previous_response]`. Fahre dort fort, wo du aufgehört hast."
* **Kontexterinnerungen:** Platziere sie im Nutzer-Turn.

**Escaping von Tool-Eingaben.** Das Escaping in Argumenten von Tool-Aufrufen kann abweichen. Parse `input` mit einem Standard-JSON-Parser.

**Computer Use.** Claude Sonnet 5.5 akzeptiert `computer_20250124` nicht. Siehe die [Computer-Use-Tabelle](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Effort.** Claude Sonnet 4.5 hat keinen Effort-Parameter. Lege eine Effort-Stufe explizit fest, wie unter [Empfohlene Änderungen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#recommended-changes) beschrieben.

**Kontext und Ausgabe.** Claude Sonnet 5.5 hat ein größeres Kontextfenster ohne Beta-Header und ein höheres Ausgabelimit. Siehe die [Modellseite](https://platform.claude.com/docs/de/models/sonnet-5-5/overview). Entferne jeden Kontextfenster-Beta-Header.

**Beta-Header.** Entferne `interleaved-thinking-2025-05-14`, da adaptives Nachdenken automatisch verschachtelt. Ersetze `fine-grained-tool-streaming-2025-05-14` durch `eager_input_streaming: true` bei jedem Tool, das es benötigt. Dieser Header gibt zusammen mit einem Toolset-Eintrag für Computer Use oder Browser Use einen 400-Fehler zurück. Siehe [Feingranulares Tool-Streaming](https://platform.claude.com/docs/de/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Strukturierte Ausgaben.** 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. Verwende stattdessen `output_config.format`.

### Migration von Claude Sonnet 4 oder früher

Claude Sonnet 4 ist auf der Claude API eingestellt und auf Amazon Bedrock und Google Cloud weiterhin verfügbar. Claude 3.7 Sonnet ist eingestellt. Wende bei beiden Modellen zuerst jeden vorangehenden Abschnitt an, dann diese Änderungen:

* **Tool-Versionen:** Verwende `text_editor_20250728` mit dem Tool-Namen `str_replace_based_edit_tool` und ohne den Befehl `undo_edit`. Verwende `code_execution_20260521`. Siehe das [Text-Editor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool) und das [Code-Execution-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Stop-Gründe:** Behandle `refusal`. Claude 4.5 und spätere Modelle stoppen außerdem mit `model_context_window_exceeded` am Limit des Kontextfensters. Siehe [Umgang mit Stop-Gründen](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons).
* **Abschließende Zeilenumbrüche:** Claude 4.5 und spätere Modelle behalten sie in String-Parametern von Tool-Aufrufen bei.
* **Veraltete Beta-Header:** Entferne `token-efficient-tools-2025-02-19` und `output-128k-2025-02-19`.
* **Prompts:** Überprüfe sie anhand der [Best Practices für Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Migration zu Claude Sonnet 5.5 von Claude Haiku 4.5

Wende zuerst jeden Abschnitt bis einschließlich [Migration von Claude Sonnet 4.5 oder früher](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45) an und überspringe dabei den Unterabschnitt zu Claude Sonnet 4. Nimm dann diese Änderungen vor:

* **Modell-ID:** Ersetze `claude-haiku-4-5-20251001` oder den Alias `claude-haiku-4-5` durch `claude-sonnet-5-5`.
* **Kosten:** Der Preis pro Token ist höher, und derselbe Text erzeugt mehr Token. Zähle Token neu und lege die Kostenbasis neu fest. Siehe [Claude-Preise](https://platform.claude.com/docs/de/about-claude/pricing).
* **Prompt-Caching:** Der minimale cachebare Prompt sinkt von 4.096 Token auf das [Minimum von Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Verschachteltes Nachdenken:** Adaptives Nachdenken läuft automatisch zwischen Tool-Aufrufen, ohne Beta-Header.
* **Routing:** Claude Sonnet 5.5 liest Thinking-Blöcke von Claude Haiku 4.5. Ein Gespräch, das nach oben wechselt, behält sein Reasoning. Eines, das zurück zu Claude Haiku 4.5 wechselt, verwirft die Blöcke von Claude Sonnet 5.5.