---
title: Claude en Amazon Bedrock (Opus 4.7 y posteriores)
url: https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock
description: Accede a los modelos Claude a través de Amazon Bedrock con autenticación, facturación y límites de seguridad nativos de AWS.
---

Esta guía te lleva paso a paso por la configuración y la realización de llamadas a la API de Claude en Amazon Bedrock. Claude en Amazon Bedrock se ejecuta en infraestructura administrada por AWS con cero acceso de operadores (el personal de Anthropic no tiene acceso a la infraestructura de inferencia), lo que te permite crear aplicaciones sensibles completamente dentro del límite de seguridad de AWS mientras usas la misma forma de la Messages API que usas con la API propia de Anthropic.

<Note>
  Esta página cubre Claude en Amazon Bedrock, que sirve Claude a través de la Messages API en `/anthropic/v1/messages` sobre infraestructura administrada por AWS. La integración anterior de Amazon Bedrock (las APIs `InvokeModel` y `Converse` con identificadores de modelo versionados por ARN) sigue disponible y está documentada en [Claude en Amazon Bedrock (Opus 4.6 y anteriores)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy). Para una alternativa operada por Anthropic en AWS con facturación a través de AWS Marketplace y acceso a funciones normalmente el mismo día, consulta [Claude Platform en AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws).
</Note>

## Acceso

Amazon Bedrock establece criterios de acceso para cada modelo Claude de forma individual. Claude Fable 5.1, Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5, Claude Opus 4.7 y Claude Haiku 4.5 están abiertos a todos los clientes de Amazon Bedrock. Para conocer los criterios actuales de cualquier otro modelo, consulta [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) en la consola de AWS. Claude Mythos Preview requiere una invitación a través de [Project Glasswing](https://anthropic.com/glasswing). Para la disponibilidad por región, consulta [Regiones](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#regions).

## Requisitos previos

Antes de comenzar, asegúrate de tener:

* Una cuenta de AWS con [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) habilitado para los modelos Claude que planeas usar.
* La [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) instalada y configurada (opcional, para la gestión de credenciales).

Claude Mythos Preview requiere además una cuenta de AWS dedicada que haya sido incluida en la lista de permitidos por el equipo de Bedrock Marketplace. Tu ejecutivo de cuenta de Anthropic puede enviar el ID de tu cuenta para su inclusión en la lista de permitidos (normalmente se procesa en un plazo de 24 horas), y AWS envía un correo electrónico de bienvenida una vez completado.

## Autenticación

Claude en Amazon Bedrock admite tres vías de autenticación. Elige la que mejor se adapte a tus requisitos de seguridad.

### Rol de servicio de Bedrock (recomendado)

Usa un rol de servicio de Bedrock con claves administradas por AWS para obtener el acceso más seguro y de larga duración:

<Steps>
  <Step title="Administrador: aprovisionar el rol de servicio">
    Un administrador de AWS aprovisiona un rol de servicio de Bedrock y otorga a los desarrolladores el permiso `iam:PassRole` sobre el ARN del rol de servicio.
  </Step>

  <Step title="Desarrollador: pasar el rol">
    Al llamar a la API, Bedrock asume el rol de servicio en tu nombre. Consulta la [documentación de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html) para saber cómo asociar el rol con tus solicitudes.
  </Step>
</Steps>

### Roles asumidos de IAM

Para acceso federado por identidad con una sesión máxima de 12 horas:

<Steps>
  <Step title="Administrador: configurar el rol de IAM">
    Crea un rol de IAM con alcance limitado a tus modelos Claude. La política de confianza nombra a tu proveedor de identidad (SAML, OIDC o AWS Identity Center). La política de permisos otorga `bedrock-mantle:CreateInference` únicamente sobre los ARN de modelo permitidos.
  </Step>

  <Step title="Desarrollador: autenticarse y asumir">
    Autentícate a través de tu proveedor de identidad corporativo y luego asume el rol de IAM. AWS STS emite credenciales temporales que el SDK o la CLI usan para firmar las solicitudes.
  </Step>
</Steps>

### Tokens bearer

Para acceso a corto plazo sin roles de IAM (máximo de 12 horas, la opción menos preferida):

<Steps>
  <Step title="Administrador: restringir los tipos de token">
    Bloquea las claves de larga duración adjuntando una política que deniegue `bedrock:CallWithBearerToken` a menos que la condición `bedrock:BearerTokenType` coincida con un token de corto plazo.
  </Step>

  <Step title="Desarrollador: generar un token">
    Usa la CLI `aws-bedrock-token-generator` para generar un token bearer. Pásalo en el encabezado `x-api-key` en cada solicitud.
  </Step>
</Steps>

## Instala un SDK

Los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic admiten Claude en Amazon Bedrock mediante un paquete o módulo específico para Bedrock.

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

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

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

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

  <Tab title="Java">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:2.73.0")
        implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java</artifactId>
            <version>2.73.0</version>
        </dependency>
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java-bedrock</artifactId>
            <version>2.73.0</version>
        </dependency>
        ```
      </Tab>
    </Tabs>
  </Tab>

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

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "aws-sdk-core"
    ```
  </Tab>
</Tabs>

## Realiza tu primera solicitud

El endpoint sigue el patrón `https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages`. A diferencia de la integración basada en `InvokeModel`, este endpoint usa streaming SSE estándar y la misma estructura de cuerpo de solicitud que la API propia de Anthropic.

El SDK resuelve las credenciales y la región usando el orden de precedencia estándar de AWS: primero los argumentos del constructor, luego las variables de entorno (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_REGION`) y, por último, el archivo de configuración de AWS y la cadena de credenciales (SSO, roles asumidos, rol de tarea de ECS, IMDS).

<Tabs>
  <Tab title="cURL">
    ```bash
    curl https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
      --aws-sigv4 "aws:amz:us-east-1:bedrock-mantle" \
      --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" \
      -d '{
        "model": "anthropic.claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [
          {"role": "user", "content": "Hello, Claude"}
        ]
      }'
    ```
  </Tab>

  <Tab title="CLI">
    La CLI `ant` no es compatible con Amazon Bedrock. Usa cURL o un SDK.
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrockMantle

    client = AnthropicBedrockMantle(aws_region="us-east-1")

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

    print(next(block.text for block in message.content if block.type == "text"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import { AnthropicBedrockMantle } from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrockMantle({
      awsRegion: "us-east-1"
    });

    const message = await client.messages.create({
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    });

    const textBlock = message.content.find((block) => block.type === "text");
    if (textBlock) {
      console.log(textBlock.text);
    }
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    var client = new AnthropicBedrockMantleClient(new() { AwsRegion = "us-east-1" });

    var message = await client.Messages.Create(new()
    {
        Model = "anthropic.claude-opus-5-5",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
    });

    foreach (var item in message.Content)
    {
        if (item.Value is TextBlock block)
        {
            Console.WriteLine(block.Text);
            break;
        }
    }
    ```
  </Tab>

  <Tab title="Go">
    ```go
    client, err := bedrock.NewMantleClient(context.Background(), bedrock.MantleClientConfig{
    	AWSRegion: "us-east-1",
    })
    if err != nil {
    	panic(err)
    }

    message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    	Model:     "anthropic.claude-opus-5-5",
    	MaxTokens: 1024,
    	Messages: []anthropic.MessageParam{
    		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
    	},
    })
    if err != nil {
    	panic(err)
    }

    for _, block := range message.Content {
    	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
    		fmt.Println(textBlock.Text)
    		break
    	}
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockMantleBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.ContentBlock;
    import com.anthropic.models.messages.Message;
    import com.anthropic.models.messages.MessageCreateParams;

    void main() {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(BedrockMantleBackend.fromEnv())
            .build();

        Message message = client.messages().create(
            MessageCreateParams.builder()
                .model("anthropic.claude-opus-5-5")
                .maxTokens(1024)
                .addUserMessage("Hello, Claude")
                .build()
        );

        message.content().stream()
                .filter(ContentBlock::isText)
                .findFirst()
                .ifPresent(block -> IO.println(block.asText().text()));
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    use Anthropic\Bedrock\MantleClient;

    $client = new MantleClient(awsRegion: 'us-east-1');

    $message = $client->messages->create(
        model: 'anthropic.claude-opus-5-5',
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello, Claude'],
        ],
    );

    echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockMantleClient.new(aws_region: "us-east-1")

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

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

<Tip>
  También puedes crear el cliente estándar con `Anthropic` (go: `anthropic.NewClient()`; java: `AnthropicOkHttpClient.builder()`; csharp: `AnthropicClient`; php: `Anthropic\Client`; ruby: `Anthropic::Client`): establece `base_url` (typescript: `baseURL`; go: `option.WithBaseURL()`; java: `.baseUrl()`; csharp: `BaseUrl`; php: `baseUrl`) en `https://bedrock-mantle.{region}.api.aws/anthropic` y pasa tu token bearer como `api_key` (typescript, php: `apiKey`; go: `option.WithAPIKey()`; java: `.apiKey()`; csharp: `ApiKey`). Esta opción solo admite autenticación con token bearer. La firma SigV4 requiere `AnthropicBedrockMantle` (csharp: `AnthropicBedrockMantleClient`; go: `bedrock.NewMantleClient`; java: `BedrockMantleBackend`; php: `MantleClient`; ruby: `Anthropic::BedrockMantleClient`).
</Tip>

## Modelos compatibles

Los ID de modelo en Claude en Amazon Bedrock llevan el prefijo de proveedor `anthropic.`. Las capacidades y comportamientos de los modelos están documentados en la página [Descripción general de modelos](https://platform.claude.com/docs/es/models/overview).

| Model                                                                                       | Model ID                          | Access                                                                                              |
| :------------------------------------------------------------------------------------------ | :-------------------------------- | :-------------------------------------------------------------------------------------------------- |
| Claude Fable 5.1                                                                            | `anthropic.claude-fable-5-1`      | Open                                                                                                |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842)) | `anthropic.claude-mythos-5-1`     | Active (verification required)                                                                      |
| Claude Fable 5                                                                              | `anthropic.claude-fable-5`        | Open                                                                                                |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))   | `anthropic.claude-mythos-5`       | Active (verification required)                                                                      |
| Claude Mythos Preview ([limited availability](https://anthropic.com/glasswing))             | `anthropic.claude-mythos-preview` | Invitation only                                                                                     |
| Claude Opus 5.5                                                                             | `anthropic.claude-opus-5-5`       | [See Access](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 5                                                                               | `anthropic.claude-opus-5`         | [See Access](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 4.8                                                                             | `anthropic.claude-opus-4-8`       | Open                                                                                                |
| Claude Opus 4.7                                                                             | `anthropic.claude-opus-4-7`       | Open                                                                                                |
| Claude Sonnet 5.5                                                                           | `anthropic.claude-sonnet-5-5`     | [See Access](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Sonnet 5                                                                             | `anthropic.claude-sonnet-5`       | Open                                                                                                |
| Claude Haiku 5.5                                                                            | `anthropic.claude-haiku-5-5`      | [See Access](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Haiku 4.5                                                                            | `anthropic.claude-haiku-4-5`      | Open                                                                                                |

Usa la versión más reciente de Claude Code con Claude en Amazon Bedrock; ejecuta `claude update` para actualizar.

<Tip>
  ¿Estás actualizando a un modelo de Claude más reciente? En Claude Code, ejecuta `/claude-api migrate` para aplicar los cambios de ID de modelo y los cambios de parámetros incompatibles en toda tu base de código. 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. Consulta [Migrar a un modelo de Claude más reciente](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

## Compatibilidad de funciones

Para ver la lista completa de funciones con su disponibilidad en Amazon Bedrock, consulta [Descripción general de funciones](https://platform.claude.com/docs/es/build-with-claude/overview).

### Funciones compatibles destacadas

* [Messages API](https://platform.claude.com/docs/es/api/messages/create) (`/anthropic/v1/messages`)
* [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching)
* [Pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking)
* [Uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview), incluidas la [herramienta Bash](https://platform.claude.com/docs/es/agents-and-tools/tool-use/bash-tool), la [herramienta de uso de computadora](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool), la [herramienta de memoria](https://platform.claude.com/docs/es/agents-and-tools/tool-use/memory-tool) y la [herramienta de editor de texto](https://platform.claude.com/docs/es/agents-and-tools/tool-use/text-editor-tool)
* [Citas](https://platform.claude.com/docs/es/build-with-claude/citations)

### Funciones no compatibles

* [Salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs)
* Fuentes de entrada (fuentes URL para imágenes y documentos, Files API)
* Herramientas del lado del servidor (ejecución de código, búsqueda web, obtención web, advisor)
* Infraestructura de agentes (Agent Skills, conector MCP, llamada programática de herramientas)
* Endpoints de API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Fallback del lado del servidor (el [parámetro `fallbacks`](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback); usa en su lugar el [patrón de fallback del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#client-side-fallback))
* Conjuntos de herramientas de [uso de computadora](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool) y [uso de navegador](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` y `browser_toolset_20260801` no están disponibles actualmente en Amazon Bedrock; las versiones beta de la herramienta de uso de computadora siguen disponibles)

## Regiones

Claude en Amazon Bedrock está disponible en las siguientes regiones de AWS. Amazon Bedrock ofrece dos tipos de endpoint:

* **Global:** enrutamiento dinámico entre todas las regiones disponibles para lograr la máxima disponibilidad. Sin recargo en el precio.
* **Regional:** el endpoint se resuelve en la única región de AWS que especifiques, para cumplir requisitos de residencia de datos. Los endpoints regionales tienen un recargo del 10 % en el precio respecto a los endpoints globales. Para enrutar entre varias regiones dentro de una zona geográfica, usa un [perfil de inferencia](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) (US, EU, JP o AU). Las regiones marcadas como **Solo en la región** en la tabla admiten enrutamiento directo a una sola región sin un perfil de inferencia.

El endpoint global está disponible para Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5 y Claude Haiku 4.5. Para Claude Fable 5.1, los endpoints regionales están disponibles actualmente solo en `us-east-1`. Claude Mythos Preview es solo regional y está disponible en `us-east-1`.

| Región de AWS    | Ubicación                              | Tipos de endpoint             |
| ---------------- | -------------------------------------- | ----------------------------- |
| `af-south-1`     | África (Ciudad del Cabo)               | Global                        |
| `ap-northeast-1` | Asia Pacífico (Tokio)                  | Global, JP, Solo en la región |
| `ap-northeast-2` | Asia Pacífico (Seúl)                   | Global                        |
| `ap-northeast-3` | Asia Pacífico (Osaka)                  | Global, JP                    |
| `ap-south-1`     | Asia Pacífico (Bombay)                 | Global                        |
| `ap-south-2`     | Asia Pacífico (Hyderabad)              | Global                        |
| `ap-southeast-1` | Asia Pacífico (Singapur)               | Global                        |
| `ap-southeast-2` | Asia Pacífico (Sídney)                 | Global, AU                    |
| `ap-southeast-3` | Asia Pacífico (Yakarta)                | Global                        |
| `ap-southeast-4` | Asia Pacífico (Melbourne)              | Global, AU, Solo en la región |
| `ca-central-1`   | Canadá (Central)                       | Global, US                    |
| `ca-west-1`      | Oeste de Canadá (Calgary)              | Global                        |
| `eu-central-1`   | Europa (Fráncfort)                     | Global, EU                    |
| `eu-central-2`   | Europa (Zúrich)                        | Global, EU                    |
| `eu-north-1`     | Europa (Estocolmo)                     | Global, EU, Solo en la región |
| `eu-south-1`     | Europa (Milán)                         | Global, EU                    |
| `eu-south-2`     | Europa (España)                        | Global, EU                    |
| `eu-west-1`      | Europa (Irlanda)                       | Global, EU, Solo en la región |
| `eu-west-2`      | Europa (Londres)                       | Global, EU                    |
| `eu-west-3`      | Europa (París)                         | Global, EU                    |
| `il-central-1`   | Israel (Tel Aviv)                      | Global                        |
| `me-central-1`   | Medio Oriente (EAU)                    | Global                        |
| `sa-east-1`      | América del Sur (São Paulo)            | Global                        |
| `us-east-1`      | Este de EE. UU. (Norte de Virginia)    | Global, US, Solo en la región |
| `us-east-2`      | Este de EE. UU. (Ohio)                 | Global, US, Solo en la región |
| `us-west-1`      | Oeste de EE. UU. (Norte de California) | Global, US                    |
| `us-west-2`      | Oeste de EE. UU. (Oregón)              | Global, US, Solo en la región |

## Cuotas

La cuota predeterminada es de 2 millones de tokens de entrada por minuto (TPM). Puedes solicitar hasta 5 millones de TPM de entrada y 500,000 TPM de salida sin aprobación adicional de Anthropic. AWS aplica límites de solicitudes por minuto (RPM) del lado de Bedrock; contacta al soporte de AWS para ajustes de RPM.

## Retención de datos

El manejo de datos para esta oferta está regido por Amazon Bedrock. Para más detalles, consulta [Protección de datos en Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html).

## Monitoreo y registro

Claude en Amazon Bedrock emite registros tanto a CloudWatch como a CloudTrail. Anthropic recomienda conservar los registros de actividad durante al menos 30 días de forma continua para comprender los patrones de uso e investigar posibles problemas.

## Soporte

Para obtener soporte, contacta a **[bedrock-ant-eap@amazon.com](mailto:bedrock-ant-eap@amazon.com)**. Incluye el ID de tu cuenta de AWS y el `request-id` de cualquier respuesta fallida de la API.

<Note>
  **Claude Mythos Preview** es un modelo de vista previa de investigación disponible para clientes invitados en Amazon Bedrock. Para más información, consulta [Project Glasswing](https://anthropic.com/glasswing).
</Note>
