---
title: Claude Models on Google Cloud (Anthropic managed)
url: https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed
description: Claude Models on Google Cloud (Anthropic managed) es la API de Claude, operada por Anthropic y accesible a través de tu proyecto de Google Cloud.
---
Google Cloud gestiona el acceso y la facturación de Claude Models on Google Cloud (Anthropic managed). Para comparar las dos ofertas de Google Cloud, o para comprobar cuál usas, consulta [Claude Models on Google Cloud](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/overview).
## Configura tu cuenta
Para configurar tu cuenta de Claude Models on Google Cloud (Anthropic managed), necesitas lo siguiente:
* Permiso para comprar en Google Cloud Marketplace en tu cuenta de facturación
* Permiso para habilitar servicios en el proyecto
* Un [rol de IAM que te permita abrir la Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), que necesitas para el paso 4
Estos pasos crean una nueva organización de Anthropic para tu proyecto de Google Cloud. Es independiente de cualquier organización de Anthropic que tu empresa ya tenga. Eso incluye una organización de Claude Enterprise. Para migrar desde una organización existente, consulta [Migrar desde una organización de Anthropic existente](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#moving-from-an-existing-anthropic-organization).
Si tienes un descuento existente, contacta a tu representante de cuenta de Anthropic o de Google Cloud antes de comenzar estos pasos. Los descuentos no se pueden aplicar al uso pasado.
1. Abre [Google Cloud Marketplace](https://console.cloud.google.com/marketplace) y busca la ficha de **Claude Models on Google Cloud (Anthropic managed)**.
2. Elige **Subscribe** y completa el flujo de compra.
3. Vuelve a la ficha y elige **Manage on Console**. Esto abre la página de Claude en la consola de Google Cloud.
Para volver a la página de Claude más tarde, selecciona tu proyecto en la consola de Google Cloud. Luego ve a **Agent Platform > Models > Claude Platform** y elige **Anthropic managed**.
Habilita dos servicios en cada proyecto que llame a Claude Models on Google Cloud (Anthropic managed):
* `claude.googleapis.com` sirve la API de Claude Models on Google Cloud (Anthropic managed). Este servicio también define los permisos de IAM. Las llamadas fallan sin él.
* `anthropic-managed-claude.cloudpartnerservices.goog` es el servicio de Marketplace que atribuye el uso del proyecto a tu suscripción.
```bash CLI
gcloud services enable claude.googleapis.com \
anthropic-managed-claude.cloudpartnerservices.goog \
--project=my-project-id
```
Reemplaza `my-project-id` con el ID de tu proyecto.
También puedes habilitar ambos desde la página de Claude o desde **APIs & Services**. La habilitación es un paso único para cada proyecto. Para comprobar que ambos servicios están habilitados, ejecuta `gcloud services list --enabled --project=my-project-id` y busca ambos nombres.
1. En la página de Claude, elige **Activate**.
2. En el flujo de configuración de Anthropic, ingresa una dirección de correo electrónico de contacto.
3. Abre el enlace de configuración enviado a esa dirección.
4. Completa el nombre de la organización, el tipo de entidad, el país y el uso previsto.
5. Acepta los Términos de Servicio Comerciales y la Política de Uso de Anthropic.
La dirección de contacto se usa solo para la configuración y los avisos del servicio. Para saber cómo las personas abren la Claude Console después de la configuración, consulta [Usar la Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Cuando tu organización de Anthropic esté activa, el botón de la página de Claude cambia a **Open Claude Console**. Elígelo. Google Cloud verifica tu acceso de IAM. Luego redirige tu navegador a `platform.claude.com`. Habrás iniciado sesión en la nueva organización.
Mientras estés en la Claude Console, [busca tu ID de workspace](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) y cópialo. Todas las personas que llamen a Claude Models on Google Cloud (Anthropic managed) lo necesitan. Compártelo con tus desarrolladores.
Para agregar otro proyecto, repite estos pasos en ese proyecto, comenzando desde el paso 2.
### Solución de problemas de configuración de la cuenta
Si te encuentras con uno de los siguientes problemas mientras configuras Claude Models on Google Cloud (Anthropic managed), aplica su solución:
* **`gcloud services enable` no encuentra `anthropic-managed-claude.cloudpartnerservices.goog`:** Ejecuta el comando con la cuenta que completó la compra en Marketplace, o contacta a tu representante de cuenta de Anthropic.
* **Un error de permisos en tu primera llamada a la API:** Comprueba que `claude.googleapis.com` esté habilitado en el proyecto al que llamas. Comprueba que quien llama tenga `roles/claude.user` o `roles/claude.admin` en ese proyecto. Para saber qué permite cada rol, consulta [Roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles). Una nueva concesión o un servicio recién habilitado puede tardar un momento en aplicarse.
* **"Signed in as a different account" después de seguir el enlace de configuración:** Elige **Log out and continue**. Luego usa la dirección de correo electrónico que ingresaste en el paso 3.
* **El botón dice "Finish Setup" en lugar de "Open Claude Console":** Tu organización de Anthropic existe, pero su configuración no está completa. Un administrador tiene que terminar el formulario de detalles de la organización.
* **La página Usage no muestra datos después de tu primera llamada a la API:** Los datos de uso pueden tardar unos minutos en aparecer en la Claude Console.
## Gestiona el acceso
### Roles de IAM
Claude Models on Google Cloud (Anthropic managed) tiene tres roles de IAM predefinidos. Concede los roles en el proyecto.
| Rol | Nombre visible | Qué permite |
| --------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `roles/claude.viewer` | Claude Viewer | Todos los permisos `get` y `list` sobre los recursos del workspace
Este rol es de solo lectura. |
| `roles/claude.user` | Claude User | Todo lo que permite `roles/claude.viewer`, además de crear y modificar recursos del workspace
Esto incluye enviar mensajes y contar tokens. También incluye gestionar lotes, archivos, skills y recursos de Claude Managed Agents. |
| `roles/claude.admin` | Claude Admin | Todo lo que permite `roles/claude.user`, además de los permisos que se verifican en tu organización de Anthropic
Las rutas a nivel de organización actúan sobre tu organización de Anthropic en su conjunto, no sobre un solo workspace. |
Por ejemplo, el siguiente comando permite que una cuenta de servicio llame a Claude Models on Google Cloud (Anthropic managed):
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="serviceAccount:my-app@my-project-id.iam.gserviceaccount.com" \
--role="roles/claude.user"
```
Para conocer los permisos, los roles predefinidos y los tipos de registros de auditoría, consulta [Permisos de IAM para Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
Habilitar `claude.googleapis.com` crea un agente de servicio para el proyecto. No elimines sus concesiones de roles. Eliminarlas hace que Claude Models on Google Cloud (Anthropic managed) deje de funcionar en el proyecto.
### Usar la Claude Console
Con Claude Models on Google Cloud (Anthropic managed), no puedes usar una dirección de correo electrónico para iniciar sesión en tu organización de Anthropic. En su lugar, elige **Open Claude Console** en la [página de Claude](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) de la consola de Google Cloud. Google Cloud IAM controla quién puede abrir la Claude Console. De los tres [roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) predefinidos, solo `roles/claude.admin` en el proyecto te permite abrir la Claude Console.
### Workspaces
En Claude Models on Google Cloud (Anthropic managed), la configuración crea tu organización de Anthropic con un workspace, el Default Workspace. Para crear más workspaces, [abre la Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) y ve a **Settings > Workspaces**. En la misma página, puedes cambiar el nombre o archivar cualquier workspace excepto el Default Workspace. Cada workspace tiene su propio [ID de workspace](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Los archivos, skills, lotes, sesiones de Claude Managed Agents y otros recursos del workspace pertenecen al workspace cuyo ID [estableces para la solicitud](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Concedes los [roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) en el proyecto, por lo que un rol se aplica a todos los workspaces de ese proyecto. Cuando los equipos necesiten acceso separado, dale a cada equipo su propio proyecto de Google Cloud. Cada proyecto tiene su propia organización de Anthropic, así que repite los [pasos de configuración](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) en cada proyecto, comenzando desde el paso 2.
## Antes de hacer llamadas a la API
Para llamar a Claude Models on Google Cloud (Anthropic managed), necesitas lo siguiente:
1. Un proyecto de Google Cloud con una suscripción activa y una organización de Anthropic cuya configuración esté completa. Consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
2. La [CLI de gcloud](https://cloud.google.com/sdk/docs/install) instalada, para el desarrollo local.
3. El rol `roles/claude.user`, concedido en el proyecto a la identidad que hace las llamadas.
4. Application Default Credentials para esa identidad. Consulta [Autenticación](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#authentication).
5. El ID de tu proyecto y tu [ID de workspace](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id).
Para concederte el rol a tu propia cuenta para el desarrollo local, ejecuta el siguiente comando. Necesitas permiso para modificar la política de IAM del proyecto.
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="user:you@example.com" \
--role="roles/claude.user"
```
Reemplaza `my-project-id` con el ID de tu proyecto. Reemplaza `you@example.com` con la dirección de correo electrónico de tu cuenta de Google. Para ver el proyecto que está usando gcloud, ejecuta `gcloud config get-value project`. Para las cuentas de servicio y los demás roles, consulta [Roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
### Busca tu ID de workspace
Para encontrar tu ID de workspace de Claude Models on Google Cloud (Anthropic managed), [abre la Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) y ve a **Settings > Workspaces**. El ID comienza con `wrkspc_`. Si no puedes abrir la Claude Console, pídele a alguien que pueda abrirla que te envíe el ID.
Establece el proyecto y el workspace como variables de entorno para que los clientes del SDK y la [CLI `ant`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/quickstart) los detecten:
```bash CLI
export ANTHROPIC_GOOGLE_CLOUD_PROJECT="my-project-id"
export ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID="wrkspc_01AbCdEf23GhIj"
```
### Instala un SDK
El [cliente del SDK](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para Claude Models on Google Cloud (Anthropic managed) es `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). El cliente resuelve tus credenciales de Google. También construye la URL base a partir de tu proyecto, ubicación e ID de workspace.
Los clientes del SDK para Claude Models on Google Cloud (Anthropic managed) están en beta.
Instala el paquete que proporciona el cliente:
```bash
pip install -U "anthropic[google_cloud]"
```
```bash
npm install @anthropic-ai/google-cloud-sdk
```
```bash
dotnet add package Anthropic.GoogleCloud
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.1.0")
implementation("com.anthropic:anthropic-java-google-cloud:3.1.0")
```
```xml Maven
com.anthropic
anthropic-java
3.1.0
com.anthropic
anthropic-java-google-cloud
3.1.0
```
```bash
composer require anthropic-ai/sdk google/auth
```
```bash
gem install anthropic googleauth
```
Para usar la CLI `ant` en su lugar, [instálala o actualízala](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/quickstart#installation) a la versión más reciente. Una versión sin soporte para Claude Models on Google Cloud (Anthropic managed) ignora las variables `ANTHROPIC_GOOGLE_CLOUD_*`. Entonces hace una de las siguientes cosas:
* Envía la solicitud a la API de Claude con cualquier otra credencial que hayas configurado
* Falla con un error de autenticación
## Hacer solicitudes
Claude Models on Google Cloud (Anthropic managed) sirve los endpoints de la API de Claude bajo una URL base que nombra tu proyecto, una ubicación y tu workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/workspaces/{workspace}/invoke
```
Las [rutas a nivel de organización](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles), cuyas rutas comienzan con `/v1/organizations/`, usan una URL base sin el workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/claudeOrganization/invoke
```
Si no [estableces la URL base](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution), los clientes del SDK eligen entre estas dos para cada solicitud.
Agrega la ruta de la API de Claude a la URL base. Por ejemplo, la [API de Messages](https://platform.claude.com/docs/es/api/messages/create) está en `.../invoke/v1/messages`. Tres cosas difieren de una solicitud a la API de Claude:
* **URL base:** Las URL con alcance de proyecto mostradas anteriormente, en lugar de `https://api.anthropic.com`.
* **Autenticación:** Un encabezado `Authorization: Bearer` con un token de acceso de Google. No envíes un encabezado `x-api-key`.
* **Workspace:** El ID de workspace forma parte de la URL. No envíes un encabezado `anthropic-workspace-id`.
Todo lo demás es igual que en la API de Claude, incluido lo siguiente:
* Los encabezados `anthropic-version` y `anthropic-beta`
* El cuerpo de la solicitud
* El streaming
* La respuesta
Los ejemplos de código en otras partes de esta documentación crean el cliente de la API de Claude y leen una clave de API. Para ejecutar uno con Claude Models on Google Cloud (Anthropic managed), reemplaza su importación y el constructor del cliente por los de los siguientes ejemplos. Para un ejemplo de cURL, aplica las tres diferencias enumeradas anteriormente.
Antes de ejecutar estos ejemplos, completa los pasos de [Antes de hacer llamadas a la API](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
```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()
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(message)
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
const message = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
console.log(message);
```
```csharp C#
using Anthropic.GoogleCloud;
using Anthropic.Models.Messages;
var client = new AnthropicGoogleCloudClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello, 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/googlecloud"
)
func main() {
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(GoogleCloudBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
use Anthropic\Messages\Model;
$client = new Client();
$message = $client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
puts message
```
El ejemplo de cURL le pide a gcloud un token de Application Default Credentials. Los tokens de acceso son de corta duración. Genera uno para cada sesión en lugar de almacenarlo.
### IDs de modelo de la API
Claude Models on Google Cloud (Anthropic managed) usa los mismos IDs de modelo que la API de Claude, por ejemplo `claude-opus-5-5`. Para conocer los modelos y sus IDs, consulta [Descripción general de los modelos](https://platform.claude.com/docs/es/models/overview).
En Claude Models on Google Cloud (Anthropic managed), una solicitud de un modelo que no está disponible para tu organización de Anthropic devuelve un error. El mensaje de error dice `Model {model} is not available for this organization's inference configuration.`
## Resolución del proyecto, la ubicación y el workspace
Los clientes de Claude Models on Google Cloud (Anthropic managed) aceptan la configuración de la siguiente tabla. Un valor que pasas al crear el cliente tiene prioridad sobre la variable de entorno. Para establecer el proyecto y el ID de workspace explícitamente, pasa `project` (go: `Project`; java: `.project()`; csharp: `GoogleCloudClientOptions.Project`; cli: `--google-cloud-project`) y `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `GoogleCloudClientOptions.WorkspaceId`; cli: `--google-cloud-workspace-id`).
| Configuración | Variable de entorno | Si no está establecida |
| --------------- | -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ID del proyecto | `ANTHROPIC_GOOGLE_CLOUD_PROJECT`, luego `GOOGLE_CLOUD_PROJECT` | El proyecto que informa Application Default Credentials, cuando el tipo de credencial incluye uno |
| ID de workspace | `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` | El cliente genera un error a menos que establezcas la URL base. Las [rutas a nivel de organización](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) no necesitan un ID de workspace. |
| Ubicación | `ANTHROPIC_GOOGLE_CLOUD_LOCATION` | `global` |
| URL base | `ANTHROPIC_GOOGLE_CLOUD_BASE_URL` | Se deriva del proyecto, la ubicación y el ID de workspace |
Deja la ubicación en `global`. La ubicación es independiente de dónde se ejecuta la inferencia, así que para inferencia solo en EE. UU., establece `inference_geo: "us"` en cada solicitud, como se describe en [Residencia de datos](https://platform.claude.com/docs/es/manage-claude/data-residency#inference-geo).
La CLI `ant` acepta la misma configuración como flags:
* **ID del proyecto:** `--google-cloud-project`
* **ID de workspace:** `--google-cloud-workspace-id`
* **Ubicación:** `--google-cloud-location`
* **URL base:** `--google-cloud-base-url`
La CLI usa Claude Models on Google Cloud (Anthropic managed) cuando se establece el proyecto, el ID de workspace o la ubicación. Establecer `GOOGLE_CLOUD_PROJECT`, la URL base o ambos no es suficiente.
## Autenticación
Cada solicitud a Claude Models on Google Cloud (Anthropic managed) lleva un token de acceso de Google OAuth 2.0 en un encabezado `Authorization: Bearer`. El token tiene el alcance `https://www.googleapis.com/auth/cloud-platform`.
Google Cloud gestiona el acceso. Su gateway en `claude.googleapis.com` hace lo siguiente para cada solicitud:
1. Verifica tus credenciales de Google Cloud.
2. Verifica que quien llama tenga el permiso de IAM que necesita la solicitud. Si no lo tiene, Google Cloud devuelve un error HTTP 403.
3. Reenvía la solicitud a Anthropic. Anthropic valida la solicitud.
Para conceder permisos, consulta [Roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
Los clientes del SDK obtienen el token de [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials) (ADC). Funciona cualquier fuente de credenciales que ADC admita:
* **Desarrollo local:** Ejecuta `gcloud auth application-default login`.
* **En Google Cloud:** El cliente usa automáticamente la cuenta de servicio asociada a la carga de trabajo, por ejemplo en Compute Engine, GKE o Cloud Run.
* **Un archivo de clave de cuenta de servicio:** Establece `GOOGLE_APPLICATION_CREDENTIALS` con su ruta.
* **Workload Identity Federation y suplantación de cuentas de servicio:** Configúralas como lo harías para cualquier API de Google Cloud.
Comprueba que ADC funcione:
```bash CLI
gcloud auth application-default print-access-token
```
Claude Models on Google Cloud (Anthropic managed) no usa claves de API. En la Claude Console, no puedes crear claves de API para la organización de Anthropic que crea la configuración. Los clientes del SDK para Claude Models on Google Cloud (Anthropic managed) ignoran estas variables de entorno:
* `ANTHROPIC_API_KEY`
* `ANTHROPIC_AUTH_TOKEN`
* `ANTHROPIC_BASE_URL`
### Precedencia de credenciales
El cliente del SDK para Claude Models on Google Cloud (Anthropic managed) busca credenciales en el siguiente orden. El cliente usa la primera que encuentra:
1. Un proveedor de tokens que pasas como `token_provider` (typescript: `bearerTokenProvider`; csharp: `GoogleCloudClientOptions.TokenProvider`; go: `TokenSource`; java: `.bearerTokenSupplier()`; php: `tokenProvider`) al crear el cliente. Es una función o fuente de tokens que devuelve un token de acceso. El cliente le pide un token en cada solicitud. Almacenar en caché y renovar el token depende de ti.
2. Un objeto de credenciales de Google que pasas como `credentials` (typescript: `googleAuth`; csharp: `GoogleCloudClientOptions.GoogleCredential`; java: `.googleCredentials()`; php: `googleCredentials`; ruby: `google_credentials`) al crear el cliente. El SDK de Go no tiene esta opción.
3. Application Default Credentials.
Go y Java difieren de los demás SDK:
* **Go:** Para la opción 1, el cliente acepta un `oauth2.TokenSource`. Almacena el token en caché hasta que caduca.
* **Java:** Usa `GoogleCloudBackend.fromEnv()` para leer Application Default Credentials y las variables de entorno de [Resolución del proyecto, la ubicación y el workspace](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
El cliente no tiene una variable de entorno propia para la credencial. Usa `GOOGLE_APPLICATION_CREDENTIALS` de ADC en su lugar.
Si tus solicitudes pasan por un proxy que adjunta el token por ti, establece `skip_auth` (typescript, php: `skipAuth`; go: `SkipAuth`; java: `.skipAuth()`; csharp: `GoogleCloudClientOptions.SkipAuth`). El cliente entonces no envía ningún encabezado `Authorization`. No puedes combinar esta configuración con las opciones de credenciales anteriores.
Cuando la CLI `ant` usa Claude Models on Google Cloud (Anthropic managed), siempre obtiene el token de Application Default Credentials. No acepta un proveedor de tokens, un objeto de credenciales ni una configuración para omitir la autenticación.
Antes de usar `ant` con Claude Models on Google Cloud (Anthropic managed), asegúrate de que ninguno de estos esté establecido:
* Una clave de API
* Un token de autenticación
* `--profile` o `ANTHROPIC_PROFILE`, si nombra un [perfil de configuración](https://platform.claude.com/docs/es/manage-claude/wif-reference#profile-configuration-file) con el que la CLI pueda autenticarse
* Cualquiera de las variables de federación de Anthropic:
* `ANTHROPIC_FEDERATION_RULE_ID`
* `ANTHROPIC_ORGANIZATION_ID`
* `ANTHROPIC_SERVICE_ACCOUNT_ID`
* `ANTHROPIC_IDENTITY_TOKEN`
* `ANTHROPIC_IDENTITY_TOKEN_FILE`
Si alguno está establecido, la CLI usa esa credencial en lugar de la configuración de Google Cloud de [Busca tu ID de workspace](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Si solo algunas de las variables de federación están establecidas, la CLI se detiene con un error. Cuando hay más de una credencial establecida, la CLI imprime una nota que indica cuál usa.
Deja también sin establecer `ANTHROPIC_WORKSPACE_ID` y el flag `--workspace-id`. La CLI sigue enviando ese valor como un encabezado `anthropic-workspace-id`. Las solicitudes a Claude Models on Google Cloud (Anthropic managed) no deben llevar ese encabezado. Establece el workspace con `--google-cloud-workspace-id` o `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` en su lugar.
Al igual que los clientes del SDK, la CLI no envía las solicitudes de Claude Models on Google Cloud (Anthropic managed) a `--base-url` ni a `ANTHROPIC_BASE_URL`.
## Compatibilidad de funciones
Esta sección enumera las funciones que funcionan en Claude Models on Google Cloud (Anthropic managed) y las funciones que no son compatibles allí. No enumera todas las funciones de la API de Claude, y no indica si una función no enumerada funciona.
Las siguientes funciones funcionan en Claude Models on Google Cloud (Anthropic managed) igual que en la API de Claude:
* **Modo rápido:** [Modo rápido](https://platform.claude.com/docs/es/build-with-claude/fast-mode) para Claude Opus 5.5.
- **Funciones beta:** Si una beta está limitada a organizaciones seleccionadas en la API de Claude, la organización de Anthropic que crea la configuración necesita el mismo acceso.
- **Herramientas:** El [uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview), incluidos:
* Búsqueda web
* Obtención web
* Ejecución de código
* La herramienta de memoria
* La herramienta advisor
* El conector MCP
- **Skills y archivos:** [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview) y la [API de Files](https://platform.claude.com/docs/es/build-with-claude/files).
- **Capacidades del modelo:**
* [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching)
* [Pensamiento extendido](https://platform.claude.com/docs/es/build-with-claude/thinking)
* [Fallback del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback)
* [Streaming](https://platform.claude.com/docs/es/build-with-claude/streaming)
* [Salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs)
* [Conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting)
- **Lotes y modelos:** La [API de Message Batches](https://platform.claude.com/docs/es/build-with-claude/batch-processing) y la API de Models.
Para activar o desactivar la [API de Compliance](https://platform.claude.com/docs/es/manage-claude/compliance-api) para la organización de Anthropic que crea la configuración, [abre la Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), ve a **Settings > Compliance** y usa el interruptor **Compliance API**.
Las claves de cifrado administradas por el cliente (CMEK) están disponibles con claves de Google Cloud KMS. Para activar CMEK para la organización de Anthropic que crea la configuración, consulta [Claves de cifrado administradas por el cliente](https://platform.claude.com/docs/es/manage-claude/cmek). Para configurar una clave, sigue [Configurar Google Cloud KMS para CMEK](https://platform.claude.com/docs/es/manage-claude/cmek-google-cloud-kms). Luego registra, verifica y asocia la clave en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), como describe la pestaña **Claude Console** de la página de configuración.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview) está disponible a través de Claude Models on Google Cloud (Anthropic managed), incluido lo siguiente:
* [Agentes](https://platform.claude.com/docs/es/managed-agents/agent-setup)
* [Entornos](https://platform.claude.com/docs/es/managed-agents/environments)
* [Sesiones](https://platform.claude.com/docs/es/managed-agents/sessions)
* [Bóvedas de credenciales](https://platform.claude.com/docs/es/managed-agents/vaults)
* [Almacenes de memoria](https://platform.claude.com/docs/es/managed-agents/memory)
* [Implementaciones programadas](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments)
* [Sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes)
El acceso se verifica cuando se crea una sesión o una implementación, no mientras se ejecuta:
* **Las sesiones en ejecución siguen ejecutándose.** Si revocas el acceso de Google Cloud a la identidad que creó una sesión, la sesión no se detiene. Para detenerla, envíale un [evento `user.interrupt`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#integrating-events) por sí solo. Después de que la sesión esté `idle`, puedes archivarla o eliminarla.
* **Las implementaciones programadas siguen ejecutándose.** Una implementación no vuelve a verificar el acceso de su creador en cada ejecución programada. Para detenerla, pausa, actualiza o archiva la implementación.
Cuando elimines a un usuario o rotes una cuenta de servicio, revisa las sesiones e implementaciones que creó esa identidad.
### Funciones no compatibles
Lo siguiente no es compatible en Claude Models on Google Cloud (Anthropic managed):
* **Claves de API:** La autenticación se realiza solo mediante credenciales de Google Cloud.
* **Túneles MCP:** Los [túneles MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-tunnels/overview) no están disponibles en Claude Models on Google Cloud (Anthropic managed).
* **[Almacenes de memoria en entornos autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory):** Los almacenes de memoria no son compatibles con sesiones en entornos autoalojados.
* **Workers de sandbox autoalojados prediseñados:** Los [workers autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers) de la CLI `ant` y de los SDK de Python, TypeScript y Go no son compatibles con Claude Models on Google Cloud (Anthropic managed). En su lugar, implementa tu propio worker que llame directamente a los [endpoints de Environments Work](https://platform.claude.com/docs/es/api/beta/environments/work). Para conocer los roles y permisos que necesita tu worker, consulta [Permisos de IAM para entornos](https://platform.claude.com/docs/es/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions#environments).
### Ventana de contexto
Los tamaños de la "context window" (ventana de contexto) en Claude Models on Google Cloud (Anthropic managed) son los mismos que en la API de Claude. Para conocer el límite de cada modelo, consulta [Ventanas de contexto](https://platform.claude.com/docs/es/build-with-claude/context-windows).
## Facturación, límites de velocidad y registro
### Límites de velocidad
Anthropic gestiona los "rate limits" (límites de velocidad) de Claude Models on Google Cloud (Anthropic managed). Para solicitar límites más altos, contacta a tu representante de cuenta de Anthropic o [contacta a ventas](https://claude.com/contact-sales). Para saber cómo se miden e informan los límites de velocidad, consulta [Límites de velocidad](https://platform.claude.com/docs/es/api/rate-limits).
### Facturación
Claude Models on Google Cloud (Anthropic managed) factura a través de Google Cloud Marketplace. Anthropic mide tu uso. Informa el uso a Google Cloud en Claude Consumption Units. Los cargos aparecen en tu factura de Google Cloud. Anthropic no envía una factura separada.
Consulta los datos de uso y costos en las páginas **Usage** y **Cost** de la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Si tienes un compromiso de gasto con Google Cloud, el uso cuenta para él de la misma forma que otras compras de Marketplace.
### Retención de datos
Anthropic es el encargado del tratamiento de datos para Claude Models on Google Cloud (Anthropic managed). Algunos servicios de soporte, como los sistemas de confianza y seguridad de Anthropic, procesan datos fuera de Google Cloud.
Claude Models on Google Cloud (Anthropic managed) sigue la misma política de retención de datos que la API de Claude. Consulta [API y retención de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention). Zero Data Retention (ZDR) está disponible bajo solicitud. Contacta a tu representante de cuenta de Anthropic.
Un acuerdo de ZDR en otra organización de Anthropic no se transfiere a tu organización de Claude Models on Google Cloud (Anthropic managed).
### Monitoreo y registro
[Cloud Audit Logs](https://cloud.google.com/logging/docs/audit) registra la actividad de la API de Claude Models on Google Cloud (Anthropic managed) en tu proyecto. Las entradas aparecen bajo el servicio `claude.googleapis.com`. Cada ruta de la API pertenece a uno de dos tipos de registro:
* **Registros de Data Access:** Cubren la mayoría de las rutas, incluidos mensajes, lotes, archivos, skills, modelos y la mayoría de los recursos de Claude Managed Agents. Están desactivados de forma predeterminada.
* **Registros de Admin Activity:** Cubren las demás rutas, incluidas las rutas de claves de cifrado y la mayoría de las rutas de bóvedas de credenciales. La excepción es la ruta de `vaults.verify`, que es de Data Access. Los registros de Admin Activity siempre están activados.
Para mantener un registro de las solicitudes, activa los registros de Data Access para `claude.googleapis.com` en la configuración de registros de auditoría de tu proyecto.
Para conocer los tipos de registros de auditoría por ruta, consulta [Permisos de IAM para Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
#### IDs de solicitud
Las respuestas exitosas de Claude Models on Google Cloud (Anthropic managed) llevan el encabezado [`request-id`](https://platform.claude.com/docs/es/api/errors#request-id).
## Migrar desde una organización de Anthropic existente
No puedes convertir una organización de Anthropic existente en una organización de Claude Models on Google Cloud (Anthropic managed). Eso incluye una organización que usas directamente con la API de Claude.
Planifica la migración como un cambio a una nueva organización:
* **Crea primero la nueva organización.** Sigue [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
* **Vuelve a crear el acceso y la configuración.** Las claves de API, los workspaces y la configuración de la Claude Console no se transfieren. Concede [roles de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) en el proyecto en lugar de crear claves de API. Para volver a crear tus workspaces, consulta [Workspaces](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#workspaces). Para los acuerdos de ZDR, consulta [Retención de datos](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention).
* **Planifica los recursos almacenados.** Los archivos, skills, lotes y recursos de Claude Managed Agents permanecen en la organización existente.
* **Actualiza tu integración.** Para saber qué cambia y qué se mantiene igual, consulta [Hacer solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests). Para las funciones que no son compatibles, consulta [Funciones no compatibles](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#features-not-supported).
* **Haz el cambio según tu propio calendario.** Las dos organizaciones son independientes y pueden atender tráfico en paralelo. Puedes migrar las cargas de trabajo gradualmente. La organización existente mantiene su facturación actual. Antes de trasladar el tráfico de producción, revisa los [límites de velocidad](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Migrar desde Claude Models on Google Cloud (Google managed)
Para pasar a Claude Models on Google Cloud (Anthropic managed), completa los siguientes pasos. Antes de mover cargas de trabajo que dependan de un acuerdo de ZDR, consulta [Retención de datos](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention). Para saber qué cambia cuando te mueves, 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).
Completa cada paso de [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
Otorga `roles/claude.user` a cada identidad que llame a Claude Models on Google Cloud (Anthropic managed). Establece tu proyecto y el ID de tu espacio de trabajo como variables de entorno. Para ambos, consulta [Antes de hacer llamadas a la API](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
Instala el paquete que proporciona el cliente para Claude Models on Google Cloud (Anthropic managed). Consulta [Instalar un SDK](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#install-an-sdk).
Cambia el código que importa y crea tu cliente. Usa `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`) en lugar de `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). En una solicitud cURL, cambia la URL, los encabezados y el cuerpo. Tu código actual crea un cliente para Claude Models on Google Cloud (Google managed). Por ejemplo, el siguiente código crea ese cliente con el endpoint global:
```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
}'
```
La CLI `ant` no es compatible con Claude Models on Google Cloud (Google managed).
```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"
)
```
El siguiente código crea el cliente para Claude Models on Google Cloud (Anthropic managed):
```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
```
El nuevo cliente lee tu proyecto y el ID de tu espacio de trabajo de las variables de entorno que estableciste en [Encuentra el ID de tu espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). No los pasas al crear el cliente. Tus llamadas a la Messages API se mantienen igual, excepto por los IDs de modelo y las funciones del siguiente paso.
* **IDs de modelo:** Si usas un modelo anterior a Claude 4.6, reemplaza la `@` antes de la fecha de la instantánea en su ID por un guion. Por ejemplo, `claude-haiku-4-5@20251001` se convierte en `claude-haiku-4-5-20251001`. Para ver 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/anthropic-managed#api-model-ids).
* **Funciones:** Consulta [Compatibilidad de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#feature-support) para cada función que use tu código.
* **Ubicación:** Si hoy usas un endpoint multirregional o regional, verifica qué ubicación usa Claude Models on Google Cloud (Anthropic managed). Consulta [Resolución de proyecto, ubicación y espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Ejecuta la solicitud de [Hacer solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) para verificar que tu configuración funciona. Luego ejecuta tu propio código. Si una llamada falla con un error de permisos, consulta [Solución de problemas de configuración de la cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#troubleshooting-account-setup). Antes de mover el tráfico de producción, revisa los [límites de velocidad](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Próximos pasos
Explora las funciones de Claude.
Consulta permisos, roles y tipos de registros de auditoría.
A medida que se lanzan modelos más seguros y capaces, Anthropic retira regularmente los más antiguos. Consulta todos los retiros de la API, junto con los reemplazos recomendados.
Administra tu suscripción y facturación.