---
title: Amazon Bedrock上のClaude（Opus 4.6以前）
url: https://platform.claude.com/docs/ja/build-with-claude/claude-on-amazon-bedrock-legacy
description: ARNバージョン付きモデル識別子を用いたInvokeModelおよびConverse APIを使用する、Claudeモデル向けのレガシーAmazon Bedrock統合。
---

<Note>
  このページでは、レガシーのAmazon Bedrock統合について説明します。これは、ARNバージョン付きモデル識別子とAWSイベントストリームエンコーディングを使用する`InvokeModel`および`Converse` APIです。Messages-API Bedrockエンドポイントで利用可能なモデルについては、[Claude in Amazon Bedrock](https://platform.claude.com/docs/ja/build-with-claude/claude-in-amazon-bedrock)を参照してください。こちらは`/anthropic/v1/messages`でMessages APIをSSEストリーミングとともに使用します。AWS Marketplace課金に対応し、通常は同日中に機能へアクセスできるAnthropic運営の代替手段については、[Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)を参照してください。既存のBedrockユーザーは[移行ガイド](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock)に従うことができます。
</Note>

Bedrockを通じてClaudeを呼び出す方法は、Claude APIで直接Claudeを呼び出す方法とは若干異なります。このガイドでは、Anthropicの[クライアントSDK](https://platform.claude.com/docs/ja/cli-sdks-libraries/overview)のいずれかを使用して、Bedrock上のClaudeへのAPI呼び出しを完了する手順を説明します。

なお、このガイドは、すでに[AWSアカウント](https://portal.aws.amazon.com/billing/signup)にサインアップし、プログラムによるアクセスを設定済みであることを前提としています。

## AWS CLIのインストールと設定

1. バージョン`2.13.23`以降の[AWS CLIをインストール](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)します。
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/ja/cli-sdks-libraries/overview)はBedrockをサポートしています。`boto3`のようなAWS SDKを直接使用することもできます。

<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/ja/build-with-claude/claude-in-amazon-bedrock) エンドポイントと同じインフラストラクチャで処理されます。ネイティブのMessages APIリクエスト形式と完全な機能の 同等性が必要な場合は、そちらのページを使用してください。これらのモデルはARNでバージョン管理されたモデルIDを持たないため、このページのモデル テーブルには記載されていません。
</Note>

ライフサイクル用語（非推奨、廃止済み）は[モデルの非推奨化](https://platform.claude.com/docs/ja/about-claude/model-deprecations)で定義されています。パートナーが運営するプラットフォームでのライフサイクル日程はパートナーによって設定され、Claude APIのスケジュールとは異なる場合があります。Amazon Bedrock上の各モデルの現在の廃止日については、[Amazon Bedrockのモデルライフサイクルページ](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html)を参照してください。

AWSは、新しいClaudeモデルをオンデマンドスループットではなく、[「cross-region inference」（クロスリージョン推論）](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)を通じて提供しています。これらのモデルでは、ベースモデル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.
```

これらのモデルを呼び出すには、ベースモデルIDの代わりに「inference profile」（推論プロファイル）を渡します。推論プロファイルIDは、ベースモデルIDに次の表で「Yes」とマークされた列のプレフィックスを付けたものです。例：us.anthropic.claude-sonnet-4-5-20250929-v1:0。`arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`の形式で、完全な推論プロファイルARNを渡すこともできます。利用可能な推論プロファイルに関するAWSの公式リストについては、[推論プロファイルでサポートされているリージョンとモデル](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html)を参照してください。プレフィックスがルーティングと料金にどのように影響するかについては、[グローバルエンドポイントとリージョナルエンドポイント](https://platform.claude.com/docs/ja/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/ja/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/ja/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/ja/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エンドポイントについては、[Claude in Amazon Bedrock](https://platform.claude.com/docs/ja/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/ja/cli-sdks-libraries/overview)および[Bedrock公式ドキュメント](https://docs.aws.amazon.com/bedrock/)を参照してください。

### ベアラートークン認証

AWS認証情報の代わりに「bearer token」（ベアラートークン）を使用してBedrockで認証できます。これは、AWS認証情報、IAMロール、またはアカウントレベルの権限を管理せずにチームがBedrockにアクセスする必要がある企業環境で役立ちます。

最も簡単な方法は、`AWS_BEARER_TOKEN_BEDROCK`環境変数を設定することです。SDKは環境から認証情報を解決する際に、この変数を自動的に検出します。

プログラムでトークンを指定するには：

<Tabs>
  <Tab title="cURL">
    <Note>
      このセクションでは、SDKクライアントでベアラートークンを設定する方法を示します。SDKクライアントは`AWS_BEARER_TOKEN_BEDROCK`環境変数からもトークンを読み取ります。ベアラートークンを使用して直接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/ja/build-with-claude/overview)を参照してください。

### サポートされている主な機能

* [Messages API](https://platform.claude.com/docs/ja/api/messages/create)
* [プロンプトキャッシング](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching)
* [思考](https://platform.claude.com/docs/ja/build-with-claude/thinking)
* [ツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)（[Bashツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/bash-tool)、[コンピュータ使用ツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/computer-use-tool)、[メモリツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/memory-tool)、[テキストエディタツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/text-editor-tool)を含む）
* [引用](https://platform.claude.com/docs/ja/build-with-claude/citations)
* [構造化出力](https://platform.claude.com/docs/ja/build-with-claude/structured-outputs)（その[互換性](https://platform.claude.com/docs/ja/build-with-claude/structured-outputs#compatibility)セクションにあるAmazon Bedrockに関する注記に記載されたモデルが対象）

### サポートされていない機能

* 入力ソース（画像およびドキュメントのURLソース、Files API）
* サーバーサイドツール（コード実行、ウェブ検索、ウェブフェッチ、アドバイザー）
* エージェントインフラストラクチャ（Agent Skills、MCPコネクタ、プログラムによるツール呼び出し）
* APIエンドポイント（Message Batches、Models、Admin、Compliance、Usage and Cost）
* Claude Managed Agents
* サーバーサイドフォールバック（[`fallbacks`パラメータ](https://platform.claude.com/docs/ja/build-with-claude/refusals-and-fallback#server-side-fallback)。代わりに[クライアントサイドフォールバックパターン](https://platform.claude.com/docs/ja/build-with-claude/refusals-and-fallback#client-side-fallback)を使用してください）
* 自動プロンプトキャッシング（[トップレベルの`cache_control`フィールド](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching#automatic-caching)。代わりに[明示的なキャッシュブレークポイント](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching#explicit-cache-breakpoints)を使用してください）
* [コンピュータ使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/computer-use-tool)および[ブラウザ使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/browser-use-tool)ツールセット（`computer_toolset_20260801`および`browser_toolset_20260801`は現在Amazon Bedrockでは利用できません。ベータ版のコンピュータ使用ツールバージョンは引き続き利用可能です）

### BedrockでのPDFサポート

PDFサポートは、Converse APIとInvokeModel APIの両方を通じてBedrockで利用できます。PDF処理機能と制限の詳細については、[Amazon Bedrock PDFサポート](https://platform.claude.com/docs/ja/build-with-claude/pdf-support#amazon-bedrock-pdf-support)を参照してください。

**Converse APIユーザー向けの重要な考慮事項：**

* 視覚的なPDF分析（チャート、画像、レイアウト）には引用を有効にする必要があります
* 引用がない場合、基本的なテキスト抽出のみが利用可能です
* 強制的な引用なしで完全に制御するには、InvokeModel APIを使用してください

### Bedrockでの会話途中のシステムメッセージ

[会話途中のシステムメッセージ](https://platform.claude.com/docs/ja/build-with-claude/mid-conversation-system-messages)は、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でInvokeModel APIを通じて利用できます。[APIモデルID](https://platform.claude.com/docs/ja/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids)の注記で説明したように、これらのリクエストは[Amazon Bedrock上のClaude](https://platform.claude.com/docs/ja/build-with-claude/claude-in-amazon-bedrock)エンドポイントと同じインフラストラクチャで処理されます。会話途中のシステムメッセージにベータヘッダーは必要ありません。この機能はClaude Sonnet 5では利用できません。代わりにトップレベルの`system`フィールドを使用してください。また、このページのモデルテーブルにあるARNでバージョン管理されたモデルでも利用できません。

`role: "system"`メッセージでは、Claude Fable 5.1およびClaude Opus 5.5において、`output_config.effort`を設定して[会話途中でeffortを変更](https://platform.claude.com/docs/ja/build-with-claude/effort#change-effort-mid-conversation-beta)することもできます。これはベータ版です。リクエストボディの`anthropic_beta`配列に`mid-conversation-output-config-2026-07-01`を追加してください。この値がない場合、またはClaude Fable 5、Claude Opus 5、Claude Opus 4.8では、リクエストは400エラー`messages.N.output_config: Extra inputs are not permitted`を返します。エラー内の`N`は、`messages`内の`system`メッセージのインデックスです。

**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で[100万トークンの「context window」（コンテキストウィンドウ）](https://platform.claude.com/docs/ja/build-with-claude/context-windows)を備えています。Sonnet 4.5（非推奨）やSonnet 4（非推奨）を含むその他のClaudeモデルのコンテキストウィンドウは20万トークンです。

Bedrockはリクエストペイロードを20 MBに制限しています。大きなドキュメントや多数の画像を送信する場合、トークン制限より先にこの制限に達する可能性があります。

## グローバルエンドポイントとリージョナルエンドポイント

**Claude Sonnet 4.5以降のすべてのモデル**から、Bedrockは2種類のエンドポイントを提供しています：

* **グローバルエンドポイント：** 最大限の可用性を実現する動的ルーティング
* **リージョナルエンドポイント：** 特定の地理的リージョンを経由することが保証されたデータルーティング

リージョナルエンドポイントには、グローバルエンドポイントに対して10%の価格プレミアムが含まれます。

<Note>
  これはClaude Sonnet 4.5（非推奨）および今後のモデルにのみ適用されます。古いモデル（Claude Sonnet 4（非推奨）以前）は既存の料金体系を維持します。
</Note>

### 各オプションを使用する場面

**グローバルエンドポイント（推奨）：**

* 最大限の可用性と稼働時間を提供
* 利用可能なキャパシティのあるリージョンにリクエストを動的にルーティング
* 料金プレミアムなし
* データレジデンシーに柔軟性があるアプリケーションに最適

**リージョナルエンドポイント（CRIS）：**

* 特定の地理的リージョンを経由してトラフィックをルーティング
* データレジデンシーおよびコンプライアンス要件に必要
* 米国、EU、日本、アジア太平洋で利用可能
* 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/ja/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/ja/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")

    # US リージョンエンドポイント (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"
    });

    // US リージョナルエンドポイント (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" }
    );

    // US リージョンエンドポイント (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()),
    	)

    	// US リージョンエンドポイント（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();

    // US リージョンエンドポイント（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"

    # US リージョンエンドポイント (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ブログ記事：** [Amazon BedrockでのClaude Sonnet 4.5の紹介](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/ja/about-claude/pricing#cloud-platform-pricing)