---
title: Claude no Amazon Bedrock (Opus 4.7 e posteriores)
url: https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock
description: Acesse os modelos Claude por meio do Amazon Bedrock com autenticação, faturamento e limites de segurança nativos da AWS.
---

Este guia orienta você na configuração e na realização de chamadas de API para o Claude no Amazon Bedrock. O Claude no Amazon Bedrock é executado em infraestrutura gerenciada pela AWS com zero acesso de operador (o pessoal da Anthropic não tem acesso à infraestrutura de inferência), permitindo que você crie aplicações sensíveis inteiramente dentro do limite de segurança da AWS, usando o mesmo formato da Messages API que você usa com a API própria da Anthropic.

<Note>
  Esta página aborda o Claude no Amazon Bedrock, que disponibiliza o Claude por meio da Messages API em `/anthropic/v1/messages` em infraestrutura gerenciada pela AWS. A integração anterior com o Amazon Bedrock (as APIs `InvokeModel` e `Converse` com identificadores de modelo versionados por ARN) continua disponível e está documentada em [Claude no Amazon Bedrock (Opus 4.6 e anteriores)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy). Para uma alternativa operada pela Anthropic na AWS, com faturamento pelo 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).
</Note>

## Acesso

O Amazon Bedrock define critérios de acesso para cada modelo Claude individualmente. Claude Fable 5.1, Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5, Claude Opus 4.7 e Claude Haiku 4.5 estão abertos a todos os clientes do Amazon Bedrock. Para os critérios atuais de qualquer outro modelo, verifique o [acesso a modelos do Amazon Bedrock](https://console.aws.amazon.com/bedrock/home#/modelaccess) no console da AWS. O Claude Mythos Preview requer um convite por meio do [Project Glasswing](https://anthropic.com/glasswing). Para disponibilidade por região, consulte [Regiões](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock#regions).

## Pré-requisitos

Antes de começar, certifique-se de ter:

* Uma conta da AWS com [acesso a modelos do Amazon Bedrock](https://console.aws.amazon.com/bedrock/home#/modelaccess) habilitado para os modelos Claude que você pretende usar.
* A [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) instalada e configurada (opcional, para gerenciamento de credenciais).

O Claude Mythos Preview requer adicionalmente uma conta da AWS dedicada que tenha sido incluída na lista de permissões pela equipe do Bedrock Marketplace. Seu executivo de contas da Anthropic pode enviar o ID da sua conta para inclusão na lista de permissões (normalmente processado em até 24 horas), e a AWS envia um e-mail de boas-vindas quando o processo é concluído.

## Autenticação

O Claude no Amazon Bedrock oferece suporte a três caminhos de autenticação. Escolha o que melhor se adapta aos seus requisitos de segurança.

### Função de serviço do Bedrock (recomendado)

Use uma função de serviço do Bedrock com chaves gerenciadas pela AWS para o acesso mais seguro e de longa duração:

<Steps>
  <Step title="Administrador: provisionar a função de serviço">
    Um administrador da AWS provisiona uma função de serviço do Bedrock e concede aos desenvolvedores a permissão `iam:PassRole` no ARN da função de serviço.
  </Step>

  <Step title="Desenvolvedor: passar a função">
    Ao chamar a API, o Bedrock assume a função de serviço em seu nome. Consulte a [documentação do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html) para saber como associar a função às suas requisições.
  </Step>
</Steps>

### Funções assumidas do IAM

Para acesso federado por identidade com sessão máxima de 12 horas:

<Steps>
  <Step title="Administrador: configurar a função do IAM">
    Crie uma função do IAM com escopo restrito aos seus modelos Claude. A política de confiança nomeia seu provedor de identidade (SAML, OIDC ou AWS Identity Center). A política de permissões concede `bedrock-mantle:CreateInference` apenas nos ARNs de modelo permitidos.
  </Step>

  <Step title="Desenvolvedor: autenticar e assumir">
    Autentique-se por meio do seu provedor de identidade corporativo e, em seguida, assuma a função do IAM. O AWS STS emite credenciais temporárias que o SDK ou a CLI usa para assinar as requisições.
  </Step>
</Steps>

### Tokens bearer

Para acesso de curto prazo sem funções do IAM (máximo de 12 horas, opção menos preferida):

<Steps>
  <Step title="Administrador: restringir tipos de token">
    Bloqueie chaves de longo prazo anexando uma política que negue `bedrock:CallWithBearerToken`, a menos que a condição `bedrock:BearerTokenType` corresponda a um token de curto prazo.
  </Step>

  <Step title="Desenvolvedor: gerar um token">
    Use a CLI `aws-bedrock-token-generator` para gerar um token bearer. Passe-o no cabeçalho `x-api-key` em cada requisição.
  </Step>
</Steps>

## Instalar um SDK

Os [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) da Anthropic oferecem suporte ao Claude no Amazon Bedrock por meio de um pacote ou módulo específico para o Bedrock.

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

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

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

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

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

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

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

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

## Fazendo sua primeira requisição

O endpoint segue o padrão `https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages`. Diferentemente da integração baseada em `InvokeModel`, este endpoint usa streaming SSE padrão e o mesmo formato de corpo de requisição da API própria da Anthropic.

O SDK resolve as credenciais e a região usando a precedência padrão da AWS: argumentos do construtor, depois variáveis de ambiente (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_REGION`) e, em seguida, o arquivo de configuração da AWS e a cadeia de credenciais (SSO, funções assumidas, função de tarefa do ECS, IMDS).

<Tabs>
  <Tab title="cURL">
    ```bash
    curl https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
      --aws-sigv4 "aws:amz:us-east-1:bedrock-mantle" \
      --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
      -H "x-amz-security-token: $AWS_SESSION_TOKEN" \
      -H "content-type: application/json" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "anthropic.claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [
          {"role": "user", "content": "Hello, Claude"}
        ]
      }'
    ```
  </Tab>

  <Tab title="CLI">
    A CLI `ant` não oferece suporte ao Amazon Bedrock. Use cURL ou um SDK.
  </Tab>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<Tip>
  Você também pode criar o cliente padrão com `Anthropic` (go: `anthropic.NewClient()`; java: `AnthropicOkHttpClient.builder()`; csharp: `AnthropicClient`; php: `Anthropic\Client`; ruby: `Anthropic::Client`): defina `base_url` (typescript: `baseURL`; go: `option.WithBaseURL()`; java: `.baseUrl()`; csharp: `BaseUrl`; php: `baseUrl`) como `https://bedrock-mantle.{region}.api.aws/anthropic` e passe seu token bearer como `api_key` (typescript, php: `apiKey`; go: `option.WithAPIKey()`; java: `.apiKey()`; csharp: `ApiKey`). Esse caminho oferece suporte apenas à autenticação por token bearer. A assinatura SigV4 requer `AnthropicBedrockMantle` (csharp: `AnthropicBedrockMantleClient`; go: `bedrock.NewMantleClient`; java: `BedrockMantleBackend`; php: `MantleClient`; ruby: `Anthropic::BedrockMantleClient`).
</Tip>

## Modelos compatíveis

Os IDs de modelo no Claude no Amazon Bedrock têm o prefixo de provedor `anthropic.`. As capacidades e os comportamentos dos modelos estão documentados na página [Visão geral dos modelos](https://platform.claude.com/docs/pt-BR/models/overview).

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

Use a versão mais recente do Claude Code com o Claude no Amazon Bedrock; execute `claude update` para atualizar.

<Tip>
  Atualizando para um modelo Claude mais recente? No Claude Code, execute `/claude-api migrate` para aplicar trocas de ID de modelo e alterações de parâmetros incompatíveis em toda a sua base de código. A skill detecta qual plataforma de nuvem seu código tem como alvo e ajusta os formatos de ID de modelo e as alterações de recursos para essa plataforma. Consulte [Migrando para um modelo Claude mais recente](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

## Suporte a recursos

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

### Destaques dos recursos compatíveis

* [Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create) (`/anthropic/v1/messages`)
* [Prompt caching (cache de prompt)](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching)
* [Pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking)
* [Tool use (uso de ferramentas)](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/overview), 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)

### Recursos não compatíveis

* [Saídas estruturadas](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs)
* Fontes de entrada (fontes de URL para imagens e documentos, Files API)
* Ferramentas do lado do servidor (execução de código, pesquisa na web, busca na web, 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)
* 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 continuam disponíveis)

## Regiões

O Claude no Amazon Bedrock está disponível nas seguintes regiões da AWS. O Amazon Bedrock oferece dois tipos de endpoint:

* **Global:** roteamento dinâmico entre todas as regiões disponíveis para máxima disponibilidade. Sem acréscimo de preço.
* **Regional:** o endpoint é resolvido para a única região da AWS que você especificar, para requisitos de residência de dados. Os endpoints regionais têm um acréscimo de 10% no preço em relação aos endpoints globais. Para rotear entre várias regiões dentro de uma área geográfica, use um [perfil de inferência](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) (US, EU, JP ou AU). As regiões marcadas como **Somente na região** na tabela oferecem suporte ao roteamento direto para uma única região sem um perfil de inferência.

O endpoint global está disponível para Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5 e Claude Haiku 4.5. Para o Claude Fable 5.1, os endpoints regionais estão atualmente disponíveis apenas em `us-east-1`. O Claude Mythos Preview é somente regional e está disponível em `us-east-1`.

| Região da AWS    | Localização                         | Tipos de endpoint             |
| ---------------- | ----------------------------------- | ----------------------------- |
| `af-south-1`     | África (Cidade do Cabo)             | Global                        |
| `ap-northeast-1` | Ásia-Pacífico (Tóquio)              | Global, JP, Somente na região |
| `ap-northeast-2` | Ásia-Pacífico (Seul)                | Global                        |
| `ap-northeast-3` | Ásia-Pacífico (Osaka)               | Global, JP                    |
| `ap-south-1`     | Ásia-Pacífico (Mumbai)              | Global                        |
| `ap-south-2`     | Ásia-Pacífico (Hyderabad)           | Global                        |
| `ap-southeast-1` | Ásia-Pacífico (Singapura)           | Global                        |
| `ap-southeast-2` | Ásia-Pacífico (Sydney)              | Global, AU                    |
| `ap-southeast-3` | Ásia-Pacífico (Jacarta)             | Global                        |
| `ap-southeast-4` | Ásia-Pacífico (Melbourne)           | Global, AU, Somente na região |
| `ca-central-1`   | Canadá (Central)                    | Global, US                    |
| `ca-west-1`      | Oeste do Canadá (Calgary)           | Global                        |
| `eu-central-1`   | Europa (Frankfurt)                  | Global, EU                    |
| `eu-central-2`   | Europa (Zurique)                    | Global, EU                    |
| `eu-north-1`     | Europa (Estocolmo)                  | Global, EU, Somente na região |
| `eu-south-1`     | Europa (Milão)                      | Global, EU                    |
| `eu-south-2`     | Europa (Espanha)                    | Global, EU                    |
| `eu-west-1`      | Europa (Irlanda)                    | Global, EU, Somente na região |
| `eu-west-2`      | Europa (Londres)                    | Global, EU                    |
| `eu-west-3`      | Europa (Paris)                      | Global, EU                    |
| `il-central-1`   | Israel (Tel Aviv)                   | Global                        |
| `me-central-1`   | Oriente Médio (EAU)                 | Global                        |
| `sa-east-1`      | América do Sul (São Paulo)          | Global                        |
| `us-east-1`      | Leste dos EUA (Norte da Virgínia)   | Global, US, Somente na região |
| `us-east-2`      | Leste dos EUA (Ohio)                | Global, US, Somente na região |
| `us-west-1`      | Oeste dos EUA (Norte da Califórnia) | Global, US                    |
| `us-west-2`      | Oeste dos EUA (Oregon)              | Global, US, Somente na região |

## Cotas

A cota padrão é de 2 milhões de tokens de entrada por minuto (TPM). Você pode solicitar até 5 milhões de TPM de entrada e 500.000 TPM de saída sem aprovação adicional da Anthropic. A AWS aplica limites de requisições por minuto (RPM) no lado do Bedrock; entre em contato com o suporte da AWS para ajustes de RPM.

## Retenção de dados

O tratamento de dados para esta oferta é regido pelo Amazon Bedrock. Para detalhes, consulte [Proteção de dados no Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html).

## Monitoramento e registro de logs

O Claude no Amazon Bedrock emite logs tanto para o CloudWatch quanto para o CloudTrail. A Anthropic recomenda reter os logs de atividade em uma base contínua de pelo menos 30 dias para entender os padrões de uso e investigar possíveis problemas.

## Suporte

Para suporte, entre em contato com **[bedrock-ant-eap@amazon.com](mailto:bedrock-ant-eap@amazon.com)**. Inclua o ID da sua conta da AWS e o `request-id` de quaisquer respostas de API com falha.

<Note>
  O **Claude Mythos Preview** é um modelo de prévia de pesquisa disponível para clientes convidados no Amazon Bedrock. Para mais informações, consulte o [Project Glasswing](https://anthropic.com/glasswing).
</Note>
