---
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 modelos Claude, que usa las APIs InvokeModel y Converse con identificadores de modelo versionados por ARN.
---

<Note>
  Esta página cubre la integración heredada de Amazon Bedrock: las APIs `InvokeModel` y `Converse` con identificadores de modelo versionados por ARN y codificación 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 on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws). Los usuarios actuales 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>

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 lleva paso a paso para completar una llamada a la API de Claude en Bedrock usando uno de los [SDKs 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.

## Instala y configura 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 más reciente que 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 en 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 son compatibles con 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:2.73.0")
      implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
      ```

      ```xml Maven
      <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>
      ```

      ```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>

## Acceso a Bedrock

### Suscríbete 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 [Deprecaciones de modelos](https://platform.claude.com/docs/es/about-claude/model-deprecations). Las fechas del ciclo de vida en las 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 "[cross-region inference](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)" (inferencia entre regiones) en lugar de rendimiento bajo demanda. Para estos modelos, una solicitud que pasa el ID de 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 "inference profile" (perfil de inferencia) en lugar del ID de modelo base. El ID del perfil de inferencia es el ID de modelo base con un prefijo de una columna marcada con "Sí" 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 ver la lista oficial de AWS de perfiles de inferencia disponibles, consulta [Regiones y modelos compatibles con perfiles de inferencia](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     |

### Lista 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 SDKs de las otras pestañas manejan automáticamente. Para un endpoint de Bedrock que puedas 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 es compatible con 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, como
        # ~/.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.
        # Lee más 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 hace la solicitud. Si no se proporciona, el SDK lee
        # AWS_REGION / AWS_DEFAULT_REGION, luego la región configurada para 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 de abajo o usa
      // los proveedores de credenciales de AWS predeterminados, 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.
      // Lee más 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 hace
      // la solicitud. Por defecto, el SDK lee AWS_REGION y, si
      // no está presente, usa us-east-1. Ten en cuenta que
      // el SDK no lee ~/.aws/config para 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 [SDKs de cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para 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 de SDK, que también lee el token desde 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 es compatible con 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 respuestas asociados con tu uso.

Anthropic recomienda que registres tu actividad al menos durante 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 la lista completa de funciones con 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)
* [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), incluyendo 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), para los modelos indicados en la nota de Amazon Bedrock de su sección [Compatibilidad](https://platform.claude.com/docs/es/build-with-claude/structured-outputs#compatibility)

### 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 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 el [patrón de fallback del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#client-side-fallback) en su lugar)
* 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 [puntos de interrupción de caché explícitos](https://platform.claude.com/docs/es/build-with-claude/prompt-caching#explicit-cache-breakpoints) en su lugar)
* 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 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 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 un control total sin citas forzadas, usa la InvokeModel API

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

Los [mensajes del sistema a mitad de la 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 la 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 la 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 la 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 una disponibilidad máxima
* **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 únicamente 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 sobreprecio
* 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., UE, Japón y Asia-Pacífico
* El sobreprecio del 10% 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 es compatible con 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 es compatible con 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 de vista previa 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:** [Presentamos Claude Sonnet 4.5 en 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 en plataformas en la nube](https://platform.claude.com/docs/es/about-claude/pricing#cloud-platform-pricing)