---
title: Panduan migrasi Claude Sonnet 5.5
url: https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide
description: Beralih ke Claude Sonnet 5.5 dari model Sonnet sebelumnya atau Claude Haiku 4.5 dengan panduan migrasi ini. Panduan untuk mengaktifkan Claude Sonnet 5.5 mencakup pengaturan yang mengembalikan error, perubahan pemikiran, dan daftar periksa untuk setiap model awal.
---

Panduan ini mencantumkan perubahan kode untuk beralih ke Claude Sonnet 5.5 dari Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet, atau Claude Haiku 4.5. Baca dua bagian pertama, lalu baca ke bawah hingga bagian untuk model Anda saat ini. [Daftar periksa migrasi](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migration-checklist) mencantumkan setiap perubahan berdasarkan model awal.

<Note>
  Panduan ini membahas migrasi kode [Messages API](https://platform.claude.com/docs/id/build-with-claude/working-with-messages). Jika Anda menggunakan [Claude Managed Agents](https://platform.claude.com/docs/id/managed-agents/overview), tidak ada perubahan yang diperlukan selain memperbarui nama model.
</Note>

Biarkan Claude Code memigrasikan kode Anda

```text
/claude-api migrate proyek ini ke claude-sonnet-5-5
```

Claude Sonnet 5.5 memiliki harga yang sama dengan Claude Sonnet 5, kecuali untuk pembacaan cache prompt, yang berbiaya $0,10 USD per juta token, setengah dari tarif Claude Sonnet 5. Lihat [Harga](https://platform.claude.com/docs/id/about-claude/pricing). Untuk “context window” (jendela konteks) dan batas outputnya, lihat halaman model [Claude Sonnet 5.5](https://platform.claude.com/docs/id/models/sonnet-5-5/overview). Untuk fitur dan prompting, lihat [Yang baru di Claude Sonnet 5.5](https://platform.claude.com/docs/id/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) dan [Prompting untuk Claude Sonnet 5.5](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Mengirim permintaan ke Claude Sonnet 5.5

Permintaan ini berfungsi di Claude Sonnet 5.5 sebagaimana tertulis. Permintaan ini menetapkan tingkat effort dan tidak menyertakan lima pengaturan yang mengembalikan error 400: [anggaran pemikiran](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [parameter sampling](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [prefill asisten](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), [pilihan alat yang dipaksakan](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#forced-tool-use), dan [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/id/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>

## Pemikiran berjalan secara default

Di Claude Sonnet 5.5, permintaan tanpa field `thinking` berjalan dengan [pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/thinking), sama seperti `thinking: {"type": "adaptive"}`. Di Claude Sonnet 4.6 dan model sebelumnya serta di Claude Haiku 4.5, permintaan tersebut berjalan tanpa pemikiran. Untuk tetap berjalan tanpa pemikiran di awal, lihat [Menonaktifkan pemikiran di awal](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Model                                  | Pemikiran tanpa field `thinking` | Nilai `thinking.type` yang diterima             | `display` default |
| -------------------------------------- | -------------------------------- | ----------------------------------------------- | ----------------- |
| Claude Sonnet 5.5                      | Aktif                            | `"adaptive"`, `"between_tools"`                 | `"omitted"`       |
| Claude Sonnet 5                        | Aktif                            | `"adaptive"`, `"disabled"`                      | `"omitted"`       |
| Claude Sonnet 4.6                      | Nonaktif                         | `"adaptive"`, `"disabled"`, `"enabled"` (usang) | `"summarized"`    |
| Claude Sonnet 4.5 dan Claude Haiku 4.5 | Nonaktif                         | `"disabled"`, `"enabled"`                       | `"summarized"`    |

### Menangani pemikiran dalam respons

Kode yang berjalan tanpa pemikiran memerlukan ketiga item ini. Kode dari Claude Sonnet 5 kemungkinan sudah memiliki dua yang pertama.

* **Baca blok konten berdasarkan `type`.** Respons dapat dimulai dengan blok `thinking`, sehingga kode yang membaca `content[0].text` akan rusak.
* **Kirimkan kembali blok `thinking` tanpa perubahan** dalam loop penggunaan alat, termasuk blok yang kosong. Lihat [Mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks).
* **Tinjau kembali `max_tokens`.** Nilai ini mencakup pemikiran ditambah teks, dan token pemikiran ditagih sebagai token output. Lihat [Kontrol biaya](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#cost-control).

Teks pemikiran dihilangkan secara default. Blok `thinking` tiba dengan field `thinking` yang kosong dan sebuah `signature`. Untuk mendapatkan ringkasan yang dapat dibaca, tetapkan `display: "summarized"`, yang merupakan default di Claude Sonnet 4.6 dan model sebelumnya serta di Claude Haiku 4.5. Lihat [Mengontrol tampilan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display).

### Menonaktifkan pemikiran di awal

Untuk menonaktifkan pemikiran di awal pada Claude Sonnet 5.5, kirim `thinking: {"type": "between_tools"}`. Ini adalah pengaturan pemikiran terendah. Pembaruan progresnya di antara panggilan alat tetap dikembalikan sebagai blok `thinking` dengan teks ringkasannya. Tanpa alat, respons hanya berisi teks. Claude Sonnet 5 menonaktifkan pemikiran dengan `thinking: {"type": "disabled"}` sebagai gantinya, dan model sebelumnya berjalan tanpa pemikiran secara default. Di Claude Sonnet 5.5, `disabled` mengembalikan `invalid_request_error` 400:

```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` berfungsi di setiap platform yang menawarkan Claude Sonnet 5.5. Pengaturan ini diterima pada effort `low`, `medium`, dan `high`. Pada `xhigh` atau `max`, pengaturan ini mengembalikan error 400. Untuk berjalan pada tingkat tersebut, gunakan pemikiran adaptif: hilangkan field `thinking` atau kirim `thinking: {"type": "adaptive"}`. `between_tools` tidak menerima field lain: `display`, `budget_tokens`, atau `block_binding` yang dikirim bersamanya mengembalikan error 400. Dengan [fallback sisi server](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#server-side-fallback), permintaan `between_tools` yang beralih ke Claude Sonnet 5 akan berjalan di sana dengan `thinking: {"type": "disabled"}`.

Dengan `between_tools`, effort tidak dapat berubah di tengah percakapan: `output_config.effort` per pesan yang berbeda dari tingkat yang sedang berlaku mengembalikan error 400. Untuk memvariasikan effort di setiap giliran, gunakan pemikiran adaptif. Untuk panduan prompting, lihat [Berjalan tanpa pemikiran di awal](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Sebelum (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>

Sesudah (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>

## Daftar periksa migrasi berdasarkan model awal

Kerjakan grup-grup ini dari atas ke bawah dan berhenti setelah grup yang menyebutkan model Anda. Pada Claude Haiku 4.5, terapkan setiap grup kecuali “Claude Sonnet 4 atau sebelumnya”, dan akhiri dengan “Hanya Claude Haiku 4.5”.

### Setiap model awal

* Ubah ID model menjadi `claude-sonnet-5-5`.
* [Baca blok konten berdasarkan `type`](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-in-responses), dan kirimkan kembali blok `thinking` tanpa perubahan.
* Agar tetap berjalan tanpa pemikiran di awal, kirimkan [pengaturan pemikiran terendah](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) pada effort `high` atau di bawahnya.
* Ganti [“forced tool use” (penggunaan alat yang dipaksakan)](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#forced-tool-use) dengan `auto` dan alat strict.
* Pertahankan percakapan tetap [“append-only” (hanya-tambah)](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-blocks).
* Pindahkan penggunaan komputer ke [toolset](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#computer-use-toolset), tanpa header beta `fine-grained-tool-streaming-2025-05-14`. Di Amazon Bedrock, `computer_20251124` juga berfungsi.
* [Pasangkan alat advisor](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#advisor-tool) dengan advisor yang didukung, dan harapkan saran yang terenkripsi.
* Baca [teks di antara pemanggilan alat](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#text-between-tool-calls) dari blok `thinking`.
* [Tangani penolakan](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback), dan konfigurasikan fallback.
* [Jalankan ulang sweep effort Anda](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#recommended-changes), dan tetapkan ulang baseline biaya.

### Claude Sonnet 4.6 atau sebelumnya

* Siapkan diri untuk [pemikiran pada permintaan tanpa field `thinking`](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-on-by-default), dan tinjau kembali `max_tokens`.
* Ganti [anggaran pemikiran](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) dengan tingkat effort.
* Hapus `temperature`, `top_p`, dan `top_k`.
* Jika Anda [menampilkan teks pemikiran](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-in-responses), tetapkan `display: "summarized"`.
* [Hitung ulang token](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6), dan anggarkan ulang token gambar.

### Claude Sonnet 4.5 atau sebelumnya

* Ganti [“assistant prefills” (prefill asisten)](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45).
* Parse input pemanggilan alat dengan parser JSON standar.
* Tetapkan `output_config.effort` secara eksplisit.
* Hapus header beta jendela konteks apa pun.
* Hapus `interleaved-thinking-2025-05-14`, dan ganti `fine-grained-tool-streaming-2025-05-14` dengan `eager_input_streaming`.
* Pindahkan `output_format` ke `output_config.format`.

### Claude Sonnet 4 atau sebelumnya

* Perbarui [versi alat](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) ke `text_editor_20250728` dan `code_execution_20260521`.
* Tangani alasan berhenti `refusal` dan `model_context_window_exceeded`.
* Periksa parameter string alat untuk baris baru di akhir.
* Hapus `token-efficient-tools-2025-02-19` dan `output-128k-2025-02-19`.
* Tinjau prompt Anda.

### Hanya Claude Haiku 4.5

* Ganti [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) atau aliasnya.
* Tetapkan ulang baseline biaya dengan harga per token yang lebih tinggi.
* Tinjau prompt yang terlalu pendek untuk di-cache di Claude Haiku 4.5.

## Migrasi ke Claude Sonnet 5.5 dari Claude Sonnet 5

Setiap model awal memerlukan perubahan di bagian ini. Ganti ID model Anda dengan `claude-sonnet-5-5`, yang tidak memiliki akhiran tanggal. Di platform lain, gunakan ID yang tercantum di bawah [Ketersediaan](https://platform.claude.com/docs/id/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### Penggunaan alat yang dipaksakan tidak didukung

Setiap model sebelumnya di halaman ini menerima `tool_choice` bertipe `any` atau `tool`. Claude Sonnet 5.5 menolak keduanya dengan error 400, termasuk di endpoint [penghitungan token](https://platform.claude.com/docs/id/build-with-claude/token-counting):

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

Kirim `tool_choice: {"type": "auto"}`, dan tandai alat dengan `strict: true` agar inputnya sesuai dengan skema. Model kemudian dapat menjawab tanpa memanggil alat, jadi sebutkan dalam prompt kapan alat harus digunakan. [Penggunaan alat strict](https://platform.claude.com/docs/id/agents-and-tools/tool-use/strict-tool-use) mendukung subset JSON Schema dan memerlukan `additionalProperties: false` pada setiap objek. Lihat [Keterbatasan JSON Schema](https://platform.claude.com/docs/id/build-with-claude/structured-outputs#json-schema-limitations).

Sebelum (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>

Sesudah (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  # penggunaan alat ketat (strict): setiap panggilan sesuai dengan input_schema milik alat
  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
      # penggunaan alat ketat (strict tool use): setiap panggilan cocok dengan input_schema alat
      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,
      # penggunaan alat ketat (strict tool use): setiap panggilan sesuai dengan input_schema alat
      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,
    // penggunaan alat ketat: setiap panggilan sesuai dengan input_schema milik alat
    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,
      // penggunaan alat ketat: setiap panggilan sesuai dengan input_schema alat
      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
  // penggunaan alat ketat: setiap panggilan sesuai dengan input_schema alat
  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)
      // penggunaan alat ketat: setiap panggilan sesuai dengan input_schema milik alat
      .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,
      // strict tool use (penggunaan alat ketat): setiap panggilan sesuai dengan input_schema alat
      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,
    # penggunaan alat ketat: setiap panggilan sesuai dengan input_schema alat
    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>

Contoh ini menandai setiap alat dalam daftar sebagai strict. Sebuah permintaan dapat memiliki paling banyak 20 alat strict, dan entri toolset MCP, penggunaan komputer, dan penggunaan browser tidak menerima `strict`. Dalam daftar alat yang lebih panjang, tandai hanya alat yang memerlukannya.

### Blok pemikiran terikat pada model dan percakapan

Claude Sonnet 5.5 membaca blok pemikiran dari Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5, dan [model sebelumnya](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#earlier-models). Di Claude API dan Claude Models on Google Cloud (Google managed), model ini juga membacanya dari Claude Haiku 5.5. Model ini tidak membaca blok dari Claude Opus 5, Claude Opus 5.5, atau model Claude Fable maupun Claude Mythos mana pun.

API tidak menyertakan blok yang tidak dapat dibaca oleh model. Permintaan mengembalikan 200, dan blok yang tidak disertakan tidak ditagih. Lihat [Beralih model dan kembali lagi](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#switching-models).

Pertahankan percakapan tetap append-only (hanya-tambah), sehingga blok pemikiran lolos [pemeriksaan prefiks](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking/prefix-checks#prefix-check). Untuk mengubah instruksi atau alat, lihat [Pesan sistem dan perubahan alat di tengah percakapan](https://platform.claude.com/docs/id/build-with-claude/mid-conversation-system-messages).

Gagal dalam [pemeriksaan prefiks](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking/prefix-checks#prefix-check) mungkin menghasilkan atau mungkin tidak menghasilkan [error 400](https://platform.claude.com/docs/id/api/errors#thinking-block-conversation-mismatch). Untuk mengidentifikasi dan menangani kedua kasus tersebut, lihat [Pemeriksaan prefiks pada blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking/prefix-checks).

Pemeriksaan prefiks berjalan di Claude API dan di [beberapa platform cloud](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#feature-availability).

Blok pemikiran Claude Sonnet 5.5 hanya berfungsi di akun yang menghasilkannya atau di akun yang ditautkan dengannya. Lihat [Pemikiran yang dipertahankan](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#account-bound-thinking).

### Beberapa versi alat penggunaan komputer tidak didukung

Claude Sonnet 5.5 mendukung penggunaan komputer melalui toolset `computer_toolset_20260801`. Di Amazon Bedrock, Claude Sonnet 5.5 juga menerima alat `computer_20251124` dengan header beta `computer-use-2025-11-24`. Claude Sonnet 5.5 mengembalikan error 400 untuk versi alat penggunaan komputer apa pun yang tidak diterimanya, seperti `computer_20251124` di Claude API. Model ini tidak menerima `computer_20250124` di platform mana pun.

Integrasi yang menggunakan toolset tidak memerlukan perubahan. Untuk beralih ke toolset, ganti `computer_20251124` atau `computer_20250124` dengan `computer_toolset_20260801`, dan jangan lagi sertakan header beta versi tersebut. Untuk perubahan pada permintaan dan agent loop, lihat [Migrasi dari `computer_20251124`](https://platform.claude.com/docs/id/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).

Jika Anda mengirim header beta `fine-grained-tool-streaming-2025-05-14`, hapus header tersebut saat Anda beralih ke toolset. Bersama entri toolset, header tersebut mengembalikan error 400. Sebagai gantinya, tetapkan `eager_input_streaming: true` pada setiap alat yang memerlukannya.

### Alat advisor menerima lebih sedikit advisor

Dengan [alat advisor](https://platform.claude.com/docs/id/agents-and-tools/tool-use/advisor-tool), executor Claude Sonnet 5.5 memerlukan salah satu advisor berikut: 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, atau Claude Mythos 5.2. Advisor Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6, dan Claude Haiku 5.5 mengembalikan error 400. Saran dikembalikan dalam bentuk terenkripsi sebagai blok `advisor_redacted_result`, sehingga teksnya tidak dapat dibaca dalam respons. Lihat [Kompatibilitas model](https://platform.claude.com/docs/id/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### Teks di antara pemanggilan alat dikembalikan dalam blok pemikiran

Di Claude Sonnet 5.5, catatan yang lebih panjang dari satu atau dua kalimat yang ditulis model di antara panggilan alat dikembalikan sebagai [blok `thinking` pembaruan progres](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates), yang kosong pada `display` default. Komentar yang lebih pendek tetap berupa `text`. Di Claude Sonnet 5 dan model sebelumnya, semua teks di antara panggilan alat dikembalikan sebagai blok `text`. Tidak ada permintaan yang gagal, tetapi antarmuka yang menampilkan catatan tersebut akan berhenti menampilkannya.

Dengan pemikiran adaptif, tetapkan `display` ke `"updates"` (beta, header `thinking-display-updates-2026-08-18`) untuk mendapatkan pembaruan saja, atau ke `"summarized"` untuk mendapatkannya bercampur dengan penalaran. Tampilkan setiap blok `thinking` yang tidak kosong sebelum blok `tool_use` yang mengikutinya. Dengan [`between_tools`](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), teks dikembalikan tanpa `display`. Lihat [Pembaruan progres yang ditampilkan ke pengguna](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Classifier keamanan dan fallback

Claude Sonnet 5.5 menolak dalam lebih banyak kategori daripada Claude Sonnet 5. Penolakan mengembalikan `stop_reason: "refusal"`, dan `stop_details`-nya dapat menyebutkan salah satu [kategori](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#refusal-response) berikut:

* **`"cyber"`:** Permintaan dapat memungkinkan bahaya siber, seperti pengembangan malware atau exploit.
* **`"bio"`:** Permintaan dapat memungkinkan bahaya biologis, seperti metode laboratorium yang berbahaya.
* **`"frontier_llm"`:** Permintaan dapat membantu pengembangan model AI pesaing.
* **`"reasoning_extraction"`:** Permintaan meminta model untuk mereproduksi penalaran internalnya dalam teks respons.
* **`"general_harms"`:** Permintaan termasuk dalam area kebijakan penggunaan lainnya. Pekerjaan yang tidak berbahaya juga dapat memicu kategori ini.

[Fallback sisi server](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`), dalam versi beta di Claude API dan di [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/id/build-with-claude/claude-models-on-google-cloud/anthropic-managed), mencoba ulang penolakan `"cyber"` dan `"frontier_llm"` di Claude Sonnet 5. Fallback ini tidak mencoba ulang penolakan `"bio"`, `"reasoning_extraction"`, atau `"general_harms"`. Lihat [Penolakan dan fallback](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback) dan [Cara penolakan ditagih](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Perlindungan siber real-time merupakan hal baru untuk kode dari Claude Sonnet 4.6, Claude Sonnet 4.5, dan Claude Haiku 4.5. Untuk pekerjaan keamanan yang sah, daftarkan diri ke [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Perubahan lainnya

* **“Prompt caching” (caching prompt):** Prompt minimum yang dapat di-cache adalah 512 token, turun dari 1.024 di Claude Sonnet 5, Claude Sonnet 4.6, dan Claude Sonnet 4.5. Lihat [Caching prompt](https://platform.claude.com/docs/id/build-with-claude/prompt-caching#cache-limitations).
* **Fitur baru:** Untuk pesan sistem di tengah percakapan, perubahan alat di tengah percakapan, dan effort per pesan, lihat [Yang baru di Claude Sonnet 5.5](https://platform.claude.com/docs/id/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). Dengan [`between_tools`](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), effort tidak dapat berubah di tengah percakapan.

### Perubahan yang direkomendasikan

Jalankan ulang sweep effort Anda. Claude Sonnet 5.5 memiliki lima tingkat effort: `low`, `medium`, `high`, `xhigh`, dan `max`. Default di Claude API adalah `high`. Tingkat-tingkat ini dikalibrasi ulang, sehingga suatu tingkat tidak menghasilkan jumlah pemikiran yang sama seperti di Claude Sonnet 5. Mulailah dari `high` kecuali beban kerja Anda bersifat agentik atau sensitif terhadap latensi. Untuk coding agentik dan penggunaan alat multilangkah, mulailah dari `medium` untuk tugas yang terdefinisi dengan baik dan naikkan ke `high` untuk tugas yang lebih sulit atau lebih panjang. Untuk chat dan pekerjaan lain yang sensitif terhadap latensi, mulailah dari `medium` atau `low`. Tetapkan tingkat di `output_config.effort`. Lihat [Tingkat effort yang direkomendasikan untuk Claude Sonnet 5.5](https://platform.claude.com/docs/id/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Kemudian evaluasi ulang instruksi prompt khusus model terhadap [Prompting untuk Claude Sonnet 5.5](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Migrasi ke Claude Sonnet 5.5 dari Claude Sonnet 4.6 dan model Sonnet sebelumnya

Pertama, terapkan setiap bagian sebelumnya, dengan mengganti `claude-sonnet-4-6`. Kemudian lakukan perubahan berikut. Pada Claude Sonnet 4.5 atau sebelumnya, lanjutkan dengan subbagian berikutnya.

### Perubahan yang merusak kompatibilitas

**Pemikiran berjalan pada permintaan yang tidak menyertakannya.** Lihat [Pemikiran berjalan secara default](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-on-by-default) dan [Menonaktifkan pemikiran di awal](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**Anggaran pemikiran mengembalikan error.** Claude Sonnet 4.6 menerima `thinking: {"type": "enabled", "budget_tokens": N}` sebagai pengaturan yang usang. Claude Sonnet 4.5 dan Claude Haiku 4.5 menggunakannya untuk semua pemikiran. Claude Sonnet 5.5 mengembalikan error 400:

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

Hapus anggaran dan tetapkan tingkat [effort](https://platform.claude.com/docs/id/build-with-claude/effort). Tidak ada pemetaan tetap dari anggaran ke tingkat effort, jadi jalankan evaluasi Anda pada dua atau tiga tingkat.

Sebelum (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>

Sesudah (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>

**Parameter sampling mengembalikan error.** Hapus `temperature`, `top_p`, dan `top_k`.

**Teks pemikiran dihilangkan secara default.** Lihat [Menangani pemikiran dalam respons](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Perubahan lainnya

* **Sekitar 30 persen lebih banyak token:** Claude Sonnet 5.5 menggunakan tokenizer Claude Sonnet 5. Dibandingkan dengan Claude Sonnet 4.6, Claude Sonnet 4.5, dan Claude Haiku 4.5, teks yang sama menghasilkan sekitar 30 persen lebih banyak token, tergantung pada kontennya. Hitung ulang dengan [penghitungan token](https://platform.claude.com/docs/id/build-with-claude/token-counting), dan tinjau kembali `max_tokens` serta biaya.
* **Effort:** Claude Sonnet 5.5 mendukung `xhigh`, dan tingkat-tingkatnya dikalibrasi ulang. Lihat [Perubahan yang direkomendasikan](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#recommended-changes).
* **Gambar:** Claude Sonnet 5.5 menggunakan tingkat gambar resolusi tinggi, hingga 2.576 piksel pada sisi panjang dan hingga 4.784 token visual untuk satu gambar. Claude Sonnet 4.6, Claude Sonnet 4.5, dan Claude Haiku 4.5 berhenti pada 1.568 piksel dan 1.568 token. Gambar 2000×1500 membutuhkan sekitar 2,5 kali lebih banyak token di Claude Sonnet 5.5. Lihat [Resolusi dan biaya token](https://platform.claude.com/docs/id/build-with-claude/vision#evaluate-image-size).

### Migrasi dari Claude Sonnet 4.5 atau sebelumnya

Pada Claude Sonnet 4.5, Claude Sonnet 4, atau Claude 3.7 Sonnet, pertama terapkan setiap bagian sebelumnya, lalu perubahan berikut.

**Prefill mengembalikan error.** Claude Sonnet 5.5 menolak giliran asisten terakhir yang di-prefill dengan error 400, sama seperti Claude Sonnet 4.6 dan Claude Sonnet 5. Claude Sonnet 4.5, Claude Haiku 4.5, dan model yang lebih lama menerimanya. Pesan error-nya berbunyi:

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

Ganti setiap prefill sesuai dengan tujuannya:

* **Format output:** gunakan [output terstruktur](https://platform.claude.com/docs/id/build-with-claude/structured-outputs), atau alat dengan field enum untuk klasifikasi.
* **Pembukaan:** minta jawaban langsung di prompt sistem.
* **Penolakan yang tidak diinginkan:** instruksi yang jelas dalam pesan pengguna biasanya sudah cukup.
* **Kelanjutan:** pindahkan ke pesan pengguna, misalnya “Respons Anda sebelumnya terputus dan berakhir dengan `[previous_response]`. Lanjutkan dari bagian terakhir.”
* **Pengingat konteks:** letakkan di giliran pengguna.

**Escaping input alat.** Escaping dalam argumen panggilan alat dapat berbeda. Parse `input` dengan parser JSON standar.

**Penggunaan komputer.** Claude Sonnet 5.5 tidak menerima `computer_20250124`. Lihat [Beberapa versi alat penggunaan komputer tidak didukung](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Effort.** Claude Sonnet 4.5 tidak memiliki parameter effort. Tetapkan tingkat effort secara eksplisit (lihat [Perubahan yang direkomendasikan](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#recommended-changes)).

**Konteks dan output.** Claude Sonnet 5.5 memiliki jendela konteks yang lebih besar dan batas output yang lebih tinggi. Lihat halaman model [Claude Sonnet 5.5](https://platform.claude.com/docs/id/models/sonnet-5-5/overview). Hapus header beta jendela konteks apa pun.

**Beta header.** Hapus `interleaved-thinking-2025-05-14`, karena pemikiran adaptif melakukan interleaving secara otomatis. Ganti `fine-grained-tool-streaming-2025-05-14` dengan `eager_input_streaming: true` pada setiap alat yang memerlukannya. Header tersebut mengembalikan error 400 bersama entri toolset penggunaan komputer atau penggunaan browser. Lihat [Streaming alat fine-grained](https://platform.claude.com/docs/id/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Output terstruktur.** Parameter `output_format` sudah usang. Untuk tetap menggunakannya, tambahkan header beta `structured-outputs-2025-11-13`. Tanpa header tersebut, API mengembalikan error 400. Gunakan `output_config.format` sebagai gantinya.

### Migrasi dari Claude Sonnet 4 atau sebelumnya

Claude Sonnet 4 sudah dihentikan di Claude API tetapi tersedia di Claude Models on Google Cloud (Google managed) dan Amazon Bedrock. Claude 3.7 Sonnet sudah dihentikan. Dari salah satu model tersebut, pertama terapkan setiap bagian sebelumnya, lalu perubahan berikut:

* **Versi alat:** Gunakan `text_editor_20250728`, dengan nama alat `str_replace_based_edit_tool` dan tanpa perintah `undo_edit`. Gunakan `code_execution_20260521`. Lihat [alat editor teks](https://platform.claude.com/docs/id/agents-and-tools/tool-use/text-editor-tool) dan [alat eksekusi kode](https://platform.claude.com/docs/id/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Alasan berhenti:** Tangani `refusal`. Claude 4.5 dan model yang lebih baru juga berhenti dengan `model_context_window_exceeded` pada batas jendela konteks. Lihat [Alasan berhenti dan fallback](https://platform.claude.com/docs/id/build-with-claude/handling-stop-reasons).
* **Baris baru di akhir:** Claude 4.5 dan model yang lebih baru mempertahankannya dalam parameter string panggilan alat.
* **Beta header:** Hapus `token-efficient-tools-2025-02-19` dan `output-128k-2025-02-19`.
* **Prompt:** Tinjau prompt terhadap [praktik terbaik prompting](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Migrasi ke Claude Sonnet 5.5 dari Claude Haiku 4.5

Pertama, terapkan setiap bagian hingga dan termasuk [Migrasi dari Claude Sonnet 4.5 atau sebelumnya](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), dengan melewati subbagian Claude Sonnet 4. Kemudian lakukan perubahan berikut:

* **ID model:** Ganti `claude-haiku-4-5-20251001`, atau alias `claude-haiku-4-5`, dengan `claude-sonnet-5-5`.
* **Biaya:** Harga per token lebih tinggi, dan teks yang sama menghasilkan lebih banyak token. Hitung ulang token dan tetapkan ulang baseline biaya. Lihat [Harga](https://platform.claude.com/docs/id/about-claude/pricing).
* **Caching prompt:** Prompt minimum yang dapat di-cache turun dari 4.096 token ke [minimum Claude Sonnet 5.5](https://platform.claude.com/docs/id/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Pemikiran yang disisipkan:** Pemikiran adaptif berjalan di antara panggilan alat secara otomatis.
* **Perutean:** Claude Sonnet 5.5 membaca blok pemikiran Claude Haiku 4.5. Percakapan yang naik tingkat mempertahankan penalarannya. Percakapan yang kembali turun ke Claude Haiku 4.5 tidak menyertakan blok milik Claude Sonnet 5.5.