---
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 através da AWS com infraestrutura gerenciada pela Anthropic.
---
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íveis através da sua conta AWS. Diferente do [Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock), onde 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), controle de acesso baseado em IAM e integração de faturamento através do AWS Marketplace.
Os SDKs da Anthropic suportam o 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 para as 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" (espaço de trabalho), 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 "first-party" (de primeira parte). "Zero Data Retention" (retenção zero de dados), ou ZDR, está disponível mediante solicitação. Entre em contato com seu representante de conta da 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 no 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 da API** | Claude API (`/v1/{endpoint}`) | Messages API em `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Disponibilidade de recursos** | Normalmente no mesmo dia que na 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 [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported)) | Os recursos beta que o Amazon Bedrock suporta, por meio do cabeçalho `anthropic-beta` | Os recursos beta que o Amazon Bedrock suporta, por meio do campo `anthropic_beta` do corpo da requisiçã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` / SDK do Bedrock |
| **Console** | Claude Console (`platform.claude.com`, acesso por meio do AWS Console) | Console do Bedrock | Console do Bedrock |
| **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 de primeira parte 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 pronta para 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 do Claude), não uma plataforma de API. Gerenciado no 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 de primeira parte e os planos do claude.ai faturados pela Anthropic. Gerenciados no Claude Console e no 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 de primeira parte não são transferidos.
Se você tem uma oferta privada existente do Amazon Bedrock, entre em contato com seu representante de conta da Anthropic ou da AWS antes de se inscrever, para que seu desconto seja aplicado desde a sua primeira requisição. Descontos não podem ser aplicados retroativamente ao uso incorrido antes de sua oferta privada ser aceita. 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 mostra 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 tem 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 mostrar 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**.
Concluir a 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 mostra 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" (no momento do primeiro acesso).
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 de primeira parte, não pode se tornar uma organização do Claude Platform on AWS.
Planeje a migração de uma organização existente como um "cutover" (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 requisição e resposta não mudam em relação à Claude API de primeira parte. O que muda é a URL base, o método de autenticação e o cabeçalho `anthropic-workspace-id` em requisições de inferência e de recursos; consulte [Fazendo requisiçõ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 em faturamento e 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 requisiçõ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 de primeira parte, 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 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)).
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 mostra um banner estático **Sign-up in progress** sem uma 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 reautentica você 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 descartá-la.
* **A página de uso 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. Veja [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 (veja [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 (veja [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. Seu ID de workspace (veja [Obtenha seu ID de workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id))
5. Permissão IAM para chamar a API: a ação `aws-external-anthropic:CreateInference` no seu workspace, mais `aws-external-anthropic:CallWithBearerToken` se você autenticar com uma chave de API (veja [Políticas 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 criar um JWT que ele encaminha para a Anthropic. Esta capacidade STS está **desabilitada por padrão** em todas as contas AWS. Habilite-a 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, cada requisição retorna `"Outbound web identity federation is disabled for your account"`. Este é o erro de configuração mais comum.
### Obtenha seu ID de 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 suporta dois métodos de autenticação: AWS IAM com assinatura de requisição Signature Version 4 (SigV4) (primário) e autenticação por chave de API. Ambos usam a mesma URL base e formato de requisição.
### Autenticação SigV4
SigV4 é o caminho nativo empresarial e integra-se com suas políticas, funções e auditoria IAM existentes da AWS. Configure as credenciais 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 do 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 de primeira parte) 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 token bearer mas não SigV4), gere uma chave de API de curto prazo a partir das suas credenciais 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 AWS através da cadeia de provedores padrão e retorna um token com tempo limitado que funciona com o cabeçalho `x-api-key`. O tempo de vida do token é de 12 horas por padrão e é limitado ao menor valor entre a duração solicitada, a expiração das suas credenciais AWS e 12 horas. Veja 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 pelo 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ê pode gerar o token localmente, seu processo já tem credenciais SigV4, e a autenticação SigV4 é geralmente a escolha mais simples. Use chaves de curto prazo quando o processo que faz chamadas de API é separado do processo que detém as credenciais AWS.
O SDK não atualiza chaves de curto prazo automaticamente. Quando um token expira, gere um novo e construa um novo cliente. O principal que usa o token ainda precisa da ação 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 `x-api-key`
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 `x-api-key`
5. Cadeia de provedores de credenciais AWS padrão → 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á valor 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:2.73.0")
implementation("com.anthropic:anthropic-java-aws:2.73.0")
```
```xml Maven
com.anthropic
anthropic-java
2.73.0
com.anthropic
anthropic-java-aws
2.73.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 de primeira parte. 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 de primeira parte.
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).
## Fazendo requisições
O Claude Platform on AWS usa os mesmos endpoints de API que a Claude API de primeira parte. 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 requisição se destina. O cabeçalho é obrigatório em requisições de inferência e de recursos, como chamadas para a Messages API, Models API, Files API e endpoints do Claude Managed Agents. Requisiçõ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 e a envia como x-api-key. Gere uma chave no
# Console da AWS (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!"}' \
--transform content
```
```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() { Role = Role.User, 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 longo prazo de usuário do IAM. 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 de janela de contexto no Claude Platform on AWS são idênticos à Claude API de primeira parte. Veja [Janelas de contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows) para 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 completa de recursos com a Claude API de primeira parte (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 ficam disponíveis no Claude Platform on AWS sem uma etapa de integração separada. Veja [limitações de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#features-not-supported) para exceções.
* **Recursos beta:** Passe o cabeçalho `anthropic-beta` padrão para acessar recursos beta, assim como você 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` que a 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:** Todas as [capacidades 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 de esforço](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 requisições em lote para cargas de trabalho de alto throughput.
* **Cache de prompt:** Armazene em cache ferramentas, prompts do sistema e histórico de mensagens para reduzir latência e custo. Todas as capacidades de cache de prompt (TTL de 5 minutos, TTL de 1 hora e cache automático) estão disponíveis.
* **Files API:** Faça upload e referencie arquivos entre requisições.
* **Chaves de criptografia gerenciadas pelo cliente (CMEK):** [CMEK](https://platform.claude.com/docs/pt-BR/manage-claude/cmek) está disponível apenas com chaves [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 e região AWS que o workspace ao qual está anexada, e sua política de chave deve conceder acesso ao principal de serviço `aws-external-anthropic.amazonaws.com`; veja [Configure CMEK no Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#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 chave externa também estão disponíveis, autorizados através de [ações 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 realiza um ciclo de criptografia/descriptografia), então um problema de política de chave aparece no momento da anexação em vez do registro.
* **Compliance API:** A [Compliance API](https://platform.claude.com/docs/pt-BR/manage-claude/compliance-api) está disponível. O acesso é autorizado através da [ação `ListComplianceActivities`](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#compliance) do AWS IAM.
Veja 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 diferenças de disponibilidade de recursos em relação ao Amazon Bedrock.
### Claude Managed Agents
O [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 de primeira parte de três maneiras:
* **Reautenticação de sessão autônoma:** Uma sessão pode ser executada autonomamente, sem quaisquer [eventos 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 de função de usuário para a sessão (veja [Eventos e streaming](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming)). O Claude Managed Agents de primeira parte não tem limite de tempo de execução de sessão autônoma.
* **[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 de primeira parte, sessões tanto em ambientes de nuvem quanto 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
As seguintes capacidades não estão atualmente disponíveis no Claude Platform on AWS:
* **Prontidão para HIPAA:** O programa pronto para HIPAA da Anthropic não está disponível. Veja [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 chave externa (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. As políticas IAM da AWS em 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 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 do 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 dos 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 e a envia como x-api-key. Gere uma chave no
# Console da AWS (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!"}' \
--transform content
```
```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() { Role = Role.User, 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 usará o `default_inference_geo` do workspace, se houver um configurado; caso contrário, `global`.
Os 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
As 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 com tag `wrkspc_` seguido por um identificador alfanumérico (por exemplo, `wrkspc_01AbCdEf23GhIj`). Consulte [Obtenha seu ID de 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 de workspace
Os workspaces estão vinculados a uma única região AWS. Um workspace criado em `us-west-2` só pode ser acessado através do endpoint `us-west-2`. Uso, cotas, custo, arquivos, lotes e Skills são todos agregados por workspace, fornecendo a você detalhamentos por região no Claude Console.
Os workspaces também servem como o recurso IAM primário para o Claude Platform on AWS. Você concede ou nega acesso a workspaces específicos através 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 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`. As operações de criar e listar atuam na organização; as de 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 de workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#workspace-scoping)). Com a função 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 define seu escopo para sua organização do Claude Platform on AWS. Ele fornece 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 através 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 de login pela primeira vez. Em resumo:
1. Assuma uma função IAM com a permissão `aws-external-anthropic:AssumeConsole`. Consulte [Ações IAM para 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 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, você é solicitado a fornecer um endereço de e-mail. Insira seu e-mail de trabalho. A plataforma provisiona seu usuário do Claude Console just-in-time.
Duas funções do Claude Console estão disponíveis: **Admin** e **Developer**. A função Admin concede acesso a todas as páginas e configurações do Claude Console disponíveis para o Claude Platform on AWS. A função Developer concede acesso de leitura a informações de uso, custo, limite de taxa e workspace. Entre em contato com seu representante de conta da Anthropic para atribuir a função 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 através do gateway da AWS (e, portanto, é governada por [ações IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions)). As páginas marcadas com **No** leem metadados em nível de organização diretamente da Anthropic e ignoram as verificações de ação 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 são feitos por meio do 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 os workspaces por região. Com a função Admin, você também pode criar, renomear e arquivar workspaces, além de 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-aws-kms#claude-platform-on-aws) ali (função 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 na 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 dos agentes. |
| **Webhooks** | Sim | Sim | Visualize e gerencie endpoints de webhook. |
| **API keys** | Não | N/A | Gerencie as 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 para a 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 os detalhamentos de custo na página Cost. |
| **Claude Code** | Não | N/A | Visualize o uso do Claude Code na página Usage. |
### Alternando organizações
O Claude Console não suporta a alternância de organizações para o Claude Platform on AWS. Para acessar uma organização diferente, faça logout e reautentique-se através do AWS Console usando a função IAM da conta AWS dessa organização.
## Limites de taxa e cotas
As organizações no Claude Platform on AWS são colocadas no nível Start. A Anthropic gerencia os limites de taxa diretamente, e não por meio dos sistemas de cotas da AWS.
As 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: em vez disso, 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 [limite 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 fatura através do [AWS Marketplace](https://aws.amazon.com/marketplace). O uso é denominado em Claude Consumption Units (CCUs), medido por hora e faturado mensalmente em atraso na sua fatura da AWS. As CCUs não são créditos pré-pagos. Não há saldo ou compromisso de CCU.
Para o preço da CCU, mecânica de conversão, aplicação de desconto e taxas de token 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 tiers de uso Start, Build e Scale cada um carrega um limite de gastos mensal; consulte os [limites de gastos por tier](https://platform.claude.com/docs/pt-BR/api/rate-limits#spend-limits) para os valores atuais. Quando o uso da sua organização para o mês civil atinge o limite do seu tier, as requisições de API falham com o [erro de limite de gastos](https://platform.claude.com/docs/pt-BR/api/rate-limits#reaching-your-spend-cap) até 00:00 UTC no primeiro dia do próximo mês, e tentar novamente mais cedo não terá sucesso. O limite de gastos e os limites de taxa pertencem ao mesmo tier. Para aumentar o limite, ou para restaurar o acesso após atingi-lo, solicite um aumento de tier através 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 limite, após adicionar pelo menos um destinatário em **Email recipients** na página Billing:
* **Limite de gastos da organização:** Vá para [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 no primeiro dia do próximo mês, ou até você aumentar ou remover o limite.
Os gastos são calculados a preços de tabela e podem levar cerca de 2 horas para refletir o uso recente, então o uso pode exceder o limite ou um limite antes que as requisições comecem a falhar. O excesso é faturado. Quando o limite do tier 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 função, como todos os admins, não estão disponíveis no Claude Platform on AWS. O aviso de limite de tier também é enviado ao endereço de e-mail usado no cadastro do AWS Marketplace.
## Monitoramento e registro
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 eventos 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 de resposta:
* **AWS request ID (`x-amzn-requestid`):** O ID primário, indexado no CloudTrail. Use este ao investigar requisições através das ferramentas da AWS ou ao entrar em contato com o suporte da AWS.
* **Anthropic request ID (`request-id`):** O ID secundário. Use este 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 de resposta na saída
# Omita o cabeçalho x-amz-security-token se você usar credenciais de usuário IAM de longo prazo
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 e a envia como x-api-key. Gere uma chave no
# Console da AWS (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() { Role = Role.User, 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 pelo menos uma base contínua de 30 dias para entender padrões de uso e investigar problemas.
O AWS CloudTrail é configurado dentro da sua conta AWS. Habilitar o registro não fornece à AWS ou à Anthropic acesso ao seu conteúdo além do necessário para faturamento e operação do serviço.
## Migrando do Amazon Bedrock
Se você atualmente usa Claude no Bedrock, migrar para o Claude Platform on AWS requer mudanças em toda a sua integração. A assinatura SigV4 permanece suportada, mas o contexto de assinatura, a URL base, o formato da API, os IDs de modelo, o cliente e pacote do SDK, o formato de streaming, os cabeçalhos de requisição e a disponibilidade de região, todos 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
A diferença na 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 o 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 Anthropic existente](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 das requisições.
### O que você ganha
* Acesso tipicamente 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 AWS IAM (SigV4)
* AWS como a 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)).
* Desativação de compromisso da AWS
### Armadilhas de migração
**Habilite a federação de identidade web de saída primeiro.** Se sua conta AWS não usou anteriormente 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 esta 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). Esta etapa não é necessária para o Bedrock.
**Zero Data Retention (ZDR) é opt-in no Claude Platform on AWS.** No Bedrock, a AWS é o processador de dados e a Anthropic não retém entradas ou saídas de inferência. O programa ZDR da Anthropic não se aplica lá. No Claude Platform on AWS, a Anthropic processa dados de inferência como um processador de dados independente, e o ZDR segue o modelo da Claude API de primeira parte: está disponível mediante solicitação através do seu representante de conta da Anthropic. Confirme a inscrição no ZDR antes de migrar cargas de trabalho de produção que dependem de garantias de retenção de dados.
### Considerações comerciais
* **Termos de serviço da Anthropic:** Usar o Claude Platform on AWS requer 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 Claude através do Bedrock), você é 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 para o Claude Platform on AWS.
## Políticas IAM
O Claude Platform on AWS integra-se com o 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ítica IAM.
O nome do serviço SigV4 e o namespace de ação 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 de lote quanto a rota de resultados de lote. Negá-la bloqueia ambas as leituras. Para uma política somente de Deny adequada para cargas de trabalho sensíveis a ZDR, consulte [Bloqueio de recursos para um workspace sensível a 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, então aparece em uma declaraçã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 assume autenticação AWS SigV4. Se o principal autenticar com uma chave de API, adicione também `aws-external-anthropic:CallWithBearerToken` à declaração Allow `"Resource": "*"`. `CallWithBearerToken` é uma ação de 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 declaraçõ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 IAM, o mapeamento de rota para ação e exemplos adicionais de políticas, consulte [Ações IAM para 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 taxas de 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 de API, junto com as substituições recomendadas.
## Recursos adicionais
Visualize uso, custo e workspaces no Claude Console. Faça login através do AWS Console.
Use o Claude operado pela AWS se você precisar da AWS como o único processador de dados.
Gerencie sua assinatura e faturamento do AWS Marketplace.