---
title: Claude Platform on AWS
url: https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws
description: Accede a todas las capacidades de la plataforma de Claude a través de AWS con infraestructura administrada por Anthropic.
---
Claude Platform on AWS te ofrece la experiencia completa de la plataforma de Anthropic, incluida la Messages API, Agent Skills, la ejecución de código y las funciones beta, accesible a través de tu cuenta de AWS. A diferencia de [Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), donde AWS opera la pila de inferencia, Anthropic opera Claude Platform on AWS. AWS proporciona la capa de autenticación (SigV4 o "API key" (clave de API)), el control de acceso basado en IAM y la integración de facturación a través de AWS Marketplace.
Los SDK de Anthropic son compatibles con Claude Platform on AWS.
## Cómo funciona la integración de la plataforma
Los modelos de Claude se ejecutan en infraestructura administrada por Anthropic. Esta es una integración comercial para la facturación y el acceso a través de AWS. Anthropic es el encargado del tratamiento de datos para las entradas y salidas de inferencia. AWS procesa los metadatos de facturación e identidad bajo el modelo de marketplace. Los clientes que usan Claude a través de Claude Platform on AWS están sujetos a los [términos de uso de datos](https://www.anthropic.com/legal) de Anthropic.
Anthropic usa infraestructura de AWS para procesar tus solicitudes de API, ejecutar la inferencia del modelo y almacenar el contenido de tu espacio de trabajo (como prompts, salidas, archivos, Skills y lotes). Para los espacios de trabajo creados antes del 18 de septiembre de 2026, 00:00 UTC, Anthropic podría procesar solicitudes, almacenar datos y ejecutar inferencia fuera de AWS. En cualquier caso, los subservicios podrían cambiar sin previo aviso. Establece el parámetro [`inference_geo`](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#data-residency) por solicitud para fijar la inferencia a una geografía específica.
Claude Platform on AWS sigue la misma política de retención de datos que la Claude API de primera parte. La retención de datos cero (Zero Data Retention, ZDR) está disponible bajo solicitud. Contacta a tu representante de cuenta de Anthropic para habilitarla en tu organización.
## Claude Platform on AWS frente a Amazon Bedrock
Ambas ofertas te permiten usar Claude a través de AWS, pero difieren en arquitectura, superficie de API y disponibilidad de funciones.
| Aspecto | Claude Platform on AWS | [Claude in Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock) | [Amazon Bedrock (Opus 4.6 y anteriores)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy) |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Quién opera la pila** | Anthropic | AWS | AWS |
| **Superficie de API** | Claude API (`/v1/{endpoint}`) | Messages API en `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Disponibilidad de funciones** | Normalmente el mismo día que la Claude API (consulta las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported)) | Según el calendario de lanzamientos de Amazon Bedrock | Según el calendario de lanzamientos de Amazon Bedrock |
| **Agent Skills** | Disponible | No disponible (requiere ejecución de código) | No disponible |
| **Funciones beta** | Se transmiten con encabezados `anthropic-beta` (consulta las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported)) | Las funciones beta que admite Amazon Bedrock, mediante el encabezado `anthropic-beta` | Las funciones beta que admite Amazon Bedrock, mediante el campo `anthropic_beta` del cuerpo de la solicitud InvokeModel |
| **Autenticación** | AWS IAM / SigV4 o clave de API | AWS IAM / SigV4 | AWS IAM / SigV4 o token de portador |
| **Facturación** | AWS Marketplace | AWS (servicio nativo) | AWS (servicio nativo) |
| **URL base** | `aws-external-anthropic.{region}.api.aws` | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` |
| **Cliente del SDK** | `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), en beta | `AnthropicBedrockMantle` | `AnthropicBedrock` / SDK de Bedrock |
| **Consola** | Claude Console (`platform.claude.com`, acceso a través de la consola de AWS) | Consola de Bedrock | Consola de Bedrock |
| **Límites de velocidad y cuotas** | Administrados por Anthropic | Administrados por AWS | Administrados por AWS |
| **Encargado del tratamiento de datos de inferencia** | Anthropic | AWS | AWS |
Si necesitas Claude operado por AWS, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock). Claude Platform on AWS usa un grupo de capacidad separado tanto de la Claude API de primera parte como de Amazon Bedrock. Puedes ejecutar cargas de trabajo en más de una plataforma y conmutar por error entre ellas.
[AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) es compatible para conectar tu VPC al endpoint de Claude Platform on AWS.
**Cuándo elegir Bedrock:** Las organizaciones de industrias reguladas que requieren cumplimiento de FedRAMP High, IL4, IL5 o preparado para HIPAA, o que necesitan que AWS sea el único encargado del tratamiento de datos, deben usar [Claude in Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock). Bedrock se ejecuta completamente en infraestructura controlada por AWS, con AWS como parte operadora.
**¿Qué oferta estás usando?** Claude está disponible a través de varios productos distintos:
* **Claude Platform on AWS** (esta página): La plataforma de la Claude API facturada a través de AWS Marketplace. Se administra en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console) y en la consola de AWS.
* **[Claude in Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock):** Un servicio nativo de AWS. Se administra en la consola de Amazon Bedrock y se factura como uso de servicios de AWS.
* **Claude Enterprise adquirido a través de AWS Marketplace:** Un plan de [claude.ai](https://claude.ai) (el producto de chat de Claude), no una plataforma de API. Se administra en claude.ai, y su comportamiento de cuenta y migración difiere de lo que describe esta página. Consulta el [Centro de ayuda de Claude](https://support.claude.com).
* **Cuentas directas de Anthropic:** La Claude API de primera parte y los planes de claude.ai facturados por Anthropic. Se administran en la Claude Console y en claude.ai.
## Configura tu cuenta
La configuración de Claude Platform on AWS se realiza en cuatro fases: regístrate en la página del servicio en la consola de AWS, completa la configuración de tu organización de Anthropic, anota el ID de tu espacio de trabajo e inicia sesión en la Claude Console.
Registrarte a través de la consola de AWS aprovisiona una nueva organización de Anthropic vinculada a tu cuenta de AWS. Esta organización es independiente de cualquier organización existente que tu empresa tenga con Anthropic, incluidas las organizaciones de Claude Enterprise adquiridas a través de AWS Marketplace. Las claves de API, los espacios de trabajo y la configuración de la Claude Console de una organización de Anthropic de primera parte no se transfieren.
Si tienes una oferta privada existente de Amazon Bedrock, contacta a tu representante de cuenta de Anthropic o de AWS antes de registrarte para que tu descuento se aplique desde tu primera solicitud. Los descuentos no se pueden aplicar retroactivamente al uso incurrido antes de que se acepte tu oferta privada. Consulta [Ofertas privadas](https://platform.claude.com/docs/es/about-claude/pricing#private-offers).
1. Abre la [consola de AWS](https://console.aws.amazon.com/) y navega a la página del servicio **Claude Platform on AWS**.
2. Elige **Sign up**.
3. En la página de registro, revisa los términos (el Acuerdo de licencia de usuario final de Anthropic, el Aviso de privacidad de AWS y el Acuerdo de cliente de AWS) y selecciona la casilla de aceptación.
4. Elige **Continue**.
La página muestra un banner **Sign-up in progress**. Permanece en la página. El registro tarda unos minutos mientras AWS gestiona la suscripción de AWS Marketplace por ti y luego te redirige automáticamente.
Si tu organización tiene una oferta privada de Anthropic, la consola la busca y te pide que la aceptes en AWS Marketplace. Consulta [Ofertas privadas](https://platform.claude.com/docs/es/about-claude/pricing#private-offers) para obtener más detalles.
Cuando usas Claude Platform on AWS, Anthropic procesa y almacena tu contenido (como prompts y salidas) en infraestructura de AWS. Para los espacios de trabajo creados antes del 18 de septiembre de 2026, 00:00 UTC, Anthropic podría procesar y almacenar ese contenido fuera de AWS. Las [políticas de uso de datos](https://www.anthropic.com/legal) de Anthropic describen cómo se procesan y almacenan el contenido y los metadatos.
Una vez completado el registro, se te redirige a `platform.claude.com/partner-signup`.
1. Ingresa la dirección de correo electrónico del propietario de tu organización y elige **Get started**.
2. Revisa esa bandeja de entrada para encontrar un enlace de configuración y síguelo. Si tu navegador muestra una página **Signed in as a different account**, elige **Log out and continue**.
3. Completa el formulario de detalles de la organización (nombre de la organización, tipo de entidad, país, uso previsto) y elige **Complete setup**.
Completar la configuración crea tu organización de Anthropic y acepta los Términos de servicio comerciales y la Política de uso de Anthropic. La página del servicio en la consola de AWS ahora muestra una navegación a la izquierda con **Home**, **API keys**, **Quickstart** y **Workspaces**.
Después de completar la configuración, la consola de AWS te pide que crees un espacio de trabajo. Consulta [Espacios de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#workspaces) para obtener detalles sobre la vinculación a regiones, el alcance de recursos de IAM y la creación de espacios de trabajo adicionales.
Encuentra el ID del espacio de trabajo en **Workspaces** en la página del servicio **Claude Platform on AWS** de la consola de AWS o en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console). Los ID de espacio de trabajo usan el formato `wrkspc_` seguido de un identificador alfanumérico.
El acceso a la Claude Console está federado a través de AWS IAM:
1. Asume un rol de IAM con el permiso `aws-external-anthropic:AssumeConsole`. Consulta [Acciones de IAM para Claude Platform on AWS](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#console-access).
2. Desde la página del servicio **Claude Platform on AWS**, elige **Open Claude Console**. La consola de AWS emite un JWT y te redirige a `platform.claude.com`.
3. En el primer inicio de sesión, se te solicita una dirección de correo electrónico. Ingresa tu correo de trabajo. La plataforma aprovisiona tu usuario de la Claude Console justo a tiempo.
Cuando inicias sesión a través de la consola de AWS, la Claude Console se limita a tu organización de Claude Platform on AWS. Aparece un indicador **Account managed by AWS** en la parte inferior izquierda de la barra lateral de la Claude Console.
### Migrar desde una organización de Anthropic existente
Registrarte en Claude Platform on AWS siempre aprovisiona una nueva organización de Anthropic vinculada a tu cuenta de AWS. No existe una conversión in situ: una organización existente, como una organización de la Claude API de primera parte, no puede convertirse en una organización de Claude Platform on AWS.
Planifica la migración desde una organización existente como un cambio a una nueva:
* **Crea primero la nueva organización.** Regístrate a través de la consola de AWS (consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#set-up-your-account)). Si tu migración implica una oferta privada, completa el registro antes de que se acepte la oferta: los descuentos se aplican desde la aceptación, no de forma retroactiva. Consulta [Ofertas privadas](https://platform.claude.com/docs/es/about-claude/pricing#private-offers).
* **Vuelve a crear el acceso y la configuración.** Las claves de API, los espacios de trabajo y la configuración de la Claude Console no se transfieren desde una organización existente. Crea espacios de trabajo en la nueva organización y cambia tus aplicaciones a la [autenticación de Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#authentication).
* **Actualiza tu integración.** Claude Platform on AWS sirve la Claude API (`/v1/{endpoint}`), por lo que las formas de solicitud y respuesta no cambian respecto a la Claude API de primera parte. Lo que cambia es la URL base, el método de autenticación y el encabezado `anthropic-workspace-id` en las solicitudes de inferencia y de recursos; consulta [Realizar solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#making-requests). Algunas funciones de la plataforma difieren; consulta [Funciones no compatibles](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Haz el cambio según tu propio calendario.** La nueva organización es independiente de la existente, y ambas pueden atender tráfico en paralelo. No es necesario un cambio abrupto: traslada las cargas de trabajo gradualmente hasta que todo tu tráfico esté en la nueva organización.
Una vez que la nueva organización esté en funcionamiento, las diferencias se concentran en la facturación y la autenticación, que se gestionan a través de AWS:
* **La facturación** pasa a AWS Marketplace: el uso se factura en Claude Consumption Units en lugar de créditos prepagados (consulta [Facturación](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#billing)), y estableces límites de gasto en la página Billing (consulta [Límites de gasto](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#spend-limits)). Durante la transición, la facturación se mantiene separada: la organización existente se sigue facturando como hasta ahora.
* **La autenticación y el acceso** pasan a AWS: las solicitudes se autentican con credenciales de AWS o con claves de API generadas en la consola de AWS, no en la Claude Console (consulta [Autenticación](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#authentication)). La membresía de la organización se administra a través de AWS IAM en lugar de la Claude Console (consulta [Páginas disponibles](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#available-pages)), y los SDK de cliente de Anthropic proporcionan clases de cliente específicas de la plataforma (consulta [Instala un SDK](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **El uso diario de la API** funciona igual que en la Claude API de primera parte, excepto donde se indica en las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported). Antes de trasladar el tráfico de producción, revisa tus "rate limits" (límites de velocidad): las nuevas organizaciones se colocan en el nivel Start, y los aumentos de límites se gestionan a través de tu representante de cuenta de Anthropic (consulta [Límites de velocidad y cuotas](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Para las organizaciones de Claude Enterprise (claude.ai), que se comportan de manera diferente, consulta la [comparación de ofertas](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Solución de problemas de configuración de la cuenta
* **"Sign-up failed: Failed to enable OutboundWebIdentityFederation":** Si ves este banner en el primer envío, elige **Continue** de nuevo. La habilitación de IAM puede tardar un momento en surtir efecto.
* **No hay indicador de progreso durante el registro:** El registro tarda unos minutos. La página muestra un banner estático **Sign-up in progress** sin barra de progreso mientras AWS aprovisiona tu cuenta.
* **"Signed in as a different account" después de seguir el enlace de configuración:** Elige **Log out and continue**. La página te vuelve a autenticar con la dirección de correo electrónico que ingresaste.
* **Mensaje "Not found" durante el inicio de sesión:** Este mensaje podría aparecer brevemente durante la redirección. Puedes descartarlo.
* **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.
* **"Outbound web identity federation is disabled" en tu primera llamada a la API:** Habilita la federación una vez por cuenta. Consulta [Habilita la federación de identidad web saliente](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Antes de realizar llamadas a la API
Asegúrate de tener:
1. Una cuenta de AWS activa con una suscripción a Claude Platform on AWS (consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#set-up-your-account))
2. La [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) instalada y configurada
3. **La federación de identidad web saliente habilitada** en tu cuenta de AWS, un paso de configuración único (consulta [Habilita la federación de identidad web saliente](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation))
4. El ID de tu espacio de trabajo (consulta [Obtén el ID de tu espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id))
5. Permiso de IAM para llamar a la API: la acción `aws-external-anthropic:CreateInference` en tu espacio de trabajo, además de `aws-external-anthropic:CallWithBearerToken` si te autenticas con una clave de API (consulta [Políticas de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#iam-policies))
### Habilita la federación de identidad web saliente
La puerta de enlace de Claude Platform on AWS llama a `sts:GetWebIdentityToken` del lado del servidor para generar un JWT que reenvía a Anthropic. Esta capacidad de STS está **deshabilitada de forma predeterminada** en todas las cuentas de AWS. Habilítala una vez por cuenta:
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Si la respuesta es `[ERROR] (FeatureEnabled) ... already enabled`, la configuración ya está activada para tu cuenta y puedes continuar. Verifica y obtén la URL del emisor de tu cuenta:
```bash CLI
aws iam get-outbound-web-identity-federation-info
```
Sin este paso, cada solicitud devuelve `"Outbound web identity federation is disabled for your account"`. Este es el error de configuración más común.
### Obtén el ID de tu espacio de trabajo
Creas un espacio de trabajo desde la consola de AWS después de completar la configuración de la cuenta (consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#set-up-your-account)). Los espacios de trabajo están vinculados a una sola región de AWS. Puedes encontrar el ID del espacio de trabajo en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console) en **Workspaces** o en la sección **Workspaces** de la página del servicio en la consola de AWS.
Establece las variables de entorno `ANTHROPIC_AWS_WORKSPACE_ID` y `AWS_REGION` para que los clientes del SDK las lean automáticamente:
```bash CLI
export ANTHROPIC_AWS_WORKSPACE_ID='wrkspc_01AbCdEf23GhIj'
export AWS_REGION='us-west-2' # Your workspace's AWS region
```
La región es obligatoria. El cliente del SDK genera un error si no se establece ninguna región. Pasa `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) al crear el cliente, o establece `AWS_REGION` (o `AWS_DEFAULT_REGION`). Se admiten todas las regiones comerciales de AWS.
## Autenticación
Claude Platform on AWS admite dos métodos de autenticación: AWS IAM con firma de solicitudes Signature Version 4 (SigV4) (principal) y autenticación con clave de API. Ambos usan la misma URL base y el mismo formato de solicitud.
### Autenticación SigV4
SigV4 es la ruta nativa empresarial y se integra con tus políticas, roles y auditorías existentes de AWS IAM. Configura las credenciales de AWS usando cualquier método compatible con la [cadena de proveedores de credenciales predeterminada de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html):
* Variables de entorno (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`)
* Archivo de credenciales compartido (`~/.aws/credentials`)
* Archivo de configuración compartido (`~/.aws/config`), incluidos SSO y `credential_process`
* Identidad web (`AWS_WEB_IDENTITY_TOKEN_FILE` y `AWS_ROLE_ARN`) para IRSA y GitHub Actions
* Credenciales de contenedor de ECS
* Servicio de metadatos de instancia de EC2 (IMDS)
Verifica que tus credenciales funcionen:
```bash CLI
aws sts get-caller-identity
```
### Autenticación con clave de API
Para rutas de integración más sencillas (desarrollo local y scripts), puedes autenticarte con una clave de API en lugar de SigV4. Establece la variable de entorno `ANTHROPIC_AWS_API_KEY` o pasa `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) al crear el cliente.
Genera claves de API en la **consola de AWS** en **Claude Platform on AWS → API keys**. Elige **Generate a key** y luego copia el valor de la clave. Otorga la acción de IAM `aws-external-anthropic:CallWithBearerToken` a las entidades principales que deban poder usar la autenticación con clave de API.
Las claves de API para Claude Platform on AWS se administran en la consola de AWS, no en la Claude Console. Las claves creadas en la [Claude Console](https://platform.claude.com/) estándar (para acceso a la API de primera parte) no funcionan con el endpoint de Claude Platform on AWS.
#### Claves de API de corta duración
Para cargas de trabajo que necesitan entregar una credencial a un proceso separado (como una puerta de enlace de LLM, una función sin servidor o una herramienta que admite autenticación con token de portador pero no SigV4), genera una clave de API de corta duración a partir de tus credenciales de AWS en lugar de aprovisionar una clave de larga duración en la consola de AWS.
AWS publica bibliotecas generadoras de tokens para [JavaScript](https://github.com/aws/token-generator-for-aws-external-anthropic-js), [Python](https://github.com/aws/token-generator-for-aws-external-anthropic-python) y [Java](https://github.com/aws/token-generator-for-aws-external-anthropic-java). Cada biblioteca lee tus credenciales de AWS a través de la cadena de proveedores estándar y devuelve un token de tiempo limitado que envías como `Authorization: Bearer `. La vida útil del token es de 12 horas de forma predeterminada y está limitada al menor valor entre la duración que solicites, la expiración de tus credenciales de AWS y 12 horas. Consulta los README de los repositorios enlazados para conocer la instalación y todas las opciones de configuración.
Pasa el token generado al SDK de la misma manera que pasarías una clave de API generada en la consola de AWS:
```python Python
from token_generator_for_aws_external_anthropic import TokenGenerator
from anthropic import AnthropicAWS
token = TokenGenerator(region="us-west-2").get_token()
client = AnthropicAWS(api_key=token, aws_region="us-west-2")
```
```typescript TypeScript
import { getTokenProvider } from "@aws/token-generator-for-aws-external-anthropic";
import AnthropicAws from "@anthropic-ai/aws-sdk";
const tokenProvider = getTokenProvider({ region: "us-west-2" });
const token = await tokenProvider();
const client = new AnthropicAws({ apiKey: token, awsRegion: "us-west-2" });
```
```java Java
import software.amazon.awsexternalanthropic.TokenGenerator;
import software.amazon.awssdk.regions.Region;
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
void main() {
String token = TokenGenerator.builder().region(Region.US_WEST_2).build().getToken();
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.builder()
.apiKey(token)
.region(Region.US_WEST_2)
.workspaceId(System.getenv("ANTHROPIC_AWS_WORKSPACE_ID"))
.build())
.build();
}
```
Si puedes generar el token localmente, tu proceso ya tiene credenciales SigV4, y la autenticación SigV4 suele ser la opción más sencilla. Usa claves de corta duración cuando el proceso que realiza las llamadas a la API sea distinto del proceso que tiene las credenciales de AWS.
El SDK no actualiza automáticamente las claves de corta duración. Cuando un token expire, genera uno nuevo y construye un nuevo cliente. La entidad principal que usa el token sigue necesitando la acción de IAM `aws-external-anthropic:CallWithBearerToken`.
### Precedencia de credenciales
El cliente específico de la plataforma resuelve la autenticación en el siguiente orden, comenzando por lo que pasas al crearlo:
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → encabezado `Authorization: Bearer`
2. `aws_access_key` (typescript, php: `awsAccessKey`; go: `AWSAccessKey`; java: `.awsAccessKey()`; csharp: `AwsClientOptions.AwsAccessKey`) + `aws_secret_key` (ruby: `aws_secret_access_key`; typescript, php: `awsSecretAccessKey`; go: `AWSSecretAccessKey`; java: `.awsSecretAccessKey()`; csharp: `AwsClientOptions.AwsSecretAccessKey`) → AWS SigV4
3. `aws_profile` (typescript, php: `awsProfile`; go: `AWSProfile`; java: `.awsProfile()`; csharp: `AwsClientOptions.AwsProfile`) → AWS SigV4 con perfil con nombre
4. Variable de entorno `ANTHROPIC_AWS_API_KEY` → encabezado `Authorization: Bearer`
5. Cadena de proveedores de credenciales predeterminada de AWS → AWS SigV4
### Resolución de la región
El cliente lee `AWS_REGION` del entorno si no estableces `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`), y recurre a `AWS_DEFAULT_REGION` por compatibilidad con los SDK estándar de AWS. La región es obligatoria y no hay un valor predeterminado: `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) genera un error si no se establece ni el argumento del constructor ni una variable de entorno.
## Instala un SDK
Los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic son compatibles con Claude Platform on AWS. Tu SDK proporciona `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), que gestiona la firma SigV4, la construcción de la URL base según la región y el encabezado `anthropic-workspace-id`.
```bash
pip install -U "anthropic[aws]"
```
En macOS con Python de Homebrew u otros entornos de Python administrados externamente, `pip install` puede fallar con un error PEP 668 `externally-managed-environment`. Primero crea y activa un entorno virtual: `python3 -m venv .venv && source .venv/bin/activate`.
```bash
npm install @anthropic-ai/aws-sdk
```
```bash
dotnet add package Anthropic.Aws
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.3.0")
implementation("com.anthropic:anthropic-java-aws:3.3.0")
```
```xml Maven
com.anthropic
anthropic-java
3.3.0
com.anthropic
anthropic-java-aws
3.3.0
```
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
```bash
gem install anthropic aws-sdk-core
```
Los clientes del SDK para Claude Platform on AWS están en beta.
## Modelos disponibles
Los siguientes modelos están disponibles en Claude Platform on AWS:
| Model | Model ID |
| :---------------------------------------------------------------------------------------------------- | :------------------ |
| Claude Fable 5.1 | `claude-fable-5-1` |
| Claude Fable 5 | `claude-fable-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` |
| 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` |
| Claude Haiku 5.5 | `claude-haiku-5-5` |
| Claude Haiku 4.5 | `claude-haiku-4-5` |
Los ID de modelo son idénticos a los de la Claude API de primera parte. No hay ARN al estilo de Bedrock ni prefijos `anthropic.`.
Los nuevos modelos normalmente se lanzan en Claude Platform on AWS el mismo día que en la Claude API de primera parte.
¿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.
## Realizar solicitudes
Claude Platform on AWS usa los mismos endpoints de API que la Claude API de primera parte. Las diferencias son la URL base, el método de autenticación y el encabezado `anthropic-workspace-id`, que identifica el [espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#workspaces) al que se dirige una solicitud. El encabezado es obligatorio en las solicitudes de inferencia y de recursos, como las llamadas a la Messages API, la Models API, la Files API y los endpoints de Claude Managed Agents. Las solicitudes a la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api) no lo requieren.
Antes de ejecutar estos ejemplos, completa los pasos de [Antes de realizar llamadas a la API](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#before-making-api-calls).
```bash cURL
# Reemplaza us-west-2 con tu región de AWS tanto en la URL como en --aws-sigv4
# Omite el encabezado x-amz-security-token si usas credenciales de usuario de IAM a largo plazo
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Reemplaza us-west-2 con tu región de AWS
# ant lee ANTHROPIC_API_KEY. Genera una clave en la consola de AWS
# (consulta la autenticación con clave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
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;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
El cliente lee `AWS_REGION` (o `AWS_DEFAULT_REGION`) y `ANTHROPIC_AWS_WORKSPACE_ID` del entorno. Puedes anular cualquiera de ellos pasando `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) o `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `AwsClientOptions.WorkspaceId`) al crear el cliente. Tanto la región como el ID del espacio de trabajo son obligatorios. El constructor genera un error si alguno de ellos no se puede resolver.
El encabezado `x-amz-security-token` (cURL) solo es necesario para credenciales temporales, como roles de IAM, SSO o STS. Omítelo cuando uses credenciales de usuario de IAM de larga duración. Los clientes del SDK gestionan esto automáticamente según el origen de las credenciales.
El valor de `--aws-sigv4` sigue el formato `aws:amz::`. El nombre del servicio SigV4 es `aws-external-anthropic`, y la región debe coincidir con la región de la URL de tu endpoint. Una discrepancia en cualquiera de ellos produce un error genérico de rechazo de firma en lugar de un diagnóstico específico.
### Ventana de contexto
Los tamaños de la "context window" (ventana de contexto) en Claude Platform on AWS son idénticos a los de la Claude API de primera parte. Consulta [Ventanas de contexto](https://platform.claude.com/docs/es/build-with-claude/context-windows) para conocer los límites por modelo.
## Compatibilidad de funciones
Claude Platform on AWS usa directamente los endpoints de la Claude API, lo que significa que obtienes paridad total de funciones con la Claude API de primera parte (excepto donde se indica en las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported)):
* **Acceso a funciones:** Como Anthropic opera ambas plataformas, la mayoría de las nuevas funciones y encabezados beta están disponibles en Claude Platform on AWS sin un paso de integración separado. Consulta las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported) para conocer las excepciones.
* **Funciones beta:** Pasa el encabezado estándar `anthropic-beta` para acceder a las funciones beta, igual que lo harías con la Claude API.
* **Agent Skills:** Usa [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview) prediseñadas y personalizadas con el mismo parámetro `container.skills` que en la Claude API. Todas las Skills prediseñadas (PowerPoint, Excel, Word, PDF) funcionan de inmediato.
* **Ejecución de código:** Ejecuta código en el entorno aislado administrado por Anthropic usando la [herramienta de ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool).
* **Uso de herramientas:** Todas las [capacidades de "tool use" (uso de herramientas)](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview) están disponibles, excepto los conjuntos de herramientas de uso de computadora y uso de navegador; consulta [Funciones no compatibles](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Pensamiento:** El [pensamiento adaptativo](https://platform.claude.com/docs/es/build-with-claude/thinking), el [parámetro de esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) y, en los modelos que lo admiten, el ["extended thinking" (pensamiento extendido)](https://platform.claude.com/docs/es/build-with-claude/extended-thinking) funcionan con los mismos parámetros que en la Claude API.
* **Streaming:** Compatibilidad completa con "streaming" SSE para respuestas en tiempo real.
* **Procesamiento por lotes:** Envía solicitudes por lotes para cargas de trabajo de alto rendimiento.
* **Almacenamiento en caché de prompts:** Almacena en caché herramientas, "system prompts" (indicaciones del sistema) e historial de mensajes para reducir la latencia y el costo. Todas las capacidades de "prompt caching" (almacenamiento en caché de prompts) (TTL de 5 minutos, TTL de 1 hora y almacenamiento en caché automático) están disponibles.
* **Files API:** Sube archivos y haz referencia a ellos en distintas solicitudes.
* **Claves de cifrado administradas por el cliente (CMEK):** [CMEK](https://platform.claude.com/docs/es/manage-claude/cmek) está disponible solo con claves de [AWS KMS](https://platform.claude.com/docs/es/manage-claude/cmek-aws-kms). No se pueden registrar claves de Google Cloud KMS ni de Azure Key Vault. La clave debe ser una clave de KMS de una sola región en la misma cuenta y región de AWS que el espacio de trabajo al que está asociada, y su política de clave debe otorgar acceso a la entidad principal de servicio `aws-external-anthropic.amazonaws.com`; consulta [Configura CMEK en Claude Platform on AWS](https://platform.claude.com/docs/es/manage-claude/cmek-claude-platform-on-aws). Registra y asocia claves en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console); los endpoints de claves externas también están disponibles, autorizados mediante [acciones de IAM](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#encryption-keys). No hay un paso de validación separado: la clave se valida implícitamente cuando la asocias a un espacio de trabajo (la llamada de asociación realiza una ronda de cifrado/descifrado), por lo que un problema con la política de clave aparece en el momento de la asociación y no en el registro.
* **Compliance API:** La [Compliance API](https://platform.claude.com/docs/es/manage-claude/compliance-api) está disponible. El acceso se autoriza mediante la [acción `ListComplianceActivities`](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#compliance) de AWS IAM.
Consulta la [tabla comparativa](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock) para conocer las diferencias de disponibilidad de funciones respecto a Amazon Bedrock.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview) está disponible en Claude Platform on AWS, incluidos [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), [implementaciones programadas](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments), [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), [webhooks](https://platform.claude.com/docs/es/managed-agents/webhooks), [orquestación multiagente](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration) y [sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes).
Las sesiones y los workers autoalojados en Claude Platform on AWS difieren de Claude Managed Agents de primera parte en tres aspectos:
* **Reautenticación de sesiones autónomas:** Una sesión puede ejecutarse de forma autónoma, sin ningún [evento de usuario](https://platform.claude.com/docs/es/managed-agents/reference#event-types), durante un máximo de 6 horas. Después de 6 horas, la sesión requiere reautenticación antes de continuar. Para reautenticarte, envía cualquier evento con rol de usuario a la sesión (consulta [Eventos y streaming](https://platform.claude.com/docs/es/managed-agents/events-and-streaming)). Claude Managed Agents de primera parte no tiene límite de tiempo de ejecución para sesiones autónomas.
* **[Almacenes de memoria en entornos autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory):** Una sesión que se ejecuta en un entorno autoalojado no puede adjuntar almacenes de memoria; una sesión que incluya uno se rechaza al crearse. Las sesiones en entornos en la nube adjuntan almacenes de memoria como de costumbre. En Claude Managed Agents de primera parte, las sesiones tanto en entornos en la nube como autoalojados pueden adjuntar almacenes de memoria.
* **[Autenticación de workers en entornos autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#prerequisites):** Un worker se autentica con AWS IAM (SigV4) o con una [clave de API generada en la consola de AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#api-key-authentication), no con una clave de entorno. Las claves de entorno generadas en la Claude Console no funcionan con el endpoint de Claude Platform on AWS.
### Funciones no compatibles
Las siguientes capacidades no están disponibles actualmente en Claude Platform on AWS:
* **Preparación para HIPAA:** El programa de preparación para HIPAA de Anthropic no está disponible. Consulta [API y retención de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention).
* **Conjuntos de herramientas de uso de computadora y uso de navegador:** `computer_toolset_20260801` y `browser_toolset_20260801` no están disponibles actualmente en Claude Platform on AWS. Las versiones beta de la herramienta de uso de computadora siguen disponibles para los modelos indicados en [Versiones anteriores de la herramienta](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
- **Admin API:** Están disponibles los endpoints de espacios de trabajo (crear, obtener, listar, actualizar y archivar en `/v1/organizations/workspaces`), los endpoints de claves externas (registrar, obtener, listar, actualizar y eliminar en `/v1/organizations/external_keys`, para [CMEK](https://platform.claude.com/docs/es/manage-claude/cmek); las claves se validan al adjuntarse a un espacio de trabajo en lugar de mediante un endpoint de validación) y los [endpoints de destinos de telemetría](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#telemetry-destinations). Otros endpoints de la Admin API (miembros de la organización, miembros del espacio de trabajo, invitaciones, claves de API, informes de uso, informes de costos e informes de límites de velocidad) no están disponibles actualmente. En su lugar, consulta los datos de uso y costos en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console). AWS IAM gestiona la membresía de la organización.
- **Gestión de miembros del espacio de trabajo:** No está disponible agregar ni quitar usuarios de espacios de trabajo individuales. Las políticas de AWS IAM sobre los ARN de los espacios de trabajo controlan el acceso.
- **Espacio de trabajo de Claude Code y Analytics API:** El espacio de trabajo de Claude Code con límites de velocidad automáticos no está disponible. El uso de Claude Code aparece en la vista general de uso en lugar de en una pantalla dedicada.
- **Autenticación OAuth:** No es compatible. Usa autenticación SigV4 o con clave de API.
- **Modo rápido:** No está disponible en Claude Platform on AWS.
- **Endpoints de API compatibles con OpenAI:** No están disponibles en Claude Platform on AWS.
- **Túneles MCP:** Solo se admiten servidores MCP expuestos a través de internet pública.
## Residencia de datos
Claude Platform on AWS admite las siguientes geografías de inferencia:
* **US:** La inferencia permanece dentro de centros de datos de EE. UU. Se aplica un multiplicador de precio de 1.1x.
* **Global:** La inferencia puede enrutarse a cualquier centro de datos operado por Anthropic en todo el mundo. Se aplican los precios estándar.
La región de AWS a la que está vinculado tu espacio de trabajo controla a qué endpoint de gateway llamas y dónde se delimitan los recursos del lado de AWS (IAM, CloudTrail, facturación). No fija dónde se ejecuta la inferencia del modelo. Para fijar la inferencia a una geografía específica, establece `inference_geo` en cada solicitud o configura un valor predeterminado del espacio de trabajo.
Establece la geografía de inferencia por solicitud con el parámetro `inference_geo`:
El parámetro `inference_geo` es compatible con Claude 4.6 y modelos posteriores. Las solicitudes con `inference_geo` en Claude Opus 4.5, Claude Sonnet 4.5 (obsoleto) o Claude Haiku 4.5 devuelven un error 400. Consulta [Residencia de datos](https://platform.claude.com/docs/es/manage-claude/data-residency) para obtener detalles sobre la disponibilidad de modelos.
```bash cURL
# Reemplaza us-west-2 con tu región de AWS tanto en la URL como en --aws-sigv4
# Omite el encabezado x-amz-security-token si usas credenciales de usuario IAM a largo plazo
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"inference_geo": "us",
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Reemplaza us-west-2 con tu región de AWS
# ant lee ANTHROPIC_API_KEY. Genera una clave en la consola de AWS
# (consulta la autenticación con clave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--inference-geo us \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
inference_geo="us",
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
InferenceGeo = "us",
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
InferenceGeo: anthropic.String("us"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
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;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.inferenceGeo("us")
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
inferenceGeo: 'us',
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Si omites `inference_geo`, la solicitud usa el `default_inference_geo` del espacio de trabajo si hay uno configurado; de lo contrario, `global`.
Los controles de geografía de inferencia a nivel de espacio de trabajo (`allowed_inference_geos` y `default_inference_geo`) también están disponibles en Claude Platform on AWS. Consulta [Restricciones a nivel de espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/data-residency#workspace-level-restrictions).
## Espacios de trabajo
Las solicitudes de inferencia y de recursos en Claude Platform on AWS se dirigen a un "workspace" (espacio de trabajo). Pasas el ID del espacio de trabajo en el encabezado `anthropic-workspace-id` en estas llamadas a la API. Los ID de espacio de trabajo usan el formato etiquetado `wrkspc_` seguido de un identificador alfanumérico (por ejemplo, `wrkspc_01AbCdEf23GhIj`). Consulta [Obtén el ID de tu espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id) si aún no lo tienes.
### Alcance del espacio de trabajo
Los espacios de trabajo están vinculados a una sola región de AWS. Un espacio de trabajo creado en `us-west-2` solo puede accederse a través del endpoint de `us-west-2`. El uso, las cuotas, los costos, los archivos, los lotes y las Skills se agregan por espacio de trabajo, lo que te proporciona desgloses por región en la Claude Console.
Los espacios de trabajo también sirven como el recurso principal de IAM para Claude Platform on AWS. Concedes o deniegas el acceso a espacios de trabajo específicos mediante políticas de AWS IAM usando el ARN del espacio de trabajo. El segmento de recurso del ARN es el mismo ID con prefijo `wrkspc_` que pasas en el encabezado `anthropic-workspace-id`:
```text wrap
arn:aws:aws-external-anthropic:{region}:{account-id}:workspace/{workspace-id}
```
Por ejemplo:
```text wrap
arn:aws:aws-external-anthropic:us-west-2:123456789012:workspace/wrkspc_01AbCdEf23GhIj
```
Consulta [Políticas de IAM](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#iam-policies) para ver ejemplos de políticas.
### Gestión de espacios de trabajo
Crea espacios de trabajo adicionales, cambia el nombre de un espacio de trabajo o archívalo desde la página **Workspaces** de la consola de AWS o con los endpoints de espacios de trabajo de la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api). Estos endpoints no requieren el encabezado `anthropic-workspace-id`. Crear y listar actúan sobre la organización; obtener, actualizar y archivar toman el ID del espacio de trabajo en la ruta de la URL. Un nuevo espacio de trabajo queda vinculado a la región de AWS del endpoint al que llamas para crearlo (consulta [Alcance del espacio de trabajo](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#workspace-scoping)). Con el rol Admin, también puedes crear, cambiar el nombre y archivar espacios de trabajo desde la página **Workspaces** de la Claude Console.
## Uso de la Claude Console
Claude Platform on AWS usa la Claude Console estándar en [platform.claude.com](https://platform.claude.com). Cuando inicias sesión desde la consola de AWS, aparece un indicador **Account managed by AWS** en la parte inferior izquierda de la barra lateral de la Claude Console y la Console se limita a tu organización de Claude Platform on AWS. Proporciona análisis de uso, desgloses de costos, visibilidad de límites de velocidad, gestión de espacios de trabajo y páginas para gestionar archivos, Agent Skills, trabajos por lotes y recursos de Claude Managed Agents (agentes, sesiones, entornos, bóvedas de credenciales, almacenes de memoria y webhooks).
### Inicio de sesión
El acceso a la Claude Console está federado a través de AWS IAM. Consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#set-up-your-account) para ver el flujo completo de inicio de sesión por primera vez. En resumen:
1. Asume un rol de IAM con el permiso `aws-external-anthropic:AssumeConsole`. Consulta [Acciones de IAM para Claude Platform on AWS](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#console-access).
2. Navega a la página de Claude Platform on AWS en la [consola de AWS](https://console.aws.amazon.com/).
3. Elige **Open Claude Console**. La consola de AWS emite un JWT y te redirige a `platform.claude.com`.
4. En el primer inicio de sesión, se te solicita una dirección de correo electrónico. Ingresa tu correo electrónico de trabajo. La plataforma aprovisiona tu usuario de la Claude Console justo a tiempo.
Hay dos roles de la Claude Console disponibles: **Admin** y **Developer**. El rol Admin otorga acceso a todas las páginas y configuraciones de la Claude Console disponibles para Claude Platform on AWS. El rol Developer otorga acceso de lectura a la información de uso, costos, límites de velocidad y espacios de trabajo. Contacta a tu representante de cuenta de Anthropic para asignar el rol Admin o Developer a una entidad principal.
### Páginas disponibles
La columna **A través del gateway de AWS** indica si la página lee y escribe datos a través del gateway de AWS (y, por lo tanto, está regida por las [acciones de IAM](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions)). Las páginas marcadas con **No** leen metadatos a nivel de organización directamente de Anthropic y omiten las comprobaciones de acciones de IAM.
| Página | Disponible | A través del gateway de AWS | Notas |
| --------------------- | ------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Usage** | Sí | No | Consulta el uso de tokens por modelo, espacio de trabajo y dimensión. Los datos pueden tardar unos minutos en aparecer después de una solicitud. |
| **Cost** | Sí | No | Consulta los desgloses de costos por modelo y espacio de trabajo. AWS Cost Explorer muestra la partida agregada de [Claude Consumption Unit (CCU)](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#billing). |
| **Rate limits** | Sí | No | Consulta los límites de velocidad (solo lectura). Los aumentos de nivel se gestionan a través de tu representante de cuenta de Anthropic; consulta [Límites de velocidad y cuotas](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas). |
| **Workspaces** | Sí | Sí (excepto los límites de gasto) | Consulta los espacios de trabajo por región. Con el rol Admin, también puedes crear, cambiar el nombre y archivar espacios de trabajo, y establecer [límites de gasto](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#spend-limits) por espacio de trabajo. |
| **Encryption keys** | Sí | Sí | Una sección de la página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`) en la Claude Console, que se muestra mientras **Organization** está seleccionado en el menú desplegable de la parte superior de la página. Registra allí las claves de AWS KMS para [CMEK](https://platform.claude.com/docs/es/manage-claude/cmek-claude-platform-on-aws) (rol Admin). Para adjuntar una clave registrada a un espacio de trabajo, selecciona el espacio de trabajo en ese menú desplegable y luego selecciona la clave en **Encryption key**. |
| **Files** | Sí | Sí | Consulta y gestiona los archivos cargados. |
| **Skills** | Sí | Sí | Consulta y gestiona las Agent Skills. |
| **Batches** | Sí | Sí | Consulta y gestiona los trabajos de procesamiento por lotes. |
| **Agents** | Sí | Sí | Consulta y gestiona las definiciones de agentes. |
| **Sessions** | Sí | Sí | Consulta las sesiones de agentes y el historial de eventos. |
| **Environments** | Sí | Sí | Consulta y gestiona las configuraciones de sandbox en la nube para las sesiones. |
| **Credential vaults** | Sí | Sí | Consulta y gestiona las bóvedas de credenciales para la autenticación de sesiones. |
| **Memory stores** | Sí | Sí | Consulta y gestiona la memoria persistente de los agentes. |
| **Webhooks** | Sí | Sí | Consulta y gestiona los endpoints de webhooks. |
| **API keys** | No | N/A | Gestiona las claves de API en la consola de AWS (**Claude Platform on AWS → API keys**). Consulta [Autenticación con clave de API](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | No | N/A | No aplica. AWS IAM gestiona el acceso. |
| **Billing** | Sí (limitado) | No | Establece un límite de gasto mensual de la organización; consulta [Límites de gasto](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#spend-limits). AWS Marketplace gestiona la facturación. Consulta los desgloses de costos en la página Cost. |
| **Claude Code** | No | N/A | Consulta el uso de Claude Code en la página Usage. |
### Cambio de organización
La Claude Console no admite el cambio de organización para Claude Platform on AWS. Para acceder a una organización diferente, cierra sesión y vuelve a autenticarte a través de la consola de AWS usando el rol de IAM de la cuenta de AWS de esa organización.
## Límites de velocidad y cuotas
Las organizaciones en Claude Platform on AWS se ubican en el nivel Start. Anthropic gestiona los "rate limits" (límites de velocidad) directamente, no a través de los sistemas de cuotas de AWS.
Las organizaciones en Claude Platform on AWS pueden pasar automáticamente a un nivel de uso superior a medida que acumulan un historial de facturas pagadas de AWS Marketplace. El flujo de autoservicio **Request tier increase** de la Claude Console no está disponible: la página Rate limits te dirige a tu representante de cuenta de Anthropic en su lugar.
Para solicitar límites más altos, contacta a tu representante de cuenta de Anthropic o al [soporte de Anthropic](https://support.claude.com). Incluye lo siguiente en tu solicitud:
* Los modelos cuyos límites necesitas aumentar
* Los tokens de entrada por minuto y los tokens de salida por minuto máximos para cada modelo (no totales diarios)
* La proporción aproximada de tu entrada que corresponde a contexto almacenado en caché o repetido (las lecturas de caché no cuentan para los límites de tokens de entrada en la mayoría de los modelos; consulta [ITPM con reconocimiento de caché](https://platform.claude.com/docs/es/api/rate-limits#cache-aware-itpm))
Los niveles de uso son escalones fijos: cada nivel combina límites de velocidad con un [tope de gasto mensual](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#spend-limits), y pasar a un nivel superior aumenta ambos. Para obtener detalles de los niveles y los límites por modelo, consulta [Límites de velocidad](https://platform.claude.com/docs/es/api/rate-limits).
## Facturación
Claude Platform on AWS factura a través de [AWS Marketplace](https://aws.amazon.com/marketplace). El uso se expresa en Claude Consumption Units (CCU), se mide por hora y se factura mensualmente a mes vencido en tu factura de AWS. Las CCU no son créditos prepagados. No hay saldo ni compromiso de CCU.
Para conocer el precio de las CCU, la mecánica de conversión, la aplicación de descuentos y las tarifas de tokens por modelo, consulta [Precios de Claude Platform on AWS](https://platform.claude.com/docs/es/about-claude/pricing#claude-platform-on-aws-pricing).
### Límites de gasto
Los niveles de uso Start, Build y Scale tienen cada uno un tope de gasto mensual; consulta los [topes de gasto por nivel](https://platform.claude.com/docs/es/api/rate-limits#spend-limits) para ver los valores actuales. Cuando el uso de tu organización en el mes calendario alcanza el tope de su nivel, las solicitudes a la API fallan con el [error de tope de gasto](https://platform.claude.com/docs/es/api/rate-limits#reaching-your-spend-cap) hasta las 00:00 UTC del primer día del mes siguiente, y reintentar antes no tiene éxito. El tope de gasto y los límites de velocidad pertenecen al mismo nivel. Para aumentar el tope, o para restablecer el acceso después de alcanzarlo, solicita un aumento de nivel a través de tu representante de cuenta de Anthropic o del [soporte de Anthropic](https://support.claude.com) (consulta [Límites de velocidad y cuotas](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
También puedes establecer tus propios límites de gasto mensuales por debajo del tope, después de agregar al menos un destinatario en **Email recipients** en la página Billing:
* **Límite de gasto de la organización:** Ve a [Settings > Billing](https://platform.claude.com/settings/billing) en la [Claude Console](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#using-the-claude-console) para establecer un límite de gasto mensual.
* **Límites de gasto del espacio de trabajo:** En la página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) de la Claude Console, selecciona un espacio de trabajo. En el panel que se abre, haz clic en **Spend limits**.
Cuando el uso alcanza un límite que estableciste, las solicitudes fallan con HTTP 400 (consulta el [error de límite de gasto](https://platform.claude.com/docs/es/api/rate-limits#setting-your-own-spend-limit)) hasta las 00:00 UTC del primer día del mes siguiente, o hasta que aumentes o elimines el límite.
El gasto se calcula a precios de lista y puede tardar unas 2 horas en reflejar el uso reciente, por lo que el uso puede superar el tope o un límite antes de que las solicitudes empiecen a fallar. El excedente se factura. Cuando el tope del nivel o un límite de gasto de la organización detiene tus solicitudes, se envía un aviso por correo electrónico a los destinatarios indicados en **Email recipients** en la página Billing. Los destinatarios basados en roles, como todos los administradores, no están disponibles en Claude Platform on AWS. El aviso del tope del nivel también se envía a la dirección de correo electrónico usada al registrarse en AWS Marketplace.
## Monitoreo y registro
AWS CloudTrail puede capturar todas las solicitudes a Claude Platform on AWS. Las operaciones de espacios de trabajo, claves externas, destinos de telemetría, cumplimiento, bóvedas y webhooks se registran como eventos de administración (Management events) de forma predeterminada. Las operaciones de inferencia, lotes, archivos, skills, modelos, perfiles de usuario y Claude Managed Agents (excepto bóvedas y webhooks) se clasifican como eventos de datos (Data events) y requieren una configuración explícita de registro de eventos de datos, lo que genera cargos adicionales de CloudTrail. Consulta la [referencia de acciones de IAM](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#route-to-action-mapping) para ver la clasificación completa de tipos de eventos y la [documentación de AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) para obtener detalles de configuración.
### ID de solicitud
Cada respuesta incluye dos ID de solicitud en los encabezados de respuesta:
* **ID de solicitud de AWS (`x-amzn-requestid`):** El ID principal, indexado en CloudTrail. Úsalo al investigar solicitudes mediante herramientas de AWS o al contactar al soporte de AWS.
* **ID de solicitud de Anthropic (`request-id`):** El ID secundario. Úsalo al contactar al soporte de Anthropic.
```bash cURL
# Reemplaza us-west-2 con tu región de AWS tanto en la URL como en --aws-sigv4
# -i incluye los encabezados de la respuesta en la salida
# Omite el encabezado x-amz-security-token si usas credenciales de usuario de IAM a largo plazo
curl -i "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Reemplaza us-west-2 con tu región de AWS
# ant lee ANTHROPIC_API_KEY. Genera una clave en la consola de AWS
# (consulta la autenticación con clave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
# --debug imprime la respuesta HTTP, incluidos los encabezados X-Amzn-Requestid y
# Request-Id, en stderr
ant --debug messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
response = client.messages.with_raw_response.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.headers.get("x-amzn-requestid")) # AWS request ID
print(response.headers.get("request-id")) # Anthropic request ID
message = response.parse()
print(message.content)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const { data: message, response } = await client.messages
.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
})
.withResponse();
console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var response = await client.WithRawResponse.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
var response *http.Response
message, err := client.Messages.New(
context.Background(),
anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
},
option.WithResponseInto(&response),
)
if err != nil {
panic(err)
}
fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id")) // Anthropic request ID
fmt.Println(message.Content)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
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(AwsBackend.fromEnv())
.build();
HttpResponseFor response = client.messages().withRawResponse().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(response.headers().values("x-amzn-requestid").get(0)); // AWS request ID
IO.println(response.requestId().orElse(null)); // Anthropic request ID
IO.println(response.parse().content());
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$response = $client->messages->raw->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse()->content;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
# Lee los encabezados de respuesta en el middleware por solicitud, que recibe la
# respuesta HTTP sin procesar antes de que el SDK la analice
aws_request_id = nil
anthropic_request_id = nil
read_request_ids = lambda do |request, call_next|
response = call_next.call(request)
# Las claves en response.headers están en minúsculas
aws_request_id = response.headers["x-amzn-requestid"]
anthropic_request_id = response.headers["request-id"]
response
end
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }],
request_options: { middleware: [read_request_ids] }
)
puts aws_request_id # AWS request ID
puts anthropic_request_id # Anthropic request ID
puts message.content
```
Anthropic recomienda registrar tu actividad al menos en un período móvil de 30 días para comprender los patrones de uso e investigar problemas.
AWS CloudTrail se configura dentro de tu cuenta de AWS. Habilitar el registro no otorga a AWS ni a Anthropic acceso a tu contenido más allá de lo necesario para la facturación y el funcionamiento del servicio.
## Migración desde Amazon Bedrock
Si actualmente usas Claude en Bedrock, migrar a Claude Platform on AWS requiere cambios en toda tu integración. La firma SigV4 sigue siendo compatible, pero cambian el contexto de firma, la URL base, el formato de la API, los ID de modelo, el cliente y el paquete del SDK, el formato de streaming, los encabezados de solicitud y la disponibilidad por región. Claude Platform on AWS también aprovisiona una nueva organización de Anthropic. La siguiente tabla resume las diferencias.
### Qué cambia
La diferencia de migración depende de la integración de Bedrock desde la que vengas. La siguiente tabla muestra tanto la [integración actual de Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock) (Messages API en `bedrock-mantle.{region}.api.aws`) como la [integración heredada de InvokeModel](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy).
| Aspecto | Desde [Claude in Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock) | Desde [Amazon Bedrock (Opus 4.6 y anteriores)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy) | A Claude Platform on AWS |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **URL base** | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` | `aws-external-anthropic.{region}.api.aws` |
| **Formato de la API** | Messages API en `/anthropic/v1/messages` | Bedrock Converse / InvokeModel | Claude API (`/v1/{endpoint}`) |
| **ID de modelo** | anthropic.claude-haiku-4-5 | anthropic.claude-haiku-4-5-20251001-v1:0 (con un prefijo de perfil de inferencia `us.` o `global.`) | claude-haiku-4-5 |
| **Cliente del SDK** | `AnthropicBedrockMantle` | `AnthropicBedrock` / SDK de Bedrock | Cliente específico de la plataforma (consulta [Instala un SDK](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#install-an-sdk)), en beta |
| **Paquete del SDK** | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`), o el SDK de AWS | `anthropic[aws]` (typescript: `@anthropic-ai/aws-sdk`; csharp: `Anthropic.Aws`; go: `github.com/anthropics/anthropic-sdk-go/aws`; java: `com.anthropic:anthropic-java-aws`; php: `anthropic-ai/sdk`; ruby: `anthropic`) (consulta [Instala un SDK](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#install-an-sdk)) |
| **Nombre de servicio SigV4** | `bedrock-mantle` | `bedrock` | `aws-external-anthropic` |
| **Formato de streaming** | SSE | AWS EventStream | SSE (igual que la Claude API) |
| **Encabezado de espacio de trabajo** | No aplica | No aplica | `anthropic-workspace-id`, obligatorio en solicitudes de inferencia y de recursos |
| **Disponibilidad por región** | Consulta [Regiones de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Consulta [Regiones de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Todas las regiones comerciales de AWS |
| **Organización de Anthropic** | No se requiere | No se requiere | Se crea una nueva organización al registrarse. Las organizaciones existentes no se pueden convertir (consulta [Cambio desde una organización de Anthropic existente](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#moving-from-an-existing-anthropic-organization)) |
Si usas la integración actual de Bedrock, el formato del cuerpo de la solicitud ya es el de la Messages API. Los cambios son la URL base, el nombre de servicio SigV4, los ID de modelo y agregar el encabezado `anthropic-workspace-id`. Si usas la API heredada InvokeModel o Converse, también tendrás que reescribir las estructuras de solicitud y respuesta al formato de la Messages API. Consulta [Claude en Amazon Bedrock (Opus 4.6 y anteriores)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy) para ver la correspondencia de estructuras de solicitud.
### Qué obtienes
* Acceso normalmente el mismo día a nuevos modelos y funciones (consulta las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported))
* Agent Skills para la generación de documentos (PowerPoint, Excel, Word, PDF)
* Ejecución de código en el sandbox gestionado de Anthropic
* Funciones beta de la Claude API que Amazon Bedrock no ofrece, mediante el encabezado `anthropic-beta` (consulta las [limitaciones de funciones](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#features-not-supported))
* Claude Console para visibilidad de cuotas y análisis de uso
* Soporte directo de Anthropic
* Autenticación con clave de API como alternativa a SigV4 (consulta [Autenticación con clave de API](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#api-key-authentication))
### Qué se mantiene igual
* Autenticación de AWS IAM (SigV4)
* AWS como la parte que factura. El canal de facturación cambia del servicio nativo de AWS a AWS Marketplace (consulta [Consideraciones comerciales](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#commercial-considerations)).
* Consumo de compromisos de AWS
### Errores comunes en la migración
**Habilita primero la federación de identidades web salientes.** Si tu cuenta de AWS no ha usado antes Claude Platform on AWS, debes [habilitar la federación de identidades web salientes](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) una vez por cuenta antes de realizar solicitudes. Sin este paso, todas las solicitudes fallan con un error de federación (consulta [Habilita la federación de identidades web salientes](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) para ver el error exacto y la solución). Este paso no es necesario para Bedrock.
**Zero Data Retention (ZDR) es opcional en Claude Platform on AWS.** En Bedrock, AWS es el procesador de datos y Anthropic no retiene las entradas ni las salidas de inferencia. El programa ZDR de Anthropic no aplica allí. En Claude Platform on AWS, Anthropic procesa los datos de inferencia como procesador de datos independiente, y ZDR sigue el modelo de la Claude API de primera parte: está disponible bajo solicitud a través de tu representante de cuenta de Anthropic. Confirma la inscripción en ZDR antes de migrar cargas de trabajo de producción que dependan de garantías de retención de datos.
### Consideraciones comerciales
* **Términos de servicio de Anthropic:** Usar Claude Platform on AWS requiere aceptar los Términos de Servicio Comerciales y la Política de Uso de Anthropic. Si tu organización aún no los ha aceptado (por ejemplo, si solo has usado Claude a través de Bedrock), se te solicitará durante la configuración de la cuenta. Consulta [Configura tu cuenta](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#set-up-your-account).
* **Descuentos y ofertas privadas:** Los descuentos negociados y las ofertas privadas de AWS Marketplace no se transfieren automáticamente entre Bedrock y Claude Platform on AWS. Trabaja con tu representante de cuenta de Anthropic para establecer los términos comerciales de Claude Platform on AWS.
## Políticas de IAM
Claude Platform on AWS se integra con AWS IAM para el control de acceso. Concedes o deniegas el acceso a acciones específicas de la API en espacios de trabajo específicos usando la sintaxis estándar de políticas de IAM.
El nombre de servicio SigV4 y el espacio de nombres de acciones de IAM es `aws-external-anthropic`. Las acciones siguen el patrón `aws-external-anthropic:` (por ejemplo, `aws-external-anthropic:CreateInference`).
### Ejemplo: denegar la inferencia por lotes
La siguiente política permite la inferencia en tiempo real mientras bloquea el procesamiento por lotes:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aws-external-anthropic:CreateInference",
"aws-external-anthropic:CountTokens",
"aws-external-anthropic:GetModel",
"aws-external-anthropic:ListModels",
"aws-external-anthropic:GetWorkspace"
],
"Resource": "arn:aws:aws-external-anthropic:*:*:workspace/*"
},
{
"Effect": "Allow",
"Action": "aws-external-anthropic:ListWorkspaces",
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"aws-external-anthropic:CreateBatchInference",
"aws-external-anthropic:GetBatchInference",
"aws-external-anthropic:ListBatchInferences"
],
"Resource": "*"
}
]
}
```
La acción `GetBatchInference` autoriza tanto la ruta de metadatos del lote como la ruta de resultados del lote. Denegarla bloquea ambas lecturas. Para una política solo de denegación adecuada para cargas de trabajo sensibles a ZDR, consulta [Bloqueo de funciones para un espacio de trabajo sensible a ZDR](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#feature-lockdown-for-a-zdr-sensitive-workspace).
`ListWorkspaces` tiene alcance de cuenta, por lo que aparece en una declaración Allow separada con `"Resource": "*"`. Especificar un ARN de espacio de trabajo en una acción con alcance de cuenta no tiene efecto (consulta [Automatización del aprovisionamiento](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#provisioning-automation)).
Esta política asume autenticación AWS SigV4. Si la entidad principal se autentica con una clave de API, agrega también `aws-external-anthropic:CallWithBearerToken` a la declaración Allow con `"Resource": "*"`. `CallWithBearerToken` es una acción de la capa de autenticación sin ruta que no se vincula a un ARN de espacio de trabajo. Consulta [Aislamiento de espacios de trabajo por cliente](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#per-customer-workspace-isolation) para ver el patrón de dos declaraciones.
### Políticas administradas
AWS proporciona cinco políticas administradas (`AnthropicFullAccess`, `AnthropicReadOnlyAccess`, `AnthropicInferenceAccess`, `AnthropicLimitedAccess` y `AnthropicSelfHostedEnvironmentAccess`) para patrones de acceso comunes. Para conocer las acciones que otorga cada política, la lista completa de acciones de IAM, la correspondencia de rutas a acciones y ejemplos adicionales de políticas, consulta [Acciones de IAM para Claude Platform on AWS](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#managed-policies).
## Próximos pasos
Explora las funciones y capacidades avanzadas de Claude.
Conoce los precios de Claude Platform on AWS y las tarifas de Claude Consumption Unit.
A medida que se lanzan modelos más seguros y capaces, Anthropic retira periódicamente los más antiguos. Consulta todas las obsolescencias de la API, junto con los reemplazos recomendados.
## Recursos adicionales
Consulta el uso, los costos y los espacios de trabajo en la Claude Console. Inicia sesión a través de la consola de AWS.
Usa Claude operado por AWS si necesitas que AWS sea el único procesador de datos.
Gestiona tu suscripción y facturación de AWS Marketplace.