Claude on Vertex AI

Anthropic's Claude models are available through Vertex AI.

The Vertex API for accessing Claude is nearly identical to the Messages API, with two key differences in request format:

In Vertex, model is not passed in the request body. Instead, it is specified in the Google Cloud endpoint URL.
In Vertex, anthropic_version is passed in the request body (rather than as a header), and must be set to the value vertex-2023-10-16.

Vertex is also supported by Anthropic's official client SDKs. This guide walks you through making a request to Claude on Vertex AI using one of Anthropic's client SDKs.

Note that this guide assumes you already have a GCP project that is able to use Vertex AI. See Anthropic Claude models on Vertex AI for more information on the setup required and a full walkthrough.

Install an SDK for accessing Vertex AI

First, install Anthropic's client SDK for your language of choice.

pip install -U google-cloud-aiplatform "anthropic[vertex]"

npm install @anthropic-ai/vertex-sdk

dotnet add package Anthropic.Vertex

go get github.com/anthropics/anthropic-sdk-go

implementation("com.anthropic:anthropic-java-vertex:2.33.0")

<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>anthropic-java-vertex</artifactId>
    <version>2.33.0</version>
</dependency>

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.vertex.backends.VertexBackend;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.Model;

public class BasicMessage {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(VertexBackend.fromEnv())
            .build();

        MessageCreateParams params = MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_4_7)
            .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 -> System.out.println(textBlock.text()));
    }
}

composer require anthropic-ai/sdk google/auth

# Gemfile
gem "anthropic"
gem "googleauth"

Accessing Vertex AI

Model availability

Note that Anthropic model availability varies by region. Search for "Claude" in the Vertex AI Model Garden or go to Anthropic Claude models for the latest information.

API model IDs

Lifecycle terms (Deprecated, Retired) are defined in Model deprecations; a "Retiring" annotation gives the platform's announced retirement date. The dates in the following table are the Vertex AI schedule, which Google Cloud sets independently. A model's lifecycle status and dates here can differ from the Anthropic-operated schedule on the Model deprecations page.

Model	Vertex AI API model ID
Claude Opus 4.7	claude-opus-4-7
Claude Opus 4.6	claude-opus-4-6
Claude Sonnet 4.6	claude-sonnet-4-6
Claude Sonnet 4.5	claude-sonnet-4-5@20250929
Claude Sonnet 4 Deprecated. Retiring September 14, 2026.	claude-sonnet-4@20250514
Claude Sonnet 3.7 Retired May 11, 2026.	claude-3-7-sonnet@20250219
Claude Opus 4.5	claude-opus-4-5@20251101
Claude Opus 4.1	claude-opus-4-1@20250805
Claude Opus 4 Deprecated. Retiring September 14, 2026.	claude-opus-4@20250514
Claude Haiku 4.5	claude-haiku-4-5@20251001
Claude Haiku 3.5 Deprecated. Retiring July 5, 2026.	claude-3-5-haiku@20241022

Tip

Upgrading to a newer Claude model? In Claude Code, run /claude-api migrate to apply model ID swaps and breaking parameter changes across your codebase. The skill detects which cloud platform your code targets and adjusts model ID formats and feature changes for that platform. See Migrating to a newer Claude model.

Making requests

Before running requests you may need to run gcloud auth application-default login to authenticate with GCP.

The following examples show how to generate text from Claude on Vertex AI:

MODEL_ID=claude-opus-4-7
LOCATION=global
PROJECT_ID=MY_PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://$LOCATION-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL_ID}:streamRawPredict -d \
'{
  "anthropic_version": "vertex-2023-10-16",
  "messages": [{
    "role": "user",
    "content": "Hey Claude!"
  }],
  "max_tokens": 100
}'

# The ant CLI does not support Vertex AI.

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-4-7",
    max_tokens=100,
    messages=[
        {
            "role": "user",
            "content": "Hey Claude!",
        }
    ],
)
print(message)

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

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

// Goes through the standard `google-auth-library` flow.
const client = new AnthropicVertex({
  projectId,
  region
});

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

main();

using Anthropic;
using Anthropic.Models.Messages;
using Anthropic.Vertex;

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

var client = new AnthropicClient
{
    Backend = new VertexBackend(projectId, region)
};

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus4_7,
    MaxTokens = 100,
    Messages = [new() { Role = Role.User, Content = "Hey Claude!" }]
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/vertex"
)

func main() {
	// Uses default Google Cloud credentials
	client := anthropic.NewClient(
		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
	)

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

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.vertex.backends.VertexBackend;

public class VertexExample {

  public static void main(String[] args) {
    // Uses default Google Cloud credentials
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(VertexBackend.fromEnv())
      .build();

    Message message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("claude-opus-4-7")
          .maxTokens(100)
          .addUserMessage("Hey Claude!")
          .build()
      );

    System.out.println(message);
  }
}

<?php

use Anthropic\Vertex;

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

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

require "anthropic"

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

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

puts message.content.first.text

See the client SDKs and the official Vertex AI docs for more details.

Claude is also available through Amazon Bedrock, Claude Platform on AWS, and Microsoft Foundry.

Data retention

Data handling for this offering is governed by Google Cloud Vertex AI. For details, see Vertex AI and zero data retention.

Activity logging

Vertex provides a request-response logging service that allows customers to log the prompts and completions associated with your usage.

Anthropic recommends that you log your activity on at least a 30-day rolling basis in order to understand your activity and investigate any potential misuse.

Note

Turning on this service does not give Google or Anthropic any access to your content.

Feature support

For the full feature list with Vertex AI availability, see Features overview.

Supported feature highlights

Messages API
Prompt caching
Extended thinking
Tool use, including the Bash tool, Computer use tool, Memory tool, and Text editor tool
Web search tool
Citations
Structured outputs

Features not supported

Input sources (URL sources for images and documents, Files API)
Server-side tools (code execution, web fetch, advisor)
Agent infrastructure (Agent Skills, MCP connector, programmatic tool calling)
API endpoints (Message Batches, Models, Admin, Compliance, Usage and Cost)
Claude Managed Agents

Context window

Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6 have a 1M-token context window on Vertex AI. Other Claude models, including Sonnet 4.5 and Sonnet 4 (deprecated), have a 200k-token context window.

Vertex AI limits request payloads to 30 MB. When sending large documents or many images, you may reach this limit before the token limit.

Global, multi-region, and regional endpoints

Vertex AI offers three endpoint types:

Global endpoints: Dynamic routing for maximum availability
Multi-region endpoints: Dynamic routing within a geographic area (for example, the United States or the European Union) for data residency with high availability
Regional endpoints: Guaranteed data routing through specific geographic regions

Regional and multi-region endpoints include a 10% pricing premium over global endpoints.

Note

This applies to Claude Sonnet 4.5 and future models only. Older models (Claude Sonnet 4 (deprecated), Opus 4 (deprecated), and earlier) maintain their existing pricing structures.

When to use each option

Global endpoints (recommended):

Provide maximum availability and uptime
Dynamically route requests to regions with available capacity
No pricing premium
Best for applications where data residency is flexible
Only supports pay-as-you-go traffic (provisioned throughput requires regional endpoints)

Multi-region endpoints:

Dynamically route requests across regions within a geographic area (currently us and eu)
Useful when you need data residency within a broad geography but want higher availability than a single region
10% pricing premium over global endpoints
Only supports pay-as-you-go traffic (provisioned throughput requires regional endpoints)

Regional endpoints:

Route traffic through specific geographic regions
Required for single-region data residency, strict compliance mandates, or provisioned throughput
Support both pay-as-you-go and provisioned throughput
10% pricing premium reflects infrastructure costs for dedicated regional capacity

Implementation

Using global endpoints (recommended):

Set the region parameter to "global" when initializing the client:

# The ant CLI does not support Vertex AI.

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-4-7",
    max_tokens=100,
    messages=[
        {
            "role": "user",
            "content": "Hey Claude!",
        }
    ],
)
print(message)

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-4-7",
  max_tokens: 100,
  messages: [
    {
      role: "user",
      content: "Hey Claude!"
    }
  ]
});

using Anthropic;
using Anthropic.Models.Messages;
using Anthropic.Vertex;

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

var client = new AnthropicClient
{
    Backend = new VertexBackend(projectId, region)
};

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus4_7,
    MaxTokens = 100,
    Messages = [new() { Role = Role.User, Content = "Hey Claude!" }]
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/vertex"
)

func main() {
	// Uses default Google Cloud credentials
	client := anthropic.NewClient(
		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
	)

	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "claude-opus-4-7",
		MaxTokens: 100,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
		},
	})
	_ = message
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.vertex.backends.VertexBackend;

void main() {
    // Uses default Google Cloud credentials
    AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(
            VertexBackend.builder()
                .region("global")
                .project("MY_PROJECT_ID")
                .build()
        )
        .build();

    var message = client
        .messages()
        .create(
            MessageCreateParams.builder()
                .model("claude-opus-4-7")
                .maxTokens(100)
                .addUserMessage("Hey Claude!")
                .build()
        );

    IO.println(message);
}

<?php

use Anthropic\Vertex;

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

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

echo $message->content[0]->text;

require "anthropic"

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

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

puts message.content.first.text

Using multi-region endpoints:

Set the region parameter to a multi-region identifier: "us" for the United States or "eu" for the European Union. The SDK routes requests to the corresponding multi-region endpoint (https://aiplatform.us.rep.googleapis.com or https://aiplatform.eu.rep.googleapis.com), which dynamically balances traffic across regions within that geography.

# The ant CLI does not support Vertex AI.

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-4-7",
    max_tokens=100,
    messages=[
        {
            "role": "user",
            "content": "Hey Claude!",
        }
    ],
)
print(message)

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-4-7",
  max_tokens: 100,
  messages: [
    {
      role: "user",
      content: "Hey Claude!"
    }
  ]
});

using Anthropic;
using Anthropic.Models.Messages;
using Anthropic.Vertex;

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

var client = new AnthropicClient
{
    Backend = new VertexBackend(projectId, region)
};

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus4_7,
    MaxTokens = 100,
    Messages = [new() { Role = Role.User, Content = "Hey Claude!" }]
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/vertex"
)

func main() {
	// Multi-region identifier: "us" or "eu"
	client := anthropic.NewClient(
		vertex.WithGoogleAuth(context.Background(), "us", "MY_PROJECT_ID"),
	)

	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "claude-opus-4-7",
		MaxTokens: 100,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
		},
	})
	_ = message
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.vertex.backends.VertexBackend;

void main() {
    // Multi-region identifier: "us" or "eu"
    AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(
            VertexBackend.builder()
                .region("us")
                .project("MY_PROJECT_ID")
                .build()
        )
        .build();

    var message = client
        .messages()
        .create(
            MessageCreateParams.builder()
                .model("claude-opus-4-7")
                .maxTokens(100)
                .addUserMessage("Hey Claude!")
                .build()
        );

    IO.println(message);
}

<?php

use Anthropic\Vertex;

$client = Vertex\Client::fromEnvironment(
    location: '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-4-7',
);
echo $message->content[0]->text;

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-4-7",
  max_tokens: 100,
  messages: [{role: "user", content: "Hey Claude!"}]
)

puts message.content.first.text

Using regional endpoints:

Specify a specific region like "us-east1" or "europe-west1":

# The ant CLI does not support Vertex AI.

from anthropic import AnthropicVertex

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

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

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

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

const projectId = "MY_PROJECT_ID";
const region = "us-east1"; // Specify a specific region

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

const result = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 100,
  messages: [
    {
      role: "user",
      content: "Hey Claude!"
    }
  ]
});

using Anthropic;
using Anthropic.Models.Messages;
using Anthropic.Vertex;

var projectId = "MY_PROJECT_ID";
var region = "us-east1";

AnthropicClient client = new()
{
    Backend = new VertexBackend(projectId, region)
};

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus4_7,
    MaxTokens = 100,
    Messages = [new() { Role = Role.User, Content = "Hey Claude!" }]
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/vertex"
)

func main() {
	// Specify a specific region
	client := anthropic.NewClient(
		vertex.WithGoogleAuth(context.Background(), "us-east1", "MY_PROJECT_ID"),
	)

	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "claude-opus-4-7",
		MaxTokens: 100,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
		},
	})
	_ = message
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.vertex.backends.VertexBackend;

void main() {
    // Uses default Google Cloud credentials with specific region
    AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(
            VertexBackend.builder()
                .region("us-east1") // Specify a specific region
                .project("MY_PROJECT_ID")
                .build()
        )
        .build();

    var message = client
        .messages()
        .create(
            MessageCreateParams.builder()
                .model("claude-opus-4-7")
                .maxTokens(100)
                .addUserMessage("Hey Claude!")
                .build()
        );

    IO.println(message);
}

<?php

use Anthropic\Vertex;

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

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

require "anthropic"

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

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

puts message.content.first.text

Note

Claude Mythos Preview is a research preview available to invited customers on Vertex AI. For more information, see Project Glasswing.

Additional resources

Vertex AI pricing: cloud.google.com/vertex-ai/generative-ai/pricing
Claude models documentation: Claude on Vertex AI
Google blog post: Global endpoint for Claude models
Anthropic pricing details: Cloud platform pricing