---
title: Claude Models on Google Cloud (Anthropic managed)
url: https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed
description: Claude Models on Google Cloud (Anthropic managed) é a Claude API, operada pela Anthropic e acessada por meio do seu projeto do Google Cloud.
---
O Google Cloud gerencia o acesso e o faturamento do Claude Models on Google Cloud (Anthropic managed). Para comparar as duas ofertas do Google Cloud, ou para verificar qual delas você usa, consulte [Claude Models on Google Cloud](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/overview).
## Configure sua conta
Para configurar sua conta para o Claude Models on Google Cloud (Anthropic managed), você precisa do seguinte:
* Permissão para fazer compras no Google Cloud Marketplace na sua conta de faturamento
* Permissão para ativar serviços no projeto
* Um [papel do IAM que permita abrir o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), necessário para a etapa 4
Estas etapas criam uma nova organização da Anthropic para o seu projeto do Google Cloud. Ela é separada de qualquer organização da Anthropic que sua empresa já tenha. Isso inclui uma organização do Claude Enterprise. Para migrar de uma organização existente, consulte [Migrando de uma organização existente da Anthropic](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#moving-from-an-existing-anthropic-organization).
Se você tiver um desconto existente, entre em contato com seu representante de conta da Anthropic ou do Google Cloud antes de iniciar estas etapas. Descontos não podem ser aplicados a uso passado.
1. Abra o [Google Cloud Marketplace](https://console.cloud.google.com/marketplace) e encontre a listagem **Claude Models on Google Cloud (Anthropic managed)**.
2. Escolha **Subscribe** e conclua o fluxo de compra.
3. Volte à listagem e escolha **Manage on Console**. Isso abre a página do Claude no console do Google Cloud.
Para voltar à página do Claude mais tarde, selecione seu projeto no console do Google Cloud. Em seguida, vá para **Agent Platform > Models > Claude Platform** e escolha **Anthropic managed**.
Ative dois serviços em cada projeto que chama o Claude Models on Google Cloud (Anthropic managed):
* `claude.googleapis.com` fornece a API do Claude Models on Google Cloud (Anthropic managed). Esse serviço também define as permissões do IAM. As chamadas falham sem ele.
* `anthropic-managed-claude.cloudpartnerservices.goog` é o serviço do Marketplace que atribui o uso do projeto à sua assinatura.
```bash CLI
gcloud services enable claude.googleapis.com \
anthropic-managed-claude.cloudpartnerservices.goog \
--project=my-project-id
```
Substitua `my-project-id` pelo ID do seu projeto.
Você também pode ativar ambos na página do Claude ou em **APIs & Services**. A ativação é uma etapa única para cada projeto. Para verificar se ambos os serviços estão ativados, execute `gcloud services list --enabled --project=my-project-id` e procure os dois nomes.
1. Na página do Claude, escolha **Activate**.
2. No fluxo de configuração da Anthropic, insira um endereço de e-mail de contato.
3. Abra o link de configuração enviado para esse endereço.
4. Preencha o nome da organização, o tipo de entidade, o país e o uso pretendido.
5. Aceite os Termos de Serviço Comerciais e a Política de Uso da Anthropic.
O endereço de contato é usado apenas para a configuração e para avisos do serviço. Para saber como as pessoas abrem o Claude Console após a configuração, consulte [Usando o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Quando sua organização da Anthropic estiver ativa, o botão na página do Claude muda para **Open Claude Console**. Escolha-o. O Google Cloud verifica seu acesso no IAM. Em seguida, ele redireciona seu navegador para `platform.claude.com`. Você estará conectado à nova organização.
Enquanto estiver no Claude Console, [encontre o ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) e copie-o. Todos que chamam o Claude Models on Google Cloud (Anthropic managed) precisam dele. Repasse-o aos seus desenvolvedores.
Para adicionar outro projeto, repita estas etapas nesse projeto, a partir da etapa 2.
### Solução de problemas na configuração da conta
Se você encontrar um dos problemas a seguir ao configurar o Claude Models on Google Cloud (Anthropic managed), aplique a correção correspondente:
* **`gcloud services enable` não encontra `anthropic-managed-claude.cloudpartnerservices.goog`:** Execute o comando com a conta que concluiu a compra no Marketplace ou entre em contato com seu representante de conta da Anthropic.
* **Um erro de permissão na sua primeira chamada de API:** Verifique se `claude.googleapis.com` está ativado no projeto que você está chamando. Verifique se quem faz a chamada tem `roles/claude.user` ou `roles/claude.admin` nesse projeto. Para saber o que cada papel permite, consulte [Papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles). Uma nova concessão ou um serviço recém-ativado pode levar um momento para entrar em vigor.
* **"Signed in as a different account" após seguir o link de configuração:** Escolha **Log out and continue**. Em seguida, use o endereço de e-mail que você inseriu na etapa 3.
* **O botão diz "Finish Setup" em vez de "Open Claude Console":** Sua organização da Anthropic existe, mas a configuração dela não está concluída. Um administrador precisa terminar o formulário de detalhes da organização.
* **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.
## Gerencie o acesso
### Papéis do IAM
O Claude Models on Google Cloud (Anthropic managed) tem três papéis predefinidos do IAM. Conceda os papéis no projeto.
| Papel | Nome de exibição | O que permite |
| --------------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `roles/claude.viewer` | Claude Viewer | Todas as permissões `get` e `list` em recursos do workspace
Este papel é somente leitura. |
| `roles/claude.user` | Claude User | Tudo o que `roles/claude.viewer` permite, além de criar e alterar recursos do workspace
Isso inclui enviar mensagens e contar tokens. Também inclui gerenciar batches, arquivos, skills e recursos do Claude Managed Agents. |
| `roles/claude.admin` | Claude Admin | Tudo o que `roles/claude.user` permite, além das permissões verificadas na sua organização da Anthropic
Rotas no nível da organização atuam sobre sua organização da Anthropic como um todo, não sobre um único workspace. |
Por exemplo, o comando a seguir permite que uma conta de serviço chame o Claude Models on Google Cloud (Anthropic managed):
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="serviceAccount:my-app@my-project-id.iam.gserviceaccount.com" \
--role="roles/claude.user"
```
Para permissões, papéis predefinidos e tipos de log de auditoria, consulte [Permissões do IAM para o Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/pt-BR/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
Ativar `claude.googleapis.com` cria um agente de serviço para o projeto. Não remova as concessões de papel dele. Removê-las faz com que o Claude Models on Google Cloud (Anthropic managed) pare de funcionar no projeto.
### Usando o Claude Console
Com o Claude Models on Google Cloud (Anthropic managed), você não pode usar um endereço de e-mail para entrar na sua organização da Anthropic. Em vez disso, escolha **Open Claude Console** na [página do Claude](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) no console do Google Cloud. O IAM do Google Cloud controla quem pode abrir o Claude Console. Dos três [papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) predefinidos, apenas `roles/claude.admin` no projeto permite abrir o Claude Console.
### Workspaces
No Claude Models on Google Cloud (Anthropic managed), a configuração cria sua organização da Anthropic com um workspace, o Default Workspace. Para criar mais workspaces, [abra o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) e vá para **Settings > Workspaces**. Na mesma página, você pode renomear ou arquivar qualquer workspace, exceto o Default Workspace. Cada workspace tem seu próprio [ID de workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Arquivos, skills, batches, sessões do Claude Managed Agents e outros recursos do workspace pertencem ao workspace cujo ID você [define para a solicitação](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Você concede [papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) no projeto, portanto um papel se aplica a todos os workspaces desse projeto. Quando as equipes precisarem de acesso separado, dê a cada equipe seu próprio projeto do Google Cloud. Cada projeto tem sua própria organização da Anthropic, então repita as [etapas de configuração](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) em cada projeto, a partir da etapa 2.
## Antes de fazer chamadas de API
Para chamar o Claude Models on Google Cloud (Anthropic managed), você precisa do seguinte:
1. Um projeto do Google Cloud com uma assinatura ativa e uma organização da Anthropic cuja configuração esteja concluída. Consulte [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
2. A [gcloud CLI](https://cloud.google.com/sdk/docs/install) instalada, para desenvolvimento local.
3. O papel `roles/claude.user`, concedido no projeto à identidade que faz as chamadas.
4. Application Default Credentials para essa identidade. Consulte [Autenticação](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#authentication).
5. O ID do seu projeto e o [ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id).
Para conceder o papel à sua própria conta para desenvolvimento local, execute o comando a seguir. Você precisa de permissão para alterar a política do IAM do projeto.
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="user:you@example.com" \
--role="roles/claude.user"
```
Substitua `my-project-id` pelo ID do seu projeto. Substitua `you@example.com` pelo endereço de e-mail da sua conta do Google. Para ver o projeto que o gcloud está usando, execute `gcloud config get-value project`. Para contas de serviço e os outros papéis, consulte [Papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
### Encontre o ID do seu workspace
Para encontrar o ID do seu workspace para o Claude Models on Google Cloud (Anthropic managed), [abra o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) e vá para **Settings > Workspaces**. O ID começa com `wrkspc_`. Se você não conseguir abrir o Claude Console, peça a alguém que consiga abri-lo para enviar o ID a você.
Defina o projeto e o workspace como variáveis de ambiente para que os clientes do SDK e a [CLI `ant`](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/cli/quickstart) os utilizem:
```bash CLI
export ANTHROPIC_GOOGLE_CLOUD_PROJECT="my-project-id"
export ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID="wrkspc_01AbCdEf23GhIj"
```
### Instale um SDK
O [cliente do SDK](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) para o Claude Models on Google Cloud (Anthropic managed) é `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). O cliente resolve suas credenciais do Google. Ele também monta a URL base a partir do seu projeto, localização e ID do workspace.
Os clientes do SDK para o Claude Models on Google Cloud (Anthropic managed) estão em beta.
Instale o pacote que fornece o cliente:
```bash
pip install -U "anthropic[google_cloud]"
```
```bash
npm install @anthropic-ai/google-cloud-sdk
```
```bash
dotnet add package Anthropic.GoogleCloud
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.1.0")
implementation("com.anthropic:anthropic-java-google-cloud:3.1.0")
```
```xml Maven
com.anthropic
anthropic-java
3.1.0
com.anthropic
anthropic-java-google-cloud
3.1.0
```
```bash
composer require anthropic-ai/sdk google/auth
```
```bash
gem install anthropic googleauth
```
Para usar a CLI `ant` em vez disso, [instale-a ou atualize-a](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/cli/quickstart#installation) para a versão mais recente. Uma versão sem suporte ao Claude Models on Google Cloud (Anthropic managed) ignora as variáveis `ANTHROPIC_GOOGLE_CLOUD_*`. Ela então faz uma das seguintes coisas:
* Envia a solicitação para a Claude API com qualquer outra credencial que você tenha configurado
* Falha com um erro de autenticação
## Fazendo solicitações
O Claude Models on Google Cloud (Anthropic managed) fornece os endpoints da Claude API sob uma URL base que nomeia seu projeto, uma localização e seu workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/workspaces/{workspace}/invoke
```
As [rotas no nível da organização](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles), cujos caminhos começam com `/v1/organizations/`, usam uma URL base sem o workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/claudeOrganization/invoke
```
Se você não [definir a URL base](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution), os clientes do SDK escolhem entre essas duas para cada solicitação.
Acrescente o caminho da Claude API à URL base. Por exemplo, a [Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create) fica em `.../invoke/v1/messages`. Três coisas diferem de uma solicitação à Claude API:
* **URL base:** As URLs com escopo de projeto mostradas anteriormente, no lugar de `https://api.anthropic.com`.
* **Autenticação:** Um cabeçalho `Authorization: Bearer` com um token de acesso do Google. Não envie um cabeçalho `x-api-key`.
* **Workspace:** O ID do workspace faz parte da URL. Não envie um cabeçalho `anthropic-workspace-id`.
Todo o resto é igual ao da Claude API, incluindo o seguinte:
* Os cabeçalhos `anthropic-version` e `anthropic-beta`
* O corpo da solicitação
* Streaming
* A resposta
Os exemplos de código em outras partes desta documentação criam o cliente da Claude API e leem uma chave de API. Para executar um deles com o Claude Models on Google Cloud (Anthropic managed), substitua a importação e o construtor do cliente pelos dos exemplos a seguir. Para um exemplo em cURL, aplique as três diferenças listadas anteriormente.
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-models-on-google-cloud/anthropic-managed#before-making-api-calls).
```bash cURL
curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello, Claude"}
]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}'
```
```python Python
from anthropic import AnthropicGoogleCloud
client = AnthropicGoogleCloud()
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(message)
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
const message = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
console.log(message);
```
```csharp C#
using Anthropic.GoogleCloud;
using Anthropic.Models.Messages;
var client = new AnthropicGoogleCloudClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello, Claude" }]
};
var message = await client.Messages.Create(parameters);
Console.WriteLine(message);
```
```go Go
import (
"context"
"fmt"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/googlecloud"
)
func main() {
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
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(GoogleCloudBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
use Anthropic\Messages\Model;
$client = new Client();
$message = $client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
puts message
```
O exemplo em cURL pede ao gcloud um token de Application Default Credentials. Os tokens de acesso têm vida curta. Gere um para cada sessão em vez de armazená-lo.
### IDs de modelo da API
O Claude Models on Google Cloud (Anthropic managed) usa os mesmos IDs de modelo da Claude API, por exemplo `claude-opus-5-5`. Para os modelos e seus IDs, consulte [Visão geral dos modelos](https://platform.claude.com/docs/pt-BR/models/overview).
No Claude Models on Google Cloud (Anthropic managed), uma solicitação para um modelo que não está disponível para sua organização da Anthropic retorna um erro. A mensagem de erro diz `Model {model} is not available for this organization's inference configuration.`
## Resolução de projeto, localização e workspace
Os clientes do Claude Models on Google Cloud (Anthropic managed) aceitam as configurações da tabela a seguir. Um valor que você passa ao criar o cliente tem prioridade sobre a variável de ambiente. Para definir o projeto e o ID do workspace explicitamente, passe `project` (go: `Project`; java: `.project()`; csharp: `GoogleCloudClientOptions.Project`; cli: `--google-cloud-project`) e `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `GoogleCloudClientOptions.WorkspaceId`; cli: `--google-cloud-workspace-id`).
| Configuração | Variável de ambiente | Se não definida |
| --------------- | --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ID do projeto | `ANTHROPIC_GOOGLE_CLOUD_PROJECT`, depois `GOOGLE_CLOUD_PROJECT` | O projeto que as Application Default Credentials informam, quando o tipo de credencial inclui um |
| ID do workspace | `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` | O cliente gera um erro, a menos que você defina a URL base. [Rotas no nível da organização](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) não precisam de um ID de workspace. |
| Localização | `ANTHROPIC_GOOGLE_CLOUD_LOCATION` | `global` |
| URL base | `ANTHROPIC_GOOGLE_CLOUD_BASE_URL` | Derivada do projeto, da localização e do ID do workspace |
Mantenha a localização como `global`. A localização é independente de onde a inferência é executada; portanto, para inferência somente nos EUA, defina `inference_geo: "us"` em cada solicitação, conforme descrito em [Residência de dados](https://platform.claude.com/docs/pt-BR/manage-claude/data-residency#inference-geo).
A CLI `ant` aceita as mesmas configurações como flags:
* **ID do projeto:** `--google-cloud-project`
* **ID do workspace:** `--google-cloud-workspace-id`
* **Localização:** `--google-cloud-location`
* **URL base:** `--google-cloud-base-url`
A CLI usa o Claude Models on Google Cloud (Anthropic managed) quando o projeto, o ID do workspace ou a localização está definido. Definir `GOOGLE_CLOUD_PROJECT`, a URL base ou ambos não é suficiente.
## Autenticação
Cada solicitação ao Claude Models on Google Cloud (Anthropic managed) carrega um token de acesso OAuth 2.0 do Google em um cabeçalho `Authorization: Bearer`. O token tem o escopo `https://www.googleapis.com/auth/cloud-platform`.
O Google Cloud gerencia o acesso. Seu gateway em `claude.googleapis.com` faz o seguinte para cada solicitação:
1. Verifica suas credenciais do Google Cloud.
2. Verifica se quem faz a chamada tem a permissão do IAM de que a solicitação precisa. Caso não tenha, o Google Cloud retorna um erro HTTP 403.
3. Encaminha a solicitação para a Anthropic. A Anthropic valida a solicitação.
Para conceder permissões, consulte [Papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
Os clientes do SDK obtêm o token das [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials) (ADC). Qualquer fonte de credenciais compatível com ADC funciona:
* **Desenvolvimento local:** Execute `gcloud auth application-default login`.
* **No Google Cloud:** O cliente usa automaticamente a conta de serviço anexada à carga de trabalho, por exemplo no Compute Engine, GKE ou Cloud Run.
* **Um arquivo de chave de conta de serviço:** Defina `GOOGLE_APPLICATION_CREDENTIALS` com o caminho dele.
* **Workload Identity Federation e representação de conta de serviço:** Configure-os como faria para qualquer API do Google Cloud.
Verifique se as ADC estão funcionando:
```bash CLI
gcloud auth application-default print-access-token
```
O Claude Models on Google Cloud (Anthropic managed) não usa chaves de API. No Claude Console, você não pode criar chaves de API para a organização da Anthropic que a configuração cria. Os clientes do SDK para o Claude Models on Google Cloud (Anthropic managed) ignoram estas variáveis de ambiente:
* `ANTHROPIC_API_KEY`
* `ANTHROPIC_AUTH_TOKEN`
* `ANTHROPIC_BASE_URL`
### Precedência de credenciais
O cliente do SDK para o Claude Models on Google Cloud (Anthropic managed) procura credenciais na ordem a seguir. O cliente usa a primeira que encontrar:
1. Um provedor de token que você passa como `token_provider` (typescript: `bearerTokenProvider`; csharp: `GoogleCloudClientOptions.TokenProvider`; go: `TokenSource`; java: `.bearerTokenSupplier()`; php: `tokenProvider`) ao criar o cliente. É uma função ou fonte de token que retorna um token de acesso. O cliente solicita um token a ele em cada solicitação. Armazenar em cache e renovar o token fica a seu cargo.
2. Um objeto de credenciais do Google que você passa como `credentials` (typescript: `googleAuth`; csharp: `GoogleCloudClientOptions.GoogleCredential`; java: `.googleCredentials()`; php: `googleCredentials`; ruby: `google_credentials`) ao criar o cliente. O SDK de Go não tem essa opção.
3. Application Default Credentials.
Go e Java diferem dos outros SDKs:
* **Go:** Para a opção 1, o cliente aceita um `oauth2.TokenSource`. Ele armazena o token em cache até que o token expire.
* **Java:** Use `GoogleCloudBackend.fromEnv()` para ler as Application Default Credentials e as variáveis de ambiente em [Resolução de projeto, localização e workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
O cliente não tem uma variável de ambiente própria para a credencial. Use a `GOOGLE_APPLICATION_CREDENTIALS` das ADC em vez disso.
Se suas solicitações passam por um proxy que anexa o token para você, defina `skip_auth` (typescript, php: `skipAuth`; go: `SkipAuth`; java: `.skipAuth()`; csharp: `GoogleCloudClientOptions.SkipAuth`). O cliente então não envia nenhum cabeçalho `Authorization`. Você não pode combinar essa configuração com as opções de credencial anteriores.
Quando a CLI `ant` usa o Claude Models on Google Cloud (Anthropic managed), ela sempre obtém o token das Application Default Credentials. Ela não aceita provedor de token, objeto de credenciais nem configuração de skip-auth.
Antes de usar `ant` com o Claude Models on Google Cloud (Anthropic managed), certifique-se de que nenhum destes esteja definido:
* Uma chave de API
* Um token de autenticação
* `--profile` ou `ANTHROPIC_PROFILE`, se nomear um [perfil de configuração](https://platform.claude.com/docs/pt-BR/manage-claude/wif-reference#profile-configuration-file) com o qual a CLI consiga se autenticar
* Qualquer uma das variáveis de federação da Anthropic:
* `ANTHROPIC_FEDERATION_RULE_ID`
* `ANTHROPIC_ORGANIZATION_ID`
* `ANTHROPIC_SERVICE_ACCOUNT_ID`
* `ANTHROPIC_IDENTITY_TOKEN`
* `ANTHROPIC_IDENTITY_TOKEN_FILE`
Se algum estiver definido, a CLI usa essa credencial em vez das configurações do Google Cloud de [Encontre o ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Se apenas algumas das variáveis de federação estiverem definidas, a CLI para com um erro. Quando mais de uma credencial está definida, a CLI exibe uma nota indicando qual delas usa.
Deixe também `ANTHROPIC_WORKSPACE_ID` e a flag `--workspace-id` sem definir. A CLI ainda envia esse valor como um cabeçalho `anthropic-workspace-id`. As solicitações ao Claude Models on Google Cloud (Anthropic managed) não devem carregar esse cabeçalho. Defina o workspace com `--google-cloud-workspace-id` ou `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` em vez disso.
Assim como os clientes do SDK, a CLI não envia solicitações do Claude Models on Google Cloud (Anthropic managed) para `--base-url` ou `ANTHROPIC_BASE_URL`.
## Suporte a recursos
Esta seção lista os recursos que funcionam no Claude Models on Google Cloud (Anthropic managed) e os recursos que não são compatíveis nele. Ela não lista todos os recursos da Claude API e não indica se um recurso não listado funciona.
Os recursos a seguir funcionam no Claude Models on Google Cloud (Anthropic managed) da mesma forma que na Claude API:
* **"Fast mode" (modo rápido):** [Modo rápido](https://platform.claude.com/docs/pt-BR/build-with-claude/fast-mode) para Claude Opus 5.5.
- **Recursos beta:** Se um beta estiver limitado a organizações selecionadas na Claude API, a organização da Anthropic que a configuração cria precisa do mesmo acesso.
- **Ferramentas:** [Uso de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/overview), incluindo:
* Pesquisa na web
* Busca na web (web fetch)
* Execução de código
* A ferramenta de memória
* A ferramenta advisor
* O conector MCP
- **Skills e arquivos:** [Agent Skills](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/overview) e a [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files).
- **Capacidades do modelo:**
* [Cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching)
* [Pensamento estendido](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking)
* [Fallback no lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#server-side-fallback)
* [Streaming](https://platform.claude.com/docs/pt-BR/build-with-claude/streaming)
* [Saídas estruturadas](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs)
* [Contagem de tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/token-counting)
- **Batches e modelos:** A [Message Batches API](https://platform.claude.com/docs/pt-BR/build-with-claude/batch-processing) e a Models API.
Para ativar ou desativar a [Compliance API](https://platform.claude.com/docs/pt-BR/manage-claude/compliance-api) para a organização da Anthropic que a configuração cria, [abra o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), vá para **Settings > Compliance** e use a opção **Compliance API**.
Chaves de criptografia gerenciadas pelo cliente (CMEK) estão disponíveis com chaves do Google Cloud KMS. Para ativar CMEK para a organização da Anthropic que a configuração cria, consulte [Chaves de criptografia gerenciadas pelo cliente](https://platform.claude.com/docs/pt-BR/manage-claude/cmek). Para configurar uma chave, siga [Configurar o Google Cloud KMS para CMEK](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-google-cloud-kms). Em seguida, registre, verifique e anexe a chave no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), conforme descrito na aba **Claude Console** da página de configuração.
### Claude Managed Agents
O [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview) está disponível por meio do Claude Models on Google Cloud (Anthropic managed), incluindo o seguinte:
* [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)
* [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)
* [Implantações agendadas](https://platform.claude.com/docs/pt-BR/managed-agents/scheduled-deployments)
* [Sandboxes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes)
O acesso é verificado quando uma sessão ou uma implantação é criada, não enquanto ela é executada:
* **Sessões em execução continuam em execução.** Se você revogar o acesso ao Google Cloud da identidade que criou uma sessão, a sessão não para. Para interrompê-la, envie a ela um [evento `user.interrupt`](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#integrating-events) isoladamente. Depois que a sessão estiver `idle`, você pode arquivá-la ou excluí-la.
* **Implantações agendadas continuam em execução.** Uma implantação não verifica novamente o acesso de quem a criou a cada execução agendada. Para interrompê-la, pause-a, atualize-a ou arquive-a.
Ao remover um usuário ou rotacionar uma conta de serviço, revise as sessões e implantações que essa identidade criou.
### Recursos não compatíveis
Os itens a seguir não são compatíveis com o Claude Models on Google Cloud (Anthropic managed):
* **Chaves de API:** A autenticação é feita apenas por meio de credenciais do Google Cloud.
* **Túneis MCP:** Os [túneis MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/overview) não estão disponíveis no Claude Models on Google Cloud (Anthropic managed).
* **[Memory stores em ambientes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-memory):** Memory stores não são compatíveis com sessões em ambientes auto-hospedados.
* **Workers pré-construídos de sandbox auto-hospedado:** Os [workers auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-workers) na CLI `ant` e nos SDKs de Python, TypeScript e Go não são compatíveis com o Claude Models on Google Cloud (Anthropic managed). Em vez disso, implemente seu próprio worker que chame diretamente os [endpoints Work de Environments](https://platform.claude.com/docs/pt-BR/api/beta/environments/work). Para os papéis e permissões de que seu worker precisa, consulte [Permissões de IAM para ambientes](https://platform.claude.com/docs/pt-BR/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions#environments).
### Janela de contexto
Os tamanhos da "context window" (janela de contexto) no Claude Models on Google Cloud (Anthropic managed) são os mesmos da Claude API. Para o limite de cada modelo, consulte [Janelas de contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows).
## Faturamento, limites de taxa e registro em log
### Limites de taxa
A Anthropic gerencia os "rate limits" (limites de taxa) do Claude Models on Google Cloud (Anthropic managed). Para solicitar limites mais altos, entre em contato com seu representante de conta da Anthropic ou [fale com vendas](https://claude.com/contact-sales). Para saber como os limites de taxa são medidos e informados, consulte [Limites de taxa](https://platform.claude.com/docs/pt-BR/api/rate-limits).
### Faturamento
O Claude Models on Google Cloud (Anthropic managed) é faturado por meio do Google Cloud Marketplace. A Anthropic mede seu uso. Ela informa o uso ao Google Cloud em Claude Consumption Units. As cobranças aparecem na sua fatura do Google Cloud. A Anthropic não envia uma fatura separada.
Veja os dados de uso e custo nas páginas **Usage** e **Cost** no [Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Se você tiver um compromisso de gastos com o Google Cloud, o uso conta para ele da mesma forma que outras compras no Marketplace.
### Retenção de dados
A Anthropic é a processadora de dados do Claude Models on Google Cloud (Anthropic managed). Alguns serviços de suporte, como os sistemas de confiança e segurança da Anthropic, processam dados fora do Google Cloud.
O Claude Models on Google Cloud (Anthropic managed) segue a mesma política de retenção de dados da Claude API. Consulte [API e retenção de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention). A Zero Data Retention (ZDR) está disponível mediante solicitação. Entre em contato com seu representante de conta da Anthropic.
Um acordo de ZDR em outra organização da Anthropic não se estende à sua organização do Claude Models on Google Cloud (Anthropic managed).
### Monitoramento e registro em log
O [Cloud Audit Logs](https://cloud.google.com/logging/docs/audit) registra a atividade da API do Claude Models on Google Cloud (Anthropic managed) no seu projeto. As entradas aparecem sob o serviço `claude.googleapis.com`. Cada rota da API pertence a um de dois tipos de log:
* **Logs de Data Access:** Abrangem a maioria das rotas, incluindo mensagens, batches, arquivos, skills, modelos e a maioria dos recursos do Claude Managed Agents. Ficam desativados por padrão.
* **Logs de Admin Activity:** Abrangem as demais rotas, incluindo as rotas de chaves de criptografia e a maioria das rotas de cofres de credenciais. A exceção é a rota de `vaults.verify`, que é Data Access. Os logs de Admin Activity estão sempre ativados.
Para manter um registro das solicitações, ative os logs de Data Access para `claude.googleapis.com` nas configurações de log de auditoria do seu projeto.
Para os tipos de log de auditoria por rota, consulte [Permissões do IAM para o Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/pt-BR/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
#### IDs de solicitação
As respostas bem-sucedidas do Claude Models on Google Cloud (Anthropic managed) carregam o cabeçalho [`request-id`](https://platform.claude.com/docs/pt-BR/api/errors#request-id).
## Migrando de uma organização existente da Anthropic
Você não pode converter uma organização existente da Anthropic em uma organização do Claude Models on Google Cloud (Anthropic managed). Isso inclui uma organização que você usa diretamente com a Claude API.
Planeje a migração como uma transição para uma nova organização:
* **Crie a nova organização primeiro.** Siga [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
* **Recrie o acesso e a configuração.** Chaves de API, workspaces e configurações do Claude Console não são transferidos. Conceda [papéis do IAM](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) no projeto em vez de criar chaves de API. Para recriar seus workspaces, consulte [Workspaces](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#workspaces). Para acordos de ZDR, consulte [Retenção de dados](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention).
* **Planeje os recursos armazenados.** Arquivos, skills, batches e recursos do Claude Managed Agents permanecem na organização existente.
* **Atualize sua integração.** Para saber o que muda e o que permanece igual, consulte [Fazendo solicitações](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests). Para os recursos não compatíveis, consulte [Recursos não compatíveis](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#features-not-supported).
* **Faça a transição no seu próprio ritmo.** As duas organizações são independentes e podem atender tráfego em paralelo. Você pode migrar as cargas de trabalho gradualmente. A organização existente mantém seu faturamento atual. Antes de transferir o tráfego de produção, verifique os [limites de taxa](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Migrando do Claude Models on Google Cloud (Google managed)
Para migrar para o Claude Models on Google Cloud (Anthropic managed), conclua as etapas a seguir. Antes de migrar cargas de trabalho que dependem de um acordo de ZDR, consulte [Retenção de dados](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention). Para saber o que muda quando você migra, consulte [Como as duas ofertas do Google Cloud diferem](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ).
Conclua todas as etapas em [Configure sua conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
Conceda `roles/claude.user` a cada identidade que chama o Claude Models on Google Cloud (Anthropic managed). Defina seu projeto e o ID do workspace como variáveis de ambiente. Para ambos, consulte [Antes de fazer chamadas de API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
Instale o pacote que fornece o cliente para o Claude Models on Google Cloud (Anthropic managed). Consulte [Instalar um SDK](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#install-an-sdk).
Altere o código que importa e cria seu cliente. Use `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`) no lugar de `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Em uma requisição cURL, altere a URL, os cabeçalhos e o corpo. Seu código atual cria um cliente para o Claude Models on Google Cloud (Google managed). Por exemplo, o código a seguir cria esse cliente com o endpoint global:
```bash cURL
curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{
"anthropic_version": "vertex-2023-10-16",
"messages": [{"role": "user", "content": "Hey Claude!"}],
"max_tokens": 100
}'
```
A CLI `ant` não oferece suporte ao Claude Models on Google Cloud (Google managed).
```python Python
from anthropic import AnthropicVertex
project_id = "MY_PROJECT_ID"
region = "global"
client = AnthropicVertex(project_id=project_id, region=region)
```
```typescript TypeScript
import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
const projectId = "MY_PROJECT_ID";
const region = "global";
const client = new AnthropicVertex({
projectId,
region
});
```
```csharp C#
using Anthropic.Vertex;
var projectId = "MY_PROJECT_ID";
var region = "global";
var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
```
```go Go
import (
"context"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/vertex"
)
// ...
// Usa as credenciais padrão do Google Cloud
client := anthropic.NewClient(
vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
)
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.vertex.backends.VertexBackend;
import com.google.auth.oauth2.GoogleCredentials;
void main() throws Exception {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(
VertexBackend.builder()
.googleCredentials(GoogleCredentials.getApplicationDefault())
.region("global")
.project("MY_PROJECT_ID")
.build()
)
.build();
}
```
```php PHP
use Anthropic\Vertex;
$client = Vertex\Client::fromEnvironment(
region: 'global',
projectId: 'MY_PROJECT_ID',
);
```
```ruby Ruby
require "anthropic"
client = Anthropic::VertexClient.new(
region: "global",
project_id: "MY_PROJECT_ID"
)
```
O código a seguir cria o cliente para o Claude Models on Google Cloud (Anthropic managed):
```bash cURL
curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello, Claude"}
]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}'
```
```python Python
from anthropic import AnthropicGoogleCloud
client = AnthropicGoogleCloud()
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
```
```csharp C#
using Anthropic.GoogleCloud;
var client = new AnthropicGoogleCloudClient();
```
```go Go
import (
"context"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/googlecloud"
)
// ...
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(GoogleCloudBackend.fromEnv())
.build();
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
$client = new Client();
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
```
O novo cliente lê seu projeto e o ID do workspace das variáveis de ambiente que você definiu em [Encontre o ID do seu workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Você não os passa ao criar o cliente. Suas chamadas à Messages API permanecem como estão, exceto pelos IDs de modelo e recursos da próxima etapa.
* **IDs de modelo:** Se você usa um modelo anterior ao Claude 4.6, substitua o `@` antes da data do snapshot em seu ID por um hífen. Por exemplo, `claude-haiku-4-5@20251001` se torna `claude-haiku-4-5-20251001`. Para os modelos e seus IDs, consulte [IDs de modelo da API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#api-model-ids).
* **Recursos:** Verifique o [Suporte a recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#feature-support) para cada recurso que seu código usa.
* **Localização:** Se você usa hoje um endpoint multirregional ou regional, verifique qual localização o Claude Models on Google Cloud (Anthropic managed) usa. Consulte [Resolução de projeto, localização e workspace](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Execute a requisição em [Fazendo requisições](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) para verificar se sua configuração funciona. Em seguida, execute seu próprio código. Se uma chamada falhar com um erro de permissão, consulte [Solução de problemas na configuração da conta](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#troubleshooting-account-setup). Antes de migrar o tráfego de produção, verifique os ["rate limits" (limites de taxa)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Próximos passos
Explore os recursos do Claude.
Consulte permissões, funções e tipos de logs de auditoria.
À medida que modelos mais seguros e mais 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.
Gerencie sua assinatura e faturamento.