---
title: Claude en Amazon Bedrock (Opus 4.6 y anteriores)
url: https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy
description: La integración heredada de Amazon Bedrock para los modelos Claude, que usa las API InvokeModel y Converse con identificadores de modelo versionados por ARN.
---

<Note>
  Esta página cubre la integración heredada de Amazon Bedrock: las API `InvokeModel` y `Converse` con identificadores de modelo versionados por ARN y codificación de event-stream de AWS. Para los modelos disponibles en el endpoint de Bedrock de la Messages API, consulta [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), que usa la Messages API en `/anthropic/v1/messages` con streaming SSE. Para una alternativa operada por Anthropic 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). Los usuarios existentes de Bedrock pueden seguir la [guía de migración](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock).
</Note>

<Warning>
  La versión más reciente del SDK envía la versión de API `2026-10-21` de forma predeterminada, incluso a través de Amazon Bedrock. Los modelos versionados por ARN de la tabla de modelos de esta página no admiten `2026-10-21` en Bedrock, y las solicitudes a ellos que la envíen pueden devolver un error 400. Si los llamas a través del SDK, mantén el SDK en la versión que usas hoy y fija esa versión donde lo instalas para que una instalación posterior no lo actualice. El ejemplo de Boto3 establece `anthropic_version` en el cuerpo de su solicitud y no se ve afectado.
</Warning>

Llamar a Claude a través de Bedrock difiere ligeramente de cómo llamarías a Claude directamente en la Claude API. Esta guía te explica cómo completar una llamada a la API a Claude en Bedrock usando uno de los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic.

Ten en cuenta que esta guía asume que ya te registraste en una [cuenta de AWS](https://portal.aws.amazon.com/billing/signup) y configuraste el acceso programático.

## Instalar y configurar la AWS CLI

1. [Instala una versión de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) igual o posterior a la versión `2.13.23`.
2. Configura tus credenciales de AWS usando el comando AWS configure (consulta [Configurar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)) o encuentra tus credenciales navegando a "Command line or programmatic access" dentro de tu panel de AWS y siguiendo las instrucciones de la ventana modal.
3. Verifica que tus credenciales funcionen:

```bash AWS CLI
aws sts get-caller-identity
```

## Instalar un SDK para acceder a Bedrock

Los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic admiten Bedrock. También puedes usar directamente un SDK de AWS como `boto3`.

<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">
    <CodeGroup>
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:3.3.0")
      implementation("com.anthropic:anthropic-java-bedrock:3.3.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>3.3.0</version>
      </dependency>
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java-bedrock</artifactId>
          <version>3.3.0</version>
      </dependency>
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.bedrock.backends.BedrockBackend;
      import com.anthropic.models.messages.MessageCreateParams;
      import com.anthropic.models.messages.Message;
      import com.anthropic.models.messages.Model;

      public class BasicMessage {
          public static void main(String[] args) {
              AnthropicClient client = AnthropicOkHttpClient.builder()
                  .backend(BedrockBackend.fromEnv())
                  .build();

              MessageCreateParams params = MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_4_6)
                  .maxTokens(1024L)
                  .addUserMessage("What is the capital of France?")
                  .build();

              Message response = client.messages().create(params);
              response.content().stream()
                  .flatMap(block -> block.text().stream())
                  .forEach(textBlock -> System.out.println(textBlock.text()));
          }
      }
      ```
    </CodeGroup>
  </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-bedrockruntime"
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```bash
    pip install "boto3>=1.28.59"
    ```
  </Tab>
</Tabs>

## Acceder a Bedrock

### Suscribirse a los modelos de Anthropic

Ve a [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) y solicita acceso a los modelos de Anthropic. Ten en cuenta que la disponibilidad de los modelos de Anthropic varía según la región. Consulta la [documentación de AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) para obtener la información más reciente.

#### ID de modelo de la API

<Note>
  Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5, Claude Opus 4.8 y Claude Opus 4.7 son accesibles a través de `InvokeModel` en `bedrock-runtime`. Estas solicitudes se atienden con la misma infraestructura que el endpoint de [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock). Para la forma de solicitud nativa de la Messages API y la paridad completa de funciones, usa esa página. Estos modelos se omiten de la tabla de modelos de esta página porque no tienen ID de modelo versionados por ARN.
</Note>

Los términos del ciclo de vida (Deprecated, Retired) se definen en [Obsolescencia de modelos](https://platform.claude.com/docs/es/about-claude/model-deprecations). Las fechas del ciclo de vida en plataformas operadas por socios las establece el socio y pueden diferir del calendario de la Claude API. Para conocer la fecha de retiro actual de cualquier modelo en Amazon Bedrock, consulta la [página del ciclo de vida de modelos de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html).

AWS ofrece los modelos Claude más recientes a través de [inferencia entre regiones](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) en lugar de rendimiento bajo demanda. Para estos modelos, una solicitud que pasa el ID del modelo base falla con un error HTTP 400 como el siguiente:

```text wrap
Invocation of model ID anthropic.claude-sonnet-4-5-20250929-v1:0 with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model.
```

Para invocar estos modelos, pasa un perfil de inferencia en lugar del ID del modelo base. El ID del perfil de inferencia es el ID del modelo base con un prefijo de una columna marcada con "Yes" en la siguiente tabla, por ejemplo us.anthropic.claude-sonnet-4-5-20250929-v1:0. También puedes pasar el ARN completo del perfil de inferencia, con el formato `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`. Para consultar la lista oficial de AWS de perfiles de inferencia disponibles, consulta [Supported Regions and models for inference profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). Para saber cómo afectan los prefijos al enrutamiento y los precios, consulta la sección [Endpoints globales frente a regionales](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy#global-vs-regional-endpoints).

| Model                                                                                                 | Base Bedrock model ID                       | `global` | `us` | `eu` | `jp` | `apac` |
| :---------------------------------------------------------------------------------------------------- | :------------------------------------------ | :------- | :--- | :--- | :--- | :----- |
| Claude Opus 4.6                                                                                       | `anthropic.claude-opus-4-6-v1`              | Yes      | Yes  | Yes  | Yes  | Yes    |
| Claude Opus 4.5                                                                                       | `anthropic.claude-opus-4-5-20251101-v1:0`   | Yes      | Yes  | Yes  | No   | No     |
| Claude Opus 4.1 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))   | `anthropic.claude-opus-4-1-20250805-v1:0`   | No       | Yes  | No   | No   | No     |
| Claude Sonnet 4.6                                                                                     | `anthropic.claude-sonnet-4-6`               | Yes      | Yes  | Yes  | Yes  | No     |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations)) | `anthropic.claude-sonnet-4-5-20250929-v1:0` | Yes      | Yes  | Yes  | Yes  | No     |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations))   | `anthropic.claude-sonnet-4-20250514-v1:0`   | Yes      | Yes  | Yes  | No   | Yes    |
| Claude Haiku 4.5                                                                                      | `anthropic.claude-haiku-4-5-20251001-v1:0`  | Yes      | Yes  | Yes  | No   | No     |

### Listar los modelos disponibles

Los siguientes ejemplos muestran cómo imprimir una lista de todos los modelos Claude disponibles a través de Bedrock:

<CodeGroup>
  ```bash AWS CLI
  aws bedrock list-foundation-models --region=us-west-2 --by-provider anthropic --query "modelSummaries[*].modelId"
  ```

  ```python Boto3 (Python)
  import boto3

  bedrock = boto3.client(service_name="bedrock")
  response = bedrock.list_foundation_models(byProvider="anthropic")

  for summary in response["modelSummaries"]:
      print(summary["modelId"])
  ```

  ```typescript TypeScript
  import { BedrockClient, ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";

  const client = new BedrockClient({ region: "us-west-2" });

  const command = new ListFoundationModelsCommand({ byProvider: "anthropic" });
  const response = await client.send(command);

  if (response.modelSummaries) {
    for (const summary of response.modelSummaries) {
      console.log(summary.modelId);
    }
  }
  ```

  ```csharp C#
  using Amazon;
  using Amazon.Bedrock;
  using Amazon.Bedrock.Model;

  var client = new AmazonBedrockClient(RegionEndpoint.USWest2);

  var request = new ListFoundationModelsRequest
  {
      ByProvider = "anthropic"
  };

  var response = await client.ListFoundationModelsAsync(request);

  foreach (var summary in response.ModelSummaries)
  {
      Console.WriteLine(summary.ModelId);
  }
  ```

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

  	"github.com/aws/aws-sdk-go-v2/config"
  	"github.com/aws/aws-sdk-go-v2/service/bedrock"
  )
  // ...
  	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
  	if err != nil {
  		log.Fatal(err)
  	}

  	client := bedrock.NewFromConfig(cfg)

  	byProvider := "anthropic"
  	response, err := client.ListFoundationModels(context.TODO(), &bedrock.ListFoundationModelsInput{
  		ByProvider: &byProvider,
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	for _, summary := range response.ModelSummaries {
  		fmt.Println(*summary.ModelId)
  	}
  ```

  ```java Java
  import software.amazon.awssdk.regions.Region;
  import software.amazon.awssdk.services.bedrock.BedrockClient;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsRequest;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsResponse;
  import software.amazon.awssdk.services.bedrock.model.FoundationModelSummary;

  public class ListAnthropicModels {
      public static void main(String[] args) {
          BedrockClient client = BedrockClient.builder()
              .region(Region.US_WEST_2)
              .build();

          ListFoundationModelsRequest request = ListFoundationModelsRequest.builder()
              .byProvider("anthropic")
              .build();

          ListFoundationModelsResponse response = client.listFoundationModels(request);

          for (FoundationModelSummary summary : response.modelSummaries()) {
              System.out.println(summary.modelId());
          }

          client.close();
      }
  }
  ```

  ```php PHP
  <?php

  use Aws\Bedrock\BedrockClient;

  $client = new BedrockClient([
      'region' => 'us-west-2',
      'version' => 'latest'
  ]);

  $result = $client->listFoundationModels([
      'byProvider' => 'anthropic'
  ]);

  foreach ($result['modelSummaries'] as $summary) {
      echo $summary['modelId'] . PHP_EOL;
  }
  ```

  ```ruby Ruby
  require "aws-sdk-bedrock"

  client = Aws::Bedrock::Client.new(region: "us-west-2")

  response = client.list_foundation_models({
    by_provider: "anthropic"
  })

  response.model_summaries.each do |summary|
    puts summary.model_id
  end
  ```
</CodeGroup>

### Realizar solicitudes

Los siguientes ejemplos muestran cómo generar texto con Claude en Bedrock:

<Tabs>
  <Tab title="cURL">
    <Note>
      Llamar a la API `InvokeModel` con credenciales de AWS requiere la firma de solicitudes SigV4, que los SDK de las otras pestañas gestionan automáticamente. Para un endpoint de Bedrock al que puedes llamar con un comando cURL autónomo, consulta [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` no admite Amazon Bedrock. Usa uno de los ejemplos de SDK en su lugar.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(
        # Autentícate proporcionando las claves a continuación o usa los proveedores de credenciales predeterminados de AWS, por ejemplo,
        # usando ~/.aws/credentials o las variables de entorno "AWS_SECRET_ACCESS_KEY" y "AWS_ACCESS_KEY_ID".
        aws_access_key="<access key>",
        aws_secret_key="<secret key>",
        # Se pueden usar credenciales temporales con aws_session_token.
        # Más información en https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
        aws_session_token="<session_token>",
        # aws_region cambia la región de AWS a la que se envía la solicitud. Si no se proporciona, el SDK lee
        # AWS_REGION / AWS_DEFAULT_REGION, luego la región configurada en tu sesión de boto3 o perfil de AWS
        # (incluido ~/.aws/config), y lanza ValueError si no se puede resolver ninguna región.
        aws_region="us-west-2",
    )

    message = client.messages.create(
        model="global.anthropic.claude-opus-4-6-v1",
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    print(message.content)
    ```
  </Tab>

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

    const client = new AnthropicBedrock({
      // Autentícate proporcionando las claves a continuación o usa
      // los proveedores de credenciales predeterminados de AWS, como
      // ~/.aws/credentials o las variables de entorno "AWS_SECRET_ACCESS_KEY" y
      // "AWS_ACCESS_KEY_ID".
      awsAccessKey: "<access key>",
      awsSecretKey: "<secret key>",

      // Se pueden usar credenciales temporales con awsSessionToken.
      // Más información en https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
      awsSessionToken: "<session_token>",

      // awsRegion cambia la región de AWS a la que se envía
      // la solicitud. De forma predeterminada, el SDK lee AWS_REGION y, si
      // no está presente, usa us-east-1 por defecto. Ten en cuenta que
      // el SDK no lee ~/.aws/config para obtener la región.
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    console.log(message);
    ```
  </Tab>

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

    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "global.anthropic.claude-opus-4-6-v1",
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });

    Console.WriteLine(
        string.Join("", response.Content
            .Select(block => block.Value)
            .OfType<TextBlock>()
            .Select(textBlock => textBlock.Text)));
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"
    	"fmt"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Usa la cadena predeterminada de proveedores de credenciales de AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "global.anthropic.claude-opus-4-6-v1",
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println(message.Content)
    ```
  </Tab>

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

    public class BedrockExample {

      public static void main(String[] args) {
        // Usa la cadena predeterminada de proveedores de credenciales de AWS
        AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(BedrockBackend.fromEnv())
          .build();

        Message message = client
          .messages()
          .create(
            MessageCreateParams.builder()
              .model("global.anthropic.claude-opus-4-6-v1")
              .maxTokens(256)
              .addUserMessage("Hello, world")
              .build()
          );

        System.out.println(message.content());
      }
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::withCredentials(
        accessKeyId: getenv("AWS_ACCESS_KEY_ID"),
        secretAccessKey: getenv("AWS_SECRET_ACCESS_KEY"),
        region: 'us-west-2',
        securityToken: getenv("AWS_SESSION_TOKEN"),
    );

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'global.anthropic.claude-opus-4-6-v1',
    );
    echo $message->content[0]->text;
    ```
  </Tab>

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

    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )

    puts message.content.first.text
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```python
    import boto3
    import json

    bedrock = boto3.client(service_name="bedrock-runtime")
    body = json.dumps(
        {
            "max_tokens": 256,
            "messages": [{"role": "user", "content": "Hello, world"}],
            "anthropic_version": "bedrock-2023-05-31",
        }
    )

    response = bedrock.invoke_model(
        body=body, modelId="global.anthropic.claude-opus-4-6-v1"
    )

    response_body = json.loads(response.get("body").read())
    print(response_body.get("content"))
    ```
  </Tab>
</Tabs>

Consulta los [SDK de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para obtener más detalles, y la [documentación oficial de Bedrock](https://docs.aws.amazon.com/bedrock/).

### Autenticación con bearer token

Puedes autenticarte con Bedrock usando "bearer tokens" (tokens de portador) en lugar de credenciales de AWS. Esto es útil en entornos corporativos donde los equipos necesitan acceso a Bedrock sin administrar credenciales de AWS, roles de IAM ni permisos a nivel de cuenta.

El enfoque más sencillo es establecer la variable de entorno `AWS_BEARER_TOKEN_BEDROCK`, que el SDK detecta automáticamente al resolver las credenciales desde el entorno.

Para proporcionar un token de forma programática:

<Tabs>
  <Tab title="cURL">
    <Note>
      Esta sección muestra cómo configurar un bearer token en un cliente del SDK, que también lee el token de la variable de entorno `AWS_BEARER_TOKEN_BEDROCK`. Para realizar solicitudes HTTP directas con un bearer token, consulta la [documentación de Amazon Bedrock](https://docs.aws.amazon.com/bedrock/).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` no admite Amazon Bedrock. Usa uno de los ejemplos de SDK en su lugar.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(
        api_key="your-bearer-token",
        aws_region="us-west-2",
    )

    message = client.messages.create(
        model="us.anthropic.claude-sonnet-4-5-20250929-v1:0",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}],
    )
    print(message.content)
    ```
  </Tab>

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

    const client = new AnthropicBedrock({
      apiKey: "your-bearer-token",
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello!" }]
    });
    console.log(message);
    ```
  </Tab>

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

    var client = new AnthropicBedrockClient(
        new AnthropicBedrockApiTokenCredentials
        {
            BearerToken = "your-bearer-token",
            Region = "us-west-2",
        }
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello!" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"
    	"fmt"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    	"github.com/aws/aws-sdk-go-v2/aws"
    )
    // ...
    	cfg := aws.Config{
    		Region:                  "us-west-2",
    		BearerAuthTokenProvider: bedrock.NewStaticBearerTokenProvider("your-bearer-token"),
    	}
    	client := anthropic.NewClient(
    		bedrock.WithConfig(cfg),
    	)

    	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    		Model:     "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
    		MaxTokens: 1024,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
    		},
    	})
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println(message.Content[0].Text)
    ```
  </Tab>

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

    // Opción 1: Establece la variable de entorno AWS_BEARER_TOKEN_BEDROCK y usa fromEnv()
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Opción 2: Proporciona el token mediante programación
    client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.builder()
        .apiKey("your-bearer-token")
        .build())
      .build();

    MessageCreateParams params = MessageCreateParams.builder()
      .model("us.anthropic.claude-sonnet-4-5-20250929-v1:0")
      .maxTokens(1024)
      .addUserMessage("Hello!")
      .build();

    client.messages().create(params).content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> System.out.println(textBlock.text()));
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::withApiKey('your-bearer-token', 'us-west-2');

    $message = $client->messages->create(
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello!']
        ],
        model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
    );
    echo $message->content[0]->text;
    ```
  </Tab>

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

    client = Anthropic::BedrockClient.new(
      api_key: "your-bearer-token",
      aws_region: "us-west-2"
    )

    message = client.messages.create(
      model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
      max_tokens: 1024,
      messages: [{role: "user", content: "Hello!"}]
    )
    puts message.content.first.text
    ```
  </Tab>
</Tabs>

## Registro de actividad

Bedrock proporciona un [servicio de registro de invocaciones](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) que te permite registrar los prompts y las completaciones asociados con tu uso.

Anthropic recomienda que registres tu actividad al menos en un período continuo de 30 días para comprender tu actividad e investigar cualquier posible uso indebido.

<Note>
  Activar este servicio no otorga a AWS ni a Anthropic ningún acceso a tu contenido.
</Note>

## 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)
* [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching)
* [Thinking](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)
* [Salidas estructuradas](https://platform.claude.com/docs/es/build-with-claude/structured-outputs)

### Funciones no compatibles

* 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 la 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))
* Almacenamiento en caché de prompts automático (el [campo `cache_control` de nivel superior](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#automatic-caching); usa en su lugar [puntos de interrupción de caché explícitos](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#explicit-cache-breakpoints))
* 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)

### Compatibilidad con PDF en Bedrock

La compatibilidad con PDF está disponible en Bedrock tanto a través de la Converse API como de la InvokeModel API. Para obtener información detallada sobre las capacidades y limitaciones del procesamiento de PDF, consulta [Compatibilidad con PDF en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/pdf-support#amazon-bedrock-pdf-support).

**Consideraciones importantes para los usuarios de la Converse API:**

* El análisis visual de PDF (gráficos, imágenes, diseños) requiere que las citas estén habilitadas
* Sin citas, solo está disponible la extracción básica de texto
* Para tener control total sin citas forzadas, usa la InvokeModel API

### Mensajes del sistema a mitad de conversación en Bedrock

Los [mensajes del sistema a mitad de conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages) están disponibles a través de la InvokeModel API para Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5 y Claude Haiku 5.5. Como se describe en la nota de [ID de modelo de la API](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids), estas solicitudes se atienden con la misma infraestructura que el endpoint de [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock). No se requiere ningún encabezado beta para los mensajes del sistema a mitad de conversación. Esta función no está disponible en Claude Sonnet 5. Usa en su lugar el campo `system` de nivel superior. No está disponible para los modelos versionados por ARN de la tabla de modelos de esta página.

Un mensaje `role: "system"` también puede establecer `output_config.effort` para [cambiar el esfuerzo a mitad de conversación](https://platform.claude.com/docs/es/build-with-claude/effort#change-effort-mid-conversation-beta) en Claude Fable 5.1 y Claude Opus 5.5. Esto está en beta: agrega `mid-conversation-output-config-2026-07-01` al arreglo `anthropic_beta` en el cuerpo de la solicitud. Sin ese valor, o en Claude Fable 5, Claude Opus 5 o Claude Opus 4.8, la solicitud devuelve un error 400: `messages.N.output_config: Extra inputs are not permitted`. En el error, `N` es el índice del mensaje `system` en `messages`.

**Para los usuarios de la Converse API:** la Converse API acepta instrucciones del sistema a través de su [parámetro `system`](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) de nivel superior. Para agregar instrucciones del sistema a mitad de conversación, usa la InvokeModel API.

### Ventana de contexto

Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 y Claude Haiku 5.5 tienen una ["context window" (ventana de contexto) de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) en Amazon Bedrock. Otros modelos Claude, incluidos Sonnet 4.5 (obsoleto) y Sonnet 4 (obsoleto), tienen una ventana de contexto de 200k tokens.

Bedrock limita las cargas útiles de las solicitudes a 20 MB. Al enviar documentos grandes o muchas imágenes, es posible que alcances este límite antes que el límite de tokens.

## Endpoints globales frente a regionales

A partir de **Claude Sonnet 4.5 y todos los modelos futuros**, Bedrock ofrece dos tipos de endpoints:

* **Endpoints globales:** enrutamiento dinámico para máxima disponibilidad
* **Endpoints regionales:** enrutamiento de datos garantizado a través de regiones geográficas específicas

Los endpoints regionales incluyen un recargo del 10 % en el precio respecto a los endpoints globales.

<Note>
  Esto se aplica solo a Claude Sonnet 4.5 (obsoleto) y a los modelos futuros. Los modelos anteriores (Claude Sonnet 4 (obsoleto) y anteriores) mantienen sus estructuras de precios existentes.
</Note>

### Cuándo usar cada opción

**Endpoints globales (recomendado):**

* Proporcionan máxima disponibilidad y tiempo de actividad
* Enrutan dinámicamente las solicitudes a regiones con capacidad disponible
* Sin recargo en el precio
* Ideales para aplicaciones donde la residencia de datos es flexible

**Endpoints regionales (CRIS):**

* Enrutan el tráfico a través de regiones geográficas específicas
* Necesarios para requisitos de residencia de datos y cumplimiento normativo
* Disponibles para EE. UU., la UE, Japón y Asia-Pacífico
* El recargo del 10 % en el precio refleja los costos de infraestructura de la capacidad regional dedicada

### Implementación

**Uso de endpoints globales (predeterminado para Opus 4.6, Sonnet 4.6 y Sonnet 4.5 (obsoleto)):**

Los ID de modelo de Claude Opus 4.6, Sonnet 4.6 y Sonnet 4.5 (obsoleto) ya incluyen el prefijo `global.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Llamar a la API `InvokeModel` con credenciales de AWS requiere la firma de solicitudes SigV4, que los SDK de las otras pestañas gestionan automáticamente. Para un endpoint de Bedrock al que puedes llamar con un comando cURL autónomo, consulta [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` no admite Amazon Bedrock. Usa uno de los ejemplos de SDK en su lugar.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(aws_region="us-west-2")

    message = client.messages.create(
        model="global.anthropic.claude-opus-4-6-v1",
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    ```
  </Tab>

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

    const client = new AnthropicBedrock({
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    ```
  </Tab>

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

    // El cliente de Bedrock para C# usa IDs de modelo con prefijo de región para el enrutamiento global
    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        // Usa el prefijo "global." para la inferencia global entre regiones
        Model = "global.anthropic.claude-opus-4-6-v1",
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Usa la cadena predeterminada de proveedores de credenciales de AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "global.anthropic.claude-opus-4-6-v1",
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    ```
  </Tab>

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

    // Usa la cadena predeterminada de proveedores de credenciales de AWS
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    var message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("global.anthropic.claude-opus-4-6-v1")
          .maxTokens(256)
          .addUserMessage("Hello, world")
          .build()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::fromEnvironment();

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'global.anthropic.claude-opus-4-6-v1',
    );
    ```
  </Tab>

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

    # Las credenciales predeterminadas obtienen la región de la variable de entorno AWS_REGION
    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      # Usa el prefijo "global." para la inferencia global entre regiones
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

**Uso de endpoints regionales (CRIS):**

Para usar endpoints regionales, reemplaza el prefijo `global.` por un prefijo regional como `us.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Llamar a la API `InvokeModel` con credenciales de AWS requiere la firma de solicitudes SigV4, que los SDK de las otras pestañas gestionan automáticamente. Para un endpoint de Bedrock al que puedes llamar con un comando cURL autónomo, consulta [Claude en Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` no admite Amazon Bedrock. Usa uno de los ejemplos de SDK en su lugar.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(aws_region="us-west-2")

    # Usando el endpoint regional de EE. UU. (CRIS)
    message = client.messages.create(
        model="us.anthropic.claude-opus-4-6-v1",  # Regional prefix
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    ```
  </Tab>

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

    const client = new AnthropicBedrock({
      awsRegion: "us-west-2"
    });

    // Usando el endpoint regional de EE. UU. (CRIS)
    const message = await client.messages.create({
      model: "us.anthropic.claude-opus-4-6-v1", // Regional prefix
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    ```
  </Tab>

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

    AnthropicBedrockClient client = new(
        new AnthropicBedrockPrivateKeyCredentials { Region = "us-west-2" }
    );

    // Usando el endpoint regional de EE. UU. (CRIS)
    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "us.anthropic.claude-opus-4-6-v1", // Regional prefix
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Usa la cadena predeterminada de proveedores de credenciales de AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Usando el endpoint regional de EE. UU. (CRIS)
    	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "us.anthropic.claude-opus-4-6-v1", // Regional prefix
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    ```
  </Tab>

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

    // Usa la cadena predeterminada de proveedores de credenciales de AWS
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Usando el endpoint regional de EE. UU. (CRIS)
    var message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("us.anthropic.claude-opus-4-6-v1") // Regional prefix
          .maxTokens(256)
          .addUserMessage("Hello, world")
          .build()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::fromEnvironment();

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'us.anthropic.claude-opus-4-6-v1',
    );
    ```
  </Tab>

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

    # Usando el endpoint regional de EE. UU. (CRIS)
    client = Anthropic::BedrockClient.new(aws_region: "us-west-2")

    message = client.messages.create(
      model: "us.anthropic.claude-opus-4-6-v1", # Regional prefix
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

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

## Recursos adicionales

* **Precios de Bedrock:** [Página de precios de Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/)
* **Documentación de precios de AWS:** [Guía de precios de Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **Publicación del blog de AWS:** [Introducing Claude Sonnet 4.5 in Amazon Bedrock](https://aws.amazon.com/blogs/aws/introducing-claude-sonnet-4-5-in-amazon-bedrock-anthropics-most-intelligent-model-best-for-coding-and-complex-agents/)
* **Detalles de precios de Anthropic:** [Precios de plataformas en la nube](https://platform.claude.com/docs/es/about-claude/pricing#cloud-platform-pricing)