---
title: Claude auf Amazon Bedrock (Opus 4.6 und früher)
url: https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy
description: Die veraltete Amazon Bedrock-Integration für Claude-Modelle, die die InvokeModel- und Converse-APIs mit ARN-versionierten Modellkennungen verwendet.
---

<Note>
  Diese Seite behandelt die veraltete Amazon Bedrock-Integration: die `InvokeModel`- und `Converse`-APIs mit ARN-versionierten Modellkennungen und AWS-Event-Stream-Kodierung. Für Modelle, die über den Messages-API-Bedrock-Endpunkt verfügbar sind, siehe [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock), das die Messages API unter `/anthropic/v1/messages` mit SSE-Streaming verwendet. Für eine von Anthropic betriebene Alternative mit Abrechnung über AWS Marketplace und in der Regel Zugriff auf neue Funktionen noch am selben Tag siehe [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws). Bestehende Bedrock-Nutzer können dem [Migrationsleitfaden](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock) folgen.
</Note>

<Warning>
  Die neueste Version des SDK sendet standardmäßig die API-Version `2026-10-21`, auch über Amazon Bedrock. Die ARN-versionierten Modelle in der Modelltabelle auf dieser Seite unterstützen `2026-10-21` auf Bedrock nicht, und Anfragen an sie, die diese Version senden, können einen 400-Fehler zurückgeben. Wenn du sie über das SDK aufrufst, behalte das SDK auf der Version, die du heute verwendest, und pinne diese Version dort, wo du sie installierst, damit eine spätere Installation sie nicht aktualisiert. Das Boto3-Beispiel setzt `anthropic_version` im Request-Body und ist nicht betroffen.
</Warning>

Der Aufruf von Claude über Bedrock unterscheidet sich geringfügig davon, wie du Claude direkt über die Claude API aufrufen würdest. Dieser Leitfaden führt dich durch einen API-Aufruf an Claude auf Bedrock mit einem der [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic.

Beachte, dass dieser Leitfaden voraussetzt, dass du dich bereits für ein [AWS-Konto](https://portal.aws.amazon.com/billing/signup) registriert und den programmatischen Zugriff konfiguriert hast.

## AWS CLI installieren und konfigurieren

1. [Installiere eine Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html), die mindestens Version `2.13.23` entspricht oder neuer ist.
2. Konfiguriere deine AWS-Anmeldedaten mit dem Befehl AWS configure (siehe [Configure the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)) oder finde deine Anmeldedaten, indem du in deinem AWS-Dashboard zu „Command line or programmatic access" navigierst und den Anweisungen im modalen Fenster folgst.
3. Überprüfe, ob deine Anmeldedaten funktionieren:

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

## Ein SDK für den Zugriff auf Bedrock installieren

Die [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic unterstützen Bedrock. Du kannst auch direkt ein AWS SDK wie `boto3` verwenden.

<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:3.3.0")
      implementation("com.anthropic:anthropic-java-bedrock:3.3.0")
      ```

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

## Zugriff auf Bedrock

### Anthropic-Modelle abonnieren

Gehe zu [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) und beantrage Zugriff auf Anthropic-Modelle. Beachte, dass die Verfügbarkeit von Anthropic-Modellen je nach Region variiert. Aktuelle Informationen findest du in der [AWS-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html).

#### API-Modell-IDs

<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 und Claude Opus 4.7 sind über `InvokeModel` auf `bedrock-runtime` erreichbar. Diese Anfragen werden von derselben Infrastruktur bedient wie der [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock)-Endpunkt. Für die native Anfrageform der Messages API und vollständige Funktionsparität verwende diese Seite. Diese Modelle sind in der Modelltabelle auf dieser Seite nicht aufgeführt, da sie keine ARN-versionierten Modell-IDs haben.
</Note>

Lebenszyklusbegriffe (abgekündigt, eingestellt) sind unter [Modell-Abkündigungen](https://platform.claude.com/docs/de/about-claude/model-deprecations) definiert. Lebenszyklusdaten auf partnerbetriebenen Plattformen werden vom Partner festgelegt und können vom Zeitplan der Claude API abweichen. Das aktuelle Einstellungsdatum eines Modells auf Amazon Bedrock findest du auf der [Modell-Lebenszyklusseite von Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html).

AWS bietet neuere Claude-Modelle über „[cross-region inference](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)" (regionsübergreifende Inferenz) statt über On-Demand-Durchsatz an. Bei diesen Modellen schlägt eine Anfrage, die die Basis-Modell-ID übergibt, mit einem HTTP-400-Fehler wie dem folgenden fehl:

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

Um diese Modelle aufzurufen, übergib ein „inference profile" (Inferenzprofil) anstelle der Basis-Modell-ID. Die Inferenzprofil-ID ist die Basis-Modell-ID mit einem Präfix aus einer Spalte, die in der folgenden Tabelle mit „Yes" markiert ist, zum Beispiel us.anthropic.claude-sonnet-4-5-20250929-v1:0. Du kannst auch den vollständigen Inferenzprofil-ARN in der Form `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}` übergeben. Die maßgebliche Liste der verfügbaren Inferenzprofile von AWS findest du unter [Supported Regions and models for inference profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). Wie sich die Präfixe auf Routing und Preise auswirken, erfährst du im Abschnitt [Globale versus regionale Endpunkte](https://platform.claude.com/docs/de/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/de/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/de/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/de/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     |

### Verfügbare Modelle auflisten

Die folgenden Beispiele zeigen, wie du eine Liste aller über Bedrock verfügbaren Claude-Modelle ausgibst:

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

### Anfragen stellen

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

<Tabs>
  <Tab title="cURL">
    <Note>
      Der Aufruf der `InvokeModel`-API mit AWS-Anmeldedaten erfordert SigV4-Request-Signierung, die die SDKs in den anderen Tabs automatisch übernehmen. Für einen Bedrock-Endpunkt, den du mit einem eigenständigen cURL-Befehl aufrufen kannst, siehe [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      Die `ant` CLI unterstützt Amazon Bedrock nicht. Verwende stattdessen eines der SDK-Beispiele.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

    client = AnthropicBedrock(
        # Authentifiziere dich, indem du entweder die unten stehenden Keys angibst oder die Standard-AWS-Credential-Provider verwendest, z. B.
        # über ~/.aws/credentials oder die Umgebungsvariablen "AWS_SECRET_ACCESS_KEY" und "AWS_ACCESS_KEY_ID".
        aws_access_key="<access key>",
        aws_secret_key="<secret key>",
        # Temporäre Anmeldedaten können mit aws_session_token verwendet werden.
        # Mehr dazu unter https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
        aws_session_token="<session_token>",
        # aws_region ändert die AWS-Region, an die die Anfrage gesendet wird. Fehlt sie, liest das SDK
        # AWS_REGION / AWS_DEFAULT_REGION, dann die für deine boto3-Session oder dein AWS-Profil konfigurierte Region
        # (einschließlich ~/.aws/config) und löst ValueError aus, wenn keine Region ermittelt werden kann.
        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({
      // Authentifiziere dich, indem du entweder die Keys unten angibst oder
      // die Standard-AWS-Credential-Provider verwendest, etwa
      // ~/.aws/credentials oder die Umgebungsvariablen "AWS_SECRET_ACCESS_KEY" und
      // "AWS_ACCESS_KEY_ID".
      awsAccessKey: "<access key>",
      awsSecretKey: "<secret key>",

      // Temporäre Credentials können mit awsSessionToken verwendet werden.
      // Mehr dazu unter https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
      awsSessionToken: "<session_token>",

      // awsRegion ändert die AWS-Region, an die die Anfrage
      // gesendet wird. Standardmäßig liest das SDK AWS_REGION und, falls
      // nicht vorhanden, wird us-east-1 verwendet. Beachte, dass
      // das SDK ~/.aws/config nicht für die Region ausliest.
      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"
    )
    // ...
    	// Verwendet die Standard-Credential-Provider-Chain von 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) {
        // Verwendet die Standard-Credential-Provider-Chain von 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>

Weitere Details findest du in den [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) und in der [offiziellen Bedrock-Dokumentation](https://docs.aws.amazon.com/bedrock/).

### Bearer-Token-Authentifizierung

Du kannst dich bei Bedrock mit „bearer tokens" (Bearer-Token) statt mit AWS-Anmeldedaten authentifizieren. Das ist in Unternehmensumgebungen nützlich, in denen Teams Zugriff auf Bedrock benötigen, ohne AWS-Anmeldedaten, IAM-Rollen oder Berechtigungen auf Kontoebene verwalten zu müssen.

Der einfachste Ansatz ist, die Umgebungsvariable `AWS_BEARER_TOKEN_BEDROCK` zu setzen, die das SDK automatisch erkennt, wenn es Anmeldedaten aus der Umgebung auflöst.

So stellst du ein Token programmatisch bereit:

<Tabs>
  <Tab title="cURL">
    <Note>
      Dieser Abschnitt zeigt, wie du ein Bearer-Token in einem SDK-Client konfigurierst, der das Token auch aus der Umgebungsvariable `AWS_BEARER_TOKEN_BEDROCK` liest. Um direkte HTTP-Anfragen mit einem Bearer-Token zu stellen, siehe die [Amazon Bedrock-Dokumentation](https://docs.aws.amazon.com/bedrock/).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      Die `ant` CLI unterstützt Amazon Bedrock nicht. Verwende stattdessen eines der SDK-Beispiele.
    </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;

    // Option 1: Setze die Umgebungsvariable AWS_BEARER_TOKEN_BEDROCK und verwende fromEnv()
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Option 2: Übergib das Token programmatisch
    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>

## Aktivitätsprotokollierung

Bedrock bietet einen [Dienst zur Aufrufprotokollierung](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html), mit dem du die Prompts und Completions protokollieren kannst, die mit deiner Nutzung verbunden sind.

Anthropic empfiehlt, deine Aktivität mindestens über einen rollierenden Zeitraum von 30 Tagen zu protokollieren, um deine Aktivität nachvollziehen und möglichen Missbrauch untersuchen zu können.

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

## Funktionsunterstützung

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

### Wichtige unterstützte Funktionen

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

### Nicht unterstützte Funktionen

* Eingabequellen (URL-Quellen für Bilder und Dokumente, Files API)
* Serverseitige Tools (Codeausführung, Websuche, Web-Abruf, Advisor)
* Agent-Infrastruktur (Agent Skills, MCP-Connector, programmatischer Tool-Aufruf)
* API-Endpunkte (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Serverseitiger Fallback (der [`fallbacks`-Parameter](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback); verwende stattdessen das [clientseitige Fallback-Muster](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#client-side-fallback))
* Automatisches Prompt-Caching (das [`cache_control`-Feld auf oberster Ebene](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#automatic-caching); verwende stattdessen [explizite Cache-Breakpoints](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#explicit-cache-breakpoints))
* [Computer-Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool)- und [Browser-Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool)-Toolsets (`computer_toolset_20260801` und `browser_toolset_20260801` sind derzeit auf Amazon Bedrock nicht verfügbar; die Beta-Versionen des Computer-Use-Tools bleiben verfügbar)

### PDF-Unterstützung auf Bedrock

PDF-Unterstützung ist auf Bedrock sowohl über die Converse API als auch über die InvokeModel API verfügbar. Detaillierte Informationen zu den Möglichkeiten und Einschränkungen der PDF-Verarbeitung findest du unter [PDF-Unterstützung auf Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/pdf-support#amazon-bedrock-pdf-support).

**Wichtige Hinweise für Nutzer der Converse API:**

* Die visuelle PDF-Analyse (Diagramme, Bilder, Layouts) erfordert, dass Zitate aktiviert sind
* Ohne Zitate ist nur eine einfache Textextraktion verfügbar
* Für volle Kontrolle ohne erzwungene Zitate verwende die InvokeModel API

### Systemnachrichten mitten im Gespräch auf Bedrock

[Systemnachrichten mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages) sind über die InvokeModel API für Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5 und Claude Haiku 5.5 verfügbar. Wie im Hinweis unter [API-Modell-IDs](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids) beschrieben, werden diese Anfragen von derselben Infrastruktur bedient wie der [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock)-Endpunkt. Für Systemnachrichten mitten im Gespräch ist kein Beta-Header erforderlich. Diese Funktion ist auf Claude Sonnet 5 nicht verfügbar. Verwende stattdessen das `system`-Feld auf oberster Ebene. Für die ARN-versionierten Modelle in der Modelltabelle auf dieser Seite ist sie nicht verfügbar.

Eine `role: "system"`-Nachricht kann auf Claude Fable 5.1 und Claude Opus 5.5 auch `output_config.effort` setzen, um den [Effort mitten im Gespräch zu ändern](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta). Dies befindet sich in der Beta: Füge `mid-conversation-output-config-2026-07-01` zum `anthropic_beta`-Array im Request-Body hinzu. Ohne diesen Wert oder auf Claude Fable 5, Claude Opus 5 oder Claude Opus 4.8 gibt die Anfrage einen 400-Fehler zurück: `messages.N.output_config: Extra inputs are not permitted`. Im Fehler ist `N` der Index der `system`-Nachricht in `messages`.

**Für Nutzer der Converse API:** Die Converse API akzeptiert Systemanweisungen über ihren [`system`-Parameter](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) auf oberster Ebene. Um Systemanweisungen mitten im Gespräch hinzuzufügen, verwende die InvokeModel API.

### Kontextfenster

Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 und Claude Haiku 5.5 haben auf Amazon Bedrock ein „context window" (Kontextfenster) von [1M Token](https://platform.claude.com/docs/de/build-with-claude/context-windows). Andere Claude-Modelle, einschließlich Sonnet 4.5 (abgekündigt) und Sonnet 4 (abgekündigt), haben ein Kontextfenster von 200k Token.

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

## Globale versus regionale Endpunkte

Ab **Claude Sonnet 4.5 und allen zukünftigen Modellen** bietet Bedrock zwei Endpunkttypen:

* **Globale Endpunkte:** Dynamisches Routing für maximale Verfügbarkeit
* **Regionale Endpunkte:** Garantiertes Datenrouting durch bestimmte geografische Regionen

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

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

### Wann welche Option verwendet werden sollte

**Globale Endpunkte (empfohlen):**

* Bieten maximale Verfügbarkeit und Betriebszeit
* Leiten Anfragen dynamisch an Regionen mit verfügbarer Kapazität weiter
* Kein Preisaufschlag
* Am besten für Anwendungen, bei denen die Datenresidenz flexibel ist

**Regionale Endpunkte (CRIS):**

* Leiten Datenverkehr durch bestimmte geografische Regionen
* Erforderlich für Anforderungen an Datenresidenz und Compliance
* Verfügbar für USA, EU, Japan und Asien-Pazifik
* Der Preisaufschlag von 10 % spiegelt die Infrastrukturkosten für dedizierte regionale Kapazität wider

### Implementierung

**Verwendung globaler Endpunkte (Standard für Opus 4.6, Sonnet 4.6 und Sonnet 4.5 (abgekündigt)):**

Die Modell-IDs für Claude Opus 4.6, Sonnet 4.6 und Sonnet 4.5 (abgekündigt) enthalten bereits das Präfix `global.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Der Aufruf der `InvokeModel`-API mit AWS-Anmeldedaten erfordert SigV4-Request-Signierung, die die SDKs in den anderen Tabs automatisch übernehmen. Für einen Bedrock-Endpunkt, den du mit einem eigenständigen cURL-Befehl aufrufen kannst, siehe [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      Die `ant` CLI unterstützt Amazon Bedrock nicht. Verwende stattdessen eines der SDK-Beispiele.
    </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;

    // Der C#-Bedrock-Client verwendet Modell-IDs mit Regionspräfix für globales Routing
    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        // Verwende das Präfix "global." für globale regionsübergreifende Inferenz
        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"
    )
    // ...
    	// Verwendet die Standard-Credential-Provider-Chain von 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;

    // Verwendet die standardmäßige AWS-Credential-Provider-Chain
    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"

    # Standard-Credentials ermitteln die Region aus der Umgebungsvariable AWS_REGION
    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      # Verwende das Präfix "global." für globale regionsübergreifende Inferenz
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

**Verwendung regionaler Endpunkte (CRIS):**

Um regionale Endpunkte zu verwenden, ersetze das Präfix `global.` durch ein regionales Präfix wie `us.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Der Aufruf der `InvokeModel`-API mit AWS-Anmeldedaten erfordert SigV4-Request-Signierung, die die SDKs in den anderen Tabs automatisch übernehmen. Für einen Bedrock-Endpunkt, den du mit einem eigenständigen cURL-Befehl aufrufen kannst, siehe [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      Die `ant` CLI unterstützt Amazon Bedrock nicht. Verwende stattdessen eines der SDK-Beispiele.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

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

    # Verwendung des regionalen US-Endpunkts (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"
    });

    // Verwendung des regionalen US-Endpunkts (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" }
    );

    // Verwendung des regionalen US-Endpunkts (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"
    )
    // ...
    	// Verwendet die Standard-Credential-Provider-Chain von AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Verwendung des regionalen US-Endpunkts (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;

    // Verwendet die Standard-Credential-Provider-Chain von AWS
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Verwendung des regionalen US-Endpunkts (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"

    # Verwendung des US-Regional-Endpoints (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** ist ein Research-Preview-Modell, das eingeladenen Kunden auf Amazon Bedrock zur Verfügung steht. Weitere Informationen findest du unter [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Zusätzliche Ressourcen

* **Bedrock-Preise:** [Amazon Bedrock-Preisseite](https://aws.amazon.com/bedrock/pricing/)
* **AWS-Preisdokumentation:** [Bedrock-Preisleitfaden](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **AWS-Blogbeitrag:** [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-Preisdetails:** [Preise für Cloud-Plattformen](https://platform.claude.com/docs/de/about-claude/pricing#cloud-platform-pricing)