---
title: Claude sur Google Cloud
url: https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai
description: Les modèles Claude d'Anthropic sont disponibles via [Google Cloud's Agent Platform](https://cloud.google.com/vertex-ai).
---

L'API permettant d'accéder à Claude sur Google Cloud's Agent Platform est presque identique à l'[API Messages](https://platform.claude.com/docs/fr/api/messages/create), avec deux différences clés dans le format des requêtes :

* Sur Agent Platform, `model` n'est pas transmis dans le corps de la requête. Il est plutôt spécifié dans l'URL du point de terminaison Google Cloud.
* Sur Agent Platform, `anthropic_version` est transmis dans le corps de la requête (plutôt que sous forme d'en-tête), et doit être défini sur la valeur `vertex-2023-10-16`.

Agent Platform est également pris en charge par les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) officiels d'Anthropic. Ce guide vous explique comment effectuer une requête vers Claude sur Agent Platform à l'aide de l'un des SDK clients d'Anthropic.

Notez que ce guide suppose que vous disposez déjà d'un projet Google Cloud capable d'utiliser Agent Platform. Consultez [Modèles Anthropic Claude sur Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) pour plus d'informations sur la configuration requise et une procédure complète.

## Installer un SDK pour accéder à Agent Platform

Tout d'abord, installez le [SDK client](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d'Anthropic pour le langage de votre choix.

<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:2.73.0")
      implementation("com.anthropic:anthropic-java-vertex:2.73.0")
      ```

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

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

          MessageCreateParams params = MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024L)
              .addUserMessage("What is the capital of France?")
              .build();

          Message response = client.messages().create(params);
          response.content().stream()
              .flatMap(block -> block.text().stream())
              .forEach(textBlock -> IO.println(textBlock.text()));
      }
      ```
    </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>

## Accéder à Agent Platform

### Disponibilité des modèles

Notez que la disponibilité des modèles Anthropic varie selon la région. Recherchez « Claude » dans le [Model Garden](https://cloud.google.com/model-garden) ou rendez-vous sur [Modèles Anthropic Claude](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) pour obtenir les informations les plus récentes.

#### Identifiants de modèles de l'API

Les termes relatifs au cycle de vie (Déprécié, Retiré) sont définis dans [Dépréciations de modèles](https://platform.claude.com/docs/fr/about-claude/model-deprecations). Les dates de cycle de vie sur les plateformes exploitées par des partenaires sont fixées par le partenaire et peuvent différer du calendrier de l'API Claude. Pour connaître la date de retrait actuelle de tout modèle sur Agent Platform, consultez la [documentation de Google Cloud pour les modèles Claude sur Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude).

| 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/fr/about-claude/model-deprecations))   | `claude-opus-4-1@20250805`   |
| Claude Opus 4 ([deprecated](https://platform.claude.com/docs/fr/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/fr/about-claude/model-deprecations)) | `claude-sonnet-4-5@20250929` |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/fr/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/fr/about-claude/model-deprecations))  | `claude-3-5-haiku@20241022`  |

<Tip>
  Vous passez à un modèle Claude plus récent ? Dans Claude Code, exécutez `/claude-api migrate` pour appliquer les remplacements d'identifiants de modèle et les changements de paramètres non rétrocompatibles dans l'ensemble de votre base de code. La skill détecte la plateforme cloud ciblée par votre code et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour cette plateforme. Consultez [Migrer vers un modèle Claude plus récent](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

### Envoyer des requêtes

Avant d'exécuter des requêtes, vous devrez peut-être exécuter `gcloud auth application-default login` pour vous authentifier auprès de Google Cloud.

Les exemples suivants montrent comment générer du texte à partir de Claude sur Agent Platform :

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  MODEL_ID=claude-opus-5-5
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/anthropic/models/${MODEL_ID}: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">
    La CLI `ant` ne prend pas en charge Agent Platform.
  </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";

  // Passe par le flux standard de `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() { Role = Role.User, 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"
  )
  // ...
  	// Utilise les identifiants Google Cloud par défaut.
  	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\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',
  );
  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;
  ```

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

Consultez les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) et la [documentation officielle d'Agent Platform](https://cloud.google.com/vertex-ai/docs) pour plus de détails.

Claude est également disponible via [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), [Claude Platform sur AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) et [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry).

## Conservation des données

Le traitement des données pour cette offre est régi par Google Cloud. Pour plus de détails, consultez [Agent Platform et conservation zéro des données](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance).

## Journalisation de l'activité

Agent Platform fournit un [service de journalisation des requêtes et réponses](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/request-response-logging) qui vous permet de journaliser les prompts et les complétions associés à votre utilisation.

Anthropic vous recommande de journaliser votre activité sur une période glissante d'au moins 30 jours afin de comprendre votre activité et d'enquêter sur toute utilisation abusive potentielle.

<Note>
  L'activation de ce service ne donne ni à Google ni à Anthropic un quelconque accès à votre contenu.
</Note>

## Prise en charge des fonctionnalités

Pour la liste complète des fonctionnalités avec leur disponibilité sur Google Cloud, consultez la [Vue d'ensemble des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview).

### Principales fonctionnalités prises en charge

* [API Messages](https://platform.claude.com/docs/fr/api/messages/create)
* [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) (prompt caching)
* [Réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking) (thinking)
* [Utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview) (tool use), y compris l'[outil Bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool), l'[outil d'utilisation du navigateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool), l'[outil d'utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool), l'[outil de mémoire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool) et l'[outil d'édition de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool)
* [Outil de recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool)
* [Citations](https://platform.claude.com/docs/fr/build-with-claude/citations)
* [Sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs)

### Fonctionnalités non prises en charge

* Sources d'entrée (sources URL pour les images et les documents, API Files)
* Outils côté serveur (exécution de code, récupération web, advisor)
* Infrastructure d'agents (Agent Skills, connecteur MCP, appel d'outils programmatique)
* Points de terminaison de l'API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Repli côté serveur (le [paramètre `fallbacks`](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback) ; utilisez plutôt le [modèle de repli côté client](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#client-side-fallback))

### Fenêtre de contexte

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 et Claude Haiku 5.5 disposent d'une [« context window » (fenêtre de contexte) de 1M tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows) sur Agent Platform. Les autres modèles Claude, y compris Sonnet 4.5 (déprécié) et Sonnet 4 (déprécié), disposent d'une fenêtre de contexte de 200k tokens.

Agent Platform limite la taille des charges utiles des requêtes à 30 Mo. Lors de l'envoi de documents volumineux ou de nombreuses images, vous pourriez atteindre cette limite avant la limite de tokens.

## Points de terminaison globaux, multirégionaux et régionaux

Agent Platform propose trois types de points de terminaison :

* **Points de terminaison globaux :** routage dynamique pour une disponibilité maximale
* **Points de terminaison multirégionaux :** routage dynamique au sein d'une zone géographique (par exemple, les États-Unis ou l'Union européenne) pour la « data residency » (résidence des données) avec une haute disponibilité
* **Points de terminaison régionaux :** routage garanti des données via des régions géographiques spécifiques

Les points de terminaison régionaux et multirégionaux comportent une majoration tarifaire de 10 % par rapport aux points de terminaison globaux.

<Note>
  Cela s'applique uniquement à Claude Sonnet 4.5 (déprécié) et aux modèles futurs. Les modèles plus anciens (Claude Sonnet 4 (déprécié), Opus 4 (déprécié) et antérieurs) conservent leurs structures tarifaires existantes.
</Note>

### Quand utiliser chaque option

**Points de terminaison globaux (recommandés) :**

* Offrent une disponibilité et un temps de fonctionnement maximaux
* Acheminent dynamiquement les requêtes vers les régions disposant de capacité disponible
* Aucune majoration tarifaire
* Idéaux pour les applications où la résidence des données est flexible
* Prennent uniquement en charge le trafic à l'usage (le débit provisionné nécessite des points de terminaison régionaux)

**Points de terminaison multirégionaux :**

* Acheminent dynamiquement les requêtes entre les régions d'une zone géographique (actuellement `us` et `eu`)
* Utiles lorsque vous avez besoin d'une résidence des données au sein d'une vaste zone géographique mais souhaitez une disponibilité supérieure à celle d'une seule région
* Majoration tarifaire de 10 % par rapport aux points de terminaison globaux
* Prennent uniquement en charge le trafic à l'usage (le débit provisionné nécessite des points de terminaison régionaux)

**Points de terminaison régionaux :**

* Acheminent le trafic via des régions géographiques spécifiques
* Requis pour la résidence des données dans une seule région, les exigences de conformité strictes ou le débit provisionné
* Prennent en charge à la fois le trafic à l'usage et le débit provisionné
* La majoration tarifaire de 10 % reflète les coûts d'infrastructure liés à la capacité régionale dédiée

### Implémentation

**Utiliser les points de terminaison globaux (recommandé) :**

Définissez le paramètre `region` sur `"global"` lors de l'initialisation du client :

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  MODEL_ID=claude-opus-5-5
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/anthropic/models/${MODEL_ID}: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">
    La CLI `ant` ne prend pas en charge Agent Platform.
  </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";

  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() { Role = Role.User, 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"
  )
  // ...
  	// Utilise les identifiants Google Cloud par défaut.
  	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.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();

      var 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\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',
  );

  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;
  ```

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

**Utiliser les points de terminaison multirégionaux :**

Définissez le paramètre `region` sur un identifiant multirégional : `"us"` pour les États-Unis ou `"eu"` pour l'Union européenne. Le SDK achemine les requêtes vers le point de terminaison multirégional correspondant (`https://aiplatform.us.rep.googleapis.com` ou `https://aiplatform.eu.rep.googleapis.com`), qui équilibre dynamiquement le trafic entre les régions de cette zone géographique.

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  MODEL_ID=claude-opus-5-5
  LOCATION=us # Multi-region identifier: "us" or "eu"
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.${LOCATION}.rep.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL_ID}: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">
    La CLI `ant` ne prend pas en charge Agent Platform.
  </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)

  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 = "us"; // Multi-region identifier: "us" or "eu"

  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 = "us"; // Multi-region identifier: "us" or "eu"

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, 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"
  )
  // ...
  	// Identifiant multirégion : "us" ou "eu".
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us", "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.MessageCreateParams;
  import com.anthropic.models.messages.Model;
  import com.anthropic.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Identifiant multirégion : "us" ou "eu".
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      var 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\Vertex;

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

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Claude!']
      ],
      model: 'claude-opus-5-5',
  );
  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "us", # Multi-region identifier: "us" or "eu"
    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>

**Utiliser les points de terminaison régionaux :**

Spécifiez une région précise, telle que `"us-east5"` ou `"europe-west1"` :

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  # Les endpoints régionaux spécifiques prennent en charge Claude Sonnet 4.6 et les modèles antérieurs ; les modèles plus récents utilisent les endpoints globaux ou multirégionaux.
  MODEL_ID=claude-sonnet-4-6
  LOCATION=us-east5 # Specify a specific region
  PROJECT_ID=MY_PROJECT_ID

  curl https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL_ID}: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">
    La CLI `ant` ne prend pas en charge Agent Platform.
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "us-east5"  # Specify a specific region

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

  message = client.messages.create(
      # Les endpoints régionaux spécifiques prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles plus récents utilisent les endpoints globaux ou multirégionaux.
      model="claude-sonnet-4-6",
      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 = "us-east5"; // Specify a specific region

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

  const result = await client.messages.create({
    // Les points de terminaison régionaux spécifiques prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles plus récents utilisent les points de terminaison globaux ou multirégionaux.
    model: "claude-sonnet-4-6",
    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 = "us-east5"; // Specify a specific region

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

  var parameters = new MessageCreateParams
  {
      // Les points de terminaison régionaux spécifiques prennent en charge Claude Sonnet 4.6 et les modèles antérieurs ; les modèles plus récents utilisent les points de terminaison globaux ou multirégionaux.
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, 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"
  )
  // ...
  	// Spécifier une région précise.
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us-east5", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		// Les endpoints régionaux spécifiques prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles plus récents utilisent les endpoints globaux ou multirégionaux.
  		Model:     anthropic.ModelClaudeSonnet4_6,
  		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.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("us-east5") // Specify a specific region
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      var message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  // Les points de terminaison régionaux prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles récents utilisent les points globaux ou multirégionaux.
                  .model(Model.CLAUDE_SONNET_4_6)
                  .maxTokens(100)
                  .addUserMessage("Hey Claude!")
                  .build()
          );

      IO.println(message);
  }
  ```

  ```php PHP
  <?php

  use Anthropic\Vertex;

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

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Claude!']
      ],
      // Les points de terminaison régionaux spécifiques prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles plus récents utilisent les points de terminaison globaux ou multirégionaux.
      model: 'claude-sonnet-4-6',
  );
  echo $message->content[0]->text;
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "us-east5", # Specify a specific region
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    # Les endpoints régionaux spécifiques prennent en charge Claude Sonnet 4.6 et antérieurs ; les modèles plus récents utilisent les endpoints globaux ou multirégionaux.
    model: "claude-sonnet-4-6",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Claude!"}]
  )

  puts message.content.first.text
  ```
</CodeGroup>

<Note>
  Claude Mythos Preview est un aperçu de recherche disponible pour les clients invités sur Agent Platform. Pour plus d'informations, consultez [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Ressources supplémentaires

* **Tarification d'Agent Platform :** [Tarification de l'IA générative sur cloud.google.com](https://cloud.google.com/vertex-ai/generative-ai/pricing)
* **Documentation des modèles Claude :** [Claude sur Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude)
* **Article de blog Google :** [Point de terminaison global pour les modèles Claude](https://cloud.google.com/blog/products/ai-machine-learning/global-endpoint-for-claude-models-generally-available-on-vertex-ai)
* **Détails de la tarification Anthropic :** [Tarification des plateformes cloud](https://platform.claude.com/docs/fr/about-claude/pricing#cloud-platform-pricing)