---
title: Claude auf Google Cloud
url: https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai
description: Die Claude-Modelle von Anthropic sind über [Google Cloud's Agent Platform](https://cloud.google.com/vertex-ai) verfügbar.
---

Die API für den Zugriff auf Claude auf Google Cloud's Agent Platform ist nahezu identisch mit der [Messages API](https://platform.claude.com/docs/de/api/messages/create), mit zwei wesentlichen Unterschieden im Anfrageformat:

* Auf Agent Platform wird `model` nicht im Request-Body übergeben. Stattdessen wird es in der Google Cloud-Endpunkt-URL angegeben.
* Auf Agent Platform wird `anthropic_version` im Request-Body übergeben (statt als Header) und muss auf den Wert `vertex-2023-10-16` gesetzt werden.

Agent Platform wird auch von den offiziellen [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic unterstützt. Dieser Leitfaden führt dich durch das Senden einer Anfrage an Claude auf Agent Platform mit einem der Client-SDKs von Anthropic.

Beachte, dass dieser Leitfaden davon ausgeht, dass du bereits ein Google Cloud-Projekt hast, das Agent Platform nutzen kann. Siehe [Anthropic Claude-Modelle auf Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude) für weitere Informationen zur erforderlichen Einrichtung sowie eine vollständige Schritt-für-Schritt-Anleitung.

## Ein SDK für den Zugriff auf Agent Platform installieren

Installiere zunächst das [Client-SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic für die Sprache deiner Wahl.

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

## Zugriff auf Agent Platform

### Modellverfügbarkeit

Beachte, dass die Verfügbarkeit der Anthropic-Modelle je nach Region variiert. Suche im [Model Garden](https://cloud.google.com/model-garden) nach „Claude“ oder gehe zu [Anthropic Claude-Modelle](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude), um die neuesten Informationen zu erhalten.

#### API-Modell-IDs

Die Lebenszyklusbegriffe („Deprecated“ (abgekündigt), „Retired“ (eingestellt)) sind in [Modellabkündigungen](https://platform.claude.com/docs/de/about-claude/model-deprecations) definiert. Lebenszyklusdaten auf von Partnern betriebenen Plattformen werden vom Partner festgelegt und können vom Zeitplan der Claude API abweichen. Das aktuelle Einstellungsdatum eines beliebigen Modells auf Agent Platform findest du in der [Google Cloud-Dokumentation für Claude-Modelle auf 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/de/about-claude/model-deprecations))   | `claude-opus-4-1@20250805`   |
| Claude Opus 4 ([deprecated](https://platform.claude.com/docs/de/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/de/about-claude/model-deprecations)) | `claude-sonnet-4-5@20250929` |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/de/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/de/about-claude/model-deprecations))  | `claude-3-5-haiku@20241022`  |

<Tip>
  Du wechselst auf ein neueres Claude-Modell? Führe in Claude Code `/claude-api migrate` aus, um Modell-ID-Austausche und inkompatible Parameteränderungen in deiner gesamten Codebasis anzuwenden. Der Skill erkennt, auf welche Cloud-Plattform dein Code abzielt, und passt Modell-ID-Formate und Funktionsänderungen für diese Plattform an. Siehe [Migration auf ein neueres Claude-Modell](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

### Anfragen senden

Bevor du Anfragen ausführst, musst du möglicherweise `gcloud auth application-default login` ausführen, um dich bei Google Cloud zu authentifizieren.

Die folgenden Beispiele zeigen, wie du mit Claude auf Agent Platform Text generierst:

<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">
    Die `ant` CLI unterstützt Agent Platform nicht.
  </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";

  // Durchläuft den Standard-Flow von `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"
  )
  // ...
  	// Verwendet die Standard-Anmeldedaten von 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\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>

Weitere Details findest du in den [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) und in der offiziellen [Agent Platform-Dokumentation](https://cloud.google.com/vertex-ai/docs).

Claude ist auch über [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) und [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) verfügbar.

## Datenaufbewahrung

Die Datenverarbeitung für dieses Angebot unterliegt Google Cloud. Details findest du unter [Agent Platform und Zero Data Retention](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance).

## Aktivitätsprotokollierung

Agent Platform bietet einen [Request-Response-Logging-Dienst](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/request-response-logging), mit dem du die mit deiner Nutzung verbundenen Prompts und Completions protokollieren kannst.

Anthropic empfiehlt, deine Aktivität mindestens auf rollierender 30-Tage-Basis zu protokollieren, um deine Aktivität nachzuvollziehen und möglichen Missbrauch zu untersuchen.

<Note>
  Das Aktivieren dieses Dienstes gewährt weder Google noch Anthropic Zugriff auf deine Inhalte.
</Note>

## Funktionsunterstützung

Die vollständige Funktionsliste mit Verfügbarkeit auf Google Cloud findest du in der [Funktionsübersicht](https://platform.claude.com/docs/de/build-with-claude/overview).

### Highlights der unterstützten Funktionen

* [Messages API](https://platform.claude.com/docs/de/api/messages/create)
* [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)
* [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking)
* [Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview), einschließlich des [Bash-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool), des [Browser-Use-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool), des [Computer-Use-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool), des [Memory-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool) und des [Texteditor-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool)
* [Websuche-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool)
* [Zitate](https://platform.claude.com/docs/de/build-with-claude/citations)
* [Strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs)

### Nicht unterstützte Funktionen

* Eingabequellen (URL-Quellen für Bilder und Dokumente, Files API)
* Serverseitige Tools (Codeausführung, Web Fetch, Advisor)
* Agenten-Infrastruktur (Agent Skills, MCP-Connector, programmatische Tool-Aufrufe)
* API-Endpunkte (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Serverseitiges Fallback (der [`fallbacks`-Parameter](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback); verwende stattdessen das [clientseitige Fallback-Muster](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#client-side-fallback))

### Kontextfenster

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 und Claude Haiku 5.5 haben auf Agent Platform ein [„context window" (Kontextfenster) von 1M Token](https://platform.claude.com/docs/de/build-with-claude/context-windows). Andere Claude-Modelle, einschließlich Sonnet 4.5 (abgekündigt) und Sonnet 4 (abgekündigt), haben ein Kontextfenster von 200k Token.

Agent Platform begrenzt Request-Payloads auf 30 MB. Wenn du große Dokumente oder viele Bilder sendest, kannst du dieses Limit erreichen, bevor das Token-Limit erreicht ist.

## Globale, multiregionale und regionale Endpunkte

Agent Platform bietet drei Endpunkttypen:

* **Globale Endpunkte:** Dynamisches Routing für maximale Verfügbarkeit
* **Multiregionale Endpunkte:** Dynamisches Routing innerhalb eines geografischen Gebiets (zum Beispiel der Vereinigten Staaten oder der Europäischen Union) für Datenresidenz bei hoher Verfügbarkeit
* **Regionale Endpunkte:** Garantiertes Datenrouting durch bestimmte geografische Regionen

Regionale und multiregionale Endpunkte beinhalten einen Preisaufschlag von 10 % gegenüber globalen Endpunkten.

<Note>
  Dies gilt nur für Claude Sonnet 4.5 (abgekündigt) und zukünftige Modelle. Ältere Modelle (Claude Sonnet 4 (abgekündigt), Opus 4 (abgekündigt) und früher) behalten ihre bestehenden Preisstrukturen bei.
</Note>

### Wann welche Option verwendet werden sollte

**Globale Endpunkte (empfohlen):**

* Bieten maximale Verfügbarkeit und Betriebszeit
* Leiten Anfragen dynamisch an Regionen mit verfügbarer Kapazität weiter
* Kein Preisaufschlag
* Am besten für Anwendungen, bei denen die Datenresidenz flexibel ist
* Unterstützen nur Pay-as-you-go-Traffic (Provisioned Throughput erfordert regionale Endpunkte)

**Multiregionale Endpunkte:**

* Leiten Anfragen dynamisch über Regionen innerhalb eines geografischen Gebiets weiter (derzeit `us` und `eu`)
* Nützlich, wenn du Datenresidenz innerhalb einer größeren Geografie benötigst, aber eine höhere Verfügbarkeit als bei einer einzelnen Region wünschst
* Preisaufschlag von 10 % gegenüber globalen Endpunkten
* Unterstützen nur Pay-as-you-go-Traffic (Provisioned Throughput erfordert regionale Endpunkte)

**Regionale Endpunkte:**

* Leiten Traffic über bestimmte geografische Regionen
* Erforderlich für Datenresidenz in einer einzelnen Region, strenge Compliance-Vorgaben oder Provisioned Throughput
* Unterstützen sowohl Pay-as-you-go als auch Provisioned Throughput
* Der Preisaufschlag von 10 % spiegelt die Infrastrukturkosten für dedizierte regionale Kapazität wider

### Implementierung

**Globale Endpunkte verwenden (empfohlen):**

Setze den Parameter `region` beim Initialisieren des Clients auf `"global"`:

<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">
    Die `ant` CLI unterstützt Agent Platform nicht.
  </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"
  )
  // ...
  	// Verwendet die Standard-Anmeldedaten von 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.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>

**Multiregionale Endpunkte verwenden:**

Setze den Parameter `region` auf eine multiregionale Kennung: `"us"` für die Vereinigten Staaten oder `"eu"` für die Europäische Union. Das SDK leitet Anfragen an den entsprechenden multiregionalen Endpunkt weiter (`https://aiplatform.us.rep.googleapis.com` oder `https://aiplatform.eu.rep.googleapis.com`), der den Traffic dynamisch über die Regionen innerhalb dieses geografischen Gebiets verteilt.

<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">
    Die `ant` CLI unterstützt Agent Platform nicht.
  </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"
  )
  // ...
  	// Multi-Region-Kennung: "us" oder "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 {
      // Multi-Region-Kennung: "us" oder "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>

**Regionale Endpunkte verwenden:**

Gib eine bestimmte Region an, zum Beispiel `"us-east5"` oder `"europe-west1"`:

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  # Spezifische regionale Endpunkte unterstützen Claude Sonnet 4.6 und älter; neuere Modelle nutzen globale oder Multi-Region-Endpunkte
  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">
    Die `ant` CLI unterstützt Agent Platform nicht.
  </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(
      # Bestimmte regionale Endpunkte unterstützen Claude Sonnet 4.6 und älter; neuere Modelle nutzen die globalen oder Multi-Region-Endpunkte
      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({
    // Spezifische regionale Endpunkte unterstützen Claude Sonnet 4.6 und ältere Modelle; neuere Modelle nutzen globale oder Multi-Region-Endpunkte
    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
  {
      // Spezifische regionale Endpunkte unterstützen Claude Sonnet 4.6 und ältere Modelle; neuere Modelle nutzen die globalen oder Multi-Region-Endpunkte
      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"
  )
  // ...
  	// Gib eine bestimmte Region an
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us-east5", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		// Regionale Endpunkte unterstützen Claude Sonnet 4.6 und älter; neuere Modelle nutzen globale oder Multi-Region-Endpunkte
  		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()
                  // Regionale Endpunkte unterstützen Claude Sonnet 4.6 und älter; neuere Modelle nutzen globale oder Multi-Region-Endpunkte
                  .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!']
      ],
      // Bestimmte regionale Endpunkte unterstützen Claude Sonnet 4.6 und ältere Modelle; neuere Modelle nutzen die globalen oder Multi-Region-Endpunkte
      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(
    # Bestimmte regionale Endpunkte unterstützen Claude Sonnet 4.6 und älter; neuere Modelle nutzen die globalen oder Multi-Region-Endpunkte
    model: "claude-sonnet-4-6",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Claude!"}]
  )

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

<Note>
  Claude Mythos Preview ist eine Research Preview, die eingeladenen Kunden auf Agent Platform zur Verfügung steht. Weitere Informationen findest du unter [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Zusätzliche Ressourcen

* **Agent Platform-Preise:** [Preise für generative KI auf cloud.google.com](https://cloud.google.com/vertex-ai/generative-ai/pricing)
* **Dokumentation der Claude-Modelle:** [Claude auf Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude)
* **Google-Blogbeitrag:** [Globaler Endpunkt für Claude-Modelle](https://cloud.google.com/blog/products/ai-machine-learning/global-endpoint-for-claude-models-generally-available-on-vertex-ai)
* **Anthropic-Preisdetails:** [Cloud-Plattform-Preise](https://platform.claude.com/docs/de/about-claude/pricing#cloud-platform-pricing)