Amazon Bedrock 上的 Claude（Opus 4.6 及更早版本）

注意

本页介绍旧版 Amazon Bedrock 集成：使用带 ARN 版本的模型标识符和 AWS event-stream 编码的 InvokeModel 和 Converse API。有关 Messages-API Bedrock 端点上可用的模型，请参阅 Claude in Amazon Bedrock，它在 /anthropic/v1/messages 使用 Messages API 并采用 SSE 流式传输。如需由 Anthropic 运营、通过 AWS Marketplace 计费且通常可在同一天获得新功能的替代方案，请参阅 Claude Platform on AWS。现有 Bedrock 用户可以按照迁移指南进行操作。

警告

最新版本的 SDK 默认发送 API 版本 2026-10-21，包括通过 Amazon Bedrock 发送时。本页模型表中带 ARN 版本的模型在 Bedrock 上不支持 2026-10-21，向这些模型发送该版本的请求可能会返回 400 错误。如果您通过 SDK 调用这些模型，请将 SDK 保持在您当前使用的版本，并在安装位置固定该版本，以免之后的安装将其升级。Boto3 示例在其请求体中设置了 anthropic_version，因此不受影响。

通过 Bedrock 调用 Claude 与直接在 Claude API 上调用 Claude 的方式略有不同。本指南将引导您使用 Anthropic 的某个客户端 SDK 完成对 Bedrock 上 Claude 的 API 调用。

请注意，本指南假设您已经注册了 AWS 账户并配置了编程访问。

安装和配置 AWS CLI

1. 安装 AWS CLI，版本需为 2.13.23 或更高。
2. 使用 AWS configure 命令配置您的 AWS 凭证（请参阅配置 AWS CLI），或者在 AWS 控制面板中导航到“Command line or programmatic access”并按照弹出窗口中的说明查找您的凭证。
3. 验证您的凭证是否有效：

AWS CLI

aws sts get-caller-identity

安装用于访问 Bedrock 的 SDK

Anthropic 的客户端 SDK 支持 Bedrock。您也可以直接使用 boto3 等 AWS SDK。

Python

pip install -U "anthropic[bedrock]"

TypeScript

npm install @anthropic-ai/bedrock-sdk

C#

dotnet add package Anthropic.Bedrock

Go

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

Java

Gradle

implementation("com.anthropic:anthropic-java:3.3.0")
implementation("com.anthropic:anthropic-java-bedrock:3.3.0")

Maven

<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>anthropic-java</artifactId>
    <version>3.3.0</version>
</dependency>
<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>anthropic-java-bedrock</artifactId>
    <version>3.3.0</version>
</dependency>

Java

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.bedrock.backends.BedrockBackend;
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(BedrockBackend.fromEnv())
            .build();

        MessageCreateParams params = MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_4_6)
            .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()));
    }
}

PHP

composer require anthropic-ai/sdk aws/aws-sdk-php

Ruby

# Gemfile
gem "anthropic"
gem "aws-sdk-bedrockruntime"

Boto3 (Python)

pip install "boto3>=1.28.59"

访问 Bedrock

订阅 Anthropic 模型

前往 AWS Console > Bedrock > Model Access 并申请访问 Anthropic 模型。请注意，Anthropic 模型的可用性因区域而异。有关最新信息，请参阅 AWS 文档。

API 模型 ID

注意

Claude Fable 5.1、Claude Fable 5、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5、Claude Sonnet 5、Claude Haiku 5.5、Claude Opus 4.8 和 Claude Opus 4.7 可以通过 bedrock-runtime 上的 InvokeModel 访问。 这些请求由与 Claude in Amazon Bedrock 端点相同的基础设施提供服务。如需原生 Messages API 请求格式和完整的功能 对等，请使用该页面。这些模型未列入本页的模型 表中，因为它们没有带 ARN 版本的模型 ID。

生命周期术语（Deprecated、Retired）的定义请参阅模型弃用。合作伙伴运营平台上的生命周期日期由合作伙伴设定，可能与 Claude API 的时间表不同。有关 Amazon Bedrock 上任何模型的当前停用日期，请参阅 Amazon Bedrock 的模型生命周期页面。

AWS 通过 “cross-region inference”（跨区域推理）而非按需吞吐量提供较新的 Claude 模型（请参阅跨区域推理）。对于这些模型，传递基础模型 ID 的请求会失败，并返回类似以下内容的 HTTP 400 错误：

Invocation of model ID anthropic.claude-sonnet-4-5-20250929-v1:0 with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model.

要调用这些模型，请传递推理配置文件（inference profile）而不是基础模型 ID。推理配置文件 ID 是在基础模型 ID 前加上下表中标记为“Yes”的列所对应的前缀，例如 us.anthropic.claude-sonnet-4-5-20250929-v1:0。您也可以传递完整的推理配置文件 ARN，格式为 arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}。有关 AWS 提供的可用推理配置文件的权威列表，请参阅推理配置文件支持的区域和模型。要了解这些前缀如何影响路由和定价，请参阅全局端点与区域端点部分。

Model	Base Bedrock model ID	global	us	eu	jp	apac
Claude Opus 4.6	anthropic.claude-opus-4-6-v1	Yes	Yes	Yes	Yes	Yes
Claude Opus 4.5	anthropic.claude-opus-4-5-20251101-v1:0	Yes	Yes	Yes	No	No
Claude Opus 4.1 (deprecated)	anthropic.claude-opus-4-1-20250805-v1:0	No	Yes	No	No	No
Claude Sonnet 4.6	anthropic.claude-sonnet-4-6	Yes	Yes	Yes	Yes	No
Claude Sonnet 4.5 (deprecated)	anthropic.claude-sonnet-4-5-20250929-v1:0	Yes	Yes	Yes	Yes	No
Claude Sonnet 4 (deprecated)	anthropic.claude-sonnet-4-20250514-v1:0	Yes	Yes	Yes	No	Yes
Claude Haiku 4.5	anthropic.claude-haiku-4-5-20251001-v1:0	Yes	Yes	Yes	No	No

列出可用模型

以下示例展示了如何打印通过 Bedrock 可用的所有 Claude 模型列表：

AWS CLI

aws bedrock list-foundation-models --region=us-west-2 --by-provider anthropic --query "modelSummaries[*].modelId"

Boto3 (Python)

import boto3

bedrock = boto3.client(service_name="bedrock")
response = bedrock.list_foundation_models(byProvider="anthropic")

for summary in response["modelSummaries"]:
    print(summary["modelId"])

TypeScript

import { BedrockClient, ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";

const client = new BedrockClient({ region: "us-west-2" });

const command = new ListFoundationModelsCommand({ byProvider: "anthropic" });
const response = await client.send(command);

if (response.modelSummaries) {
  for (const summary of response.modelSummaries) {
    console.log(summary.modelId);
  }
}

C#

using Amazon;
using Amazon.Bedrock;
using Amazon.Bedrock.Model;

var client = new AmazonBedrockClient(RegionEndpoint.USWest2);

var request = new ListFoundationModelsRequest
{
    ByProvider = "anthropic"
};

var response = await client.ListFoundationModelsAsync(request);

foreach (var summary in response.ModelSummaries)
{
    Console.WriteLine(summary.ModelId);
}

Go

import (
	"context"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/bedrock"
)
// ...
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
	if err != nil {
		log.Fatal(err)
	}

	client := bedrock.NewFromConfig(cfg)

	byProvider := "anthropic"
	response, err := client.ListFoundationModels(context.TODO(), &bedrock.ListFoundationModelsInput{
		ByProvider: &byProvider,
	})
	if err != nil {
		log.Fatal(err)
	}

	for _, summary := range response.ModelSummaries {
		fmt.Println(*summary.ModelId)
	}

Java

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrock.BedrockClient;
import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsRequest;
import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsResponse;
import software.amazon.awssdk.services.bedrock.model.FoundationModelSummary;

public class ListAnthropicModels {
    public static void main(String[] args) {
        BedrockClient client = BedrockClient.builder()
            .region(Region.US_WEST_2)
            .build();

        ListFoundationModelsRequest request = ListFoundationModelsRequest.builder()
            .byProvider("anthropic")
            .build();

        ListFoundationModelsResponse response = client.listFoundationModels(request);

        for (FoundationModelSummary summary : response.modelSummaries()) {
            System.out.println(summary.modelId());
        }

        client.close();
    }
}

PHP

<?php

use Aws\Bedrock\BedrockClient;

$client = new BedrockClient([
    'region' => 'us-west-2',
    'version' => 'latest'
]);

$result = $client->listFoundationModels([
    'byProvider' => 'anthropic'
]);

foreach ($result['modelSummaries'] as $summary) {
    echo $summary['modelId'] . PHP_EOL;
}

Ruby

require "aws-sdk-bedrock"

client = Aws::Bedrock::Client.new(region: "us-west-2")

response = client.list_foundation_models({
  by_provider: "anthropic"
})

response.model_summaries.each do |summary|
  puts summary.model_id
end

发送请求

以下示例展示了如何在 Bedrock 上使用 Claude 生成文本：

cURL

注意

使用 AWS 凭证调用 InvokeModel API 需要 SigV4 请求签名，其他选项卡中的 SDK 会自动处理这一点。如需可以使用独立 cURL 命令调用的 Bedrock 端点，请参阅 Claude in Amazon Bedrock。

CLI

注意

ant CLI 不支持 Amazon Bedrock。请改用其中一个 SDK 示例。

Python

from anthropic import AnthropicBedrock

client = AnthropicBedrock(
    # 可通过提供以下密钥进行身份验证，或使用默认的 AWS 凭证提供程序，例如
    # 使用 ~/.aws/credentials 或 "AWS_SECRET_ACCESS_KEY" 和 "AWS_ACCESS_KEY_ID" 环境变量。
    aws_access_key="<access key>",
    aws_secret_key="<secret key>",
    # 可通过 aws_session_token 使用临时凭证。
    # 详情请参阅 https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html。
    aws_session_token="<session_token>",
    # aws_region 用于更改请求发送到的 AWS 区域。如未提供，SDK 会读取
    # AWS_REGION / AWS_DEFAULT_REGION，然后读取您的 boto3 会话或 AWS 配置文件中配置的区域
    # （包括 ~/.aws/config），如果无法解析出区域，则抛出 ValueError。
    aws_region="us-west-2",
)

message = client.messages.create(
    model="global.anthropic.claude-opus-4-6-v1",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, world"}],
)
print(message.content)

TypeScript

import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

const client = new AnthropicBedrock({
  // 可通过提供以下密钥进行身份验证，或使用
  // 默认的 AWS 凭证提供程序，例如
  // ~/.aws/credentials 或 "AWS_SECRET_ACCESS_KEY" 和
  // "AWS_ACCESS_KEY_ID" 环境变量。
  awsAccessKey: "<access key>",
  awsSecretKey: "<secret key>",

  // 可通过 awsSessionToken 使用临时凭证。
  // 详情请参阅 https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html。
  awsSessionToken: "<session_token>",

  // awsRegion 用于更改请求发送到的
  // AWS 区域。默认情况下，SDK 读取 AWS_REGION，若
  // 该变量不存在，则默认为 us-east-1。请注意，
  // SDK 不会从 ~/.aws/config 读取区域。
  awsRegion: "us-west-2"
});

const message = await client.messages.create({
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello, world" }]
});
console.log(message);

C#

using Anthropic.Bedrock;
using Anthropic.Models.Messages;

AnthropicBedrockClient client = new(
    await AnthropicBedrockCredentialsHelper.FromEnv()
    ?? throw new InvalidOperationException("AWS credentials not configured.")
);

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "global.anthropic.claude-opus-4-6-v1",
    MaxTokens = 256,
    Messages = [new() { Role = Role.User, Content = "Hello, world" }],
});

Console.WriteLine(
    string.Join("", response.Content
        .Select(block => block.Value)
        .OfType<TextBlock>()
        .Select(textBlock => textBlock.Text)));

Go

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
)
// ...
	// 使用默认的 AWS 凭证提供程序链
	client := anthropic.NewClient(
		bedrock.WithLoadDefaultConfig(context.Background()),
	)

	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "global.anthropic.claude-opus-4-6-v1",
		MaxTokens: 256,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(message.Content)

Java

import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;

public class BedrockExample {

  public static void main(String[] args) {
    // 使用默认的 AWS 凭证提供程序链
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    Message message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("global.anthropic.claude-opus-4-6-v1")
          .maxTokens(256)
          .addUserMessage("Hello, world")
          .build()
      );

    System.out.println(message.content());
  }
}

PHP

<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::withCredentials(
    accessKeyId: getenv("AWS_ACCESS_KEY_ID"),
    secretAccessKey: getenv("AWS_SECRET_ACCESS_KEY"),
    region: 'us-west-2',
    securityToken: getenv("AWS_SESSION_TOKEN"),
);

$message = $client->messages->create(
    maxTokens: 256,
    messages: [
        ['role' => 'user', 'content' => 'Hello, world']
    ],
    model: 'global.anthropic.claude-opus-4-6-v1',
);
echo $message->content[0]->text;

Ruby

require "anthropic"

client = Anthropic::BedrockClient.new

message = client.messages.create(
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{role: "user", content: "Hello, world"}]
)

puts message.content.first.text

Boto3 (Python)

import boto3
import json

bedrock = boto3.client(service_name="bedrock-runtime")
body = json.dumps(
    {
        "max_tokens": 256,
        "messages": [{"role": "user", "content": "Hello, world"}],
        "anthropic_version": "bedrock-2023-05-31",
    }
)

response = bedrock.invoke_model(
    body=body, modelId="global.anthropic.claude-opus-4-6-v1"
)

response_body = json.loads(response.get("body").read())
print(response_body.get("content"))

更多详细信息请参阅客户端 SDK以及 Bedrock 官方文档。

Bearer 令牌身份验证

您可以使用 “bearer token”（Bearer 令牌）而不是 AWS 凭证向 Bedrock 进行身份验证。这在企业环境中非常有用，因为团队需要访问 Bedrock，但无需管理 AWS 凭证、IAM 角色或账户级权限。

最简单的方法是设置 AWS_BEARER_TOKEN_BEDROCK 环境变量，SDK 在从环境中解析凭证时会自动检测该变量。

要以编程方式提供令牌：

cURL

注意

本节展示如何在 SDK 客户端中配置 Bearer 令牌，SDK 客户端也会从 AWS_BEARER_TOKEN_BEDROCK 环境变量中读取令牌。要使用 Bearer 令牌直接发送 HTTP 请求，请参阅 Amazon Bedrock 文档。

CLI

注意

ant CLI 不支持 Amazon Bedrock。请改用其中一个 SDK 示例。

Python

from anthropic import AnthropicBedrock

client = AnthropicBedrock(
    api_key="your-bearer-token",
    aws_region="us-west-2",
)

message = client.messages.create(
    model="us.anthropic.claude-sonnet-4-5-20250929-v1:0",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)
print(message.content)

TypeScript

import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

const client = new AnthropicBedrock({
  apiKey: "your-bearer-token",
  awsRegion: "us-west-2"
});

const message = await client.messages.create({
  model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);

C#

using Anthropic.Bedrock;
using Anthropic.Models.Messages;

var client = new AnthropicBedrockClient(
    new AnthropicBedrockApiTokenCredentials
    {
        BearerToken = "your-bearer-token",
        Region = "us-west-2",
    }
);

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
    MaxTokens = 1024,
    Messages = [new() { Role = Role.User, Content = "Hello!" }],
});

Go

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
	"github.com/aws/aws-sdk-go-v2/aws"
)
// ...
	cfg := aws.Config{
		Region:                  "us-west-2",
		BearerAuthTokenProvider: bedrock.NewStaticBearerTokenProvider("your-bearer-token"),
	}
	client := anthropic.NewClient(
		bedrock.WithConfig(cfg),
	)

	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(message.Content[0].Text)

Java

import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 选项 1：设置 AWS_BEARER_TOKEN_BEDROCK 环境变量并使用 fromEnv()
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

// 选项 2：以编程方式提供令牌
client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.builder()
    .apiKey("your-bearer-token")
    .build())
  .build();

MessageCreateParams params = MessageCreateParams.builder()
  .model("us.anthropic.claude-sonnet-4-5-20250929-v1:0")
  .maxTokens(1024)
  .addUserMessage("Hello!")
  .build();

client.messages().create(params).content().stream()
  .flatMap(block -> block.text().stream())
  .forEach(textBlock -> System.out.println(textBlock.text()));

PHP

<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::withApiKey('your-bearer-token', 'us-west-2');

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Hello!']
    ],
    model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
);
echo $message->content[0]->text;

Ruby

require "anthropic"

client = Anthropic::BedrockClient.new(
  api_key: "your-bearer-token",
  aws_region: "us-west-2"
)

message = client.messages.create(
  model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello!"}]
)
puts message.content.first.text

活动日志记录

Bedrock 提供调用日志记录服务，允许您记录与您的使用相关的提示和补全内容。

Anthropic 建议您至少以 30 天滚动周期记录您的活动，以便了解您的活动并调查任何潜在的滥用行为。

注意

启用此服务不会让 AWS 或 Anthropic 访问您的任何内容。

功能支持

有关包含 Amazon Bedrock 可用性的完整功能列表，请参阅功能概览。

支持的主要功能

• Messages API
• 提示缓存
• 思考
• 工具使用，包括 Bash 工具、计算机使用工具、记忆工具和文本编辑器工具
• 引用
• 结构化输出

不支持的功能

• 输入源（图像和文档的 URL 源、Files API）
• 服务器端工具（代码执行、网络搜索、网页获取、advisor）
• 智能体基础设施（Agent Skills、MCP 连接器、程序化工具调用）
• API 端点（Message Batches、Models、Admin、Compliance、Usage and Cost）
• Claude Managed Agents
• 服务器端回退（fallbacks 参数；请改用客户端回退模式）
• 自动提示缓存（顶层 cache_control 字段；请改用显式缓存断点）
• 计算机使用和浏览器使用工具集（computer_toolset_20260801 和 browser_toolset_20260801 目前在 Amazon Bedrock 上不可用；beta 版计算机使用工具版本仍然可用）

Bedrock 上的 PDF 支持

在 Bedrock 上，可以通过 Converse API 和 InvokeModel API 使用 PDF 支持。

Bedrock 上的对话中系统消息

对话中系统消息可通过 InvokeModel API 用于 Claude Fable 5.1、Claude Fable 5、Claude Opus 5.5、Claude Opus 5、Claude Opus 4.8、Claude Sonnet 5.5 和 Claude Haiku 5.5。如 API 模型 ID 下的说明所述，这些请求由与 Claude in Amazon Bedrock 端点相同的基础设施提供服务。对话中系统消息不需要 beta 标头。此功能在 Claude Sonnet 5 上不可用，请改用顶层 system 字段。对于本页模型表中带 ARN 版本的模型，此功能也不可用。

在 Claude Fable 5.1 和 Claude Opus 5.5 上，role: "system" 消息还可以设置 output_config.effort 以在对话中更改 effort。此功能处于 beta 阶段：请将 mid-conversation-output-config-2026-07-01 添加到请求体中的 anthropic_beta 数组。如果没有该值，或者在 Claude Fable 5、Claude Opus 5 或 Claude Opus 4.8 上，请求会返回 400 错误：messages.N.output_config: Extra inputs are not permitted。在该错误中，N 是 system 消息在 messages 中的索引。

对于 Converse API 用户： Converse API 通过其顶层 system 参数接受系统指令。要在对话中添加系统指令，请使用 InvokeModel API。

上下文窗口

Claude Fable 5.1、Claude Fable 5、Claude Opus 5.5、Claude Opus 5、Claude Opus 4.8、Claude Opus 4.7、Claude Opus 4.6、Claude Sonnet 5.5、Claude Sonnet 5、Claude Sonnet 4.6 和 Claude Haiku 5.5 在 Amazon Bedrock 上具有 1M 令牌的 “context window”（上下文窗口）。其他 Claude 模型，包括 Sonnet 4.5（已弃用）和 Sonnet 4（已弃用），具有 200k 令牌的上下文窗口。

Bedrock 将请求负载限制为 20 MB。发送大型文档或大量图像时，您可能会在达到令牌限制之前先达到此限制。

全局端点与区域端点

从 Claude Sonnet 4.5 及所有未来模型开始，Bedrock 提供两种端点类型：

• 全局端点： 动态路由以实现最大可用性
• 区域端点： 保证数据通过特定地理区域路由

区域端点的价格比全局端点高 10%。

注意

这仅适用于 Claude Sonnet 4.5（已弃用）及未来模型。较旧的模型（Claude Sonnet 4（已弃用）及更早版本）保持其现有的定价结构。

何时使用每种选项

全局端点（推荐）：

• 提供最大的可用性和正常运行时间
• 将请求动态路由到有可用容量的区域
• 无价格溢价
• 最适合数据驻留要求灵活的应用程序

区域端点（CRIS）：

• 通过特定地理区域路由流量
• 满足数据驻留和合规要求时必需
• 适用于美国、欧盟、日本和亚太地区
• 10% 的价格溢价反映了专用区域容量的基础设施成本

实现

使用全局端点（Opus 4.6、Sonnet 4.6 和 Sonnet 4.5（已弃用）的默认设置）：

Claude Opus 4.6、Sonnet 4.6 和 Sonnet 4.5（已弃用）的模型 ID 已包含 global. 前缀：

cURL

注意

使用 AWS 凭证调用 InvokeModel API 需要 SigV4 请求签名，其他选项卡中的 SDK 会自动处理这一点。如需可以使用独立 cURL 命令调用的 Bedrock 端点，请参阅 Claude in Amazon Bedrock。

CLI

注意

ant CLI 不支持 Amazon Bedrock。请改用其中一个 SDK 示例。

Python

from anthropic import AnthropicBedrock

client = AnthropicBedrock(aws_region="us-west-2")

message = client.messages.create(
    model="global.anthropic.claude-opus-4-6-v1",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, world"}],
)

TypeScript

import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

const client = new AnthropicBedrock({
  awsRegion: "us-west-2"
});

const message = await client.messages.create({
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello, world" }]
});

C#

using Anthropic.Bedrock;
using Anthropic.Models.Messages;

// C# Bedrock 客户端使用带区域前缀的模型 ID 进行全局路由
AnthropicBedrockClient client = new(
    await AnthropicBedrockCredentialsHelper.FromEnv()
    ?? throw new InvalidOperationException("AWS credentials not configured.")
);

var response = await client.Messages.Create(new MessageCreateParams
{
    // 使用 "global." 前缀进行全局跨区域推理
    Model = "global.anthropic.claude-opus-4-6-v1",
    MaxTokens = 256,
    Messages = [new() { Role = Role.User, Content = "Hello, world" }],
});

Go

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
)
// ...
	// 使用默认的 AWS 凭证提供程序链
	client := anthropic.NewClient(
		bedrock.WithLoadDefaultConfig(context.Background()),
	)

	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "global.anthropic.claude-opus-4-6-v1",
		MaxTokens: 256,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
		},
	})

Java

import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 使用默认的 AWS 凭证提供程序链
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

var message = client
  .messages()
  .create(
    MessageCreateParams.builder()
      .model("global.anthropic.claude-opus-4-6-v1")
      .maxTokens(256)
      .addUserMessage("Hello, world")
      .build()
  );

PHP

<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::fromEnvironment();

$message = $client->messages->create(
    maxTokens: 256,
    messages: [
        ['role' => 'user', 'content' => 'Hello, world']
    ],
    model: 'global.anthropic.claude-opus-4-6-v1',
);

Ruby

require "anthropic"

# 默认凭证从 AWS_REGION 环境变量解析区域
client = Anthropic::BedrockClient.new

message = client.messages.create(
  # 使用 "global." 前缀进行全局跨区域推理
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{role: "user", content: "Hello, world"}]
)

使用区域端点（CRIS）：

要使用区域端点，请将 global. 前缀替换为区域前缀，例如 us.：

cURL

注意

使用 AWS 凭证调用 InvokeModel API 需要 SigV4 请求签名，其他选项卡中的 SDK 会自动处理这一点。如需可以使用独立 cURL 命令调用的 Bedrock 端点，请参阅 Claude in Amazon Bedrock。

CLI

注意

ant CLI 不支持 Amazon Bedrock。请改用其中一个 SDK 示例。

Python

from anthropic import AnthropicBedrock

client = AnthropicBedrock(aws_region="us-west-2")

# 使用美国区域端点（CRIS）
message = client.messages.create(
    model="us.anthropic.claude-opus-4-6-v1",  # Regional prefix
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, world"}],
)

TypeScript

import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

const client = new AnthropicBedrock({
  awsRegion: "us-west-2"
});

// 使用美国区域端点（CRIS）
const message = await client.messages.create({
  model: "us.anthropic.claude-opus-4-6-v1", // Regional prefix
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello, world" }]
});

C#

using Anthropic.Bedrock;
using Anthropic.Models.Messages;

AnthropicBedrockClient client = new(
    new AnthropicBedrockPrivateKeyCredentials { Region = "us-west-2" }
);

// 使用美国区域端点（CRIS）
var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "us.anthropic.claude-opus-4-6-v1", // Regional prefix
    MaxTokens = 256,
    Messages = [new() { Role = Role.User, Content = "Hello, world" }],
});

Go

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
)
// ...
	// 使用默认的 AWS 凭证提供程序链
	client := anthropic.NewClient(
		bedrock.WithLoadDefaultConfig(context.Background()),
	)

	// 使用美国区域端点（CRIS）
	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "us.anthropic.claude-opus-4-6-v1", // Regional prefix
		MaxTokens: 256,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
		},
	})

Java

import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 使用默认的 AWS 凭证提供程序链
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

// 使用美国区域端点（CRIS）
var message = client
  .messages()
  .create(
    MessageCreateParams.builder()
      .model("us.anthropic.claude-opus-4-6-v1") // Regional prefix
      .maxTokens(256)
      .addUserMessage("Hello, world")
      .build()
  );

PHP

<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::fromEnvironment();

$message = $client->messages->create(
    maxTokens: 256,
    messages: [
        ['role' => 'user', 'content' => 'Hello, world']
    ],
    model: 'us.anthropic.claude-opus-4-6-v1',
);

Ruby

require "anthropic"

# 使用美国区域端点（CRIS）
client = Anthropic::BedrockClient.new(aws_region: "us-west-2")

message = client.messages.create(
  model: "us.anthropic.claude-opus-4-6-v1", # Regional prefix
  max_tokens: 256,
  messages: [{role: "user", content: "Hello, world"}]
)

注意

Claude Mythos Preview 是一款研究预览模型，面向 Amazon Bedrock 上受邀的客户提供。有关更多信息，请参阅 Project Glasswing。

其他资源

• Bedrock 定价： Amazon Bedrock 定价页面
• AWS 定价文档： Bedrock 定价指南
• AWS 博客文章： 在 Amazon Bedrock 中推出 Claude Sonnet 4.5
• Anthropic 定价详情： 云平台定价