---
title: Guía de migración a Claude Sonnet 5.5
url: https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide
description: Cambia a Claude Sonnet 5.5 desde modelos Sonnet anteriores o desde Claude Haiku 4.5 con esta guía de migración. La guía para habilitar Claude Sonnet 5.5 incluye las configuraciones que devuelven errores, los cambios en el pensamiento y una lista de verificación para cada modelo de partida.
---

Esta guía enumera los cambios de código necesarios para pasar a Claude Sonnet 5.5 desde Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet o Claude Haiku 4.5. Lee las dos primeras secciones y luego continúa hasta la sección de tu modelo actual. La [lista de verificación de migración](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migration-checklist) enumera cada cambio según el modelo de partida.

<Note>
  Esta guía cubre la migración de código de la [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages). Si usas [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview), no se requieren cambios más allá de actualizar el nombre del modelo.
</Note>

<Tip>
  **Automatiza tu migración con la skill de Claude API.** En Claude Code, ejecuta `/claude-api migrate` para invocar la [skill de Claude API](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) incluida. Funciona con cualquier modelo actual de Claude como destino:

  Deja que Claude Code migre tu código por ti

  ```text
  /claude-api migrate este proyecto a claude-sonnet-5-5
  ```

  La skill aplica el cambio de ID de modelo y, según sea necesario, los cambios de parámetros incompatibles, el reemplazo de prefill y la calibración de esfuerzo para tu modelo de destino en toda tu base de código, y luego produce una lista de verificación de elementos para revisar manualmente. Te pide que confirmes el alcance de la migración (todo el directorio de trabajo, un subdirectorio o una lista específica de archivos) antes de editar cualquier archivo. La skill también detecta clientes de Amazon Bedrock y Claude Platform on AWS y ajusta los formatos de ID de modelo y los cambios de funcionalidades para esas plataformas.
</Tip>

Claude Sonnet 5.5 tiene los mismos precios que Claude Sonnet 5, excepto las lecturas de la caché de prompts, que cuestan $0.10 USD por millón de tokens, la mitad de la tarifa de Claude Sonnet 5. Consulta [Precios de Claude](https://platform.claude.com/docs/es/about-claude/pricing). Para conocer su "context window" (ventana de contexto) y sus límites de salida, consulta la [página del modelo Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/overview). Para funciones y prompting, consulta [Novedades de Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) y [Prompting para Claude Sonnet 5.5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Envía una solicitud a Claude Sonnet 5.5

Esta solicitud funciona en Claude Sonnet 5.5 tal como está escrita. Establece un nivel de "effort" (esfuerzo), y las pestañas de los SDK leen la respuesta por tipo de bloque. Omite cinco configuraciones que devuelven un error 400: [presupuestos de pensamiento](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [parámetros de muestreo](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [prefill del asistente](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), [elección forzada de herramienta](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#forced-tool-use) y [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## El pensamiento se ejecuta de forma predeterminada

En Claude Sonnet 5.5, una solicitud sin campo `thinking` se ejecuta con ["adaptive thinking" (pensamiento adaptativo)](https://platform.claude.com/docs/es/build-with-claude/thinking), al igual que `thinking: {"type": "adaptive"}`. En Claude Sonnet 4.6 y modelos anteriores, y en Claude Haiku 4.5, esa solicitud se ejecutaba sin pensamiento. Para seguir ejecutando sin pensamiento inicial, consulta [Desactiva el pensamiento inicial](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Modelo                               | Pensamiento sin un campo `thinking` | Valores de `thinking.type` aceptados               | `display` predeterminado |
| ------------------------------------ | ----------------------------------- | -------------------------------------------------- | ------------------------ |
| Claude Sonnet 5.5                    | Activado                            | `"adaptive"`, `"between_tools"`                    | `"omitted"`              |
| Claude Sonnet 5                      | Activado                            | `"adaptive"`, `"disabled"`                         | `"omitted"`              |
| Claude Sonnet 4.6                    | Desactivado                         | `"adaptive"`, `"disabled"`, `"enabled"` (obsoleto) | `"summarized"`           |
| Claude Sonnet 4.5 y Claude Haiku 4.5 | Desactivado                         | `"disabled"`, `"enabled"`                          | `"summarized"`           |

### Gestiona el pensamiento en las respuestas

El código que se ejecutaba sin pensamiento necesita los tres elementos. El código que proviene de Claude Sonnet 5 probablemente ya tiene los dos primeros.

* **Lee los bloques de contenido por `type`.** Una respuesta puede comenzar con bloques `thinking`, por lo que el código que lee `content[0].text` falla.
* **Devuelve los bloques `thinking` sin cambios** en los bucles de "tool use" (uso de herramientas), incluidos los vacíos. Consulta [Preservar bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#preserving-thinking-blocks).
* **Revisa `max_tokens`.** Cubre el pensamiento más el texto, y los tokens de pensamiento se facturan como tokens de salida. Consulta [Control de costos](https://platform.claude.com/docs/es/build-with-claude/thinking-steering-and-cost#cost-control).

El texto del pensamiento se omite de forma predeterminada. Los bloques `thinking` llegan con un campo `thinking` vacío y una `signature`. Para obtener resúmenes legibles, establece `display: "summarized"`, el valor predeterminado en Claude Sonnet 4.6 y modelos anteriores, y en Claude Haiku 4.5. Consulta [Controlar la visualización del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#controlling-thinking-display).

### Desactiva el pensamiento inicial

Para desactivar el pensamiento inicial en Claude Sonnet 5.5, envía `thinking: {"type": "between_tools"}`. Es la configuración de pensamiento más baja. Sus actualizaciones de progreso entre llamadas a herramientas siguen llegando como bloques `thinking` con su texto de resumen. Sin herramientas, la respuesta contiene solo texto. Claude Sonnet 5, en cambio, desactiva el pensamiento con `thinking: {"type": "disabled"}`, y los modelos anteriores se ejecutan sin pensamiento de forma predeterminada. En Claude Sonnet 5.5, `disabled` devuelve un error 400 `invalid_request_error`:

```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` funciona en todas las plataformas que ofrecen Claude Sonnet 5.5, sin encabezado beta. Se acepta con esfuerzo `low`, `medium` y `high`. Con `xhigh` o `max`, devuelve un error 400. Para ejecutar en esos niveles, usa el pensamiento adaptativo: omite el campo `thinking` o envía `thinking: {"type": "adaptive"}`. `between_tools` no admite ningún otro campo: `display`, `budget_tokens` o `block_binding` enviados junto con él devuelven un error 400. Con [fallback del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback), una solicitud `between_tools` que recurre a Claude Sonnet 5 se ejecuta allí con `thinking: {"type": "disabled"}`.

Con `between_tools`, el esfuerzo no puede cambiar a mitad de la conversación: un `output_config.effort` por mensaje que difiera del nivel vigente devuelve un error 400. Para variar el esfuerzo en cada turno, usa el pensamiento adaptativo. Para obtener orientación sobre prompting, consulta [Ejecutar sin pensamiento inicial](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Antes (Claude Sonnet 5):

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

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

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

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

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

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

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

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

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

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

Después (Claude Sonnet 5.5):

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

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

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

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

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

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

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

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

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

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

## Lista de verificación de migración por modelo de partida

Recorre los grupos en orden y detente después del que nombra tu modelo. En Claude Haiku 4.5, aplica todos los grupos excepto "Claude Sonnet 4 o anterior", y termina con "Solo Claude Haiku 4.5".

### Todos los modelos de partida

* Cambia el ID del modelo a `claude-sonnet-5-5`.
* [Lee los bloques de contenido por `type`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-in-responses) y devuelve los bloques `thinking` sin cambios.
* Para seguir ejecutando sin pensamiento inicial, envía [la configuración de pensamiento más baja](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) con esfuerzo `high` o inferior.
* Reemplaza el [uso forzado de herramientas](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#forced-tool-use) por `auto` y herramientas estrictas, o por `auto` solo en Amazon Bedrock.
* Mantén las conversaciones [solo de anexado](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-blocks).
* En la API de Claude y Google Cloud, migra el uso de computadora al [toolset](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#computer-use-toolset), sin el encabezado beta `fine-grained-tool-streaming-2025-05-14`.
* Combina la [herramienta advisor](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#advisor-tool) con un asesor compatible y espera consejos cifrados.
* Lee el [texto entre llamadas a herramientas](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#text-between-tool-calls) desde los bloques `thinking`.
* [Maneja los rechazos](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback) y configura el fallback.
* [Vuelve a ejecutar tu barrido de esfuerzo](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#recommended-changes) y restablece la línea base de costos.

### Claude Sonnet 4.6 o anterior

* Espera [pensamiento en las solicitudes sin campo `thinking`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-on-by-default) y revisa `max_tokens`.
* Reemplaza los [presupuestos de pensamiento](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) por un nivel de esfuerzo.
* Elimina los valores no predeterminados de `temperature`, `top_p` y `top_k`.
* Si [muestras el texto del pensamiento](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-in-responses), establece `display: "summarized"`.
* [Vuelve a contar los tokens](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6) y vuelve a presupuestar los tokens de imagen.

### Claude Sonnet 4.5 o anterior

* Reemplaza los [prefills del asistente](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45).
* Analiza la entrada de las llamadas a herramientas con un analizador JSON estándar.
* En Amazon Bedrock, migra el uso de computadora de `computer_20250124` a [`computer_20251124`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#computer-use-toolset).
* Establece `output_config.effort` explícitamente.
* Elimina cualquier encabezado beta de ventana de contexto.
* Elimina `interleaved-thinking-2025-05-14` y reemplaza `fine-grained-tool-streaming-2025-05-14` por `eager_input_streaming`.
* Mueve `output_format` a `output_config.format`.

### Claude Sonnet 4 o anterior

* Actualiza las [versiones de herramientas](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) a `text_editor_20250728` y `code_execution_20260521`.
* Gestiona los motivos de detención `refusal` y `model_context_window_exceeded`.
* Revisa los parámetros de cadena de las herramientas en busca de saltos de línea finales.
* Elimina `token-efficient-tools-2025-02-19` y `output-128k-2025-02-19`.
* Revisa tus prompts.

### Solo Claude Haiku 4.5

* Reemplaza [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) o su alias.
* Restablece la línea base de costos con el precio por token más alto.
* Revisa los prompts que eran demasiado cortos para almacenarse en caché en Claude Haiku 4.5.

## Migrar a Claude Sonnet 5.5 desde Claude Sonnet 5

Todos los modelos de partida necesitan los cambios de esta sección. Reemplaza tu ID de modelo por `claude-sonnet-5-5`, que no tiene sufijo de fecha. En otras plataformas, usa el ID indicado en [Disponibilidad](https://platform.claude.com/docs/es/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### El uso forzado de herramientas no es compatible

Todos los modelos anteriores de esta página aceptan un `tool_choice` de tipo `any` o `tool`. Claude Sonnet 5.5 rechaza ambos con un error 400, incluso en el endpoint de [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting):

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

Envía `tool_choice: {"type": "auto"}` y marca la herramienta con `strict: true` para que su entrada coincida con el esquema. El modelo puede entonces responder sin llamar a la herramienta, así que indica en el prompt cuándo usarla. El [uso estricto de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/strict-tool-use) admite un subconjunto de JSON Schema y necesita `additionalProperties: false` en cada objeto. Consulta [Limitaciones de JSON Schema](https://platform.claude.com/docs/es/build-with-claude/structured-outputs#json-schema-limitations). En Amazon Bedrock, las ["structured outputs" (salidas estructuradas)](https://platform.claude.com/docs/es/build-with-claude/structured-outputs), que incluyen el uso estricto de herramientas, no están disponibles para Claude Sonnet 5.5. Allí, envía `auto` sin `strict`, indica en el prompt cuándo llamar a la herramienta y valida la entrada de la herramienta en tu código.

Antes (Claude Sonnet 5):

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

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

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

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

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

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

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

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

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

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

Después (Claude Sonnet 5.5):

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

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
      # uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
      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,
      # uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
      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,
    // uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
    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,
      // uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
      Tools = [.. tools.Select(tool => tool with { Strict = true })],
      ToolChoice = new ToolChoiceAuto(),
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = "What's the weather in Paris? Use the get_weather tool.",
          },
      ],
  });
  ```

  ```go Go
  // uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
  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)
      // uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
      .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,
      // uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
      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,
    # uso de herramientas estricto: cada llamada coincide con el input_schema de la herramienta
    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>

El ejemplo marca como estrictas todas las herramientas de la lista. Una solicitud puede tener como máximo 20 herramientas estrictas, y las entradas de los conjuntos de herramientas de MCP, uso de computadora y uso de navegador no aceptan `strict`. En una lista de herramientas más larga, marca solo las herramientas que lo necesiten.

### Los bloques de pensamiento están vinculados al modelo y a la conversación

Claude Sonnet 5.5 lee bloques de pensamiento de Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 y modelos anteriores, y, en la API de Claude y Google Cloud, de Claude Haiku 5.5. No lee bloques de Claude Opus 5, Claude Opus 5.5 ni de ningún modelo Claude Fable o Claude Mythos. La API descarta los bloques que el modelo no puede leer. La solicitud sigue devolviendo 200, y los bloques descartados no se facturan. Consulta [Cambiar de modelo a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#switching-models).

Cada bloque de pensamiento de Claude Sonnet 5.5 también está firmado sobre la conversación que lo precede. Para las cuentas creadas a partir del 31 de agosto de 2026, 00:00 UTC, la API aplica esto de forma predeterminada, en la API de Claude, Amazon Bedrock y Google Cloud. En esas cuentas, una solicitud que reproduce un bloque después de una edición del historial anterior devuelve un error 400. Mantén las conversaciones solo de anexado y cambia las instrucciones o las herramientas con [mensajes del sistema a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages). Los bloques de pensamiento que produce Claude Sonnet 5.5 funcionan solo en la cuenta que los produjo o en una cuenta vinculada a ella. Consulta [Pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#account-bound-thinking).

### El uso de computadora requiere el conjunto de herramientas en la API de Claude y Google Cloud

En la API de Claude y Google Cloud, Claude Sonnet 5.5 admite el uso de computadora solo a través del conjunto de herramientas `computer_toolset_20260801`. Allí, `computer_20251124` devuelve un error 400. Claude Sonnet 5.5 no acepta `computer_20250124` en ninguna plataforma. Busca la versión que envías actualmente:

| Versión que envías actualmente | Modelos de partida que la envían                     | Qué enviar en la API de Claude y Google Cloud | Qué enviar en Amazon Bedrock |
| ------------------------------ | ---------------------------------------------------- | --------------------------------------------- | ---------------------------- |
| `computer_20251124`            | Claude Sonnet 5, Claude Sonnet 4.6                   | `computer_toolset_20260801`                   | `computer_20251124`          |
| `computer_20250124`            | Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 | `computer_toolset_20260801`                   | `computer_20251124`          |

Si envías el encabezado beta `fine-grained-tool-streaming-2025-05-14`, elimínalo cuando migres al conjunto de herramientas. Junto a una entrada de conjunto de herramientas, devuelve un error 400. En su lugar, establece `eager_input_streaming: true` en cada herramienta que lo necesite.

El código que ya envía el conjunto de herramientas no necesita cambios. [Migrar desde `computer_20251124`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) enumera los cambios en la solicitud y en el bucle del agente. Para otras plataformas, consulta [Compatibilidad](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#compatibility).

### La herramienta advisor acepta menos asesores

Con la [herramienta advisor](https://platform.claude.com/docs/es/agents-and-tools/tool-use/advisor-tool), un ejecutor Claude Sonnet 5.5 necesita uno de estos asesores: Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5, Claude Fable 5.1, Claude Mythos 5 o Claude Mythos 5.1. Los asesores Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6 y Claude Haiku 5.5 devuelven un error 400. El consejo llega cifrado como un bloque `advisor_redacted_result`, por lo que su texto no es legible en la respuesta. Consulta [Compatibilidad de modelos](https://platform.claude.com/docs/es/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### El texto entre llamadas a herramientas se devuelve en bloques de pensamiento

En Claude Sonnet 5.5, las notas de más de una o dos oraciones que el modelo escribe entre llamadas a herramientas llegan como [bloques `thinking` de actualización de progreso](https://platform.claude.com/docs/es/build-with-claude/thinking#progress-updates), vacíos con el `display` predeterminado. Los comentarios más cortos siguen siendo `text`. En Claude Sonnet 5 y modelos anteriores, todo el texto entre llamadas a herramientas llega como bloques `text`. Ninguna solicitud falla, pero una interfaz que muestra esas notas se queda en silencio.

Con pensamiento adaptativo, establece `display` en `"updates"` (beta, encabezado `thinking-display-updates-2026-08-18`) para obtener solo las actualizaciones, o en `"summarized"` para obtenerlas mezcladas con el razonamiento. Renderiza cada bloque `thinking` no vacío antes del bloque `tool_use` que lo sigue. Con [`between_tools`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), el texto llega sin `display`. Consulta [Actualizaciones de progreso para el usuario](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Clasificadores de seguridad y respaldo

Claude Sonnet 5.5 rechaza solicitudes en más categorías que Claude Sonnet 5. Un rechazo devuelve `stop_reason: "refusal"`, y su `stop_details` puede nombrar una de estas [categorías](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#refusal-response):

* **`"cyber"`:** La solicitud podría facilitar daños cibernéticos, como el desarrollo de malware o exploits.
* **`"bio"`:** La solicitud podría facilitar daños biológicos, como métodos de laboratorio peligrosos.
* **`"frontier_llm"`:** La solicitud podría ayudar al desarrollo de modelos de IA competidores.
* **`"reasoning_extraction"`:** La solicitud pide al modelo que reproduzca su razonamiento interno en el texto de la respuesta.
* **`"general_harms"`:** La solicitud corresponde a otra área de la política de uso. El trabajo benigno también puede activar esta categoría.

El [respaldo del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`, beta, solo en la API de Claude) reintenta los rechazos `"cyber"` y `"frontier_llm"` en Claude Sonnet 5. No reintenta los rechazos `"bio"`, `"reasoning_extraction"` ni `"general_harms"`. Consulta [Rechazos y respaldo](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback) y [Cómo se facturan los rechazos](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Las salvaguardas cibernéticas en tiempo real son nuevas para el código que proviene de Claude Sonnet 4.6, Claude Sonnet 4.5 y Claude Haiku 4.5. Para trabajo de seguridad legítimo, solicita acceso al [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Otros cambios

* **"Prompt caching" (almacenamiento en caché de prompts):** El prompt mínimo almacenable en caché es de 512 tokens, frente a 1,024 en Claude Sonnet 5, Claude Sonnet 4.6 y Claude Sonnet 4.5. Consulta [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#cache-limitations).
* **Nuevas funciones:** Para los mensajes del sistema a mitad de la conversación, los cambios de herramientas a mitad de la conversación y el esfuerzo por mensaje, consulta [Novedades de Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). Con [`between_tools`](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), el esfuerzo no puede cambiar a mitad de la conversación.

### Cambios recomendados

Vuelve a ejecutar tu barrido de esfuerzo. Claude Sonnet 5.5 tiene cinco niveles de esfuerzo: `low`, `medium`, `high`, `xhigh` y `max`. El valor predeterminado en la API de Claude es `high`. Los niveles se han recalibrado, por lo que un nivel no produce la misma cantidad de pensamiento que en Claude Sonnet 5. Comienza con `high`, a menos que tu carga de trabajo sea agéntica o sensible a la "latency" (latencia). Para programación agéntica y uso de herramientas de varios pasos, comienza con `medium` para tareas bien especificadas y pasa a `high` para las más difíciles o largas. Para chat y otros trabajos sensibles a la latencia, comienza con `medium` o `low`. Establece el nivel en `output_config.effort`. Consulta [Niveles de esfuerzo recomendados para Claude Sonnet 5.5](https://platform.claude.com/docs/es/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Luego, vuelve a evaluar las instrucciones de prompt específicas del modelo con respecto a [Prompting para Claude Sonnet 5.5](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Migrar a Claude Sonnet 5.5 desde Claude Sonnet 4.6 y modelos Sonnet anteriores

Primero aplica todas las secciones anteriores, reemplazando `claude-sonnet-4-6`. Luego realiza estos cambios. En Claude Sonnet 4.5 o anterior, continúa con las subsecciones que siguen.

### Cambios incompatibles

**El pensamiento se ejecuta en las solicitudes que lo omitían.** Consulta [El pensamiento se ejecuta de forma predeterminada](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-on-by-default) y [Desactiva el pensamiento inicial](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**Los presupuestos de pensamiento devuelven un error.** Claude Sonnet 4.6 acepta `thinking: {"type": "enabled", "budget_tokens": N}` como configuración obsoleta. Claude Sonnet 4.5 y Claude Haiku 4.5 lo usan para todo el pensamiento. Claude Sonnet 5.5 devuelve un 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.
```

Elimina el presupuesto y establece un nivel de [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort). No existe una correspondencia fija entre un presupuesto y un nivel de esfuerzo, así que ejecuta tus evaluaciones en dos o tres niveles.

Antes (Claude Sonnet 4.6):

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

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

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

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

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

  AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

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

Después (Claude Sonnet 5.5):

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

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

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

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

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

  AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

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

**Los parámetros de muestreo devuelven un error.** Claude Sonnet 4.6 y modelos anteriores, y Claude Haiku 4.5, aceptan `temperature`, `top_p` y `top_k`. En Claude Sonnet 5.5, un valor no predeterminado devuelve un error 400. Elimínalos.

**El texto del pensamiento se omite de forma predeterminada.** Consulta [Gestiona el pensamiento en las respuestas](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Otros cambios

* **Alrededor de un 30 % más de tokens:** Claude Sonnet 5.5 usa el tokenizador de Claude Sonnet 5. En comparación con Claude Sonnet 4.6, Claude Sonnet 4.5 y Claude Haiku 4.5, el mismo texto produce alrededor de un 30 % más de tokens, según el contenido. Vuelve a contarlos con el [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting) y revisa `max_tokens` y el costo.
* **Esfuerzo:** `xhigh` es nuevo, y los niveles se han recalibrado. Consulta [Cambios recomendados](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#recommended-changes).
* **Imágenes:** Claude Sonnet 5.5 usa el nivel de imagen de alta resolución, de hasta 2576 píxeles en el lado largo y 4,784 tokens visuales por imagen. Claude Sonnet 4.6, Claude Sonnet 4.5 y Claude Haiku 4.5 se limitan a 1568 píxeles y 1,568 tokens. Una imagen de 2000×1500 cuesta alrededor de 2.5 veces más tokens en Claude Sonnet 5.5. Consulta [Resolución y costo en tokens](https://platform.claude.com/docs/es/build-with-claude/vision#evaluate-image-size).

### Migrar desde Claude Sonnet 4.5 o anterior

En Claude Sonnet 4.5, Claude Sonnet 4 o Claude 3.7 Sonnet, primero aplica todas las secciones anteriores y luego estos cambios.

**El prefill devuelve un error.** Claude Sonnet 5.5 rechaza con un error 400 un último turno del asistente con prefill, al igual que Claude Sonnet 4.6 y Claude Sonnet 5. Claude Sonnet 4.5, Claude Haiku 4.5 y los modelos más antiguos lo aceptan. El error dice:

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

Reemplaza cada prefill según su propósito:

* **Formato de salida:** usa [salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs), o herramientas con campos enum para la clasificación. En Amazon Bedrock, las salidas estructuradas no están disponibles para Claude Sonnet 5.5. Allí, describe el formato en el prompt o usa una herramienta sin `strict`, y valida la salida en tu código.
* **Preámbulos:** pide en la indicación del sistema una respuesta directa.
* **Rechazos no deseados:** las instrucciones claras en el mensaje del usuario suelen ser suficientes.
* **Continuaciones:** trasládalas al mensaje del usuario, por ejemplo "Tu respuesta anterior se interrumpió y terminó con `[previous_response]`. Continúa desde donde lo dejaste."
* **Recordatorios de contexto:** colócalos en el turno del usuario.

**Escape en la entrada de herramientas.** El escape en los argumentos de las llamadas a herramientas puede diferir. Analiza `input` con un analizador JSON estándar.

**Uso de computadora.** Claude Sonnet 5.5 no acepta `computer_20250124`. Consulta la [tabla de uso de computadora](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Esfuerzo.** Claude Sonnet 4.5 no tiene parámetro de esfuerzo. Establece un nivel de esfuerzo explícitamente, como se describe en [Cambios recomendados](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#recommended-changes).

**Contexto y salida.** Claude Sonnet 5.5 tiene una ventana de contexto más grande, sin encabezado beta, y un límite de salida más alto. Consulta la [página del modelo](https://platform.claude.com/docs/es/models/sonnet-5-5/overview). Elimina cualquier encabezado beta de ventana de contexto.

**Encabezados beta.** Elimina `interleaved-thinking-2025-05-14`, ya que el pensamiento adaptativo se intercala automáticamente. Reemplaza `fine-grained-tool-streaming-2025-05-14` por `eager_input_streaming: true` en cada herramienta que lo necesite. Ese encabezado devuelve un error 400 junto con una entrada de conjunto de herramientas de uso de computadora o de uso de navegador. Consulta [Streaming de herramientas detallado](https://platform.claude.com/docs/es/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Salidas estructuradas.** El parámetro `output_format` está obsoleto y se eliminará en el futuro. Para usarlo de todos modos, agrega el encabezado beta `structured-outputs-2025-11-13`. Sin él, la API devuelve un error 400. Usa `output_config.format` en su lugar.

### Migrar desde Claude Sonnet 4 o anterior

Claude Sonnet 4 está retirado en la API de Claude y sigue disponible en Amazon Bedrock y Google Cloud. Claude 3.7 Sonnet está retirado. Desde cualquiera de los dos modelos, primero aplica todas las secciones anteriores y luego estos cambios:

* **Versiones de herramientas:** Usa `text_editor_20250728`, con el nombre de herramienta `str_replace_based_edit_tool` y sin el comando `undo_edit`. Usa `code_execution_20260521`. Consulta la [herramienta de editor de texto](https://platform.claude.com/docs/es/agents-and-tools/tool-use/text-editor-tool) y la [herramienta de ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Motivos de detención:** Gestiona `refusal`. Claude 4.5 y los modelos posteriores también se detienen con `model_context_window_exceeded` al alcanzar el límite de la ventana de contexto. Consulta [Gestionar los motivos de detención](https://platform.claude.com/docs/es/build-with-claude/handling-stop-reasons).
* **Saltos de línea finales:** Claude 4.5 y los modelos posteriores los conservan en los parámetros de cadena de las llamadas a herramientas.
* **Encabezados beta heredados:** Elimina `token-efficient-tools-2025-02-19` y `output-128k-2025-02-19`.
* **Prompts:** Revísalos con respecto a las [mejores prácticas de prompting](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Migrar a Claude Sonnet 5.5 desde Claude Haiku 4.5

Primero aplica todas las secciones hasta [Migrar desde Claude Sonnet 4.5 o anterior](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), inclusive, omitiendo la subsección de Claude Sonnet 4. Luego realiza estos cambios:

* **ID del modelo:** Reemplaza `claude-haiku-4-5-20251001`, o el alias `claude-haiku-4-5`, por `claude-sonnet-5-5`.
* **Costo:** El precio por token es más alto, y el mismo texto produce más tokens. Vuelve a contar los tokens y restablece la línea base de costos. Consulta [Precios de Claude](https://platform.claude.com/docs/es/about-claude/pricing).
* **Almacenamiento en caché de prompts:** El prompt mínimo almacenable en caché baja de 4,096 tokens al [mínimo de Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Pensamiento intercalado:** El pensamiento adaptativo se ejecuta automáticamente entre llamadas a herramientas, sin encabezado beta.
* **Enrutamiento:** Claude Sonnet 5.5 lee los bloques de pensamiento de Claude Haiku 4.5. Una conversación que sube de modelo conserva su razonamiento. Una que vuelve a bajar a Claude Haiku 4.5 descarta los bloques de Claude Sonnet 5.5.