---
title: Amazon Bedrock 上的 Claude（Opus 4.6 及更早版本）
url: https://platform.claude.com/docs/zh-TW/build-with-claude/claude-on-amazon-bedrock-legacy
description: Claude 模型的舊版 Amazon Bedrock 整合，使用 InvokeModel 與 Converse API 搭配 ARN 版本化的模型識別碼。
---

<Note>
  本頁涵蓋舊版 Amazon Bedrock 整合：使用 ARN 版本化模型識別碼與 AWS event-stream 編碼的 `InvokeModel` 與 `Converse` API。若要了解 Messages-API Bedrock 端點上可用的模型，請參閱 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock)，該端點在 `/anthropic/v1/messages` 使用 Messages API 並採用 SSE 串流。若需要由 Anthropic 營運、透過 AWS Marketplace 計費且通常可於當日取得新功能的替代方案，請參閱 [Claude Platform on AWS](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-platform-on-aws)。現有的 Bedrock 使用者可依照[遷移指南](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock)進行遷移。
</Note>

透過 Bedrock 呼叫 Claude 與直接在 Claude API 上呼叫 Claude 的方式略有不同。本指南將引導您使用 Anthropic 的其中一個[用戶端 SDK](https://platform.claude.com/docs/zh-TW/cli-sdks-libraries/overview)，完成對 Bedrock 上 Claude 的 API 呼叫。

請注意，本指南假設您已註冊 [AWS 帳戶](https://portal.aws.amazon.com/billing/signup)並已設定程式化存取。

## 安裝並設定 AWS CLI

1. [安裝 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)，版本需為 `2.13.23` 或更新版本。
2. 使用 AWS configure 指令設定您的 AWS 憑證（請參閱[設定 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)），或在 AWS 儀表板中前往「Command line or programmatic access」，並依照彈出視窗中的指示找到您的憑證。
3. 驗證您的憑證是否正常運作：

```bash AWS CLI
aws sts get-caller-identity
```

## 安裝用於存取 Bedrock 的 SDK

Anthropic 的[用戶端 SDK](https://platform.claude.com/docs/zh-TW/cli-sdks-libraries/overview) 支援 Bedrock。您也可以直接使用 AWS SDK，例如 `boto3`。

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

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

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

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

  <Tab title="Java">
    <CodeGroup>
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:2.73.0")
      implementation("com.anthropic:anthropic-java-bedrock: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-bedrock</artifactId>
          <version>2.73.0</version>
      </dependency>
      ```

      ```java 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()));
          }
      }
      ```
    </CodeGroup>
  </Tab>

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

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "aws-sdk-bedrockruntime"
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```bash
    pip install "boto3>=1.28.59"
    ```
  </Tab>
</Tabs>

## 存取 Bedrock

### 訂閱 Anthropic 模型

前往 [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) 並申請存取 Anthropic 模型。請注意，Anthropic 模型的可用性因區域而異。請參閱 [AWS 文件](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)以取得最新資訊。

#### API 模型 ID

<Note>
  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` 存取。 這些請求由與 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock) 端點相同的基礎架構提供服務。如需原生 Messages API 請求格式和完整的功能 對等性，請使用該頁面。這些模型未列於本頁的模型 表格中，因為它們沒有以 ARN 版本化的模型 ID。
</Note>

生命週期術語（Deprecated、Retired）的定義請參閱[模型棄用](https://platform.claude.com/docs/zh-TW/about-claude/model-deprecations)。合作夥伴營運平台上的生命週期日期由合作夥伴設定，可能與 Claude API 的時程不同。如需 Amazon Bedrock 上任何模型目前的停用日期，請參閱 [Amazon Bedrock 的模型生命週期頁面](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html)。

AWS 透過「[cross-region inference](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)」（跨區域推論）而非隨需輸送量提供較新的 Claude 模型。對於這些模型，傳入基礎模型 ID 的請求會失敗，並傳回類似以下的 HTTP 400 錯誤：

```text wrap
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 前加上下表中標示為「是」之欄位的前綴，例如 us.anthropic.claude-sonnet-4-5-20250929-v1:0。您也可以傳入完整的推論設定檔 ARN，格式為 `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`。如需 AWS 官方提供的可用推論設定檔清單，請參閱[推論設定檔支援的區域和模型](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html)。若要了解前綴如何影響路由和定價，請參閱[全球端點與區域端點](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-on-amazon-bedrock-legacy#global-vs-regional-endpoints)一節。

| 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](https://platform.claude.com/docs/zh-TW/about-claude/model-deprecations))   | `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](https://platform.claude.com/docs/zh-TW/about-claude/model-deprecations)) | `anthropic.claude-sonnet-4-5-20250929-v1:0` | Yes      | Yes  | Yes  | Yes  | No     |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/zh-TW/about-claude/model-deprecations))   | `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 模型清單：

<CodeGroup>
  ```bash AWS CLI
  aws bedrock list-foundation-models --region=us-west-2 --by-provider anthropic --query "modelSummaries[*].modelId"
  ```

  ```python 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 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);
    }
  }
  ```

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

### 發送請求

以下範例示範如何在 Bedrock 上使用 Claude 生成文字：

<Tabs>
  <Tab title="cURL">
    <Note>
      使用 AWS 憑證呼叫 `InvokeModel` API 需要 SigV4 請求簽署，其他分頁中的 SDK 會自動處理此步驟。若需要可透過獨立 cURL 指令呼叫的 Bedrock 端點，請參閱 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock#making-your-first-request)。
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      `ant` CLI 不支援 Amazon Bedrock。請改用其中一個 SDK 範例。
    </Note>
  </Tab>

  <Tab title="Python">
    ```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)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```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);
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    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)));
    ```
  </Tab>

  <Tab title="Go">
    ```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)
    ```
  </Tab>

  <Tab title="Java">
    ```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());
      }
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```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;
    ```
  </Tab>

  <Tab title="Ruby">
    ```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
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```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"))
    ```
  </Tab>
</Tabs>

請參閱[用戶端 SDK](https://platform.claude.com/docs/zh-TW/cli-sdks-libraries/overview) 以取得更多詳細資訊，以及[官方 Bedrock 文件](https://docs.aws.amazon.com/bedrock/)。

### Bearer token 驗證

您可以使用「bearer token」（持有者權杖）而非 AWS 憑證向 Bedrock 進行驗證。這在企業環境中很有用，因為團隊需要存取 Bedrock，但不必管理 AWS 憑證、IAM 角色或帳戶層級的權限。

最簡單的方法是設定 `AWS_BEARER_TOKEN_BEDROCK` 環境變數，SDK 在從環境解析憑證時會自動偵測此變數。

若要以程式化方式提供權杖：

<Tabs>
  <Tab title="cURL">
    <Note>
      本節展示如何在 SDK 用戶端中設定 bearer token，SDK 用戶端也會從 `AWS_BEARER_TOKEN_BEDROCK` 環境變數讀取權杖。若要使用 bearer token 直接發送 HTTP 請求，請參閱 [Amazon Bedrock 文件](https://docs.aws.amazon.com/bedrock/)。
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      `ant` CLI 不支援 Amazon Bedrock。請改用其中一個 SDK 範例。
    </Note>
  </Tab>

  <Tab title="Python">
    ```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)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```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);
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    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!" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```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)
    ```
  </Tab>

  <Tab title="Java">
    ```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()));
    ```
  </Tab>

  <Tab title="PHP">
    ```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;
    ```
  </Tab>

  <Tab title="Ruby">
    ```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
    ```
  </Tab>
</Tabs>

## 活動記錄

Bedrock 提供[呼叫記錄服務](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html)，讓您記錄與使用量相關的提示與完成內容。

Anthropic 建議您至少以 30 天滾動方式記錄您的活動，以便了解您的活動並調查任何潛在的濫用情形。

<Note>
  啟用此服務不會讓 AWS 或 Anthropic 取得您內容的任何存取權。
</Note>

## 功能支援

若要查看包含 Amazon Bedrock 可用性的完整功能清單，請參閱[功能總覽](https://platform.claude.com/docs/zh-TW/build-with-claude/overview)。

### 支援的功能重點

* [Messages API](https://platform.claude.com/docs/zh-TW/api/messages/create)
* [提示快取](https://platform.claude.com/docs/zh-TW/build-with-claude/prompt-caching)
* [思考](https://platform.claude.com/docs/zh-TW/build-with-claude/thinking)
* [工具使用](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/overview)，包括 [Bash 工具](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/bash-tool)、[電腦使用工具](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/computer-use-tool)、[記憶工具](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/memory-tool)與[文字編輯器工具](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/text-editor-tool)
* [引用](https://platform.claude.com/docs/zh-TW/build-with-claude/citations)
* [結構化輸出](https://platform.claude.com/docs/zh-TW/build-with-claude/structured-outputs)，適用於其[相容性](https://platform.claude.com/docs/zh-TW/build-with-claude/structured-outputs#compatibility)一節中 Amazon Bedrock 註記所列的模型

### 不支援的功能

* 輸入來源（圖片與文件的 URL 來源、Files API）
* 伺服器端工具（程式碼執行、網頁搜尋、網頁擷取、advisor）
* 代理基礎設施（Agent Skills、MCP 連接器、程式化工具呼叫）
* API 端點（Message Batches、Models、Admin、Compliance、Usage and Cost）
* Claude Managed Agents
* 伺服器端備援（[`fallbacks` 參數](https://platform.claude.com/docs/zh-TW/build-with-claude/refusals-and-fallback#server-side-fallback)；請改用[用戶端備援模式](https://platform.claude.com/docs/zh-TW/build-with-claude/refusals-and-fallback#client-side-fallback)）
* 自動提示快取（[頂層 `cache_control` 欄位](https://platform.claude.com/docs/zh-TW/build-with-claude/prompt-caching#automatic-caching)；請改用[明確快取斷點](https://platform.claude.com/docs/zh-TW/build-with-claude/prompt-caching#explicit-cache-breakpoints)）
* [電腦使用](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/computer-use-tool)與[瀏覽器使用](https://platform.claude.com/docs/zh-TW/agents-and-tools/tool-use/browser-use-tool)工具集（`computer_toolset_20260801` 與 `browser_toolset_20260801` 目前在 Amazon Bedrock 上不可用；beta 版電腦使用工具版本仍可使用）

### Bedrock 上的 PDF 支援

Bedrock 透過 Converse API 與 InvokeModel API 皆提供 PDF 支援。若要了解 PDF 處理能力與限制的詳細資訊，請參閱 [Amazon Bedrock PDF 支援](https://platform.claude.com/docs/zh-TW/build-with-claude/pdf-support#amazon-bedrock-pdf-support)。

**Converse API 使用者的重要注意事項：**

* 視覺化 PDF 分析（圖表、圖片、版面配置）需要啟用引用功能
* 若未啟用引用，僅提供基本文字擷取
* 若需要完整控制且不強制使用引用，請使用 InvokeModel API

### Bedrock 上的對話中途系統訊息

[對話中途系統訊息](https://platform.claude.com/docs/zh-TW/build-with-claude/mid-conversation-system-messages)可透過 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](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids) 下的註記所述，這些請求由與 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock) 端點相同的基礎架構提供服務。對話中途系統訊息不需要 beta 標頭。此功能在 Claude Sonnet 5 上無法使用，請改用頂層 `system` 欄位。本頁模型表格中以 ARN 版本化的模型也無法使用此功能。

在 Claude Fable 5.1 和 Claude Opus 5.5 上，`role: "system"` 訊息也可以設定 `output_config.effort` 以[在對話中變更 effort](https://platform.claude.com/docs/zh-TW/build-with-claude/effort#change-effort-mid-conversation-beta)。此功能目前為 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` 參數](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)接受系統指示。若要在對話中加入系統指示，請使用 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 token 的上下文視窗](https://platform.claude.com/docs/zh-TW/build-with-claude/context-windows)。其他 Claude 模型，包括 Sonnet 4.5（已棄用）和 Sonnet 4（已棄用），具有 200k token 的上下文視窗。

Bedrock 將請求酬載限制為 20 MB。傳送大型文件或大量圖片時，您可能會在達到 token 限制之前先達到此限制。

## 全球端點與區域端點

從 **Claude Sonnet 4.5 及所有未來模型**開始，Bedrock 提供兩種端點類型：

* **全球端點：** 動態路由以獲得最大可用性
* **區域端點：** 保證資料透過特定地理區域路由

區域端點的定價比全球端點高出 10%。

<Note>
  這僅適用於 Claude Sonnet 4.5（已棄用）及未來模型。較舊的模型（Claude Sonnet 4（已棄用）及更早版本）維持其現有的定價結構。
</Note>

### 何時使用各選項

**全球端點（建議）：**

* 提供最高的可用性與正常運作時間
* 動態將請求路由至有可用容量的區域
* 無額外定價
* 最適合資料落地要求較彈性的應用程式

**區域端點（CRIS）：**

* 經由特定地理區域路由流量
* 資料落地與合規要求所必需
* 適用於美國、歐盟、日本與亞太地區
* 10% 的額外定價反映專用區域容量的基礎設施成本

### 實作

**使用全球端點（Opus 4.6、Sonnet 4.6 和 Sonnet 4.5（已棄用）的預設值）：**

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

<Tabs>
  <Tab title="cURL">
    <Note>
      使用 AWS 憑證呼叫 `InvokeModel` API 需要 SigV4 請求簽署，其他分頁中的 SDK 會自動處理此步驟。如需可使用獨立 cURL 命令呼叫的 Bedrock 端點，請參閱 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock#making-your-first-request)。
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      `ant` CLI 不支援 Amazon Bedrock。請改用其中一個 SDK 範例。
    </Note>
  </Tab>

  <Tab title="Python">
    ```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"}],
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```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" }]
    });
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    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" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```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")),
    		},
    	})
    ```
  </Tab>

  <Tab title="Java">
    ```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()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```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',
    );
    ```
  </Tab>

  <Tab title="Ruby">
    ```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"}]
    )
    ```
  </Tab>
</Tabs>

**使用區域端點（CRIS）：**

若要使用區域端點，請將 `global.` 前綴替換為區域前綴，例如 `us.`：

<Tabs>
  <Tab title="cURL">
    <Note>
      使用 AWS 憑證呼叫 `InvokeModel` API 需要 SigV4 請求簽署，其他分頁中的 SDK 會自動處理此步驟。如需可使用獨立 cURL 命令呼叫的 Bedrock 端點，請參閱 [Amazon Bedrock 中的 Claude](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-amazon-bedrock#making-your-first-request)。
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      `ant` CLI 不支援 Amazon Bedrock。請改用其中一個 SDK 範例。
    </Note>
  </Tab>

  <Tab title="Python">
    ```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"}],
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```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" }]
    });
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    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" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```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")),
    		},
    	})
    ```
  </Tab>

  <Tab title="Java">
    ```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()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```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',
    );
    ```
  </Tab>

  <Tab title="Ruby">
    ```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"}]
    )
    ```
  </Tab>
</Tabs>

<Note>
  **Claude Mythos Preview** 是一個研究預覽模型，僅供受邀客戶在 Amazon Bedrock 上使用。如需更多資訊，請參閱 [Project Glasswing](https://anthropic.com/glasswing)。
</Note>

## 其他資源

* **Bedrock 定價：** [Amazon Bedrock 定價頁面](https://aws.amazon.com/bedrock/pricing/)
* **AWS 定價文件：** [Bedrock 定價指南](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **AWS 部落格文章：** [Introducing Claude Sonnet 4.5 in Amazon Bedrock](https://aws.amazon.com/blogs/aws/introducing-claude-sonnet-4-5-in-amazon-bedrock-anthropics-most-intelligent-model-best-for-coding-and-complex-agents/)
* **Anthropic 定價詳情：** [雲端平台定價](https://platform.claude.com/docs/zh-TW/about-claude/pricing#cloud-platform-pricing)