---
title: Claude Models on Google Cloud (Google managed)
url: https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed
description: O Google opera o Claude Models on Google Cloud (Google managed) como parte do Google Cloud's Agent Platform. Você pode chamar o Claude com os SDKs de cliente da Anthropic.
---

[Claude Models on Google Cloud](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/overview) compara as duas ofertas do Google Cloud. Também mostra como identificar qual delas você usa.

## Antes de fazer chamadas de API

Para usar o Claude Models on Google Cloud (Google managed), você precisa de:

1. Um projeto do Google Cloud que possa usar o Agent Platform. Para as etapas de configuração, consulte a página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) do Google Cloud.
2. A [gcloud CLI](https://cloud.google.com/sdk/docs/install) instalada, para desenvolvimento local.
3. Para a identidade que faz as chamadas, um papel do IAM que inclua a permissão `aiplatform.endpoints.predict`, como Agent Platform User (`roles/aiplatform.user`). Para detalhes, consulte a página [Agent Platform partner models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/use-partner-models) do Google Cloud.
4. Credenciais do Google Cloud para essa identidade. Para os exemplos de SDK, talvez você precise executar `gcloud auth application-default login` para se autenticar no Google Cloud. Os exemplos de cURL para o Claude Models on Google Cloud (Google managed) obtêm seu token com `gcloud auth print-access-token`. Esse comando usa o login próprio da gcloud CLI, não o Application Default Credentials. Para esses exemplos, execute `gcloud auth login` ou `gcloud init` primeiro.

### Instalar um SDK

Os [SDKs de cliente](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) da Anthropic oferecem suporte ao Claude Models on Google Cloud (Google managed) por meio de `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Instale o pacote que o fornece:

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

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

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

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

  <Tab title="Java">
    <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:3.1.0")
      implementation("com.anthropic:anthropic-java-vertex:3.1.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>3.1.0</version>
      </dependency>
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java-vertex</artifactId>
          <version>3.1.0</version>
      </dependency>
      ```
    </CodeGroup>
  </Tab>

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

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "googleauth"
    ```
  </Tab>
</Tabs>

A CLI `ant` não oferece suporte ao Claude Models on Google Cloud (Google managed).

## Fazendo requisições

As requisições ao Claude Models on Google Cloud (Google managed) vão para uma URL de endpoint do Agent Platform que termina em `:rawPredict`. As requisições de "streaming" (streaming) usam `:streamRawPredict` em vez disso.

Uma requisição é quase idêntica a uma requisição da [Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create). Ela difere de duas maneiras principais:

* **Modelo:** A URL do endpoint nomeia o modelo. Em uma requisição cURL, deixe `model` fora do corpo.
* **Versão:** Em uma requisição cURL, passe `anthropic_version` no corpo, não como cabeçalho. Defina-o como `vertex-2023-10-16` ou como a [versão da API `2026-10-21`](https://platform.claude.com/docs/pt-BR/api/migration-2026-10-21).

Os exemplos a seguir usam o endpoint global. Para os outros tipos de endpoint, consulte [Endpoints globais, multirregionais e regionais](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

<CodeGroup exclude="shell:CLI">
  ```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
    }'
  ```

  <CodeGroupItem language="CLI">
    A CLI `ant` não oferece suporte ao Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "global"

  client = AnthropicVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Claude!",
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "global";

  // Passa pelo fluxo padrão da `google-auth-library`.
  const client = new AnthropicVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Claude!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));
  ```

  ```csharp C#
  using Anthropic.Models.Messages;
  using Anthropic.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "global";

  var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 100,
      Messages = [new UserMessageParam { Content = "Hey 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/vertex"
  )
  // ...
  	// Usa as credenciais padrão do Google Cloud
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 100,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)
  ```

  ```java Java
  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;
  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();

      Message message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Claude!")
                  .build()
          );

      IO.println(message);
  }
  ```

  ```php PHP
  <?php

  use Anthropic\Messages\TextBlock;
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'global',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Claude!']
      ],
      model: 'claude-opus-5-5',
  );

  foreach ($message->content as $block) {
      if ($block instanceof TextBlock) {
          echo $block->text . PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "global",
    project_id: "MY_PROJECT_ID"
  )

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

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

### IDs de modelo da API

| Model                                                                                                    | Agent Platform API model ID  |
| :------------------------------------------------------------------------------------------------------- | :--------------------------- |
| Claude Fable 5.1                                                                                         | `claude-fable-5-1`           |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842))              | `claude-mythos-5-1`          |
| Claude Fable 5                                                                                           | `claude-fable-5`             |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))                | `claude-mythos-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@20251101`   |
| Claude Opus 4.1 ([deprecated](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations))   | `claude-opus-4-1@20250805`   |
| Claude Opus 4 ([deprecated](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations))     | `claude-opus-4@20250514`     |
| 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@20250929` |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations))   | `claude-sonnet-4@20250514`   |
| Claude Haiku 5.5                                                                                         | `claude-haiku-5-5`           |
| Claude Haiku 4.5                                                                                         | `claude-haiku-4-5@20251001`  |
| Claude Haiku 3.5 ([deprecated](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations))  | `claude-3-5-haiku@20241022`  |

O Claude Models on Google Cloud (Google managed) oferece diferentes modelos Claude em diferentes regiões. Para verificar quais modelos uma região oferece, pesquise "Claude" no [Model Garden](https://cloud.google.com/model-garden) ou consulte a página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) do Google Cloud.

O Google define as datas de ciclo de vida dos modelos que o Claude Models on Google Cloud (Google managed) disponibiliza. Essas datas podem diferir do cronograma da Claude API. Para a data atual de "retirement" (desativação) de um modelo, consulte a página [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) do Google Cloud. Para saber o que significam Descontinuado e Desativado, consulte [Descontinuações de modelos](https://platform.claude.com/docs/pt-BR/about-claude/model-deprecations).

<Note>
  O Claude Mythos Preview é uma prévia de pesquisa. O Claude Models on Google Cloud (Google managed) o oferece a clientes convidados. Para mais informações, consulte [Project Glasswing](https://anthropic.com/glasswing).
</Note>

<Tip>
  Atualizando para um modelo Claude mais recente? A [skill Claude API](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) no Claude Code aplica trocas de ID de modelo e alterações de parâmetros incompatíveis em toda a sua base de código:

  Deixe o Claude Code migrar seu código para você

  ```text
  /claude-api migrate este projeto para o modelo Claude Opus mais recente
  ```

  A skill detecta qual plataforma de nuvem seu código tem como alvo e ajusta os formatos de ID de modelo e as alterações de recursos para essa plataforma.
</Tip>

## Endpoints globais, multirregionais e regionais

O Claude Models on Google Cloud (Google managed) oferece três tipos de endpoint. Você escolhe um com o valor de região que passa ao criar o cliente. Em uma requisição cURL, o tipo de endpoint define o host e o segmento `locations` da URL.

| Tipo de endpoint         | Valor de região               | Host                                                                       |
| ------------------------ | ----------------------------- | -------------------------------------------------------------------------- |
| **Global** (recomendado) | `"global"`                    | `aiplatform.googleapis.com`                                                |
| **Multirregional**       | `"us"` ou `"eu"`              | `aiplatform.us.rep.googleapis.com`<br />`aiplatform.eu.rep.googleapis.com` |
| **Regional**             | Uma região, como `"us-east5"` | `{region}-aiplatform.googleapis.com`                                       |

Os tipos de endpoint diferem quanto ao destino das requisições:

* **Global:** As requisições vão para qualquer região com capacidade disponível. Use-o quando quiser disponibilidade máxima e a residência de dados for flexível.
* **Multirregional:** As requisições vão para qualquer região nos Estados Unidos (`"us"`) ou na União Europeia (`"eu"`). Use-o quando precisar de residência de dados dentro de uma área geográfica ampla e de maior disponibilidade do que uma única região.
* **Regional:** As requisições vão apenas para a região que você nomear, como `"us-east5"` ou `"europe-west1"`. Use-o quando precisar de residência de dados em uma única região ou tiver que cumprir exigências rigorosas de conformidade.

Endpoints multirregionais e regionais custam 10% a mais do que endpoints globais. Os três tipos de endpoint aceitam tráfego pay-as-you-go, e o throughput provisionado requer um endpoint regional.

Os endpoints regionais disponibilizam apenas o Claude Sonnet 4.6 e modelos anteriores. Para modelos mais recentes, use um endpoint global ou multirregional.

<Note>
  O acréscimo para endpoints multirregionais e regionais se aplica apenas ao Claude Sonnet 4.5 (descontinuado) e modelos posteriores. Para os modelos que mantêm seus preços anteriores, consulte [Preços de plataformas de nuvem](https://platform.claude.com/docs/pt-BR/about-claude/pricing#cloud-platform-pricing). Para endpoints regionais, o acréscimo reflete os custos de infraestrutura de capacidade regional dedicada.
</Note>

Os exemplos a seguir usam o endpoint multirregional `us`. As linhas destacadas definem a região. Para uma requisição completa no endpoint global, consulte [Fazendo requisições](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai).

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  # O identificador multirregião, "us" ou "eu", aparece no nome do host e no caminho
  curl https://aiplatform.us.rep.googleapis.com/v1/projects/MY_PROJECT_ID/locations/us/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
    }'
  ```

  <CodeGroupItem language="CLI">
    A CLI `ant` não oferece suporte ao Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "us"  # Multi-region identifier: "us" or "eu"

  client = AnthropicVertex(project_id=project_id, region=region)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "us"; // Multi-region identifier: "us" or "eu"

  const client = new AnthropicVertex({
    projectId,
    region
  });
  ```

  ```csharp C#
  using Anthropic.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "us"; // Multi-region identifier: "us" or "eu"

  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"
  )
  // ...
  	// Identificador multirregião: "us" ou "eu"
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us", "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 {
      // Identificador multirregião: "us" ou "eu"
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();
  }
  ```

  ```php PHP
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'us', // Multi-region identifier: "us" or "eu"
      projectId: 'MY_PROJECT_ID',
  );
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "us", # Multi-region identifier: "us" or "eu"
    project_id: "MY_PROJECT_ID"
  )
  ```
</CodeGroup>

## Suporte a recursos

Os recursos compatíveis com o Claude Models on Google Cloud (Google managed) incluem os seguintes:

* [Messages API](https://platform.claude.com/docs/pt-BR/api/messages/create)

* ["Prompt caching" (cache de prompt)](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching)

* [Thinking](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking)

* ["Tool use" (uso de ferramentas)](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/overview), incluindo estas ferramentas:

  * [Ferramenta Bash](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/bash-tool)
  * [Ferramenta de uso de navegador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/browser-use-tool)
  * [Ferramenta de uso de computador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/computer-use-tool)
  * [Ferramenta de memória](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/memory-tool)
  * [Ferramenta de editor de texto](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/text-editor-tool)
  * [Ferramenta de pesquisa na web](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-search-tool)

* [Citações](https://platform.claude.com/docs/pt-BR/build-with-claude/citations)

* [Saídas estruturadas](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs)

A [Visão geral de recursos](https://platform.claude.com/docs/pt-BR/build-with-claude/overview) lista todos os recursos e se o Claude Models on Google Cloud (Google managed) oferece suporte a cada um deles.

### Recursos não suportados

O Claude Models on Google Cloud (Google managed) não oferece suporte ao seguinte:

* **Fontes de entrada:** Fontes de URL para imagens e documentos, e a Files API
* **Ferramentas do lado do servidor:** Execução de código, web fetch e advisor
* **Infraestrutura de agentes:** Agent Skills, conector MCP e chamada programática de ferramentas
* **Endpoints de API:** Message Batches API, Models API, Admin API, Compliance API e Usage and Cost API
* **Claude Managed Agents**
* **Fallback do lado do servidor:** O [parâmetro `fallbacks`](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#server-side-fallback)

Em vez do fallback do lado do servidor, use o [padrão de fallback do lado do cliente](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#client-side-fallback).

### Janela de contexto

O Claude Models on Google Cloud (Google managed) oferece uma ["context window" (janela de contexto) de 1M de tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows) para estes modelos:

* Claude Fable 5.1
* Claude Fable 5
* Claude Opus 5.5
* Claude Opus 5
* Claude Opus 4.8
* Claude Opus 4.7
* Claude Opus 4.6
* Claude Sonnet 5.5
* Claude Sonnet 5
* Claude Sonnet 4.6
* Claude Haiku 5.5

Outros modelos Claude têm uma janela de contexto de 200k tokens. Entre eles estão o Claude Sonnet 4.5 (descontinuado) e o Claude Sonnet 4 (descontinuado).

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

## Faturamento, limites de taxa e registro em log

### Limites de taxa

O Google Cloud gerencia os "rate limits" (limites de taxa) e as cotas do Claude Models on Google Cloud (Google managed). Para detalhes, incluindo como solicitar um aumento de cota, consulte a página [Quotas for Anthropic Claude models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude/quotas) do Google Cloud.

### Faturamento

O Google Cloud fatura o uso do Claude Models on Google Cloud (Google managed). Para os preços, consulte a página [Generative AI pricing](https://cloud.google.com/vertex-ai/generative-ai/pricing#claude-models) do Google Cloud. Os preços também dependem do tipo de endpoint. Consulte [Endpoints globais, multirregionais e regionais](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

### Retenção de dados

O Google Cloud rege o tratamento de dados do Claude Models on Google Cloud (Google managed). Para detalhes, consulte [Agent Platform and zero data retention](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance).

### Monitoramento e registro em log

Para registrar prompts e conclusões do Claude Models on Google Cloud (Google managed), use o [serviço de registro de requisição-resposta](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/request-response-logging) do Agent Platform.

A Anthropic recomenda que você mantenha pelo menos os últimos 30 dias de logs. Os logs ajudam você a entender sua atividade e investigar possíveis usos indevidos.

<Note>
  Ativar esse serviço não dá ao Google nem à Anthropic nenhum acesso ao seu conteúdo.
</Note>

## Migrando do Claude Models on Google Cloud (Anthropic managed)

Para saber o que muda ao migrar, 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). Para migrar para o Claude Models on Google Cloud (Google managed), siga estas etapas:

<Steps>
  <Step title="Configurar o acesso">
    Verifique se o seu projeto e a identidade que faz as chamadas atendem aos requisitos em [Antes de fazer chamadas de API](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#before-making-api-calls).
  </Step>

  <Step title="Instalar o pacote do SDK">
    Instale o pacote que fornece o cliente para o Claude Models on Google Cloud (Google managed). Consulte [Instalar um SDK](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#install-an-sdk-for-accessing-vertex-ai).
  </Step>

  <Step title="Substituir a importação e o cliente">
    Altere o código que importa e cria seu cliente. Use `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`) no lugar de `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Uma requisição cURL precisa de uma nova URL, novos cabeçalhos e um novo corpo. O código a seguir cria o cliente para o Claude Models on Google Cloud (Anthropic managed) que você usa hoje:

    <CodeGroup>
      ```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
      ```
    </CodeGroup>

    O código a seguir cria o cliente para o Claude Models on Google Cloud (Google managed). Ele usa o endpoint global. Para os outros tipos de endpoint, consulte [Endpoints globais, multirregionais e regionais](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

    <CodeGroup exclude="shell:CLI">
      ```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
        }'
      ```

      <CodeGroupItem language="CLI">
        A CLI `ant` não oferece suporte ao Claude Models on Google Cloud (Google managed). Use cURL ou um SDK em vez disso.
      </CodeGroupItem>

      ```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"
      )
      ```
    </CodeGroup>

    Esse código passa o ID do seu projeto e uma região ao criar o cliente. Substitua `MY_PROJECT_ID` pelo ID do seu projeto. As chamadas à Messages API que você faz com o cliente permanecem como estão. As exceções são os IDs de modelo e os recursos da próxima etapa.
  </Step>

  <Step title="Verificar IDs de modelo e recursos">
    * **IDs de modelo:** Se você usa um modelo anterior ao Claude 4.6, substitua o hífen antes da data do snapshot em seu ID por `@`. 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/google-managed#api-model-ids).
    * **Recursos:** Verifique se os recursos que seu código usa não estão listados em [Recursos não suportados](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#features-not-supported).
  </Step>

  <Step title="Executar uma requisição de teste">
    Execute a requisição em [Fazendo requisições](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai) para verificar se sua configuração funciona. Em seguida, execute seu próprio código. Antes de migrar o tráfego de produção, leia sobre os [limites de taxa do Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits).
  </Step>
</Steps>

## Próximos passos

<CardGroup cols={2}>
  <Card title="Visão geral de recursos" icon="stack" href="https://platform.claude.com/docs/pt-BR/build-with-claude/overview">
    Explore os recursos do Claude.
  </Card>

  <Card title="Anthropic Claude models on Agent Platform" icon="book" href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude">
    Verifique quais modelos Claude cada região oferece e suas datas de desativação.
  </Card>

  <Card title="Documentação do Agent Platform" icon="book" href="https://cloud.google.com/vertex-ai/docs">
    Leia a documentação do Agent Platform do Google Cloud.
  </Card>

  <Card title="Endpoint global para modelos Claude" icon="link" href="https://cloud.google.com/blog/products/ai-machine-learning/global-endpoint-for-claude-models-generally-available-on-vertex-ai">
    Leia a postagem do blog do Google Cloud sobre o endpoint global para modelos Claude.
  </Card>
</CardGroup>