---
title: Claude Models on Google Cloud (Google managed)
url: https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed
description: Google opera Claude Models on Google Cloud (Google managed) como parte de Google Cloud's Agent Platform. Puedes llamar a Claude con los SDK de cliente de Anthropic.
---

[Claude Models on Google Cloud](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/overview) compara las dos ofertas de Google Cloud. También muestra cómo saber cuál usas.

## Antes de hacer llamadas a la API

Para usar Claude Models on Google Cloud (Google managed), necesitas:

1. Un proyecto de Google Cloud que pueda usar Agent Platform. Para conocer los pasos de configuración, consulta la página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) de Google Cloud.
2. La [gcloud CLI](https://cloud.google.com/sdk/docs/install) instalada, para el desarrollo local.
3. Para la identidad que hace las llamadas, un rol de IAM que incluya el permiso `aiplatform.endpoints.predict`, como Agent Platform User (`roles/aiplatform.user`). Para obtener más detalles, consulta la página [Agent Platform partner models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/use-partner-models) de Google Cloud.
4. Credenciales de Google Cloud para esa identidad. Para los ejemplos del SDK, es posible que necesites ejecutar `gcloud auth application-default login` para autenticarte con Google Cloud. Los ejemplos de cURL para Claude Models on Google Cloud (Google managed) obtienen su token con `gcloud auth print-access-token`. Ese comando usa el inicio de sesión propio de la gcloud CLI, no las Application Default Credentials. Para esos ejemplos, ejecuta primero `gcloud auth login` o `gcloud init`.

### Instalar un SDK

Los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic admiten Claude Models on Google Cloud (Google managed) mediante `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Instala el paquete que lo proporciona:

<Tabs>
  <Tab title="Python">
    ```bash
    pip install -U "anthropic[vertex]"
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/vertex-sdk
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic.Vertex
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go
    ```
  </Tab>

  <Tab title="Java">
    <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:3.1.0")
      implementation("com.anthropic:anthropic-java-vertex:3.1.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>3.1.0</version>
      </dependency>
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java-vertex</artifactId>
          <version>3.1.0</version>
      </dependency>
      ```
    </CodeGroup>
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require anthropic-ai/sdk google/auth
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "googleauth"
    ```
  </Tab>
</Tabs>

La CLI `ant` no admite Claude Models on Google Cloud (Google managed).

## Hacer solicitudes

Las solicitudes a Claude Models on Google Cloud (Google managed) van a una URL de endpoint de Agent Platform que termina en `:rawPredict`. Las solicitudes de streaming usan `:streamRawPredict` en su lugar.

Una solicitud es casi idéntica a una solicitud de la [Messages API](https://platform.claude.com/docs/es/api/messages/create). Se diferencia en dos aspectos principales:

* **Modelo:** La URL del endpoint nombra el modelo. En una solicitud cURL, omite `model` del cuerpo.
* **Versión:** En una solicitud cURL, pasa `anthropic_version` en el cuerpo, no como encabezado. Establécelo en `vertex-2023-10-16` o en la [versión de API `2026-10-21`](https://platform.claude.com/docs/es/api/migration-2026-10-21).

Los siguientes ejemplos usan el endpoint global. Para los otros tipos de endpoint, consulta [Endpoints globales, multirregionales y regionales](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "anthropic_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Claude!"}],
      "max_tokens": 100
    }'
  ```

  <CodeGroupItem language="CLI">
    La CLI `ant` no admite Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "global"

  client = AnthropicVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Claude!",
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "global";

  // Pasa por el flujo estándar de `google-auth-library`.
  const client = new AnthropicVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Claude!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));
  ```

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

  var projectId = "MY_PROJECT_ID";
  var region = "global";

  var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 100,
      Messages = [new UserMessageParam { Content = "Hey Claude!" }]
  };

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

  ```go Go
  import (
  	"context"
  	"fmt"

  	"github.com/anthropics/anthropic-sdk-go"
  	"github.com/anthropics/anthropic-sdk-go/vertex"
  )
  // ...
  	// Usa las credenciales predeterminadas de Google Cloud
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 100,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.Message;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;
  import com.anthropic.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("global")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      Message message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Claude!")
                  .build()
          );

      IO.println(message);
  }
  ```

  ```php PHP
  <?php

  use Anthropic\Messages\TextBlock;
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'global',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Claude!']
      ],
      model: 'claude-opus-5-5',
  );

  foreach ($message->content as $block) {
      if ($block instanceof TextBlock) {
          echo $block->text . PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "global",
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Claude!"}]
  )

  puts message.content.find { it.type == :text }.text
  ```
</CodeGroup>

### IDs de modelo de la API

| Model                                                                                                 | Agent Platform API model ID  |
| :---------------------------------------------------------------------------------------------------- | :--------------------------- |
| Claude Fable 5.1                                                                                      | `claude-fable-5-1`           |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842))           | `claude-mythos-5-1`          |
| Claude Fable 5                                                                                        | `claude-fable-5`             |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))             | `claude-mythos-5`            |
| Claude Opus 5.5                                                                                       | `claude-opus-5-5`            |
| Claude Opus 5                                                                                         | `claude-opus-5`              |
| Claude Opus 4.8                                                                                       | `claude-opus-4-8`            |
| Claude Opus 4.7                                                                                       | `claude-opus-4-7`            |
| Claude Opus 4.6                                                                                       | `claude-opus-4-6`            |
| Claude Opus 4.5                                                                                       | `claude-opus-4-5@20251101`   |
| Claude Opus 4.1 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))   | `claude-opus-4-1@20250805`   |
| Claude Opus 4 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))     | `claude-opus-4@20250514`     |
| Claude Sonnet 5.5                                                                                     | `claude-sonnet-5-5`          |
| Claude Sonnet 5                                                                                       | `claude-sonnet-5`            |
| Claude Sonnet 4.6                                                                                     | `claude-sonnet-4-6`          |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations)) | `claude-sonnet-4-5@20250929` |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))   | `claude-sonnet-4@20250514`   |
| Claude Haiku 5.5                                                                                      | `claude-haiku-5-5`           |
| Claude Haiku 4.5                                                                                      | `claude-haiku-4-5@20251001`  |
| Claude Haiku 3.5 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))  | `claude-3-5-haiku@20241022`  |

Claude Models on Google Cloud (Google managed) ofrece diferentes modelos de Claude en diferentes regiones. Para comprobar qué modelos ofrece una región, busca "Claude" en [Model Garden](https://cloud.google.com/model-garden) o consulta la página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) de Google Cloud.

Google establece las fechas del ciclo de vida de los modelos que sirve Claude Models on Google Cloud (Google managed). Estas fechas pueden diferir del calendario de la Claude API. Para conocer la fecha de retiro actual de un modelo, consulta la página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) de Google Cloud. Para saber qué significan Obsoleto y Retirado, consulta [Obsolescencia de modelos](https://platform.claude.com/docs/es/about-claude/model-deprecations).

<Note>
  Claude Mythos Preview es una versión preliminar de investigación. Claude Models on Google Cloud (Google managed) la ofrece a clientes invitados. Para obtener más información, consulta [Project Glasswing](https://anthropic.com/glasswing).
</Note>

<Tip>
  ¿Estás actualizando a un modelo de Claude más reciente? 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) en Claude Code aplica los cambios de ID de modelo y los cambios de parámetros incompatibles en toda tu base de código:

  Deja que Claude Code migre tu código por ti

  ```text
  /claude-api migrate este proyecto al modelo Claude Opus más reciente
  ```

  La skill detecta a qué plataforma en la nube apunta tu código y ajusta los formatos de ID de modelo y los cambios de funcionalidades para esa plataforma.
</Tip>

## Endpoints globales, multirregionales y regionales

Claude Models on Google Cloud (Google managed) ofrece tres tipos de endpoint. Eliges uno con el valor de región que pasas al crear el cliente. En una solicitud cURL, el tipo de endpoint establece el host y el segmento `locations` de la URL.

| Tipo de endpoint         | Valor de región               | Host                                                                       |
| ------------------------ | ----------------------------- | -------------------------------------------------------------------------- |
| **Global** (recomendado) | `"global"`                    | `aiplatform.googleapis.com`                                                |
| **Multirregional**       | `"us"` o `"eu"`               | `aiplatform.us.rep.googleapis.com`<br />`aiplatform.eu.rep.googleapis.com` |
| **Regional**             | Una región, como `"us-east5"` | `{region}-aiplatform.googleapis.com`                                       |

Los tipos de endpoint difieren en adónde envían las solicitudes:

* **Global:** Las solicitudes van a cualquier región con capacidad disponible. Úsalo cuando quieras la máxima disponibilidad y la residencia de datos sea flexible.
* **Multirregional:** Las solicitudes van a cualquier región de los Estados Unidos (`"us"`) o de la Unión Europea (`"eu"`). Úsalo cuando necesites residencia de datos dentro de una geografía amplia y mayor disponibilidad que la de una sola región.
* **Regional:** Las solicitudes van solo a la región que indiques, como `"us-east5"` o `"europe-west1"`. Úsalo cuando necesites residencia de datos en una sola región o debas cumplir requisitos de cumplimiento normativo estrictos.

Los endpoints multirregionales y regionales cuestan un 10% más que los endpoints globales. Los tres tipos de endpoint aceptan tráfico de pago por uso, y el rendimiento aprovisionado requiere un endpoint regional.

Los endpoints regionales sirven solo Claude Sonnet 4.6 y modelos anteriores. Para modelos más recientes, usa un endpoint global o multirregional.

<Note>
  El recargo por los endpoints multirregionales y regionales se aplica solo a Claude Sonnet 4.5 (obsoleto) y modelos posteriores. Para los modelos que mantienen sus precios anteriores, consulta [Precios de plataformas en la nube](https://platform.claude.com/docs/es/about-claude/pricing#cloud-platform-pricing). Para los endpoints regionales, el recargo refleja los costos de infraestructura de la capacidad regional dedicada.
</Note>

Los siguientes ejemplos usan el endpoint multirregional `us`. Las líneas resaltadas establecen la región. Para ver una solicitud completa en el endpoint global, consulta [Hacer solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai).

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  # El identificador multirregión, "us" o "eu", aparece en el nombre de host y en la ruta
  curl https://aiplatform.us.rep.googleapis.com/v1/projects/MY_PROJECT_ID/locations/us/publishers/anthropic/models/claude-opus-5-5:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "anthropic_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Claude!"}],
      "max_tokens": 100
    }'
  ```

  <CodeGroupItem language="CLI">
    La CLI `ant` no admite Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "us"  # Multi-region identifier: "us" or "eu"

  client = AnthropicVertex(project_id=project_id, region=region)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "us"; // Multi-region identifier: "us" or "eu"

  const client = new AnthropicVertex({
    projectId,
    region
  });
  ```

  ```csharp C#
  using Anthropic.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "us"; // Multi-region identifier: "us" or "eu"

  var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
  ```

  ```go Go
  import (
  	"context"

  	"github.com/anthropics/anthropic-sdk-go"
  	"github.com/anthropics/anthropic-sdk-go/vertex"
  )
  // ...
  	// Identificador multirregión: "us" o "eu"
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us", "MY_PROJECT_ID"),
  	)
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Identificador multirregión: "us" o "eu"
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();
  }
  ```

  ```php PHP
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'us', // Multi-region identifier: "us" or "eu"
      projectId: 'MY_PROJECT_ID',
  );
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "us", # Multi-region identifier: "us" or "eu"
    project_id: "MY_PROJECT_ID"
  )
  ```
</CodeGroup>

## Compatibilidad de funciones

Las funciones compatibles con Claude Models on Google Cloud (Google managed) incluyen las siguientes:

* [Messages API](https://platform.claude.com/docs/es/api/messages/create)

* ["Prompt caching" (almacenamiento en caché de prompts)](https://platform.claude.com/docs/es/build-with-claude/prompt-caching)

* [Pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking)

* ["Tool use" (uso de herramientas)](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview), incluidas estas herramientas:

  * [Herramienta Bash](https://platform.claude.com/docs/es/agents-and-tools/tool-use/bash-tool)
  * [Herramienta de uso del navegador](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-tool)
  * [Herramienta de uso de computadora](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool)
  * [Herramienta de memoria](https://platform.claude.com/docs/es/agents-and-tools/tool-use/memory-tool)
  * [Herramienta de editor de texto](https://platform.claude.com/docs/es/agents-and-tools/tool-use/text-editor-tool)
  * [Herramienta de búsqueda web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-search-tool)

* [Citas](https://platform.claude.com/docs/es/build-with-claude/citations)

* [Salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs)

La [descripción general de funciones](https://platform.claude.com/docs/es/build-with-claude/overview) enumera todas las funciones e indica si Claude Models on Google Cloud (Google managed) las admite.

### Funciones no compatibles

Claude Models on Google Cloud (Google managed) no admite lo siguiente:

* **Fuentes de entrada:** Fuentes URL para imágenes y documentos, y la Files API
* **Herramientas del lado del servidor:** Ejecución de código, obtención web y asesor
* **Infraestructura de agentes:** Agent Skills, conector MCP y llamada programática de herramientas
* **Endpoints de la API:** Message Batches API, Models API, Admin API, Compliance API y Usage and Cost API
* **Claude Managed Agents**
* **Respaldo del lado del servidor:** El [parámetro `fallbacks`](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback)

En lugar del respaldo del lado del servidor, usa el [patrón de respaldo del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#client-side-fallback).

### Ventana de contexto

Claude Models on Google Cloud (Google managed) ofrece una ["context window" (ventana de contexto) de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) para estos modelos:

* Claude Fable 5.1
* Claude Fable 5
* Claude Opus 5.5
* Claude Opus 5
* Claude Opus 4.8
* Claude Opus 4.7
* Claude Opus 4.6
* Claude Sonnet 5.5
* Claude Sonnet 5
* Claude Sonnet 4.6
* Claude Haiku 5.5

Otros modelos de Claude tienen una ventana de contexto de 200k tokens. Entre ellos se incluyen Claude Sonnet 4.5 (obsoleto) y Claude Sonnet 4 (obsoleto).

Agent Platform limita las cargas útiles de las solicitudes a 30 MB. Cuando envías documentos grandes o muchas imágenes, es posible que alcances este límite antes que el límite de tokens.

## Facturación, límites de velocidad y registro

### Límites de velocidad

Google Cloud administra los "rate limits" (límites de velocidad) y las cuotas de Claude Models on Google Cloud (Google managed). Para obtener más detalles, incluido cómo solicitar un aumento de cuota, consulta la página [Quotas for Anthropic Claude models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude/quotas) de Google Cloud.

### Facturación

Google Cloud te factura por Claude Models on Google Cloud (Google managed). Para conocer los precios, consulta la página [Generative AI pricing](https://cloud.google.com/vertex-ai/generative-ai/pricing#claude-models) de Google Cloud. Los precios también dependen del tipo de endpoint. Consulta [Endpoints globales, multirregionales y regionales](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

### Retención de datos

Google Cloud rige el manejo de datos de Claude Models on Google Cloud (Google managed). Para obtener más detalles, consulta [Agent Platform y retención cero de datos](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance).

### Monitoreo y registro

Para registrar prompts y respuestas de Claude Models on Google Cloud (Google managed), usa el [servicio de registro de solicitudes y respuestas](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/request-response-logging) de Agent Platform.

Anthropic recomienda que conserves al menos los últimos 30 días de registros. Los registros te ayudan a comprender tu actividad e investigar posibles usos indebidos.

<Note>
  Activar este servicio no le da a Google ni a Anthropic ningún acceso a tu contenido.
</Note>

## Migrar desde Claude Models on Google Cloud (Anthropic managed)

Para saber qué cambia al migrar, consulta [En qué se diferencian las dos ofertas de Google Cloud](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ). Para migrar a Claude Models on Google Cloud (Google managed), sigue estos pasos:

<Steps>
  <Step title="Configura el acceso">
    Comprueba que tu proyecto y la identidad que hace las llamadas cumplan los requisitos de [Antes de hacer llamadas a la API](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#before-making-api-calls).
  </Step>

  <Step title="Instala el paquete del SDK">
    Instala el paquete que proporciona el cliente para Claude Models on Google Cloud (Google managed). Consulta [Instalar un SDK](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#install-an-sdk-for-accessing-vertex-ai).
  </Step>

  <Step title="Reemplaza la importación y el cliente">
    Cambia el código que importa y crea tu cliente. Usa `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`) en lugar de `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Una solicitud cURL necesita una nueva URL, nuevos encabezados y un nuevo cuerpo. El siguiente código crea el cliente para Claude Models on Google Cloud (Anthropic managed) que usas actualmente:

    <CodeGroup>
      ```bash cURL
      curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        -H "content-type: application/json" \
        -H "anthropic-version: 2023-06-01" \
        -d '{
          "model": "claude-opus-5-5",
          "max_tokens": 1024,
          "messages": [
            {"role": "user", "content": "Hello, Claude"}
          ]
        }'
      ```

      ```bash CLI
      ant messages create \
        --model claude-opus-5-5 \
        --max-tokens 1024 \
        --message '{role: user, content: "Hello, Claude"}'
      ```

      ```python Python
      from anthropic import AnthropicGoogleCloud

      client = AnthropicGoogleCloud()
      ```

      ```typescript TypeScript
      import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";

      const client = new AnthropicGoogleCloud();
      ```

      ```csharp C#
      using Anthropic.GoogleCloud;

      var client = new AnthropicGoogleCloudClient();
      ```

      ```go Go
      import (
      	"context"

      	"github.com/anthropics/anthropic-sdk-go"
      	"github.com/anthropics/anthropic-sdk-go/googlecloud"
      )
      // ...
      	client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
      	if err != nil {
      		panic(err)
      	}
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.googlecloud.backends.GoogleCloudBackend;

      void main() {
          AnthropicClient client = AnthropicOkHttpClient.builder()
              .backend(GoogleCloudBackend.fromEnv())
              .build();
      }
      ```

      ```php PHP
      use Anthropic\GoogleCloud\Client;

      $client = new Client();
      ```

      ```ruby Ruby
      require "anthropic"

      client = Anthropic::GoogleCloudClient.new
      ```
    </CodeGroup>

    El siguiente código crea el cliente para Claude Models on Google Cloud (Google managed). Usa el endpoint global. Para los otros tipos de endpoint, consulta [Endpoints globales, multirregionales y regionales](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

    <CodeGroup exclude="shell:CLI">
      ```bash cURL
      curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json" \
        -d '{
          "anthropic_version": "vertex-2023-10-16",
          "messages": [{"role": "user", "content": "Hey Claude!"}],
          "max_tokens": 100
        }'
      ```

      <CodeGroupItem language="CLI">
        La CLI `ant` no admite Claude Models on Google Cloud (Google managed). Usa cURL o un SDK en su lugar.
      </CodeGroupItem>

      ```python Python
      from anthropic import AnthropicVertex

      project_id = "MY_PROJECT_ID"
      region = "global"

      client = AnthropicVertex(project_id=project_id, region=region)
      ```

      ```typescript TypeScript
      import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

      const projectId = "MY_PROJECT_ID";
      const region = "global";

      const client = new AnthropicVertex({
        projectId,
        region
      });
      ```

      ```csharp C#
      using Anthropic.Vertex;

      var projectId = "MY_PROJECT_ID";
      var region = "global";

      var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
      ```

      ```go Go
      import (
      	"context"

      	"github.com/anthropics/anthropic-sdk-go"
      	"github.com/anthropics/anthropic-sdk-go/vertex"
      )
      // ...
      	// Usa las credenciales predeterminadas de Google Cloud
      	client := anthropic.NewClient(
      		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
      	)
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.vertex.backends.VertexBackend;
      import com.google.auth.oauth2.GoogleCredentials;

      void main() throws Exception {
          AnthropicClient client = AnthropicOkHttpClient.builder()
              .backend(
                  VertexBackend.builder()
                      .googleCredentials(GoogleCredentials.getApplicationDefault())
                      .region("global")
                      .project("MY_PROJECT_ID")
                      .build()
              )
              .build();
      }
      ```

      ```php PHP
      use Anthropic\Vertex;

      $client = Vertex\Client::fromEnvironment(
          region: 'global',
          projectId: 'MY_PROJECT_ID',
      );
      ```

      ```ruby Ruby
      require "anthropic"

      client = Anthropic::VertexClient.new(
        region: "global",
        project_id: "MY_PROJECT_ID"
      )
      ```
    </CodeGroup>

    Este código pasa tu ID de proyecto y una región al crear el cliente. Reemplaza `MY_PROJECT_ID` con tu ID de proyecto. Las llamadas a la Messages API que haces con el cliente se mantienen igual. Las excepciones son los IDs de modelo y las funciones del siguiente paso.
  </Step>

  <Step title="Comprueba los IDs de modelo y las funciones">
    * **IDs de modelo:** Si usas un modelo anterior a Claude 4.6, reemplaza el guion antes de la fecha de la instantánea en su ID por `@`. Por ejemplo, `claude-haiku-4-5-20251001` se convierte en `claude-haiku-4-5@20251001`. Para conocer los modelos y sus IDs, consulta [IDs de modelo de la API](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#api-model-ids).
    * **Funciones:** Comprueba que las funciones que usa tu código no aparezcan en [Funciones no compatibles](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#features-not-supported).
  </Step>

  <Step title="Ejecuta una solicitud de prueba">
    Ejecuta la solicitud de [Hacer solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai) para comprobar que tu configuración funciona. Luego ejecuta tu propio código. Antes de mover el tráfico de producción, lee sobre los [límites de velocidad de Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits).
  </Step>
</Steps>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Descripción general de funciones" icon="stack" href="https://platform.claude.com/docs/es/build-with-claude/overview">
    Explora las funciones de Claude.
  </Card>

  <Card title="Modelos Anthropic Claude en Agent Platform" icon="book" href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude">
    Comprueba qué modelos de Claude ofrece cada región y sus fechas de retiro.
  </Card>

  <Card title="Documentación de Agent Platform" icon="book" href="https://cloud.google.com/vertex-ai/docs">
    Lee la documentación de Agent Platform de Google Cloud.
  </Card>

  <Card title="Endpoint global para modelos de Claude" icon="link" href="https://cloud.google.com/blog/products/ai-machine-learning/global-endpoint-for-claude-models-generally-available-on-vertex-ai">
    Lee la publicación del blog de Google Cloud sobre el endpoint global para modelos de Claude.
  </Card>
</CardGroup>