---
title: Claude Platform on AWS
url: https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws
description: Acesse todos os recursos da plataforma Claude por meio da AWS com infraestrutura gerenciada pela Anthropic.
---
O Claude Platform on AWS oferece a experiência completa da plataforma Anthropic, incluindo a Messages API, Agent Skills, execução de código e recursos beta, acessível por meio da sua conta AWS. Diferentemente do [Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock), em que a AWS opera a pilha de inferência, a Anthropic opera o Claude Platform on AWS. A AWS fornece a camada de autenticação (SigV4 ou chave de API), o controle de acesso baseado em IAM e a integração de faturamento por meio do AWS Marketplace.
Os SDKs da Anthropic oferecem suporte ao Claude Platform on AWS.
## Como funciona a integração da plataforma
Os modelos Claude são executados em infraestrutura gerenciada pela Anthropic. Esta é uma integração comercial para faturamento e acesso por meio da AWS. A Anthropic é a processadora de dados das entradas e saídas de inferência. A AWS processa metadados de faturamento e identidade sob o modelo de marketplace. Clientes que usam o Claude por meio do Claude Platform on AWS estão sujeitos aos [termos de uso de dados](https://www.anthropic.com/legal) da Anthropic.
A Anthropic usa a infraestrutura da AWS para processar suas solicitações de API, executar a inferência do modelo e armazenar o conteúdo do seu workspace (como prompts, saídas, arquivos, Skills e lotes). Para workspaces criados antes de 18 de setembro de 2026, 00:00 UTC, a Anthropic pode processar solicitações, armazenar dados e executar inferência fora da AWS. Em ambos os casos, os subserviços podem mudar sem aviso prévio. Defina o parâmetro [`inference_geo`](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#data-residency) por solicitação para fixar a inferência em uma geografia específica.
O Claude Platform on AWS segue a mesma política de retenção de dados da Claude API primária. A "Zero Data Retention" (retenção zero de dados), ou ZDR, está disponível mediante solicitação. Entre em contato com o representante da sua conta Anthropic para habilitá-la para sua organização.
## Claude Platform on AWS versus Amazon Bedrock
Ambas as ofertas permitem usar o Claude por meio da AWS, mas diferem em arquitetura, superfície de API e disponibilidade de recursos.
| Aspecto | Claude Platform on AWS | [Claude in Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock) | [Amazon Bedrock (Opus 4.6 e anteriores)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy) |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Quem opera a pilha** | Anthropic | AWS | AWS |
| **Superfície de API** | Claude API (`/v1/{endpoint}`) | Messages API em `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Disponibilidade de recursos** | Normalmente no mesmo dia que a Claude API (consulte as [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported)) | Conforme o cronograma de lançamentos do Amazon Bedrock | Conforme o cronograma de lançamentos do Amazon Bedrock |
| **Agent Skills** | Disponível | Não disponível (requer execução de código) | Não disponível |
| **Recursos beta** | Repassados com cabeçalhos `anthropic-beta` (consulte as [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported)) | Os recursos beta suportados pelo Amazon Bedrock, por meio do cabeçalho `anthropic-beta` | Os recursos beta suportados pelo Amazon Bedrock, por meio do campo `anthropic_beta` do corpo da solicitação InvokeModel |
| **Autenticação** | AWS IAM / SigV4 ou chave de API | AWS IAM / SigV4 | AWS IAM / SigV4 ou bearer token |
| **Faturamento** | AWS Marketplace | AWS (serviço nativo) | AWS (serviço nativo) |
| **URL base** | `aws-external-anthropic.{region}.api.aws` | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` |
| **Cliente SDK** | `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), em beta | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK |
| **Console** | Claude Console (`platform.claude.com`, acesso por meio do AWS Console) | Bedrock Console | Bedrock Console |
| **Limites de taxa e cotas** | Gerenciados pela Anthropic | Gerenciados pela AWS | Gerenciados pela AWS |
| **Processador de dados de inferência** | Anthropic | AWS | AWS |
Se você precisa do Claude operado pela AWS, consulte [Claude in Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock). O Claude Platform on AWS usa um pool de capacidade separado tanto da Claude API primária quanto do Amazon Bedrock. Você pode executar cargas de trabalho em mais de uma plataforma e fazer failover entre elas.
O [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) é suportado para conectar sua VPC ao endpoint do Claude Platform on AWS.
**Quando escolher o Bedrock:** Organizações em setores regulamentados que exigem conformidade FedRAMP High, IL4, IL5 ou HIPAA, ou que precisam que a AWS seja a única processadora de dados, devem usar o [Claude in Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock). O Bedrock é executado inteiramente em infraestrutura controlada pela AWS, com a AWS como parte operadora.
**Qual oferta você está usando?** O Claude está disponível por meio de vários produtos distintos:
* **Claude Platform on AWS** (esta página): A plataforma Claude API faturada por meio do AWS Marketplace. Gerenciada no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console) e no AWS Console.
* **[Claude in Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock):** Um serviço nativo da AWS. Gerenciado no console do Amazon Bedrock e faturado como uso de serviço da AWS.
* **Claude Enterprise adquirido por meio do AWS Marketplace:** Um plano do [claude.ai](https://claude.ai) (o produto de chat Claude), não uma plataforma de API. Gerenciado em claude.ai, e seu comportamento de conta e migração difere do que esta página descreve. Consulte a [Central de Ajuda do Claude](https://support.claude.com).
* **Contas diretas da Anthropic:** A Claude API primária e os planos do claude.ai faturados pela Anthropic. Gerenciados no Claude Console e em claude.ai.
## Configure sua conta
A configuração do Claude Platform on AWS acontece em quatro fases: inscrever-se na página de serviço do AWS Console, concluir a configuração da sua organização Anthropic, anotar o ID do seu workspace e entrar no Claude Console.
A inscrição por meio do AWS Console provisiona uma nova organização Anthropic vinculada à sua conta AWS. Essa organização é separada de quaisquer organizações existentes que sua empresa tenha com a Anthropic, incluindo organizações Claude Enterprise adquiridas por meio do AWS Marketplace. Chaves de API, workspaces e configurações do Claude Console de uma organização Anthropic primária não são transferidos.
Se você tiver uma oferta privada existente do Amazon Bedrock, entre em contato com o representante da sua conta Anthropic ou AWS antes de se inscrever, para que seu desconto seja aplicado desde a sua primeira solicitação. Descontos não podem ser aplicados retroativamente ao uso incorrido antes da aceitação da sua oferta privada. Consulte [Ofertas privadas](https://platform.claude.com/docs/pt-BR/about-claude/pricing#private-offers).
1. Abra o [AWS Console](https://console.aws.amazon.com/) e navegue até a página de serviço **Claude Platform on AWS**.
2. Escolha **Sign up**.
3. Na página de inscrição, revise os termos (o Contrato de Licença de Usuário Final da Anthropic, o Aviso de Privacidade da AWS e o Contrato de Cliente da AWS) e marque a caixa de seleção de concordância.
4. Escolha **Continue**.
A página exibe um banner **Sign-up in progress**. Permaneça na página. A inscrição leva alguns minutos enquanto a AWS cuida da assinatura do AWS Marketplace para você e, em seguida, redireciona você automaticamente.
Se sua organização tiver uma oferta privada da Anthropic, o Console a localiza e solicita que você a aceite no AWS Marketplace. Consulte [Ofertas privadas](https://platform.claude.com/docs/pt-BR/about-claude/pricing#private-offers) para obter detalhes.
Quando você usa o Claude Platform on AWS, a Anthropic processa e armazena seu conteúdo (como prompts e saídas) na infraestrutura da AWS. Para workspaces criados antes de 18 de setembro de 2026, 00:00 UTC, a Anthropic pode processar e armazenar esse conteúdo fora da AWS. As [políticas de uso de dados](https://www.anthropic.com/legal) da Anthropic descrevem como o conteúdo e os metadados são processados e armazenados.
Após a conclusão da inscrição, você é redirecionado para `platform.claude.com/partner-signup`.
1. Insira o endereço de e-mail do proprietário da sua organização e escolha **Get started**.
2. Verifique a caixa de entrada desse e-mail em busca de um link de configuração e siga-o. Se o seu navegador exibir uma página **Signed in as a different account**, escolha **Log out and continue**.
3. Preencha o formulário de detalhes da organização (nome da organização, tipo de entidade, país, uso pretendido) e escolha **Complete setup**.
A conclusão da configuração cria sua organização Anthropic e aceita os Termos de Serviço Comerciais e a Política de Uso da Anthropic. A página de serviço do AWS Console agora exibe uma navegação à esquerda com **Home**, **API keys**, **Quickstart** e **Workspaces**.
Depois de concluir a configuração, o AWS Console solicita que você crie um workspace. Consulte [Workspaces](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#workspaces) para obter detalhes sobre vinculação de região, escopo de recursos do IAM e criação de workspaces adicionais.
Encontre o ID do workspace em **Workspaces** na página de serviço **Claude Platform on AWS** do AWS Console ou no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console). Os IDs de workspace usam o formato `wrkspc_` seguido de um identificador alfanumérico.
O acesso ao Claude Console é federado por meio do AWS IAM:
1. Assuma uma função do IAM com a permissão `aws-external-anthropic:AssumeConsole`. Consulte [Ações do IAM para o Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#console-access).
2. Na página de serviço **Claude Platform on AWS**, escolha **Open Claude Console**. O AWS Console emite um JWT e redireciona você para `platform.claude.com`.
3. No primeiro login, será solicitado um endereço de e-mail. Insira seu e-mail de trabalho. A plataforma provisiona seu usuário do Claude Console just-in-time.
Quando você está conectado por meio do AWS Console, o Claude Console fica restrito à sua organização do Claude Platform on AWS. Um indicador **Account managed by AWS** aparece no canto inferior esquerdo da barra lateral do Claude Console.
### Migrando de uma organização Anthropic existente
A inscrição no Claude Platform on AWS sempre provisiona uma nova organização Anthropic vinculada à sua conta AWS. Não há conversão no local: uma organização existente, como uma organização da Claude API primária, não pode se tornar uma organização do Claude Platform on AWS.
Planeje a migração de uma organização existente como uma transição para uma nova:
* **Crie a nova organização primeiro.** Inscreva-se por meio do AWS Console (consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#set-up-your-account)). Se sua migração envolver uma oferta privada, conclua a inscrição antes que a oferta seja aceita: os descontos se aplicam a partir da aceitação, não retroativamente. Consulte [Ofertas privadas](https://platform.claude.com/docs/pt-BR/about-claude/pricing#private-offers).
* **Recrie o acesso e a configuração.** Chaves de API, workspaces e configurações do Claude Console não são transferidos de uma organização existente. Crie workspaces na nova organização e mude seus aplicativos para a [autenticação do Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#authentication).
* **Atualize sua integração.** O Claude Platform on AWS serve a Claude API (`/v1/{endpoint}`), portanto os formatos de solicitação e resposta não mudam em relação à Claude API primária. O que muda é a URL base, o método de autenticação e o cabeçalho `anthropic-workspace-id` em solicitações de inferência e de recursos; consulte [Fazendo solicitações](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#making-requests). Alguns recursos da plataforma diferem; consulte [Recursos não suportados](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Faça a transição no seu próprio ritmo.** A nova organização é independente da existente, e ambas podem atender tráfego em paralelo. Não há necessidade de uma transição abrupta: transfira as cargas de trabalho gradualmente até que todo o seu tráfego esteja na nova organização.
Quando a nova organização estiver em execução, as diferenças se concentram no faturamento e na autenticação, que são tratados por meio da AWS:
* **O faturamento** passa para o AWS Marketplace: o uso é faturado em Claude Consumption Units em vez de créditos pré-pagos (consulte [Faturamento](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#billing)), e você define limites de gastos na página Billing (consulte [Limites de gastos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#spend-limits)). Durante a transição, o faturamento permanece separado: a organização existente continua sendo faturada como é hoje.
* **A autenticação e o acesso** passam para a AWS: as solicitações são autenticadas com credenciais da AWS ou com chaves de API geradas no AWS Console, não no Claude Console (consulte [Autenticação](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#authentication)). A associação à organização é gerenciada por meio do AWS IAM em vez do Claude Console (consulte [Páginas disponíveis](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#available-pages)), e os SDKs de cliente da Anthropic fornecem classes de cliente específicas da plataforma (consulte [Instale um SDK](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **O uso diário da API** funciona da mesma forma que na Claude API primária, exceto onde indicado nas [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported). Antes de transferir o tráfego de produção, verifique seus limites de taxa: novas organizações são colocadas no nível Start, e aumentos de limite passam pelo representante da sua conta Anthropic (consulte [Limites de taxa e cotas](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Para organizações Claude Enterprise (claude.ai), que se comportam de forma diferente, consulte a [comparação de ofertas](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Solução de problemas na configuração da conta
* **"Sign-up failed: Failed to enable OutboundWebIdentityFederation":** Se você vir este banner no primeiro envio, escolha **Continue** novamente. A habilitação do IAM pode levar um momento para entrar em vigor.
* **Nenhum indicador de progresso durante a inscrição:** A inscrição leva alguns minutos. A página exibe um banner estático **Sign-up in progress** sem barra de progresso enquanto a AWS provisiona sua conta.
* **"Signed in as a different account" após seguir o link de configuração:** Escolha **Log out and continue**. A página autentica você novamente com o endereço de e-mail que você inseriu.
* **Mensagem "Not found" durante o login:** Esta mensagem pode aparecer brevemente durante o redirecionamento. Você pode ignorá-la.
* **A página Usage não mostra dados após sua primeira chamada de API:** Os dados de uso podem levar alguns minutos para aparecer no Claude Console.
* **"Outbound web identity federation is disabled" na sua primeira chamada de API:** Habilite a federação uma vez por conta. Consulte [Habilite a federação de identidade web de saída](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Antes de fazer chamadas de API
Certifique-se de ter:
1. Uma conta AWS ativa com uma assinatura do Claude Platform on AWS (consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#set-up-your-account))
2. A [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) instalada e configurada
3. **Federação de identidade web de saída habilitada** na sua conta AWS, uma etapa de configuração única (consulte [Habilite a federação de identidade web de saída](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation))
4. O ID do seu workspace (consulte [Obtenha o ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id))
5. Permissão do IAM para chamar a API: a ação `aws-external-anthropic:CreateInference` no seu workspace, além de `aws-external-anthropic:CallWithBearerToken` se você se autenticar com uma chave de API (consulte [Políticas do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#iam-policies))
### Habilite a federação de identidade web de saída
O gateway do Claude Platform on AWS chama `sts:GetWebIdentityToken` no lado do servidor para gerar um JWT que ele encaminha para a Anthropic. Esse recurso do STS está **desabilitado por padrão** em todas as contas AWS. Habilite-o uma vez por conta:
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Se a resposta for `[ERROR] (FeatureEnabled) ... already enabled`, a configuração já está ativada para sua conta e você pode prosseguir. Verifique e recupere a URL do emissor da sua conta:
```bash CLI
aws iam get-outbound-web-identity-federation-info
```
Sem esta etapa, todas as solicitações retornam `"Outbound web identity federation is disabled for your account"`. Este é o erro de configuração mais comum.
### Obtenha o ID do seu workspace
Você cria um workspace no AWS Console após concluir a configuração da conta (consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#set-up-your-account)). Os workspaces são vinculados a uma única região da AWS. Você pode encontrar o ID do workspace no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console) em **Workspaces** ou na seção **Workspaces** da página de serviço do AWS Console.
Defina as variáveis de ambiente `ANTHROPIC_AWS_WORKSPACE_ID` e `AWS_REGION` para que os clientes SDK as leiam automaticamente:
```bash CLI
export ANTHROPIC_AWS_WORKSPACE_ID='wrkspc_01AbCdEf23GhIj'
export AWS_REGION='us-west-2' # Your workspace's AWS region
```
A região é obrigatória. O cliente SDK gera um erro se nenhuma região estiver definida. Passe `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) ao criar o cliente, ou defina `AWS_REGION` (ou `AWS_DEFAULT_REGION`). Todas as regiões comerciais da AWS são suportadas.
## Autenticação
O Claude Platform on AWS oferece suporte a dois métodos de autenticação: AWS IAM com assinatura de solicitações Signature Version 4 (SigV4) (principal) e autenticação por chave de API. Ambos usam a mesma URL base e o mesmo formato de solicitação.
### Autenticação SigV4
O SigV4 é o caminho nativo para empresas e se integra às suas políticas, funções e auditoria existentes do AWS IAM. Configure as credenciais da AWS usando qualquer método suportado pela [cadeia de provedores de credenciais padrão da AWS](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html):
* Variáveis de ambiente (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`)
* Arquivo de credenciais compartilhado (`~/.aws/credentials`)
* Arquivo de configuração compartilhado (`~/.aws/config`), incluindo SSO e `credential_process`
* Identidade web (`AWS_WEB_IDENTITY_TOKEN_FILE` e `AWS_ROLE_ARN`) para IRSA e GitHub Actions
* Credenciais de contêiner ECS
* Serviço de metadados de instância EC2 (IMDS)
Verifique se suas credenciais estão funcionando:
```bash CLI
aws sts get-caller-identity
```
### Autenticação por chave de API
Para caminhos de integração mais simples (desenvolvimento local e scripts), você pode se autenticar com uma chave de API em vez de SigV4. Defina a variável de ambiente `ANTHROPIC_AWS_API_KEY` ou passe `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) ao criar o cliente.
Gere chaves de API no **AWS Console** em **Claude Platform on AWS → API keys**. Escolha **Generate a key** e copie o valor da chave. Conceda a ação do IAM `aws-external-anthropic:CallWithBearerToken` às entidades principais que devem ter permissão para usar a autenticação por chave de API.
As chaves de API do Claude Platform on AWS são gerenciadas no AWS Console, não no Claude Console. Chaves criadas no [Claude Console](https://platform.claude.com/) padrão (para acesso à API primária) não funcionam com o endpoint do Claude Platform on AWS.
#### Chaves de API de curto prazo
Para cargas de trabalho que precisam entregar uma credencial a um processo separado (como um gateway de LLM, uma função serverless ou uma ferramenta que suporta autenticação por bearer token, mas não SigV4), gere uma chave de API de curto prazo a partir das suas credenciais da AWS em vez de provisionar uma chave de longa duração no AWS Console.
A AWS publica bibliotecas geradoras de tokens para [JavaScript](https://github.com/aws/token-generator-for-aws-external-anthropic-js), [Python](https://github.com/aws/token-generator-for-aws-external-anthropic-python) e [Java](https://github.com/aws/token-generator-for-aws-external-anthropic-java). Cada biblioteca lê suas credenciais da AWS por meio da cadeia de provedores padrão e retorna um token com tempo limitado que você envia como `Authorization: Bearer `. A vida útil do token é de 12 horas por padrão e é limitada ao menor valor entre a duração solicitada, a expiração das suas credenciais da AWS e 12 horas. Consulte os READMEs dos repositórios vinculados para instalação e opções completas de configuração.
Passe o token gerado para o SDK da mesma forma que você passaria uma chave de API gerada no AWS Console:
```python Python
from token_generator_for_aws_external_anthropic import TokenGenerator
from anthropic import AnthropicAWS
token = TokenGenerator(region="us-west-2").get_token()
client = AnthropicAWS(api_key=token, aws_region="us-west-2")
```
```typescript TypeScript
import { getTokenProvider } from "@aws/token-generator-for-aws-external-anthropic";
import AnthropicAws from "@anthropic-ai/aws-sdk";
const tokenProvider = getTokenProvider({ region: "us-west-2" });
const token = await tokenProvider();
const client = new AnthropicAws({ apiKey: token, awsRegion: "us-west-2" });
```
```java Java
import software.amazon.awsexternalanthropic.TokenGenerator;
import software.amazon.awssdk.regions.Region;
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
void main() {
String token = TokenGenerator.builder().region(Region.US_WEST_2).build().getToken();
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.builder()
.apiKey(token)
.region(Region.US_WEST_2)
.workspaceId(System.getenv("ANTHROPIC_AWS_WORKSPACE_ID"))
.build())
.build();
}
```
Se você consegue gerar o token localmente, seu processo já tem credenciais SigV4, e a autenticação SigV4 geralmente é a opção mais simples. Use chaves de curto prazo quando o processo que faz as chamadas de API for separado do processo que detém as credenciais da AWS.
O SDK não atualiza chaves de curto prazo automaticamente. Quando um token expirar, gere um novo e construa um novo cliente. A entidade principal que usa o token ainda precisa da ação do IAM `aws-external-anthropic:CallWithBearerToken`.
### Precedência de credenciais
O cliente específico da plataforma resolve a autenticação na seguinte ordem, começando pelo que você passa ao criá-lo:
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → cabeçalho `Authorization: Bearer`
2. `aws_access_key` (typescript, php: `awsAccessKey`; go: `AWSAccessKey`; java: `.awsAccessKey()`; csharp: `AwsClientOptions.AwsAccessKey`) + `aws_secret_key` (ruby: `aws_secret_access_key`; typescript, php: `awsSecretAccessKey`; go: `AWSSecretAccessKey`; java: `.awsSecretAccessKey()`; csharp: `AwsClientOptions.AwsSecretAccessKey`) → AWS SigV4
3. `aws_profile` (typescript, php: `awsProfile`; go: `AWSProfile`; java: `.awsProfile()`; csharp: `AwsClientOptions.AwsProfile`) → AWS SigV4 com perfil nomeado
4. Variável de ambiente `ANTHROPIC_AWS_API_KEY` → cabeçalho `Authorization: Bearer`
5. Cadeia de provedores de credenciais padrão da AWS → AWS SigV4
### Resolução de região
O cliente lê `AWS_REGION` do ambiente se você não definir `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`), recorrendo a `AWS_DEFAULT_REGION` para compatibilidade com os SDKs padrão da AWS. A região é obrigatória e não há padrão: `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) gera um erro se nem o argumento do construtor nem uma variável de ambiente estiverem definidos.
## Instale um SDK
Os [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) da Anthropic oferecem suporte ao Claude Platform on AWS. Seu SDK fornece `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), que cuida da assinatura SigV4, da construção da URL base com base na região e do cabeçalho `anthropic-workspace-id`.
```bash
pip install -U "anthropic[aws]"
```
No macOS com Python do Homebrew ou outros ambientes Python gerenciados externamente, `pip install` pode falhar com um erro PEP 668 `externally-managed-environment`. Crie e ative um ambiente virtual primeiro: `python3 -m venv .venv && source .venv/bin/activate`.
```bash
npm install @anthropic-ai/aws-sdk
```
```bash
dotnet add package Anthropic.Aws
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.3.0")
implementation("com.anthropic:anthropic-java-aws:3.3.0")
```
```xml Maven
com.anthropic
anthropic-java
3.3.0
com.anthropic
anthropic-java-aws
3.3.0
```
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
```bash
gem install anthropic aws-sdk-core
```
Os clientes SDK para o Claude Platform on AWS estão em beta.
## Modelos disponíveis
Os seguintes modelos estão disponíveis no Claude Platform on AWS:
| Model | Model ID |
| :------------------------------------------------------------------------------------------------------- | :------------------ |
| Claude Fable 5.1 | `claude-fable-5-1` |
| Claude Fable 5 | `claude-fable-5` |
| Claude Opus 5.5 | `claude-opus-5-5` |
| Claude Opus 5 | `claude-opus-5` |
| Claude Opus 4.8 | `claude-opus-4-8` |
| Claude Opus 4.7 | `claude-opus-4-7` |
| Claude Opus 4.6 | `claude-opus-4-6` |
| Claude Opus 4.5 | `claude-opus-4-5` |
| Claude Sonnet 5.5 | `claude-sonnet-5-5` |
| Claude Sonnet 5 | `claude-sonnet-5` |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations)) | `claude-sonnet-4-5` |
| Claude Haiku 5.5 | `claude-haiku-5-5` |
| Claude Haiku 4.5 | `claude-haiku-4-5` |
Os IDs de modelo são idênticos aos da Claude API primária. Não há ARNs no estilo do Bedrock nem prefixos `anthropic.`.
Novos modelos normalmente são lançados no Claude Platform on AWS no mesmo dia que na Claude API primária.
Atualizando para um modelo Claude mais recente? A [skill Claude API](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) no Claude Code aplica trocas de ID de modelo e alterações de parâmetros incompatíveis em toda a sua base de código:
Deixe o Claude Code migrar seu código para você
```text
/claude-api migrate este projeto para o modelo Claude Opus mais recente
```
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.
## Fazendo solicitações
O Claude Platform on AWS usa os mesmos endpoints de API que a Claude API primária. As diferenças são a URL base, o método de autenticação e o cabeçalho `anthropic-workspace-id`, que identifica o [workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#workspaces) ao qual uma solicitação se destina. O cabeçalho é obrigatório em solicitações de inferência e de recursos, como chamadas para a Messages API, Models API, Files API e endpoints do Claude Managed Agents. Solicitações para a [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api) não o exigem.
Antes de executar estes exemplos, conclua as etapas em [Antes de fazer chamadas de API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#before-making-api-calls).
```bash cURL
# Substitua us-west-2 pela sua região da AWS tanto na URL quanto em --aws-sigv4
# Omita o cabeçalho x-amz-security-token se você usar credenciais de longo prazo de usuário IAM
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Substitua us-west-2 pela sua região da AWS
# ant lê ANTHROPIC_API_KEY. Gere uma chave no AWS Console
# (consulte autenticação por chave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
O cliente lê `AWS_REGION` (ou `AWS_DEFAULT_REGION`) e `ANTHROPIC_AWS_WORKSPACE_ID` do ambiente. Você pode substituir qualquer um deles passando `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) ou `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `AwsClientOptions.WorkspaceId`) ao criar o cliente. Tanto a região quanto o ID do workspace são obrigatórios. O construtor gera um erro se algum deles não puder ser resolvido.
O cabeçalho `x-amz-security-token` (cURL) só é necessário para credenciais temporárias, como funções do IAM, SSO ou STS. Omita-o ao usar credenciais de usuário do IAM de longo prazo. Os clientes SDK lidam com isso automaticamente com base na origem da credencial.
O valor de `--aws-sigv4` segue o formato `aws:amz::`. O nome do serviço SigV4 é `aws-external-anthropic`, e a região deve corresponder à região na URL do seu endpoint. Uma incompatibilidade em qualquer um deles produz um erro genérico de rejeição de assinatura em vez de um diagnóstico específico.
### Janela de contexto
Os tamanhos da "context window" (janela de contexto) no Claude Platform on AWS são idênticos aos da Claude API primária. Consulte [Janelas de contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows) para ver os limites por modelo.
## Suporte a recursos
O Claude Platform on AWS usa os endpoints da Claude API diretamente, o que significa que você obtém paridade total de recursos com a Claude API primária (exceto onde indicado nas [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported)):
* **Acesso a recursos:** Como a Anthropic opera ambas as plataformas, a maioria dos novos recursos e cabeçalhos beta fica disponível no Claude Platform on AWS sem uma etapa de integração separada. Consulte as [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported) para ver as exceções.
* **Recursos beta:** Passe o cabeçalho padrão `anthropic-beta` para acessar recursos beta, assim como faria com a Claude API.
* **Agent Skills:** Use [Agent Skills](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/overview) pré-construídas e personalizadas com o mesmo parâmetro `container.skills` da Claude API. Todas as Skills pré-construídas (PowerPoint, Excel, Word, PDF) funcionam imediatamente.
* **Execução de código:** Execute código no sandbox gerenciado da Anthropic usando a [ferramenta de execução de código](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool).
* **Uso de ferramentas:** Todos os [recursos de "tool use" (uso de ferramentas)](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/overview) estão disponíveis, exceto os conjuntos de ferramentas de uso do computador e uso do navegador; consulte [Recursos não suportados](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Pensamento:** O [pensamento adaptativo](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking), o [parâmetro effort](https://platform.claude.com/docs/pt-BR/build-with-claude/effort) e, nos modelos que o suportam, o ["extended thinking" (pensamento estendido)](https://platform.claude.com/docs/pt-BR/build-with-claude/extended-thinking) funcionam com os mesmos parâmetros da Claude API.
* **Streaming:** Suporte completo a "streaming" SSE para respostas em tempo real.
* **Processamento em lote:** Envie solicitações em lote para cargas de trabalho de alto throughput.
* **Cache de prompt:** Armazene em cache ferramentas, "system prompts" (prompts do sistema) e histórico de mensagens para reduzir a latência e o custo. Todos os recursos de "prompt caching" (cache de prompt) (TTL de 5 minutos, TTL de 1 hora e cache automático) estão disponíveis.
* **Files API:** Faça upload de arquivos e referencie-os entre solicitações.
* **Chaves de criptografia gerenciadas pelo cliente (CMEK):** A [CMEK](https://platform.claude.com/docs/pt-BR/manage-claude/cmek) está disponível apenas com chaves do [AWS KMS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms). Chaves do Google Cloud KMS e do Azure Key Vault não podem ser registradas. A chave deve ser uma chave KMS de região única na mesma conta AWS e região do workspace ao qual está anexada, e sua política de chave deve conceder acesso à entidade principal de serviço `aws-external-anthropic.amazonaws.com`; consulte [Configure a CMEK no Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-claude-platform-on-aws). Registre e anexe chaves no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console); os endpoints de chaves externas também estão disponíveis, autorizados por meio de [ações do IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#encryption-keys). Não há etapa de validação separada: a chave é validada implicitamente quando você a anexa a um workspace (a chamada de anexação executa um ciclo de criptografia/descriptografia), portanto um problema na política de chave aparece no momento da anexação, e não no registro.
* **Compliance API:** A [Compliance API](https://platform.claude.com/docs/pt-BR/manage-claude/compliance-api) está disponível. O acesso é autorizado por meio da [ação `ListComplianceActivities`](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#compliance) do AWS IAM.
Consulte a [tabela de comparação](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock) para ver as diferenças de disponibilidade de recursos em relação ao Amazon Bedrock.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview) está disponível no Claude Platform on AWS, incluindo [agentes](https://platform.claude.com/docs/pt-BR/managed-agents/agent-setup), [ambientes](https://platform.claude.com/docs/pt-BR/managed-agents/environments), [sessões](https://platform.claude.com/docs/pt-BR/managed-agents/sessions), [implantações agendadas](https://platform.claude.com/docs/pt-BR/managed-agents/scheduled-deployments), [cofres de credenciais](https://platform.claude.com/docs/pt-BR/managed-agents/vaults), [armazenamentos de memória](https://platform.claude.com/docs/pt-BR/managed-agents/memory), [webhooks](https://platform.claude.com/docs/pt-BR/managed-agents/webhooks), [orquestração multiagente](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration) e [sandboxes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes).
Sessões e workers auto-hospedados no Claude Platform on AWS diferem do Claude Managed Agents primário de três maneiras:
* **Reautenticação de sessão autônoma:** Uma sessão pode ser executada de forma autônoma, sem nenhum [evento de usuário](https://platform.claude.com/docs/pt-BR/managed-agents/reference#event-types), por até 6 horas. Após 6 horas, a sessão requer reautenticação antes de continuar. Para reautenticar, envie qualquer evento com papel de usuário para a sessão (consulte [Eventos e streaming](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming)). O Claude Managed Agents primário não tem limite de tempo de execução para sessões autônomas.
* **[Armazenamentos de memória em ambientes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory):** Uma sessão executada em um ambiente auto-hospedado não pode anexar armazenamentos de memória; uma sessão que inclua um é rejeitada na criação. Sessões em ambientes de nuvem anexam armazenamentos de memória normalmente. No Claude Managed Agents primário, sessões em ambientes de nuvem e auto-hospedados podem anexar armazenamentos de memória.
* **[Autenticação de workers em ambientes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes#prerequisites):** Um worker se autentica com AWS IAM (SigV4) ou com uma [chave de API gerada no AWS Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#api-key-authentication), não com uma chave de ambiente. Chaves de ambiente geradas no Claude Console não funcionam com o endpoint do Claude Platform on AWS.
### Recursos não suportados
Os seguintes recursos não estão disponíveis atualmente no Claude Platform on AWS:
* **Prontidão para HIPAA:** O programa de prontidão para HIPAA da Anthropic não está disponível. Consulte [API e retenção de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention).
* **Conjuntos de ferramentas de uso do computador e uso do navegador:** `computer_toolset_20260801` e `browser_toolset_20260801` não estão disponíveis atualmente no Claude Platform on AWS. As versões beta da ferramenta de uso do computador continuam disponíveis para os modelos listados em [Versões anteriores da ferramenta](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
- **Admin API:** Os endpoints de workspace (criar, obter, listar, atualizar e arquivar em `/v1/organizations/workspaces`), os endpoints de chaves externas (registrar, obter, listar, atualizar e excluir em `/v1/organizations/external_keys`, para [CMEK](https://platform.claude.com/docs/pt-BR/manage-claude/cmek); as chaves são validadas quando anexadas a um workspace, e não por meio de um endpoint de validação) e os [endpoints de destino de telemetria](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#telemetry-destinations) estão disponíveis. Outros endpoints da Admin API (membros da organização, membros do workspace, convites, chaves de API, relatórios de uso, relatórios de custo e relatórios de limite de taxa) não estão disponíveis atualmente. Em vez disso, visualize os dados de uso e custo no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console). O AWS IAM gerencia a associação à organização.
- **Gerenciamento de membros do workspace:** Adicionar ou remover usuários de workspaces individuais não está disponível. Políticas do AWS IAM nos ARNs de workspace controlam o acesso.
- **Workspace do Claude Code e Analytics API:** O workspace do Claude Code com limites de taxa automáticos não está disponível. O uso do Claude Code aparece na visualização geral de uso, em vez de em uma tela dedicada.
- **Autenticação OAuth:** Não suportada. Use autenticação SigV4 ou por chave de API.
- **Modo rápido:** Não disponível no Claude Platform on AWS.
- **Endpoints de API compatíveis com OpenAI:** Não disponíveis no Claude Platform on AWS.
- **Túneis MCP:** Apenas servidores MCP expostos pela internet pública são suportados.
## Residência de dados
O Claude Platform on AWS suporta as seguintes geografias de inferência:
* **US:** A inferência permanece em data centers dos EUA. Aplica-se um multiplicador de preço de 1,1x.
* **Global:** A inferência pode ser roteada para qualquer data center operado pela Anthropic no mundo. Aplica-se o preço padrão.
A região da AWS à qual seu workspace está vinculado controla qual endpoint de gateway você chama e onde os recursos do lado da AWS (IAM, CloudTrail, faturamento) têm escopo. Ela não fixa onde a inferência do modelo é executada. Para fixar a inferência em uma geografia específica, defina `inference_geo` em cada requisição ou configure um padrão no workspace.
Defina a geografia de inferência por requisição com o parâmetro `inference_geo`:
O parâmetro `inference_geo` é suportado no Claude 4.6 e em modelos posteriores. Requisições com `inference_geo` no Claude Opus 4.5, Claude Sonnet 4.5 (descontinuado) ou Claude Haiku 4.5 retornam um erro 400. Consulte [Residência de dados](https://platform.claude.com/docs/pt-BR/manage-claude/data-residency) para detalhes sobre a disponibilidade de modelos.
```bash cURL
# Substitua us-west-2 pela sua região da AWS tanto na URL quanto em --aws-sigv4
# Omita o cabeçalho x-amz-security-token se você usar credenciais de longo prazo de usuário IAM
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"inference_geo": "us",
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Substitua us-west-2 pela sua região da AWS
# ant lê ANTHROPIC_API_KEY. Gere uma chave no AWS Console
# (consulte autenticação por chave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--inference-geo us \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
inference_geo="us",
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
InferenceGeo = "us",
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
InferenceGeo: anthropic.String("us"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.inferenceGeo("us")
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
inferenceGeo: 'us',
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Se você omitir `inference_geo`, a requisição usa o `default_inference_geo` do workspace, se houver um configurado; caso contrário, usa `global`.
Controles de geografia de inferência no nível do workspace (`allowed_inference_geos` e `default_inference_geo`) também estão disponíveis no Claude Platform on AWS. Consulte [Restrições no nível do workspace](https://platform.claude.com/docs/pt-BR/manage-claude/data-residency#workspace-level-restrictions).
## Workspaces
Requisições de inferência e de recursos no Claude Platform on AWS têm como alvo um workspace. Você passa o ID do workspace no cabeçalho `anthropic-workspace-id` nessas chamadas de API. Os IDs de workspace usam o formato marcado `wrkspc_` seguido de um identificador alfanumérico (por exemplo, `wrkspc_01AbCdEf23GhIj`). Consulte [Obtenha o ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id) se você ainda não o tiver.
### Escopo do workspace
Os workspaces são vinculados a uma única região da AWS. Um workspace criado em `us-west-2` só pode ser acessado pelo endpoint `us-west-2`. Uso, cotas, custo, arquivos, lotes e Skills são todos agregados por workspace, oferecendo detalhamentos por região no Claude Console.
Os workspaces também servem como o principal recurso de IAM do Claude Platform on AWS. Você concede ou nega acesso a workspaces específicos por meio de políticas do AWS IAM usando o ARN do workspace. O segmento de recurso do ARN é o mesmo ID com prefixo `wrkspc_` que você passa no cabeçalho `anthropic-workspace-id`:
```text wrap
arn:aws:aws-external-anthropic:{region}:{account-id}:workspace/{workspace-id}
```
Por exemplo:
```text wrap
arn:aws:aws-external-anthropic:us-west-2:123456789012:workspace/wrkspc_01AbCdEf23GhIj
```
Consulte [Políticas de IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#iam-policies) para exemplos de políticas.
### Gerenciando workspaces
Crie workspaces adicionais, renomeie um workspace ou arquive um workspace na página **Workspaces** do AWS Console ou com os endpoints de workspace da [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api). Esses endpoints não exigem o cabeçalho `anthropic-workspace-id`. Criar e listar atuam na organização; obter, atualizar e arquivar recebem o ID do workspace no caminho da URL. Um novo workspace é vinculado à região da AWS do endpoint que você chama para criá-lo (consulte [Escopo do workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#workspace-scoping)). Com o papel Admin, você também pode criar, renomear e arquivar workspaces na página **Workspaces** do Claude Console.
## Usando o Claude Console
O Claude Platform on AWS usa o Claude Console padrão em [platform.claude.com](https://platform.claude.com). Quando você faz login a partir do AWS Console, um indicador **Account managed by AWS** aparece no canto inferior esquerdo da barra lateral do Claude Console, e o Console passa a ter como escopo sua organização do Claude Platform on AWS. Ele oferece análises de uso, detalhamentos de custo, visibilidade de limites de taxa, gerenciamento de workspaces e páginas para gerenciar arquivos, Agent Skills, jobs em lote e recursos do Claude Managed Agents (agentes, sessões, ambientes, cofres de credenciais, armazenamentos de memória e webhooks).
### Fazendo login
O acesso ao Claude Console é federado por meio do AWS IAM. Consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#set-up-your-account) para o fluxo completo do primeiro login. Em resumo:
1. Assuma um papel do IAM com a permissão `aws-external-anthropic:AssumeConsole`. Consulte [Ações de IAM para o Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#console-access).
2. Navegue até a página do Claude Platform on AWS no [AWS Console](https://console.aws.amazon.com/).
3. Escolha **Open Claude Console**. O AWS Console emite um JWT e redireciona você para `platform.claude.com`.
4. No primeiro login, será solicitado um endereço de e-mail. Insira seu e-mail de trabalho. A plataforma provisiona seu usuário do Claude Console sob demanda (just-in-time).
Dois papéis do Claude Console estão disponíveis: **Admin** e **Developer**. O papel Admin concede acesso a todas as páginas e configurações do Claude Console disponíveis para o Claude Platform on AWS. O papel Developer concede acesso de leitura a informações de uso, custo, limite de taxa e workspaces. Entre em contato com seu representante de conta da Anthropic para atribuir o papel Admin ou Developer a um principal.
### Páginas disponíveis
A coluna **Pelo gateway da AWS** indica se a página lê e grava dados por meio do gateway da AWS (e, portanto, é regida por [ações de IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions)). Páginas marcadas com **Não** leem metadados no nível da organização diretamente da Anthropic e ignoram as verificações de ações de IAM.
| Página | Disponível | Pelo gateway da AWS | Observações |
| --------------------- | -------------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Usage** | Sim | Não | Visualize o uso de tokens por modelo, workspace e dimensão. Os dados podem levar alguns minutos para aparecer após uma requisição. |
| **Cost** | Sim | Não | Visualize detalhamentos de custo por modelo e workspace. O AWS Cost Explorer mostra o item de linha agregado de [Claude Consumption Unit (CCU)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#billing). |
| **Rate limits** | Sim | Não | Visualize os limites de taxa (somente leitura). Aumentos de nível passam pelo seu representante de conta da Anthropic; consulte [Limites de taxa e cotas](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas). |
| **Workspaces** | Sim | Sim (exceto limites de gastos) | Visualize workspaces por região. Com o papel Admin, você também pode criar, renomear e arquivar workspaces e definir [limites de gastos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#spend-limits) por workspace. |
| **Encryption keys** | Sim | Sim | Uma seção da página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`) no Claude Console, exibida enquanto **Organization** está selecionado no menu suspenso no topo da página. Registre chaves do AWS KMS para [CMEK](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-claude-platform-on-aws) ali (papel Admin). Para anexar uma chave registrada a um workspace, selecione o workspace nesse menu suspenso e, em seguida, selecione a chave em **Encryption key**. |
| **Files** | Sim | Sim | Visualize e gerencie arquivos enviados. |
| **Skills** | Sim | Sim | Visualize e gerencie Agent Skills. |
| **Batches** | Sim | Sim | Visualize e gerencie jobs de processamento em lote. |
| **Agents** | Sim | Sim | Visualize e gerencie definições de agentes. |
| **Sessions** | Sim | Sim | Visualize sessões de agentes e o histórico de eventos. |
| **Environments** | Sim | Sim | Visualize e gerencie configurações de sandbox em nuvem para sessões. |
| **Credential vaults** | Sim | Sim | Visualize e gerencie cofres de credenciais para autenticação de sessões. |
| **Memory stores** | Sim | Sim | Visualize e gerencie a memória persistente de agentes. |
| **Webhooks** | Sim | Sim | Visualize e gerencie endpoints de webhook. |
| **API keys** | Não | N/A | Gerencie chaves de API no AWS Console (**Claude Platform on AWS → API keys**). Consulte [Autenticação por chave de API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | Não | N/A | Não aplicável. O AWS IAM gerencia o acesso. |
| **Billing** | Sim (limitado) | Não | Defina um limite de gastos mensal da organização; consulte [Limites de gastos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#spend-limits). O AWS Marketplace gerencia o faturamento. Visualize detalhamentos de custo na página Cost. |
| **Claude Code** | Não | N/A | Visualize o uso do Claude Code na página Usage. |
### Alternando entre organizações
O Claude Console não suporta a alternância entre organizações para o Claude Platform on AWS. Para acessar uma organização diferente, saia e reautentique-se pelo AWS Console usando o papel do IAM da conta da AWS dessa organização.
## Limites de taxa e cotas
Organizações no Claude Platform on AWS são colocadas no nível Start. A Anthropic gerencia os limites de taxa diretamente, não por meio dos sistemas de cotas da AWS.
Organizações no Claude Platform on AWS podem passar automaticamente para um nível de uso mais alto à medida que constroem um histórico de faturas pagas do AWS Marketplace. O fluxo de autoatendimento **Request tier increase** no Claude Console não está disponível: a página Rate limits direciona você ao seu representante de conta da Anthropic.
Para solicitar limites mais altos, entre em contato com seu representante de conta da Anthropic ou com o [suporte da Anthropic](https://support.claude.com). Inclua o seguinte em sua solicitação:
* Os modelos cujos limites você precisa aumentar
* O pico de tokens de entrada por minuto e de tokens de saída por minuto para cada modelo (não totais diários)
* A parcela aproximada da sua entrada que é contexto em cache ou repetido (leituras de cache não contam para os limites de tokens de entrada na maioria dos modelos; consulte [ITPM com reconhecimento de cache](https://platform.claude.com/docs/pt-BR/api/rate-limits#cache-aware-itpm))
Os níveis de uso são etapas fixas: cada nível combina limites de taxa com um [teto de gastos mensal](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#spend-limits), e passar para um nível mais alto aumenta ambos. Para detalhes dos níveis e limites por modelo, consulte [Limites de taxa](https://platform.claude.com/docs/pt-BR/api/rate-limits).
## Faturamento
O Claude Platform on AWS é faturado pelo [AWS Marketplace](https://aws.amazon.com/marketplace). O uso é denominado em Claude Consumption Units (CCUs), medido por hora e faturado mensalmente de forma postecipada na sua fatura da AWS. CCUs não são créditos pré-pagos. Não há saldo nem compromisso de CCU.
Para o preço da CCU, a mecânica de conversão, a aplicação de descontos e as tarifas de tokens por modelo, consulte [Preços do Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/about-claude/pricing#claude-platform-on-aws-pricing).
### Limites de gastos
Os níveis de uso Start, Build e Scale têm, cada um, um teto de gastos mensal; consulte os [tetos de gastos por nível](https://platform.claude.com/docs/pt-BR/api/rate-limits#spend-limits) para os valores atuais. Quando o uso da sua organização no mês calendário atinge o teto do seu nível, as requisições de API falham com o [erro de teto de gastos](https://platform.claude.com/docs/pt-BR/api/rate-limits#reaching-your-spend-cap) até 00:00 UTC do primeiro dia do mês seguinte, e tentar novamente antes disso não funciona. O teto de gastos e os limites de taxa pertencem ao mesmo nível. Para aumentar o teto, ou para restaurar o acesso após atingi-lo, solicite um aumento de nível por meio do seu representante de conta da Anthropic ou do [suporte da Anthropic](https://support.claude.com) (consulte [Limites de taxa e cotas](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Você também pode definir seus próprios limites de gastos mensais abaixo do teto, depois de adicionar pelo menos um destinatário em **Email recipients** na página Billing:
* **Limite de gastos da organização:** Acesse [Settings > Billing](https://platform.claude.com/settings/billing) no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console) para definir um limite de gastos mensal.
* **Limites de gastos do workspace:** Na página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) no Claude Console, selecione um workspace. No painel que se abre, clique em **Spend limits**.
Quando o uso atinge um limite que você definiu, as requisições falham com HTTP 400 (consulte o [erro de limite de gastos](https://platform.claude.com/docs/pt-BR/api/rate-limits#setting-your-own-spend-limit)) até 00:00 UTC do primeiro dia do mês seguinte, ou até que você aumente ou remova o limite.
Os gastos são calculados a preços de tabela e podem levar cerca de 2 horas para refletir o uso recente, portanto o uso pode exceder o teto ou um limite antes que as requisições comecem a falhar. O excedente é cobrado. Quando o teto do nível ou um limite de gastos da organização interrompe suas requisições, um aviso por e-mail é enviado aos destinatários listados em **Email recipients** na página Billing. Destinatários baseados em papéis, como todos os admins, não estão disponíveis no Claude Platform on AWS. O aviso de teto do nível também é enviado ao endereço de e-mail usado no cadastro do AWS Marketplace.
## Monitoramento e registro em log
O AWS CloudTrail pode capturar todas as requisições ao Claude Platform on AWS. Operações de workspace, chave externa, destino de telemetria, conformidade, cofre e webhook são registradas como eventos de gerenciamento (Management events) por padrão. Operações de inferência, lote, arquivo, skill, modelo, perfil de usuário e do Claude Managed Agents (exceto cofres e webhooks) são classificadas como eventos de dados (Data events) e exigem configuração explícita de registro de eventos de dados, o que gera cobranças adicionais do CloudTrail. Consulte a [referência de ações de IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#route-to-action-mapping) para a classificação completa dos tipos de evento e a [documentação do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) para detalhes de configuração.
### IDs de requisição
Cada resposta inclui dois IDs de requisição nos cabeçalhos da resposta:
* **ID de requisição da AWS (`x-amzn-requestid`):** O ID principal, indexado no CloudTrail. Use-o ao investigar requisições por meio das ferramentas da AWS ou ao entrar em contato com o suporte da AWS.
* **ID de requisição da Anthropic (`request-id`):** O ID secundário. Use-o ao entrar em contato com o suporte da Anthropic.
```bash cURL
# Substitua us-west-2 pela sua região da AWS tanto na URL quanto em --aws-sigv4
# -i inclui os cabeçalhos da resposta na saída
# Omita o cabeçalho x-amz-security-token se você usar credenciais de longo prazo de usuário IAM
curl -i "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Substitua us-west-2 pela sua região da AWS
# ant lê ANTHROPIC_API_KEY. Gere uma chave no AWS Console
# (consulte autenticação por chave de API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
# --debug imprime a resposta HTTP, incluindo os cabeçalhos X-Amzn-Requestid e
# Request-Id, no stderr
ant --debug messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
response = client.messages.with_raw_response.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.headers.get("x-amzn-requestid")) # AWS request ID
print(response.headers.get("request-id")) # Anthropic request ID
message = response.parse()
print(message.content)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const { data: message, response } = await client.messages
.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
})
.withResponse();
console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var response = await client.WithRawResponse.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
var response *http.Response
message, err := client.Messages.New(
context.Background(),
anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
},
option.WithResponseInto(&response),
)
if err != nil {
panic(err)
}
fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id")) // Anthropic request ID
fmt.Println(message.Content)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
HttpResponseFor response = client.messages().withRawResponse().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(response.headers().values("x-amzn-requestid").get(0)); // AWS request ID
IO.println(response.requestId().orElse(null)); // Anthropic request ID
IO.println(response.parse().content());
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$response = $client->messages->raw->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse()->content;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
# Leia os cabeçalhos de resposta no middleware por requisição, que recebe a
# resposta HTTP bruta antes de o SDK analisá-la
aws_request_id = nil
anthropic_request_id = nil
read_request_ids = lambda do |request, call_next|
response = call_next.call(request)
# As chaves em response.headers estão em minúsculas
aws_request_id = response.headers["x-amzn-requestid"]
anthropic_request_id = response.headers["request-id"]
response
end
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }],
request_options: { middleware: [read_request_ids] }
)
puts aws_request_id # AWS request ID
puts anthropic_request_id # Anthropic request ID
puts message.content
```
A Anthropic recomenda registrar sua atividade em uma janela contínua de pelo menos 30 dias para entender padrões de uso e investigar problemas.
O AWS CloudTrail é configurado dentro da sua conta da AWS. Habilitar o registro em log não concede à AWS ou à Anthropic acesso ao seu conteúdo além do necessário para o faturamento e a operação do serviço.
## Migrando do Amazon Bedrock
Se você usa atualmente o Claude no Bedrock, migrar para o Claude Platform on AWS exige alterações em toda a sua integração. A assinatura SigV4 continua suportada, mas o contexto de assinatura, a URL base, o formato da API, os IDs de modelo, o cliente e o pacote do SDK, o formato de streaming, os cabeçalhos de requisição e a disponibilidade de regiões mudam. O Claude Platform on AWS também provisiona uma nova organização da Anthropic. A tabela a seguir resume as diferenças.
### O que muda
O delta da migração depende de qual integração do Bedrock você está usando. A tabela a seguir mostra tanto a [integração atual do Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock) (Messages API em `bedrock-mantle.{region}.api.aws`) quanto a [integração legada InvokeModel](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy).
| Aspecto | De [Claude in Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock) | De [Amazon Bedrock (Opus 4.6 e anteriores)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy) | Para Claude Platform on AWS |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **URL base** | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` | `aws-external-anthropic.{region}.api.aws` |
| **Formato da API** | Messages API em `/anthropic/v1/messages` | Bedrock Converse / InvokeModel | Claude API (`/v1/{endpoint}`) |
| **IDs de modelo** | anthropic.claude-haiku-4-5 | anthropic.claude-haiku-4-5-20251001-v1:0 (com um prefixo de perfil de inferência `us.` ou `global.`) | claude-haiku-4-5 |
| **Cliente do SDK** | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK | Cliente específico da plataforma (consulte [Instale um SDK](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#install-an-sdk)), em beta |
| **Pacote do SDK** | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`), ou o AWS SDK | `anthropic[aws]` (typescript: `@anthropic-ai/aws-sdk`; csharp: `Anthropic.Aws`; go: `github.com/anthropics/anthropic-sdk-go/aws`; java: `com.anthropic:anthropic-java-aws`; php: `anthropic-ai/sdk`; ruby: `anthropic`) (consulte [Instale um SDK](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#install-an-sdk)) |
| **Nome do serviço SigV4** | `bedrock-mantle` | `bedrock` | `aws-external-anthropic` |
| **Formato de streaming** | SSE | AWS EventStream | SSE (igual à Claude API) |
| **Cabeçalho de workspace** | Não aplicável | Não aplicável | `anthropic-workspace-id`, obrigatório em requisições de inferência e de recursos |
| **Disponibilidade de regiões** | Consulte [regiões do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Consulte [regiões do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Todas as regiões comerciais da AWS |
| **Organização da Anthropic** | Nenhuma necessária | Nenhuma necessária | Nova organização criada no cadastro. Organizações existentes não podem ser convertidas (consulte [Migrando de uma organização existente da Anthropic](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#moving-from-an-existing-anthropic-organization)) |
Se você está na integração atual do Bedrock, o formato do corpo da requisição já é o da Messages API. As mudanças são a URL base, o nome do serviço SigV4, os IDs de modelo e a adição do cabeçalho `anthropic-workspace-id`. Se você está na API legada InvokeModel ou Converse, também precisará reescrever os formatos de requisição e resposta para o formato da Messages API. Consulte [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 o mapeamento do formato de requisição.
### O que você ganha
* Acesso normalmente no mesmo dia a novos modelos e recursos (consulte [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported))
* Agent Skills para geração de documentos (PowerPoint, Excel, Word, PDF)
* Execução de código no sandbox gerenciado da Anthropic
* Recursos beta da Claude API que o Amazon Bedrock não oferece, por meio do cabeçalho `anthropic-beta` (consulte [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported))
* Claude Console para visibilidade de cotas e análises de uso
* Suporte direto da Anthropic
* Autenticação por chave de API como alternativa ao SigV4 (consulte [Autenticação por chave de API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#api-key-authentication))
### O que permanece igual
* Autenticação do AWS IAM (SigV4)
* A AWS como parte faturadora. O canal de faturamento muda de serviço nativo da AWS para AWS Marketplace (consulte [Considerações comerciais](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#commercial-considerations)).
* Abatimento de compromissos com a AWS
### Armadilhas da migração
**Habilite primeiro a federação de identidade web de saída.** Se sua conta da AWS ainda não usou o Claude Platform on AWS, você deve [habilitar a federação de identidade web de saída](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) uma vez por conta antes de fazer requisições. Sem essa etapa, todas as requisições falham com um erro de federação (consulte [Habilite a federação de identidade web de saída](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) para o erro exato e a correção). Essa etapa não é necessária para o Bedrock.
**A Zero Data Retention (ZDR) é opcional (opt-in) no Claude Platform on AWS.** No Bedrock, a AWS é a processadora de dados e a Anthropic não retém entradas ou saídas de inferência. O programa de ZDR da Anthropic não se aplica lá. No Claude Platform on AWS, a Anthropic processa os dados de inferência como processadora de dados independente, e a ZDR segue o modelo da Claude API primária: ela está disponível mediante solicitação por meio do seu representante de conta da Anthropic. Confirme a inscrição na ZDR antes de migrar cargas de trabalho de produção que dependam de garantias de retenção de dados.
### Considerações comerciais
* **Termos de serviço da Anthropic:** Usar o Claude Platform on AWS exige aceitar os Termos de Serviço Comerciais e a Política de Uso da Anthropic. Se sua organização ainda não os aceitou (por exemplo, se você só usou o Claude pelo Bedrock), isso será solicitado durante a configuração da conta. Consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#set-up-your-account).
* **Descontos e ofertas privadas:** Descontos negociados e ofertas privadas do AWS Marketplace não são transferidos automaticamente entre o Bedrock e o Claude Platform on AWS. Trabalhe com seu representante de conta da Anthropic para configurar os termos comerciais do Claude Platform on AWS.
## Políticas de IAM
O Claude Platform on AWS se integra ao AWS IAM para controle de acesso. Você concede ou nega acesso a ações específicas da API em workspaces específicos usando a sintaxe padrão de políticas de IAM.
O nome do serviço SigV4 e o namespace de ações de IAM é `aws-external-anthropic`. As ações seguem o padrão `aws-external-anthropic:` (por exemplo, `aws-external-anthropic:CreateInference`).
### Exemplo: negar inferência em lote
A política a seguir permite inferência em tempo real enquanto bloqueia o processamento em lote:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aws-external-anthropic:CreateInference",
"aws-external-anthropic:CountTokens",
"aws-external-anthropic:GetModel",
"aws-external-anthropic:ListModels",
"aws-external-anthropic:GetWorkspace"
],
"Resource": "arn:aws:aws-external-anthropic:*:*:workspace/*"
},
{
"Effect": "Allow",
"Action": "aws-external-anthropic:ListWorkspaces",
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"aws-external-anthropic:CreateBatchInference",
"aws-external-anthropic:GetBatchInference",
"aws-external-anthropic:ListBatchInferences"
],
"Resource": "*"
}
]
}
```
A ação `GetBatchInference` autoriza tanto a rota de metadados do lote quanto a rota de resultados do lote. Negá-la bloqueia ambas as leituras. Para uma política somente de Deny adequada a cargas de trabalho sensíveis à ZDR, consulte [Bloqueio de recursos para um workspace sensível à ZDR](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#feature-lockdown-for-a-zdr-sensitive-workspace).
`ListWorkspaces` tem escopo de conta, por isso aparece em uma instrução Allow separada com `"Resource": "*"`. Especificar um ARN de workspace em uma ação com escopo de conta não tem efeito (consulte [Automação de provisionamento](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#provisioning-automation)).
Esta política pressupõe autenticação AWS SigV4. Se o principal se autentica com uma chave de API, adicione também `aws-external-anthropic:CallWithBearerToken` à instrução Allow com `"Resource": "*"`. `CallWithBearerToken` é uma ação da camada de autenticação sem rota que não se vincula a um ARN de workspace. Consulte [Isolamento de workspace por cliente](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#per-customer-workspace-isolation) para o padrão de duas instruções.
### Políticas gerenciadas
A AWS fornece cinco políticas gerenciadas (`AnthropicFullAccess`, `AnthropicReadOnlyAccess`, `AnthropicInferenceAccess`, `AnthropicLimitedAccess` e `AnthropicSelfHostedEnvironmentAccess`) para padrões de acesso comuns. Para as ações que cada política concede, a lista completa de ações de IAM, o mapeamento de rota para ação e exemplos adicionais de políticas, consulte [Ações de IAM para o Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#managed-policies).
## Próximos passos
Explore os recursos e capacidades avançados do Claude.
Saiba mais sobre os preços do Claude Platform on AWS e as tarifas da Claude Consumption Unit.
À medida que modelos mais seguros e capazes são lançados, a Anthropic desativa regularmente os mais antigos. Veja todas as descontinuações da API, junto com as substituições recomendadas.
## Recursos adicionais
Visualize uso, custo e workspaces no Claude Console. Faça login pelo AWS Console.
Use o Claude operado pela AWS se você precisar da AWS como única processadora de dados.
Gerencie sua assinatura e seu faturamento do AWS Marketplace.