---
title: Claude in Amazon Bedrock (Opus 4.7 und später)
url: https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock
description: Greife über Amazon Bedrock auf Claude-Modelle zu – mit AWS-nativer Authentifizierung, Abrechnung und Sicherheitsgrenzen.
---

Dieser Leitfaden führt dich durch die Einrichtung und das Ausführen von API-Aufrufen an Claude in Amazon Bedrock. Claude in Amazon Bedrock läuft auf von AWS verwalteter Infrastruktur mit „zero operator access“ (kein Betreiberzugriff) – Anthropic-Mitarbeitende haben keinen Zugriff auf die Inferenz-Infrastruktur. So kannst du sensible Anwendungen vollständig innerhalb der AWS-Sicherheitsgrenze erstellen und dabei dieselbe Messages-API-Form verwenden, die du auch mit der First-Party-API von Anthropic nutzt.

<Note>
  Diese Seite behandelt Claude in Amazon Bedrock, das Claude über die Messages API unter `/anthropic/v1/messages` auf von AWS verwalteter Infrastruktur bereitstellt. Die bisherige Amazon-Bedrock-Integration (die `InvokeModel`- und `Converse`-APIs mit ARN-versionierten Modellkennungen) bleibt verfügbar und ist unter [Claude auf Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) dokumentiert. Eine von Anthropic betriebene Alternative auf AWS mit Abrechnung über den AWS Marketplace und in der Regel taggleichem Feature-Zugang findest du unter [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws).
</Note>

## Zugang

Amazon Bedrock legt die Zugangskriterien für jedes Claude-Modell einzeln fest. Claude Fable 5.1, Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5, Claude Opus 4.7 und Claude Haiku 4.5 stehen allen Amazon-Bedrock-Kunden offen. Die aktuellen Kriterien für alle anderen Modelle findest du unter [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) in der AWS-Konsole. Claude Mythos Preview erfordert eine Einladung über [Project Glasswing](https://anthropic.com/glasswing). Zur regionalen Verfügbarkeit siehe [Regionen](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#regions).

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

* Ein AWS-Konto, für das [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) für die Claude-Modelle aktiviert ist, die du verwenden möchtest.
* Die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), installiert und konfiguriert (optional, für die Verwaltung von Anmeldedaten).

Claude Mythos Preview erfordert zusätzlich ein dediziertes AWS-Konto, das vom Bedrock-Marketplace-Team auf die Allowlist gesetzt wurde. Dein Anthropic Account Executive kann deine Konto-ID zur Aufnahme in die Allowlist einreichen (in der Regel innerhalb von 24 Stunden bearbeitet), und AWS sendet eine Willkommens-E-Mail, sobald dies abgeschlossen ist.

## Authentifizierung

Claude in Amazon Bedrock unterstützt drei Authentifizierungswege. Wähle denjenigen, der am besten zu deinen Sicherheitsanforderungen passt.

### Bedrock-Service-Rolle (empfohlen)

Verwende eine Bedrock-Service-Rolle mit von AWS verwalteten Schlüsseln für den sichersten, langlebigen Zugriff:

<Steps>
  <Step title="Admin: Service-Rolle bereitstellen">
    Ein AWS-Administrator stellt eine Bedrock-Service-Rolle bereit und erteilt Entwicklern die Berechtigung `iam:PassRole` für die ARN der Service-Rolle.
  </Step>

  <Step title="Entwickler: Rolle übergeben">
    Beim Aufruf der API übernimmt Bedrock die Service-Rolle in deinem Namen. Wie du die Rolle mit deinen Anfragen verknüpfst, findest du in der [Amazon-Bedrock-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html).
  </Step>
</Steps>

### Angenommene IAM-Rollen

Für identitätsföderierten Zugriff mit einer maximalen Sitzungsdauer von 12 Stunden:

<Steps>
  <Step title="Admin: IAM-Rolle konfigurieren">
    Erstelle eine IAM-Rolle, die auf deine Claude-Modelle beschränkt ist. Die Vertrauensrichtlinie benennt deinen Identitätsanbieter (SAML, OIDC oder AWS Identity Center). Die Berechtigungsrichtlinie gewährt `bedrock-mantle:CreateInference` nur für die zulässigen Modell-ARNs.
  </Step>

  <Step title="Entwickler: authentifizieren und Rolle annehmen">
    Authentifiziere dich über den Identitätsanbieter deines Unternehmens und nimm dann die IAM-Rolle an. AWS STS stellt temporäre Anmeldedaten aus, die das SDK oder die CLI zum Signieren von Anfragen verwendet.
  </Step>
</Steps>

### Bearer-Token

Für kurzfristigen Zugriff ohne IAM-Rollen (maximal 12 Stunden, am wenigsten bevorzugt):

<Steps>
  <Step title="Admin: Token-Typen einschränken">
    Blockiere langfristige Schlüssel, indem du eine Richtlinie anhängst, die `bedrock:CallWithBearerToken` verweigert, sofern die Bedingung `bedrock:BearerTokenType` nicht einem kurzfristigen Token entspricht.
  </Step>

  <Step title="Entwickler: Token erzeugen">
    Verwende die CLI `aws-bedrock-token-generator`, um ein Bearer-Token zu erzeugen. Übergib es bei jeder Anfrage im Header `x-api-key`.
  </Step>
</Steps>

## Ein SDK installieren

Anthropics [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) unterstützen Claude in Amazon Bedrock über ein Bedrock-spezifisches Paket oder Modul.

<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">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:2.73.0")
        implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <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>
        ```
      </Tab>
    </Tabs>
  </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-core"
    ```
  </Tab>
</Tabs>

## Deine erste Anfrage

Der Endpunkt folgt dem Muster `https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages`. Anders als die auf `InvokeModel` basierende Integration verwendet dieser Endpunkt standardmäßiges SSE-Streaming und dieselbe Struktur des Anfragekörpers wie Anthropics First-Party-API.

Das SDK ermittelt Anmeldedaten und Region gemäß der standardmäßigen AWS-Rangfolge: zuerst Konstruktorargumente, dann Umgebungsvariablen (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_REGION`), dann die AWS-Konfigurationsdatei und die Anmeldedatenkette (SSO, angenommene Rollen, ECS-Task-Rolle, IMDS).

<Tabs>
  <Tab title="cURL">
    ```bash
    curl https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
      --aws-sigv4 "aws:amz:us-east-1:bedrock-mantle" \
      --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
      -H "x-amz-security-token: $AWS_SESSION_TOKEN" \
      -H "content-type: application/json" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "anthropic.claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [
          {"role": "user", "content": "Hello, Claude"}
        ]
      }'
    ```
  </Tab>

  <Tab title="CLI">
    Die `ant`-CLI unterstützt Amazon Bedrock nicht. Verwende entweder cURL oder ein SDK.
  </Tab>

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

    client = AnthropicBedrockMantle(aws_region="us-east-1")

    message = client.messages.create(
        model="anthropic.claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello, Claude"}],
    )

    print(next(block.text for block in message.content if block.type == "text"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import { AnthropicBedrockMantle } from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrockMantle({
      awsRegion: "us-east-1"
    });

    const message = await client.messages.create({
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    });

    const textBlock = message.content.find((block) => block.type === "text");
    if (textBlock) {
      console.log(textBlock.text);
    }
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    var client = new AnthropicBedrockMantleClient(new() { AwsRegion = "us-east-1" });

    var message = await client.Messages.Create(new()
    {
        Model = "anthropic.claude-opus-5-5",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
    });

    foreach (var item in message.Content)
    {
        if (item.Value is TextBlock block)
        {
            Console.WriteLine(block.Text);
            break;
        }
    }
    ```
  </Tab>

  <Tab title="Go">
    ```go
    client, err := bedrock.NewMantleClient(context.Background(), bedrock.MantleClientConfig{
    	AWSRegion: "us-east-1",
    })
    if err != nil {
    	panic(err)
    }

    message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    	Model:     "anthropic.claude-opus-5-5",
    	MaxTokens: 1024,
    	Messages: []anthropic.MessageParam{
    		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
    	},
    })
    if err != nil {
    	panic(err)
    }

    for _, block := range message.Content {
    	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
    		fmt.Println(textBlock.Text)
    		break
    	}
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockMantleBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.ContentBlock;
    import com.anthropic.models.messages.Message;
    import com.anthropic.models.messages.MessageCreateParams;

    void main() {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(BedrockMantleBackend.fromEnv())
            .build();

        Message message = client.messages().create(
            MessageCreateParams.builder()
                .model("anthropic.claude-opus-5-5")
                .maxTokens(1024)
                .addUserMessage("Hello, Claude")
                .build()
        );

        message.content().stream()
                .filter(ContentBlock::isText)
                .findFirst()
                .ifPresent(block -> IO.println(block.asText().text()));
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    use Anthropic\Bedrock\MantleClient;

    $client = new MantleClient(awsRegion: 'us-east-1');

    $message = $client->messages->create(
        model: 'anthropic.claude-opus-5-5',
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello, Claude'],
        ],
    );

    echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockMantleClient.new(aws_region: "us-east-1")

    message = client.messages.create(
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{role: "user", content: "Hello, Claude"}]
    )

    puts message.content.find { it.type == :text }.text
    ```
  </Tab>
</Tabs>

<Tip>
  Du kannst auch den Standard-Client mit `Anthropic` (go: `anthropic.NewClient()`; java: `AnthropicOkHttpClient.builder()`; csharp: `AnthropicClient`; php: `Anthropic\Client`; ruby: `Anthropic::Client`) erstellen: Setze `base_url` (typescript: `baseURL`; go: `option.WithBaseURL()`; java: `.baseUrl()`; csharp: `BaseUrl`; php: `baseUrl`) auf `https://bedrock-mantle.{region}.api.aws/anthropic` und übergib dein Bearer-Token als `api_key` (typescript, php: `apiKey`; go: `option.WithAPIKey()`; java: `.apiKey()`; csharp: `ApiKey`). Dieser Weg unterstützt ausschließlich die Authentifizierung per Bearer-Token. Für SigV4-Signierung ist `AnthropicBedrockMantle` (csharp: `AnthropicBedrockMantleClient`; go: `bedrock.NewMantleClient`; java: `BedrockMantleBackend`; php: `MantleClient`; ruby: `Anthropic::BedrockMantleClient`) erforderlich.
</Tip>

## Unterstützte Modelle

Modell-IDs in Claude in Amazon Bedrock tragen das Anbieterpräfix `anthropic.`. Die Fähigkeiten und das Verhalten der Modelle sind auf der Seite [Modellübersicht](https://platform.claude.com/docs/de/models/overview) dokumentiert.

| Model                                                                                       | Model ID                          | Access                                                                                              |
| :------------------------------------------------------------------------------------------ | :-------------------------------- | :-------------------------------------------------------------------------------------------------- |
| Claude Fable 5.1                                                                            | `anthropic.claude-fable-5-1`      | Open                                                                                                |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842)) | `anthropic.claude-mythos-5-1`     | Active (verification required)                                                                      |
| Claude Fable 5                                                                              | `anthropic.claude-fable-5`        | Open                                                                                                |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))   | `anthropic.claude-mythos-5`       | Active (verification required)                                                                      |
| Claude Mythos Preview ([limited availability](https://anthropic.com/glasswing))             | `anthropic.claude-mythos-preview` | Invitation only                                                                                     |
| Claude Opus 5.5                                                                             | `anthropic.claude-opus-5-5`       | [See Access](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 5                                                                               | `anthropic.claude-opus-5`         | [See Access](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 4.8                                                                             | `anthropic.claude-opus-4-8`       | Open                                                                                                |
| Claude Opus 4.7                                                                             | `anthropic.claude-opus-4-7`       | Open                                                                                                |
| Claude Sonnet 5.5                                                                           | `anthropic.claude-sonnet-5-5`     | [See Access](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Sonnet 5                                                                             | `anthropic.claude-sonnet-5`       | Open                                                                                                |
| Claude Haiku 5.5                                                                            | `anthropic.claude-haiku-5-5`      | [See Access](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Haiku 4.5                                                                            | `anthropic.claude-haiku-4-5`      | Open                                                                                                |

Verwende die neueste Version von Claude Code mit Claude in Amazon Bedrock; führe `claude update` aus, um zu aktualisieren.

<Tip>
  Du wechselst auf ein neueres Claude-Modell? Führe in Claude Code `/claude-api migrate` aus, um Modell-ID-Austausche und inkompatible Parameteränderungen in deiner gesamten Codebasis anzuwenden. Der Skill erkennt, auf welche Cloud-Plattform dein Code abzielt, und passt Modell-ID-Formate und Funktionsänderungen für diese Plattform an. Siehe [Migration auf ein neueres Claude-Modell](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

## Feature-Unterstützung

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

### Highlights der unterstützten Features

* [Messages API](https://platform.claude.com/docs/de/api/messages/create) (`/anthropic/v1/messages`)
* [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)

### Nicht unterstützte Features

* [Strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs)
* Eingabequellen (URL-Quellen für Bilder und Dokumente, Files API)
* Serverseitige Tools (Codeausführung, Websuche, Web-Fetch, Advisor)
* Agenten-Infrastruktur (Agent Skills, MCP-Connector, programmatische Tool-Aufrufe)
* API-Endpunkte (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Serverseitiges Fallback (der [Parameter `fallbacks`](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))
* 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)

## Regionen

Claude in Amazon Bedrock ist in den folgenden AWS-Regionen verfügbar. Amazon Bedrock bietet zwei Endpunkttypen:

* **Global:** dynamisches Routing über alle verfügbaren Regionen für maximale Verfügbarkeit. Kein Preisaufschlag.
* **Regional:** Der Endpunkt wird in die einzelne von dir angegebene AWS-Region aufgelöst, um Anforderungen an die Datenresidenz zu erfüllen. Regionale Endpunkte haben einen Preisaufschlag von 10 % gegenüber globalen Endpunkten. Um über mehrere Regionen innerhalb eines geografischen Gebiets zu routen, verwende ein [Inferenzprofil](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) (US, EU, JP oder AU). In der Tabelle mit **Nur In-Region** gekennzeichnete Regionen unterstützen direktes Routing in eine einzelne Region ohne Inferenzprofil.

Der globale Endpunkt ist verfügbar für Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5 und Claude Haiku 4.5. Für Claude Fable 5.1 sind regionale Endpunkte derzeit nur in `us-east-1` verfügbar. Claude Mythos Preview ist nur regional und in `us-east-1` verfügbar.

| AWS-Region       | Standort                   | Endpunkttypen             |
| ---------------- | -------------------------- | ------------------------- |
| `af-south-1`     | Afrika (Kapstadt)          | Global                    |
| `ap-northeast-1` | Asien-Pazifik (Tokio)      | Global, JP, Nur In-Region |
| `ap-northeast-2` | Asien-Pazifik (Seoul)      | Global                    |
| `ap-northeast-3` | Asien-Pazifik (Osaka)      | Global, JP                |
| `ap-south-1`     | Asien-Pazifik (Mumbai)     | Global                    |
| `ap-south-2`     | Asien-Pazifik (Hyderabad)  | Global                    |
| `ap-southeast-1` | Asien-Pazifik (Singapur)   | Global                    |
| `ap-southeast-2` | Asien-Pazifik (Sydney)     | Global, AU                |
| `ap-southeast-3` | Asien-Pazifik (Jakarta)    | Global                    |
| `ap-southeast-4` | Asien-Pazifik (Melbourne)  | Global, AU, Nur In-Region |
| `ca-central-1`   | Kanada (Zentral)           | Global, US                |
| `ca-west-1`      | Kanada West (Calgary)      | Global                    |
| `eu-central-1`   | Europa (Frankfurt)         | Global, EU                |
| `eu-central-2`   | Europa (Zürich)            | Global, EU                |
| `eu-north-1`     | Europa (Stockholm)         | Global, EU, Nur In-Region |
| `eu-south-1`     | Europa (Mailand)           | Global, EU                |
| `eu-south-2`     | Europa (Spanien)           | Global, EU                |
| `eu-west-1`      | Europa (Irland)            | Global, EU, Nur In-Region |
| `eu-west-2`      | Europa (London)            | Global, EU                |
| `eu-west-3`      | Europa (Paris)             | Global, EU                |
| `il-central-1`   | Israel (Tel Aviv)          | Global                    |
| `me-central-1`   | Naher Osten (VAE)          | Global                    |
| `sa-east-1`      | Südamerika (São Paulo)     | Global                    |
| `us-east-1`      | USA Ost (Nord-Virginia)    | Global, US, Nur In-Region |
| `us-east-2`      | USA Ost (Ohio)             | Global, US, Nur In-Region |
| `us-west-1`      | USA West (Nordkalifornien) | Global, US                |
| `us-west-2`      | USA West (Oregon)          | Global, US, Nur In-Region |

## Kontingente

Das Standardkontingent beträgt 2 Millionen Input-Token pro Minute (TPM). Du kannst bis zu 5 Millionen Input-TPM und 500.000 Output-TPM ohne zusätzliche Genehmigung durch Anthropic beantragen. AWS setzt auf Bedrock-Seite Limits für „requests per minute“ (Anfragen pro Minute), oder RPM, durch; wende dich für RPM-Anpassungen an den AWS-Support.

## Datenaufbewahrung

Die Datenverarbeitung für dieses Angebot unterliegt Amazon Bedrock. Details findest du unter [Datenschutz in Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html).

## Überwachung und Protokollierung

Claude in Amazon Bedrock gibt Protokolle sowohl an CloudWatch als auch an CloudTrail aus. Anthropic empfiehlt, Aktivitätsprotokolle mindestens rollierend über 30 Tage aufzubewahren, um Nutzungsmuster zu verstehen und mögliche Probleme zu untersuchen.

## Support

Für Support wende dich an **[bedrock-ant-eap@amazon.com](mailto:bedrock-ant-eap@amazon.com)**. Gib deine AWS-Konto-ID und die `request-id` aus fehlgeschlagenen API-Antworten an.

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