---
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 Umstieg auf Claude Sonnet 5.5 von Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet oder Claude Haiku 4.5 auf. Lies die ersten beiden Abschnitte und lies 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>

Lass Claude Code deinen Code für dich migrieren

```text
/claude-api migrate dieses Projekt zu claude-sonnet-5-5
```

Claude Sonnet 5.5 hat dieselben Preise wie Claude Sonnet 5, mit Ausnahme von Prompt-Cache-Lesevorgängen, die 0,10 $ pro Million Token kosten, die Hälfte des Tarifs von Claude Sonnet 5. Siehe [Preise](https://platform.claude.com/docs/de/about-claude/pricing). Informationen zum „context window“ (Kontextfenster) und zu den Ausgabelimits findest du auf der Modellseite zu [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview). Informationen zu Funktionen und zum Prompting findest du unter [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 mit Claude Sonnet 5.5 so, wie sie geschrieben ist. Sie legt ein Effort-Level fest und 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: 2026-10-21" \
    -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.type === "text");
  console.log(textBlock?.text);
  ```

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

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

  var message = await client.Messages.Create(parameters);
  Console.WriteLine($"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: Model::CLAUDE_SONNET_5_5,
      outputConfig: ['effort' => 'medium'],
  );

  echo "Stop reason: {$message->stopReason}", PHP_EOL;
  foreach ($message->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = client.messages.create(
    model: Anthropic::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.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

## Nachdenken läuft standardmäßig

Bei Claude Sonnet 5.5 läuft eine Anfrage ohne `thinking`-Feld mit [adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking), ebenso wie `thinking: {"type": "adaptive"}`. Bei Claude Sonnet 4.6 und früheren Modellen sowie bei 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, benötigt alle drei Punkte. Code von Claude Sonnet 5 hat wahrscheinlich 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 Tool-Nutzungs-Schleifen, 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 in Rechnung gestellt. 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 bei Claude Sonnet 4.6 und früheren Modellen sowie bei 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 bei 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. Bei Claude Sonnet 5.5 gibt `disabled` einen 400-Fehler `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. Es wird bei `low`, `medium` und `high` Effort akzeptiert. Bei `xhigh` oder `max` gibt es einen 400-Fehler zurück. Um auf diesen Levels 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 in der Konversation ändern: Ein `output_config.effort` pro Nachricht, das vom aktiven Level abweicht, gibt einen 400-Fehler zurück. Um den Effort für jeden Turn zu variieren, verwende adaptives Nachdenken. Hinweise zum Prompting findest du unter [Ohne vorgelagertes Nachdenken arbeiten](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: 2026-10-21" \
    -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 UserMessageParam { 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: 2026-10-21" \
    -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 UserMessageParam { 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. Bei Claude Haiku 4.5 wende 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 anhand von `type`](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 ohne vorgelagertes Nachdenken weiterzuarbeiten, sende die [niedrigste Thinking-Einstellung](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) bei `high`-Effort 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.
* Halte Konversationen [append-only](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#thinking-blocks) (nur anhängend).
* Verlagere Computer Use in 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`. Auf Amazon Bedrock funktioniert auch `computer_20251124`.
* [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.
* [Behandle 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 Kosten-Baseline 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 ein Effort-Level.
* Entferne `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 die Eingabe von Tool-Aufrufen mit einem Standard-JSON-Parser.
* 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 [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-Reasons `refusal` und `model_context_window_exceeded`.
* Prüfe String-Parameter von Tools auf nachgestellte 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 Kosten-Baseline beim höheren Preis pro Token neu fest.
* Überprüfe Prompts, die bei 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. Verwende auf anderen Plattformen die unter [Verfügbarkeit](https://platform.claude.com/docs/de/models/sonnet-5-5/whats-new-sonnet-5-5#availability) aufgeführte ID.

### 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 [Token-Counting](https://platform.claude.com/docs/de/build-with-claude/token-counting)-Endpunkt:

```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).

Vorher (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-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 is 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 UserMessageParam { 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: 2026-10-21" \
    -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 is 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 UserMessageParam
          {
              Content = "What's the weather in Paris? Use the get_weather tool.",
          },
      ],
  });
  ```

  ```go Go
  // strikte Tool-Nutzung: jeder Aufruf entspricht dem input_schema des Tools
  var strictTools []anthropic.ToolUnionParam
  for _, tool := range tools {
  	strictTool := *tool.OfTool
  	strictTool.Strict = anthropic.Bool(true)
  	strictTools = append(strictTools, anthropic.ToolUnionParam{OfTool: &strictTool})
  }
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.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 haben, und die Toolset-Einträge für MCP, Computer Use und Browser Use akzeptieren `strict` nicht. Markiere in einer längeren Tool-Liste nur die Tools, die es benötigen.

### Thinking-Blöcke sind an das Modell und die Konversation 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#earlier-models). Auf der Claude API und Claude Models on Google Cloud (Google managed) liest es sie außerdem 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 lässt Blöcke weg, die das Modell nicht lesen kann. Die Anfrage gibt 200 zurück, und weggelassene Blöcke werden nicht in Rechnung gestellt. Siehe [Das Modell wechseln und zurück](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#switching-models).

Halte Konversationen append-only, damit Thinking-Blöcke die [Präfixprüfung](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check) bestehen. Um Anweisungen oder Tools zu ändern, siehe [System-Nachrichten und Tool-Änderungen mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages).

Wird die [Präfixprüfung](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check) („prefix check“) nicht bestanden, kann das zu einem [400-Fehler](https://platform.claude.com/docs/de/api/errors#thinking-block-conversation-mismatch) führen, muss es aber nicht. Wie du beide Fälle erkennst und behandelst, erfährst du unter [Präfixprüfungen bei Thinking-Blöcken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks).

Die Präfixprüfung läuft auf der Claude API und auf [einigen Cloud-Plattformen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#feature-availability).

Thinking-Blöcke von Claude Sonnet 5.5 funktionieren nur in dem Konto, das sie erzeugt hat, oder in einem damit verknüpften Konto. Siehe [Bewahrtes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#account-bound-thinking).

### Einige Versionen des Computer-Use-Tools werden nicht unterstützt

Claude Sonnet 5.5 unterstützt Computer Use über das Toolset `computer_toolset_20260801`. Auf Amazon Bedrock akzeptiert Claude Sonnet 5.5 außerdem das Tool `computer_20251124` mit dem Beta-Header `computer-use-2025-11-24`. Claude Sonnet 5.5 gibt einen 400-Fehler für jede Version des Computer-Use-Tools zurück, die es nicht akzeptiert, etwa `computer_20251124` auf der Claude API. `computer_20250124` akzeptiert es auf keiner Plattform.

Integrationen, die das Toolset verwenden, müssen nicht geändert werden. Um auf das Toolset umzusteigen, ersetze `computer_20251124` oder `computer_20250124` durch `computer_toolset_20260801` und lass den Beta-Header dieser Version weg. Für die Änderungen an der Anfrage und am Agent-Loop siehe [Migration von `computer_20251124`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).

Wenn du den Beta-Header `fine-grained-tool-streaming-2025-05-14` sendest, entferne ihn, wenn du auf das Toolset umsteigst. Zusammen mit einem Toolset-Eintrag gibt er einen 400-Fehler zurück. Setze stattdessen `eager_input_streaming: true` bei jedem Tool, das es benötigt.

### 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 Fable 5.2, Claude Mythos 5, Claude Mythos 5.1 oder Claude Mythos 5.2. 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 Rat kommt verschlüsselt als `advisor_redacted_result`-Block zurück, daher ist sein Text in der Antwort nicht lesbar. 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

Bei 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 [Fortschrittsmeldungs-`thinking`-Blöcke](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`. Bei Claude Sonnet 5 und früheren Modellen kommt jeglicher Text zwischen Tool-Aufrufen als `text`-Blöcke zurück. Keine Anfrage schlägt fehl, aber eine Oberfläche, die diese Notizen anzeigt, zeigt sie nicht mehr an.

Setze mit adaptivem Nachdenken `display` auf `"updates"` (Beta, Header `thinking-display-updates-2026-08-18`), um nur die Meldungen zu erhalten, oder auf `"summarized"`, um sie gemischt mit dem Reasoning zu erhalten. Stelle jeden nicht leeren `thinking`-Block vor dem darauffolgenden `tool_use`-Block dar. 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 [Fortschrittsmeldungen für Benutzer](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 Cyber-Schä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 bei der Entwicklung konkurrierender KI-Modelle helfen.
* **`"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"`), in der Beta auf der Claude API und auf [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed), wiederholt `"cyber"`- und `"frontier_llm"`-Ablehnungen auf Claude Sonnet 5. Ablehnungen vom Typ `"bio"`, `"reasoning_extraction"` oder `"general_harms"` werden nicht wiederholt. Siehe [Ablehnungen und Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback) und [Wie Ablehnungen berechnet 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. Für legitime Sicherheitsarbeit bewirb dich 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 cachebare Prompt beträgt 512 Token, statt 1.024 bei 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 in der Konversation, Tool-Änderungen mitten in der Konversation 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 in der Konversation ändern.

### Empfohlene Änderungen

Führe deinen Effort-Sweep erneut durch. Claude Sonnet 5.5 hat fünf Effort-Level: `low`, `medium`, `high`, `xhigh` und `max`. Der Standard auf der Claude API ist `high`. Die Level sind neu kalibriert, sodass ein Level nicht dieselbe Menge an Nachdenken erzeugt wie bei Claude Sonnet 5. Beginne mit `high`, es sei denn, dein Workload ist agentisch oder latenzempfindlich. Für agentisches Coding und mehrstufige Tool-Nutzung beginne bei gut spezifizierten Aufgaben mit `medium` und wechsle für schwierigere oder längere Aufgaben zu `high`. Für Chat und andere latenzempfindliche Arbeit beginne mit `medium` oder `low`. Lege das Level 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 dann 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 jegliches 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 ein [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Level fest. Es gibt keine feste Zuordnung von einem Budget zu einem Effort-Level, daher führe deine Evaluierungen auf zwei oder drei Levels 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: 2026-10-21" \
    -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 UserMessageParam { Content = "..." }]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.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: Model::CLAUDE_SONNET_4_6,
      thinking: ['type' => 'enabled', 'budgetTokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    model: Anthropic::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: 2026-10-21" \
    -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 UserMessageParam { Content = "..." }]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.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: 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: Anthropic::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.** Entferne `temperature`, `top_p` und `top_k`.

**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 Prozent 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 Prozent mehr Token. Zähle mit [Token-Counting](https://platform.claude.com/docs/de/build-with-claude/token-counting) neu und überprüfe `max_tokens` und die Kosten.
* **Effort:** Claude Sonnet 5.5 unterstützt `xhigh`, und die Level 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, bis zu 2.576 Pixel an der langen Kante und bis zu 4.784 visuelle Token pro Bild. Claude Sonnet 4.6, Claude Sonnet 4.5 und Claude Haiku 4.5 enden bei 1.568 Pixeln und 1.568 Token. Ein Bild mit 2000×1500 kostet bei 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

Wende bei Claude Sonnet 4.5, Claude Sonnet 4 oder Claude 3.7 Sonnet zuerst jeden vorangehenden Abschnitt an und 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.
* **Einleitungen:** Bitte im System-Prompt um eine direkte Antwort.
* **Unerwünschte Ablehnungen:** Klare Anweisungen in der Benutzernachricht reichen in der Regel aus.
* **Fortsetzungen:** Verschiebe sie in die Benutzernachricht, zum Beispiel „Deine vorherige Antwort wurde unterbrochen und endete mit `[previous_response]`. Fahre dort fort, wo du aufgehört hast.“
* **Kontext-Erinnerungen:** Setze sie in den Benutzer-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 [Einige Versionen des Computer-Use-Tools werden nicht unterstützt](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 ein Effort-Level explizit fest (siehe [Empfohlene Änderungen](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide#recommended-changes)).

**Kontext und Ausgabe.** Claude Sonnet 5.5 hat ein größeres Kontextfenster und ein höheres Ausgabelimit. Siehe die Modellseite zu [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview). Entferne jeglichen 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. 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, aber auf Claude Models on Google Cloud (Google managed) und Amazon Bedrock verfügbar. Claude 3.7 Sonnet ist eingestellt. Wende bei beiden Modellen zuerst jeden vorangehenden Abschnitt an und 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-Reasons:** Behandle `refusal`. Claude 4.5 und neuere Modelle stoppen am Limit des Kontextfensters außerdem mit `model_context_window_exceeded`. Siehe [Stop-Gründe und Fallback](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons).
* **Nachgestellte Zeilenumbrüche:** Claude 4.5 und neuere Modelle behalten sie in String-Parametern von Tool-Aufrufen bei.
* **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 das 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 Kosten-Baseline neu fest. Siehe [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.
* **Routing:** Claude Sonnet 5.5 liest Thinking-Blöcke von Claude Haiku 4.5. Eine Konversation, die nach oben wechselt, behält ihr Reasoning. Eine, die zurück zu Claude Haiku 4.5 wechselt, lässt die Blöcke von Claude Sonnet 5.5 weg.