---
title: Claude no Amazon Bedrock (Opus 4.6 e anteriores)
url: https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy
description: A integração legada do Amazon Bedrock para modelos Claude, usando as APIs InvokeModel e Converse com identificadores de modelo versionados por ARN.
---

<Note>
  Esta página cobre a integração legada do Amazon Bedrock: as APIs `InvokeModel` e `Converse` com identificadores de modelo versionados por ARN e codificação event-stream da AWS. Para modelos disponíveis no endpoint Bedrock da Messages API, consulte [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock), que usa a Messages API em `/anthropic/v1/messages` com streaming SSE. Para uma alternativa operada pela Anthropic com faturamento via AWS Marketplace e acesso a recursos normalmente no mesmo dia, consulte [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws). Usuários existentes do Bedrock podem seguir o [guia de migração](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock).
</Note>

Chamar o Claude através do Bedrock difere ligeiramente de como você chamaria o Claude diretamente na Claude API. Este guia orienta você na realização de uma chamada de API ao Claude no Bedrock usando um dos [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) da Anthropic.

Observe que este guia pressupõe que você já se inscreveu em uma [conta AWS](https://portal.aws.amazon.com/billing/signup) e configurou o acesso programático.

## Instalar e configurar a AWS CLI

1. [Instale uma versão da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) igual ou mais recente que a versão `2.13.23`.
2. Configure suas credenciais da AWS usando o comando AWS configure (consulte [Configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)) ou encontre suas credenciais navegando até "Command line or programmatic access" no seu painel da AWS e seguindo as instruções na janela modal.
3. Verifique se suas credenciais estão funcionando:

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

## Instalar um SDK para acessar o Bedrock

Os [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) da Anthropic oferecem suporte ao Bedrock. Você também pode usar diretamente um SDK da AWS como o `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>

## Acessando o Bedrock

### Assinar os modelos da Anthropic

Acesse o [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) e solicite acesso aos modelos da Anthropic. Observe que a disponibilidade dos modelos da Anthropic varia por região. Consulte a [documentação da AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) para obter as informações mais recentes.

#### IDs de modelo da 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 e Claude Opus 4.7 estão acessíveis por meio de `InvokeModel` em `bedrock-runtime`. Essas solicitações são atendidas pela mesma infraestrutura do endpoint [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock). Para o formato de solicitação nativo da Messages API e paridade completa de recursos, use essa página. Esses modelos são omitidos da tabela de modelos desta página porque não têm IDs de modelo versionados por ARN.
</Note>

Os termos de ciclo de vida (Descontinuado, Desativado) são definidos em [Descontinuações de modelos](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations). As datas de ciclo de vida em plataformas operadas por parceiros são definidas pelo parceiro e podem diferir do cronograma da Claude API. Para a data de desativação atual de qualquer modelo no Amazon Bedrock, consulte a [página de ciclo de vida de modelos do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html).

A AWS oferece os modelos Claude mais recentes por meio de "[cross-region inference](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)" (inferência entre regiões) em vez de throughput sob demanda. Para esses modelos, uma requisição que passa o ID do modelo base falha com um erro HTTP 400 como o seguinte:

```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 esses modelos, passe um "inference profile" (perfil de inferência) em vez do ID do modelo base. O ID do perfil de inferência é o ID do modelo base com um prefixo de uma coluna marcada com "Sim" na tabela a seguir, por exemplo us.anthropic.claude-sonnet-4-5-20250929-v1:0. Você também pode passar o ARN completo do perfil de inferência, no formato `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`. Para a lista oficial da AWS de perfis de inferência disponíveis, consulte [Regiões e modelos compatíveis com perfis de inferência](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). Para saber como os prefixos afetam o roteamento e os preços, consulte a seção [Endpoints globais versus regionais](https://platform.claude.com/docs/pt-BR/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/pt-BR/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/pt-BR/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/pt-BR/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 modelos disponíveis

Os exemplos a seguir mostram como imprimir uma lista de todos os modelos Claude disponíveis através do 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>

### Fazendo requisições

Os exemplos a seguir mostram como gerar texto com o Claude no Bedrock:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chamar a API `InvokeModel` com credenciais da AWS requer assinatura de requisição SigV4, que os SDKs nas outras abas tratam automaticamente. Para um endpoint do Bedrock que você pode chamar com um comando cURL autocontido, consulte [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI `ant` não oferece suporte ao Amazon Bedrock. Use um dos exemplos de SDK em vez disso.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(
        # Autentique fornecendo as chaves abaixo ou use os provedores de credenciais padrão da AWS, como
        # usando ~/.aws/credentials ou as variáveis de ambiente "AWS_SECRET_ACCESS_KEY" e "AWS_ACCESS_KEY_ID".
        aws_access_key="<access key>",
        aws_secret_key="<secret key>",
        # Credenciais temporárias podem ser usadas com aws_session_token.
        # Leia mais em https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
        aws_session_token="<session_token>",
        # aws_region altera a região da AWS para a qual a requisição é feita. Se não for fornecida, o SDK lê
        # AWS_REGION / AWS_DEFAULT_REGION, depois a região configurada para sua sessão boto3 ou perfil da AWS
        # (incluindo ~/.aws/config), e lança ValueError se nenhuma região puder ser resolvida.
        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({
      // Autentique fornecendo as chaves abaixo ou use
      // os provedores de credenciais padrão da AWS, como
      // ~/.aws/credentials ou as variáveis de ambiente
      // "AWS_SECRET_ACCESS_KEY" e "AWS_ACCESS_KEY_ID".
      awsAccessKey: "<access key>",
      awsSecretKey: "<secret key>",

      // Credenciais temporárias podem ser usadas com awsSessionToken.
      // Leia mais em https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
      awsSessionToken: "<session_token>",

      // awsRegion altera a região da AWS para a qual a requisição
      // é feita. Por padrão, o SDK lê AWS_REGION e, se
      // não estiver presente, usa us-east-1 como padrão. Observe que
      // o SDK não lê ~/.aws/config para obter a região.
      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 a cadeia padrão de provedores de credenciais da 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 a cadeia padrão de provedores de credenciais da 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>

Consulte os [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) para mais detalhes, e a [documentação oficial do Bedrock](https://docs.aws.amazon.com/bedrock/).

### Autenticação com bearer token

Você pode se autenticar no Bedrock usando "bearer tokens" (tokens de portador) em vez de credenciais da AWS. Isso é útil em ambientes corporativos nos quais as equipes precisam de acesso ao Bedrock sem gerenciar credenciais da AWS, funções do IAM ou permissões no nível da conta.

A abordagem mais simples é definir a variável de ambiente `AWS_BEARER_TOKEN_BEDROCK`, que o SDK detecta automaticamente ao resolver credenciais a partir do ambiente.

Para fornecer um token programaticamente:

<Tabs>
  <Tab title="cURL">
    <Note>
      Esta seção mostra como configurar um bearer token em um cliente SDK, que também lê o token da variável de ambiente `AWS_BEARER_TOKEN_BEDROCK`. Para fazer requisições HTTP diretas com um bearer token, consulte a [documentação do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI `ant` não oferece suporte ao Amazon Bedrock. Use um dos exemplos de SDK em vez disso.
    </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;

    // Opção 1: defina a variável de ambiente AWS_BEARER_TOKEN_BEDROCK e use fromEnv()
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Opção 2: forneça o token programaticamente
    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 atividades

O Bedrock fornece um [serviço de registro de invocações](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) que permite registrar os prompts e as conclusões associados ao seu uso.

A Anthropic recomenda que você registre sua atividade em uma base contínua de pelo menos 30 dias para entender sua atividade e investigar qualquer possível uso indevido.

<Note>
  Ativar este serviço não concede à AWS nem à Anthropic qualquer acesso ao seu conteúdo.
</Note>

## Suporte a recursos

Para a lista completa de recursos com disponibilidade no Amazon Bedrock, consulte a [Visão geral dos recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/overview).

### Destaques dos recursos suportados

* [Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create)
* [Cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) (prompt caching)
* [Pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking) (thinking)
* [Uso de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/overview) (tool use), incluindo a [ferramenta Bash](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/bash-tool), a [ferramenta de uso do computador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/computer-use-tool), a [ferramenta de memória](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/memory-tool) e a [ferramenta de editor de texto](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/text-editor-tool)
* [Citações](https://platform.claude.com/docs/pt-BR/build-with-claude/citations)
* [Saídas estruturadas](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs), para os modelos na nota sobre o Amazon Bedrock na seção [Compatibilidade](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs#compatibility)

### Recursos não suportados

* Fontes de entrada (fontes de URL para imagens e documentos, Files API)
* Ferramentas do lado do servidor (execução de código, busca na web, web fetch, advisor)
* Infraestrutura de agentes (Agent Skills, conector MCP, chamada programática de ferramentas)
* Endpoints de API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Fallback do lado do servidor (o [parâmetro `fallbacks`](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#server-side-fallback); use o [padrão de fallback do lado do cliente](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#client-side-fallback) em vez disso)
* Cache de prompt automático (o [campo `cache_control` de nível superior](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#automatic-caching); use [pontos de interrupção de cache explícitos](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#explicit-cache-breakpoints) em vez disso)
* Conjuntos de ferramentas de [uso do computador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/computer-use-tool) e [uso do navegador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` e `browser_toolset_20260801` não estão disponíveis atualmente no Amazon Bedrock; as versões beta da ferramenta de uso do computador permanecem disponíveis)

### Suporte a PDF no Bedrock

O suporte a PDF está disponível no Bedrock tanto através da Converse API quanto da InvokeModel API. Para informações detalhadas sobre as capacidades e limitações do processamento de PDF, consulte [Suporte a PDF no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/pdf-support#amazon-bedrock-pdf-support).

**Considerações importantes para usuários da Converse API:**

* A análise visual de PDF (gráficos, imagens, layouts) requer que as citações estejam habilitadas
* Sem citações, apenas a extração básica de texto está disponível
* Para controle total sem citações forçadas, use a InvokeModel API

### Mensagens do sistema no meio da conversa no Bedrock

As [mensagens do sistema no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/mid-conversation-system-messages) estão disponíveis pela 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 e Claude Haiku 5.5. Conforme descrito na nota em [IDs de modelo da API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids), essas solicitações são atendidas pela mesma infraestrutura do endpoint [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock). Nenhum cabeçalho beta é necessário para mensagens do sistema no meio da conversa. Este recurso não está disponível no Claude Sonnet 5. Use o campo `system` de nível superior em vez disso. Ele não está disponível para os modelos versionados por ARN na tabela de modelos desta página.

Uma mensagem `role: "system"` também pode definir `output_config.effort` para [alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) no Claude Fable 5.1 e no Claude Opus 5.5. Isso está em beta: adicione `mid-conversation-output-config-2026-07-01` ao array `anthropic_beta` no corpo da requisição. Sem esse valor, ou no Claude Fable 5, Claude Opus 5 ou Claude Opus 4.8, a requisição retorna um erro 400: `messages.N.output_config: Extra inputs are not permitted`. No erro, `N` é o índice da mensagem `system` em `messages`.

**Para usuários da Converse API:** a Converse API aceita instruções do sistema por meio de seu [parâmetro `system`](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) de nível superior. Para adicionar instruções do sistema no meio da conversa, use a InvokeModel API.

### Janela 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 e Claude Haiku 5.5 têm uma ["context window" (janela de contexto) de 1M de tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows) no Amazon Bedrock. Outros modelos Claude, incluindo Sonnet 4.5 (descontinuado) e Sonnet 4 (descontinuado), têm uma janela de contexto de 200k tokens.

O Bedrock limita os payloads de requisição a 20 MB. Ao enviar documentos grandes ou muitas imagens, você pode atingir esse limite antes do limite de tokens.

## Endpoints globais versus regionais

A partir do **Claude Sonnet 4.5 e de todos os modelos futuros**, o Bedrock oferece dois tipos de endpoint:

* **Endpoints globais:** roteamento dinâmico para disponibilidade máxima
* **Endpoints regionais:** roteamento de dados garantido por regiões geográficas específicas

Os endpoints regionais incluem um acréscimo de 10% no preço em relação aos endpoints globais.

<Note>
  Isso se aplica apenas ao Claude Sonnet 4.5 (descontinuado) e a modelos futuros. Modelos mais antigos (Claude Sonnet 4 (descontinuado) e anteriores) mantêm suas estruturas de preços existentes.
</Note>

### Quando usar cada opção

**Endpoints globais (recomendado):**

* Fornecem máxima disponibilidade e tempo de atividade
* Roteiam dinamicamente as requisições para regiões com capacidade disponível
* Sem acréscimo no preço
* Ideais para aplicações onde a residência de dados é flexível

**Endpoints regionais (CRIS):**

* Roteiam o tráfego através de regiões geográficas específicas
* Necessários para requisitos de residência de dados e conformidade
* Disponíveis para EUA, UE, Japão e Ásia-Pacífico
* O acréscimo de 10% no preço reflete os custos de infraestrutura para capacidade regional dedicada

### Implementação

**Usando endpoints globais (padrão para Opus 4.6, Sonnet 4.6 e Sonnet 4.5 (descontinuado)):**

Os IDs de modelo do Claude Opus 4.6, Sonnet 4.6 e Sonnet 4.5 (descontinuado) já incluem o prefixo `global.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chamar a API `InvokeModel` com credenciais da AWS requer assinatura de requisição SigV4, que os SDKs nas outras abas tratam automaticamente. Para um endpoint do Bedrock que você pode chamar com um comando cURL autocontido, consulte [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI `ant` não oferece suporte ao Amazon Bedrock. Use um dos exemplos de SDK em vez disso.
    </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;

    // O cliente Bedrock em C# usa IDs de modelo com prefixo de região para roteamento global
    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        // Use o prefixo "global." para inferência global entre regiões
        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 a cadeia padrão de provedores de credenciais da 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 a cadeia padrão de provedores de credenciais da 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"

    # As credenciais padrão obtêm a região da variável de ambiente AWS_REGION
    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      # Use o prefixo "global." para inferência global entre regiões (cross-region)
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

**Usando endpoints regionais (CRIS):**

Para usar endpoints regionais, substitua o prefixo `global.` por um prefixo regional, como `us.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chamar a API `InvokeModel` com credenciais da AWS requer assinatura de requisição SigV4, que os SDKs nas outras abas tratam automaticamente. Para um endpoint do Bedrock que você pode chamar com um comando cURL autocontido, consulte [Claude no Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI `ant` não oferece suporte ao Amazon Bedrock. Use um dos exemplos de SDK em vez disso.
    </Note>
  </Tab>

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

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

    # Usando endpoint regional dos EUA (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 endpoint regional dos EUA (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 endpoint regional dos EUA (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 a cadeia padrão de provedores de credenciais da AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Usando endpoint regional dos EUA (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 a cadeia padrão de provedores de credenciais da AWS
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Usando endpoint regional dos EUA (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 endpoint regional dos EUA (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** é um modelo em prévia de pesquisa disponível para clientes convidados no Amazon Bedrock. Para mais informações, consulte [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Recursos adicionais

* **Preços do Bedrock:** [Página de preços do Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/)
* **Documentação de preços da AWS:** [Guia de preços do Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **Post no blog da AWS:** [Apresentando o Claude Sonnet 4.5 no 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/)
* **Detalhes de preços da Anthropic:** [Preços em plataformas de nuvem](https://platform.claude.com/docs/pt-BR/about-claude/pricing#cloud-platform-pricing)