---
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 („legacy“) Amazon Bedrock-Integration: die `InvokeModel`- und `Converse`-APIs mit ARN-versionierten Modellkennungen und AWS-Event-Stream-Kodierung. Für Modelle, die auf dem 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 AWS-Marketplace-Abrechnung und in der Regel taggleichem Zugriff auf neue Funktionen 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>

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 vollständigen 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 davon ausgeht, 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) in Version `2.13.23` oder neuer.
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: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>

## Zugriff auf Bedrock

### Anthropic-Modelle abonnieren

Gehe zur [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. Siehe die [AWS-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) für aktuelle Informationen.

#### 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 Anfragestruktur 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 von Partnern betriebenen Plattformen werden vom jeweiligen 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 statt der Basis-Modell-ID ein „inference profile" (Inferenzprofil). Die Inferenzprofil-ID ist die Basis-Modell-ID mit einem Präfix aus einer Spalte, die in der folgenden Tabelle mit „Ja" 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-Anfragesignierung, die die SDKs in den anderen Tabs automatisch übernehmen. Einen Bedrock-Endpunkt, den du mit einem eigenständigen cURL-Befehl aufrufen kannst, findest du unter [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 entweder über die unten angegebenen Keys oder verwende die Standard-AWS-Credential-Provider, 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. Ist sie nicht angegeben, 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 einen 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 entweder über die Keys unten oder verwende
      // die standardmäßigen AWS-Credential-Provider, wie z. B.
      // ~/.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
      // diese nicht gesetzt ist, 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 standardmäßige AWS-Credential-Provider-Chain
    	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 standardmäßige AWS-Credential-Provider-Chain
        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) sowie 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 beim Auflösen von Anmeldedaten aus der Umgebung automatisch erkennt.

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 mit deiner Nutzung verbundenen Prompts und Completions protokollieren kannst.

Anthropic empfiehlt, deine Aktivität mindestens auf rollierender 30-Tage-Basis zu protokollieren, um deine Aktivität nachzuvollziehen und möglichen Missbrauch zu untersuchen.

<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), für die Modelle im Amazon Bedrock-Hinweis im Abschnitt [Kompatibilität](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#compatibility)

### Nicht unterstützte Funktionen

* Eingabequellen (URL-Quellen für Bilder und Dokumente, Files API)
* Serverseitige Tools (Codeausführung, Websuche, Web-Fetch, Advisor)
* Agenten-Infrastruktur (Agent Skills, MCP-Konnektor, programmatische Tool-Aufrufe)
* API-Endpunkte (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Serverseitiges 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))
* Toolsets für [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) (`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:**

* Visuelle PDF-Analyse (Diagramme, Bilder, Layouts) erfordert, dass Zitate aktiviert sind
* Ohne Zitate ist nur 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 außerdem `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 Anfragetext 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 verfügen auf Amazon Bedrock über ein [Kontextfenster mit 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 mit 200k Token.

Bedrock begrenzt Anfrage-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 an:

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

**Globale Endpunkte verwenden (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-Anfragesignierung, 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 Standard-Credential-Provider-Chain von 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"

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

**Regionale Endpunkte verwenden (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-Anfragesignierung, 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 standardmäßige AWS-Credential-Provider-Chain
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Verwendet regionalen US-Endpunkt (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 standardmäßige AWS-Credential-Provider-Chain
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Verwendet regionalen US-Endpunkt (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 regionalen US-Endpunkts (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)