---
title: Claude Platform on AWS
url: https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws
description: Greife über AWS auf den vollen Funktionsumfang der Claude-Plattform zu – mit von Anthropic verwalteter Infrastruktur.
---
Claude Platform on AWS bietet dir das vollständige Anthropic-Plattformerlebnis, einschließlich der Messages API, Agent Skills, Codeausführung und Beta-Funktionen, zugänglich über dein AWS-Konto. Anders als bei [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock), wo AWS den Inferenz-Stack betreibt, betreibt Anthropic Claude Platform on AWS. AWS stellt die Authentifizierungsschicht (SigV4 oder API-Key), IAM-basierte Zugriffskontrolle und die Abrechnungsintegration über AWS Marketplace bereit.
Die Anthropic SDKs unterstützen Claude Platform on AWS.
## Wie die Plattformintegration funktioniert
Claude-Modelle laufen auf von Anthropic verwalteter Infrastruktur. Es handelt sich um eine kommerzielle Integration für Abrechnung und Zugriff über AWS. Anthropic ist der Datenverarbeiter für Inferenz-Eingaben und -Ausgaben. AWS verarbeitet Abrechnungs- und Identitätsmetadaten im Rahmen des Marketplace-Modells. Kunden, die Claude über Claude Platform on AWS nutzen, unterliegen den [Datennutzungsbedingungen](https://www.anthropic.com/legal) von Anthropic.
Anthropic nutzt AWS-Infrastruktur, um deine API-Anfragen zu verarbeiten, Modellinferenz auszuführen und deine Workspace-Inhalte (wie Prompts, Ausgaben, Dateien, Skills und Batches) zu speichern. Bei Workspaces, die vor dem 18. September 2026, 00:00 UTC, erstellt wurden, kann Anthropic Anfragen verarbeiten, Daten speichern und Inferenz außerhalb von AWS ausführen. In beiden Fällen können sich Unterdienste ohne Vorankündigung ändern. Setze den Parameter [`inference_geo`](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#data-residency) pro Anfrage, um die Inferenz auf eine bestimmte Region festzulegen.
Claude Platform on AWS folgt derselben Richtlinie zur Datenaufbewahrung wie die First-Party-Claude-API. „Zero Data Retention" (Null-Datenaufbewahrung), oder ZDR, ist auf Anfrage verfügbar. Wende dich an deinen Anthropic-Ansprechpartner, um sie für deine Organisation zu aktivieren.
## Claude Platform on AWS im Vergleich zu Amazon Bedrock
Beide Angebote ermöglichen dir die Nutzung von Claude über AWS, unterscheiden sich jedoch in Architektur, API-Oberfläche und Verfügbarkeit von Funktionen.
| Aspekt | Claude Platform on AWS | [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) | [Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **Wer den Stack betreibt** | Anthropic | AWS | AWS |
| **API-Oberfläche** | Claude API (`/v1/{endpoint}`) | Messages API unter `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Verfügbarkeit von Funktionen** | In der Regel am selben Tag wie die Claude API (siehe [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported)) | Gemäß dem Release-Zeitplan von Amazon Bedrock | Gemäß dem Release-Zeitplan von Amazon Bedrock |
| **Agent Skills** | Verfügbar | Nicht verfügbar (erfordert Codeausführung) | Nicht verfügbar |
| **Beta-Funktionen** | Durchreichen mit `anthropic-beta`-Headern (siehe [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported)) | Die von Amazon Bedrock unterstützten Beta-Funktionen, über den `anthropic-beta`-Header | Die von Amazon Bedrock unterstützten Beta-Funktionen, über das Feld `anthropic_beta` im InvokeModel-Request-Body |
| **Authentifizierung** | AWS IAM / SigV4 oder API-Key | AWS IAM / SigV4 | AWS IAM / SigV4 oder Bearer-Token |
| **Abrechnung** | AWS Marketplace | AWS (nativer Dienst) | AWS (nativer Dienst) |
| **Basis-URL** | `aws-external-anthropic.{region}.api.aws` | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` |
| **SDK-Client** | `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), in der Beta | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK |
| **Konsole** | Claude Console (`platform.claude.com`, Zugriff über die AWS Console) | Bedrock Console | Bedrock Console |
| **Ratenlimits und Kontingente** | Von Anthropic verwaltet | Von AWS verwaltet | Von AWS verwaltet |
| **Datenverarbeiter für Inferenz** | Anthropic | AWS | AWS |
Wenn du ein von AWS betriebenes Claude benötigst, siehe [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock). Claude Platform on AWS nutzt einen separaten Kapazitätspool, getrennt sowohl von der First-Party-Claude-API als auch von Amazon Bedrock. Du kannst Workloads auf mehr als einer Plattform ausführen und zwischen ihnen ein Failover durchführen.
[AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) wird für die Verbindung deiner VPC mit dem Endpunkt von Claude Platform on AWS unterstützt.
**Wann du Bedrock wählen solltest:** Organisationen in regulierten Branchen, die FedRAMP High, IL4, IL5 oder HIPAA-konforme Compliance benötigen oder bei denen AWS der alleinige Datenverarbeiter sein muss, sollten [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) verwenden. Bedrock läuft vollständig auf von AWS kontrollierter Infrastruktur, wobei AWS die betreibende Partei ist.
**Welches Angebot nutzt du?** Claude ist über mehrere unterschiedliche Produkte verfügbar:
* **Claude Platform on AWS** (diese Seite): Die Claude-API-Plattform, abgerechnet über AWS Marketplace. Verwaltet in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) und der AWS Console.
* **[Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock):** Ein AWS-nativer Dienst. Verwaltet in der Amazon-Bedrock-Konsole und als AWS-Dienstnutzung abgerechnet.
* **Claude Enterprise, bezogen über AWS Marketplace:** Ein [claude.ai](https://claude.ai)-Plan (das Claude-Chat-Produkt), keine API-Plattform. Verwaltet auf claude.ai; das Konto- und Migrationsverhalten unterscheidet sich von dem, was diese Seite beschreibt. Siehe das [Claude Help Center](https://support.claude.com).
* **Direkte Anthropic-Konten:** Die First-Party-Claude-API und claude.ai-Pläne, abgerechnet von Anthropic. Verwaltet in der Claude Console und auf claude.ai.
## Dein Konto einrichten
Die Einrichtung von Claude Platform on AWS erfolgt in vier Phasen: Registrierung auf der Dienstseite der AWS Console, Abschluss der Einrichtung deiner Anthropic-Organisation, Notieren deiner Workspace-ID und Anmeldung bei der Claude Console.
Die Registrierung über die AWS Console stellt eine neue Anthropic-Organisation bereit, die an dein AWS-Konto gebunden ist. Diese Organisation ist von allen bestehenden Organisationen getrennt, die dein Unternehmen bei Anthropic hat, einschließlich Claude-Enterprise-Organisationen, die über AWS Marketplace bezogen wurden. API-Keys, Workspaces und Claude-Console-Einstellungen aus einer First-Party-Anthropic-Organisation werden nicht übernommen.
Wenn du ein bestehendes Private Offer für Amazon Bedrock hast, wende dich vor der Registrierung an deinen Anthropic- oder AWS-Ansprechpartner, damit dein Rabatt ab deiner ersten Anfrage gilt. Rabatte können nicht rückwirkend auf Nutzung angewendet werden, die vor der Annahme deines Private Offers angefallen ist. Siehe [Private Offers](https://platform.claude.com/docs/de/about-claude/pricing#private-offers).
1. Öffne die [AWS Console](https://console.aws.amazon.com/) und navigiere zur Dienstseite **Claude Platform on AWS**.
2. Wähle **Sign up**.
3. Prüfe auf der Registrierungsseite die Bedingungen (die Endbenutzer-Lizenzvereinbarung von Anthropic, den AWS Privacy Notice und das AWS Customer Agreement) und aktiviere das Zustimmungskontrollkästchen.
4. Wähle **Continue**.
Die Seite zeigt ein Banner **Sign-up in progress** an. Bleib auf der Seite. Die Registrierung dauert einige Minuten, während AWS das AWS-Marketplace-Abonnement für dich abwickelt, und leitet dich dann automatisch weiter.
Wenn deine Organisation ein Private Offer von Anthropic hat, sucht die Console danach und fordert dich auf, es in AWS Marketplace anzunehmen. Details findest du unter [Private Offers](https://platform.claude.com/docs/de/about-claude/pricing#private-offers).
Wenn du Claude Platform on AWS nutzt, verarbeitet und speichert Anthropic deine Inhalte (wie Prompts und Ausgaben) auf AWS-Infrastruktur. Bei Workspaces, die vor dem 18. September 2026, 00:00 UTC, erstellt wurden, kann Anthropic diese Inhalte außerhalb von AWS verarbeiten und speichern. Die [Datennutzungsrichtlinien](https://www.anthropic.com/legal) von Anthropic beschreiben, wie Inhalte und Metadaten verarbeitet und gespeichert werden.
Nach Abschluss der Registrierung wirst du zu `platform.claude.com/partner-signup` weitergeleitet.
1. Gib die E-Mail-Adresse des Eigentümers deiner Organisation ein und wähle **Get started**.
2. Prüfe den Posteingang dieser E-Mail-Adresse auf einen Einrichtungslink und folge ihm. Wenn dein Browser eine Seite **Signed in as a different account** anzeigt, wähle **Log out and continue**.
3. Fülle das Formular mit den Organisationsdetails aus (Organisationsname, Rechtsform, Land, beabsichtigte Nutzung) und wähle **Complete setup**.
Mit dem Abschluss der Einrichtung wird deine Anthropic-Organisation erstellt, und du akzeptierst die Commercial Terms of Service und die Usage Policy von Anthropic. Die Dienstseite in der AWS Console zeigt nun eine linke Navigation mit **Home**, **API keys**, **Quickstart** und **Workspaces**.
Nachdem du die Einrichtung abgeschlossen hast, fordert dich die AWS Console auf, einen Workspace zu erstellen. Details zur Regionsbindung, zur Eingrenzung von IAM-Ressourcen und zum Erstellen weiterer Workspaces findest du unter [Workspaces](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#workspaces).
Du findest die Workspace-ID unter **Workspaces** auf der Dienstseite **Claude Platform on AWS** in der AWS Console oder in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console). Workspace-IDs haben das Format `wrkspc_`, gefolgt von einer alphanumerischen Kennung.
Der Zugriff auf die Claude Console wird über AWS IAM föderiert:
1. Übernimm eine IAM-Rolle mit der Berechtigung `aws-external-anthropic:AssumeConsole`. Siehe [IAM-Aktionen für Claude Platform on AWS](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#console-access).
2. Wähle auf der Dienstseite **Claude Platform on AWS** die Option **Open Claude Console**. Die AWS Console stellt ein JWT aus und leitet dich zu `platform.claude.com` weiter.
3. Bei der ersten Anmeldung wirst du nach einer E-Mail-Adresse gefragt. Gib deine geschäftliche E-Mail-Adresse ein. Die Plattform stellt deinen Claude-Console-Benutzer just-in-time bereit.
Wenn du über die AWS Console angemeldet bist, ist die Claude Console auf deine Claude-Platform-on-AWS-Organisation beschränkt. Unten links in der Seitenleiste der Claude Console erscheint ein Hinweis **Account managed by AWS**.
### Umzug von einer bestehenden Anthropic-Organisation
Die Registrierung für Claude Platform on AWS stellt immer eine neue Anthropic-Organisation bereit, die an dein AWS-Konto gebunden ist. Es gibt keine direkte Umwandlung: Eine bestehende Organisation, etwa eine First-Party-Claude-API-Organisation, kann nicht zu einer Claude-Platform-on-AWS-Organisation werden.
Plane einen Umzug von einer bestehenden Organisation als Umstellung auf eine neue:
* **Erstelle zuerst die neue Organisation.** Registriere dich über die AWS Console (siehe [Dein Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account)). Wenn dein Umzug ein Private Offer umfasst, schließe die Registrierung ab, bevor das Angebot angenommen wird: Rabatte gelten ab der Annahme, nicht rückwirkend. Siehe [Private Offers](https://platform.claude.com/docs/de/about-claude/pricing#private-offers).
* **Erstelle Zugriff und Konfiguration neu.** API-Keys, Workspaces und Claude-Console-Einstellungen werden nicht aus einer bestehenden Organisation übernommen. Erstelle Workspaces in der neuen Organisation und stelle deine Anwendungen auf die [Authentifizierung von Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#authentication) um.
* **Aktualisiere deine Integration.** Claude Platform on AWS stellt die Claude API (`/v1/{endpoint}`) bereit, daher sind die Formen von Anfragen und Antworten gegenüber der First-Party-Claude-API unverändert. Was sich ändert, sind die Basis-URL, die Authentifizierungsmethode und der `anthropic-workspace-id`-Header bei Inferenz- und Ressourcenanfragen; siehe [Anfragen stellen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#making-requests). Einige Plattformfunktionen unterscheiden sich; siehe [Nicht unterstützte Funktionen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Stelle nach deinem eigenen Zeitplan um.** Die neue Organisation ist unabhängig von deiner bestehenden, und beide können parallel Traffic verarbeiten. Eine harte Umstellung ist nicht nötig: Verlagere Workloads schrittweise, bis dein gesamter Traffic auf der neuen Organisation läuft.
Sobald die neue Organisation läuft, konzentrieren sich die Unterschiede auf Abrechnung und Authentifizierung, die über AWS abgewickelt werden:
* **Die Abrechnung** wechselt zu AWS Marketplace: Die Nutzung wird in Claude Consumption Units statt in Prepaid-Guthaben abgerechnet (siehe [Abrechnung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#billing)), und du legst Ausgabenlimits auf der Seite „Billing" fest (siehe [Ausgabenlimits](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#spend-limits)). Während des Übergangs bleibt die Abrechnung getrennt: Die bestehende Organisation wird weiterhin so abgerechnet wie bisher.
* **Authentifizierung und Zugriff** wechseln zu AWS: Anfragen authentifizieren sich mit AWS-Anmeldedaten oder mit API-Keys, die in der AWS Console und nicht in der Claude Console generiert werden (siehe [Authentifizierung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#authentication)). Die Mitgliedschaft in der Organisation wird über AWS IAM statt über die Claude Console verwaltet (siehe [Verfügbare Seiten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#available-pages)), und die Client-SDKs von Anthropic stellen plattformspezifische Client-Klassen bereit (siehe [Ein SDK installieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **Die tägliche API-Nutzung** funktioniert wie bei der First-Party-Claude-API, außer wo in den [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported) anders angegeben. Prüfe vor dem Verlagern von Produktions-Traffic deine „rate limits" (Ratenlimits): Neue Organisationen werden in die Start-Stufe eingeordnet, und Erhöhungen der Limits laufen über deinen Anthropic-Ansprechpartner (siehe [Ratenlimits und Kontingente](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Für Claude-Enterprise-Organisationen (claude.ai), die sich anders verhalten, siehe den [Angebotsvergleich](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Fehlerbehebung bei der Kontoeinrichtung
* **„Sign-up failed: Failed to enable OutboundWebIdentityFederation":** Wenn du dieses Banner beim ersten Absenden siehst, wähle erneut **Continue**. Es kann einen Moment dauern, bis die IAM-Aktivierung wirksam wird.
* **Keine Fortschrittsanzeige während der Registrierung:** Die Registrierung dauert einige Minuten. Die Seite zeigt ein statisches Banner **Sign-up in progress** ohne Fortschrittsbalken an, während AWS dein Konto bereitstellt.
* **„Signed in as a different account" nach dem Folgen des Einrichtungslinks:** Wähle **Log out and continue**. Die Seite authentifiziert dich erneut mit der E-Mail-Adresse, die du eingegeben hast.
* **Meldung „Not found" während der Anmeldung:** Diese Meldung kann während der Weiterleitung kurz erscheinen. Du kannst sie schließen.
* **Die Seite „Usage" zeigt nach deinem ersten API-Aufruf keine Daten:** Es kann einige Minuten dauern, bis Nutzungsdaten in der Claude Console erscheinen.
* **„Outbound web identity federation is disabled" bei deinem ersten API-Aufruf:** Aktiviere die Föderation einmal pro Konto. Siehe [Outbound Web Identity Federation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Bevor du API-Aufrufe durchführst
Stelle sicher, dass du Folgendes hast:
1. Ein aktives AWS-Konto mit einem Abonnement für Claude Platform on AWS (siehe [Dein Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account))
2. Die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html), installiert und konfiguriert
3. **Aktivierte Outbound Web Identity Federation** in deinem AWS-Konto, ein einmaliger Einrichtungsschritt (siehe [Outbound Web Identity Federation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation))
4. Deine Workspace-ID (siehe [Deine Workspace-ID ermitteln](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id))
5. Die IAM-Berechtigung zum Aufrufen der API: die Aktion `aws-external-anthropic:CreateInference` für deinen Workspace sowie `aws-external-anthropic:CallWithBearerToken`, wenn du dich mit einem API-Key authentifizierst (siehe [IAM-Richtlinien](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#iam-policies))
### Outbound Web Identity Federation aktivieren
Das Gateway von Claude Platform on AWS ruft serverseitig `sts:GetWebIdentityToken` auf, um ein JWT zu erzeugen, das es an Anthropic weiterleitet. Diese STS-Funktion ist in jedem AWS-Konto **standardmäßig deaktiviert**. Aktiviere sie einmal pro Konto:
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Wenn die Antwort `[ERROR] (FeatureEnabled) ... already enabled` lautet, ist die Einstellung für dein Konto bereits aktiv, und du kannst fortfahren. Überprüfe die Issuer-URL deines Kontos und rufe sie ab:
```bash CLI
aws iam get-outbound-web-identity-federation-info
```
Ohne diesen Schritt gibt jede Anfrage `"Outbound web identity federation is disabled for your account"` zurück. Dies ist der häufigste Einrichtungsfehler.
### Deine Workspace-ID ermitteln
Du erstellst einen Workspace in der AWS Console, nachdem du die Kontoeinrichtung abgeschlossen hast (siehe [Dein Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account)). Workspaces sind an eine einzelne AWS-Region gebunden. Du findest die Workspace-ID in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) unter **Workspaces** oder im Abschnitt **Workspaces** der Dienstseite in der AWS Console.
Setze die Umgebungsvariablen `ANTHROPIC_AWS_WORKSPACE_ID` und `AWS_REGION`, damit die SDK-Clients sie automatisch lesen:
```bash CLI
export ANTHROPIC_AWS_WORKSPACE_ID='wrkspc_01AbCdEf23GhIj'
export AWS_REGION='us-west-2' # Your workspace's AWS region
```
Die Region ist erforderlich. Der SDK-Client löst einen Fehler aus, wenn keine Region gesetzt ist. Übergib `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) beim Erstellen des Clients oder setze `AWS_REGION` (oder `AWS_DEFAULT_REGION`). Alle kommerziellen AWS-Regionen werden unterstützt.
## Authentifizierung
Claude Platform on AWS unterstützt zwei Authentifizierungsmethoden: AWS IAM mit Signature Version 4 (SigV4) Request Signing (primär) und Authentifizierung per API-Key. Beide verwenden dieselbe Basis-URL und dasselbe Anfrageformat.
### SigV4-Authentifizierung
SigV4 ist der Enterprise-native Weg und integriert sich in deine bestehenden AWS-IAM-Richtlinien, -Rollen und -Audits. Konfiguriere AWS-Anmeldedaten mit einer beliebigen Methode, die von der [AWS Default Credential Provider Chain](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) unterstützt wird:
* Umgebungsvariablen (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`)
* Gemeinsame Anmeldedatendatei (`~/.aws/credentials`)
* Gemeinsame Konfigurationsdatei (`~/.aws/config`) einschließlich SSO und `credential_process`
* Web Identity (`AWS_WEB_IDENTITY_TOKEN_FILE` und `AWS_ROLE_ARN`) für IRSA und GitHub Actions
* ECS-Container-Anmeldedaten
* EC2 Instance Metadata Service (IMDS)
Überprüfe, ob deine Anmeldedaten funktionieren:
```bash CLI
aws sts get-caller-identity
```
### Authentifizierung per API-Key
Für einfachere Integrationswege (lokale Entwicklung und Skripte) kannst du dich mit einem API-Key statt mit SigV4 authentifizieren. Setze die Umgebungsvariable `ANTHROPIC_AWS_API_KEY` oder übergib `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) beim Erstellen des Clients.
Generiere API-Keys in der **AWS Console** unter **Claude Platform on AWS → API keys**. Wähle **Generate a key** und kopiere dann den Wert des Keys. Erteile die IAM-Aktion `aws-external-anthropic:CallWithBearerToken` den Principals, die die Authentifizierung per API-Key verwenden dürfen.
API-Keys für Claude Platform on AWS werden in der AWS Console verwaltet, nicht in der Claude Console. Keys, die in der Standard-[Claude Console](https://platform.claude.com/) (für First-Party-API-Zugriff) erstellt wurden, funktionieren nicht mit dem Endpunkt von Claude Platform on AWS.
#### Kurzlebige API-Keys
Für Workloads, die eine Anmeldeinformation an einen separaten Prozess übergeben müssen (etwa ein LLM-Gateway, eine Serverless-Funktion oder ein Tool, das Bearer-Token-Authentifizierung, aber nicht SigV4 unterstützt), generiere einen kurzlebigen API-Key aus deinen AWS-Anmeldedaten, anstatt einen langlebigen Key in der AWS Console bereitzustellen.
AWS veröffentlicht Token-Generator-Bibliotheken für [JavaScript](https://github.com/aws/token-generator-for-aws-external-anthropic-js), [Python](https://github.com/aws/token-generator-for-aws-external-anthropic-python) und [Java](https://github.com/aws/token-generator-for-aws-external-anthropic-java). Jede Bibliothek liest deine AWS-Anmeldedaten über die Standard-Provider-Chain und gibt ein zeitlich begrenztes Token zurück, das du als `Authorization: Bearer ` sendest. Die Token-Lebensdauer beträgt standardmäßig 12 Stunden und ist auf den kleinsten Wert aus deiner angeforderten Dauer, dem Ablauf deiner AWS-Anmeldedaten und 12 Stunden begrenzt. Installations- und vollständige Konfigurationsoptionen findest du in den READMEs der verlinkten Repositories.
Übergib das generierte Token auf dieselbe Weise an das SDK wie einen in der AWS Console generierten API-Key:
```python Python
from token_generator_for_aws_external_anthropic import TokenGenerator
from anthropic import AnthropicAWS
token = TokenGenerator(region="us-west-2").get_token()
client = AnthropicAWS(api_key=token, aws_region="us-west-2")
```
```typescript TypeScript
import { getTokenProvider } from "@aws/token-generator-for-aws-external-anthropic";
import AnthropicAws from "@anthropic-ai/aws-sdk";
const tokenProvider = getTokenProvider({ region: "us-west-2" });
const token = await tokenProvider();
const client = new AnthropicAws({ apiKey: token, awsRegion: "us-west-2" });
```
```java Java
import software.amazon.awsexternalanthropic.TokenGenerator;
import software.amazon.awssdk.regions.Region;
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
void main() {
String token = TokenGenerator.builder().region(Region.US_WEST_2).build().getToken();
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.builder()
.apiKey(token)
.region(Region.US_WEST_2)
.workspaceId(System.getenv("ANTHROPIC_AWS_WORKSPACE_ID"))
.build())
.build();
}
```
Wenn du das Token lokal generieren kannst, verfügt dein Prozess bereits über SigV4-Anmeldedaten, und die SigV4-Authentifizierung ist in der Regel die einfachere Wahl. Verwende kurzlebige Keys, wenn der Prozess, der API-Aufrufe durchführt, von dem Prozess getrennt ist, der die AWS-Anmeldedaten hält.
Das SDK aktualisiert kurzlebige Keys nicht automatisch. Wenn ein Token abläuft, generiere ein neues und erstelle einen neuen Client. Der Principal, der das Token verwendet, benötigt weiterhin die IAM-Aktion `aws-external-anthropic:CallWithBearerToken`.
### Rangfolge der Anmeldedaten
Der plattformspezifische Client ermittelt die Authentifizierung in der folgenden Reihenfolge, beginnend mit dem, was du beim Erstellen übergibst:
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → `Authorization: Bearer`-Header
2. `aws_access_key` (typescript, php: `awsAccessKey`; go: `AWSAccessKey`; java: `.awsAccessKey()`; csharp: `AwsClientOptions.AwsAccessKey`) + `aws_secret_key` (ruby: `aws_secret_access_key`; typescript, php: `awsSecretAccessKey`; go: `AWSSecretAccessKey`; java: `.awsSecretAccessKey()`; csharp: `AwsClientOptions.AwsSecretAccessKey`) → AWS SigV4
3. `aws_profile` (typescript, php: `awsProfile`; go: `AWSProfile`; java: `.awsProfile()`; csharp: `AwsClientOptions.AwsProfile`) → AWS SigV4 mit benanntem Profil
4. Umgebungsvariable `ANTHROPIC_AWS_API_KEY` → `Authorization: Bearer`-Header
5. Standard-AWS-Credential-Provider-Chain → AWS SigV4
### Ermittlung der Region
Der Client liest `AWS_REGION` aus der Umgebung, wenn du `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) nicht setzt, und greift aus Kompatibilitätsgründen mit den Standard-AWS-SDKs auf `AWS_DEFAULT_REGION` zurück. Die Region ist erforderlich, und es gibt keinen Standardwert: `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) löst einen Fehler aus, wenn weder das Konstruktorargument noch eine Umgebungsvariable gesetzt ist.
## Ein SDK installieren
Die [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic unterstützen Claude Platform on AWS. Dein SDK stellt `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient()`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) bereit, das SigV4-Signierung, die regionsbasierte Erstellung der Basis-URL und den `anthropic-workspace-id`-Header übernimmt.
```bash
pip install -U "anthropic[aws]"
```
Unter macOS mit Homebrew-Python oder anderen extern verwalteten Python-Umgebungen kann `pip install` mit einem PEP-668-Fehler `externally-managed-environment` fehlschlagen. Erstelle und aktiviere zuerst eine virtuelle Umgebung: `python3 -m venv .venv && source .venv/bin/activate`.
```bash
npm install @anthropic-ai/aws-sdk
```
```bash
dotnet add package Anthropic.Aws
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.3.0")
implementation("com.anthropic:anthropic-java-aws:3.3.0")
```
```xml Maven
com.anthropic
anthropic-java
3.3.0
com.anthropic
anthropic-java-aws
3.3.0
```
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
```bash
gem install anthropic aws-sdk-core
```
SDK-Clients für Claude Platform on AWS befinden sich in der Beta.
## Verfügbare Modelle
Die folgenden Modelle sind auf Claude Platform on AWS verfügbar:
| Model | Model ID |
| :---------------------------------------------------------------------------------------------------- | :------------------ |
| Claude Fable 5.1 | `claude-fable-5-1` |
| Claude Fable 5 | `claude-fable-5` |
| Claude Opus 5.5 | `claude-opus-5-5` |
| Claude Opus 5 | `claude-opus-5` |
| Claude Opus 4.8 | `claude-opus-4-8` |
| Claude Opus 4.7 | `claude-opus-4-7` |
| Claude Opus 4.6 | `claude-opus-4-6` |
| Claude Opus 4.5 | `claude-opus-4-5` |
| Claude Sonnet 5.5 | `claude-sonnet-5-5` |
| Claude Sonnet 5 | `claude-sonnet-5` |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | `claude-sonnet-4-5` |
| Claude Haiku 5.5 | `claude-haiku-5-5` |
| Claude Haiku 4.5 | `claude-haiku-4-5` |
Die Modell-IDs sind identisch mit denen der First-Party-Claude-API. Es gibt keine ARNs im Bedrock-Stil und keine `anthropic.`-Präfixe.
Neue Modelle erscheinen auf Claude Platform on AWS in der Regel am selben Tag wie in der First-Party-Claude-API.
Du wechselst auf ein neueres Claude-Modell? Der [Claude API Skill](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) in Claude Code wendet Modell-ID-Austausche und inkompatible Parameteränderungen in deiner gesamten Codebasis an:
Lass Claude Code deinen Code für dich migrieren
```text
/claude-api migrate dieses Projekt auf das neueste Claude Opus-Modell
```
Der Skill erkennt, auf welche Cloud-Plattform dein Code abzielt, und passt Modell-ID-Formate und Funktionsänderungen für diese Plattform an.
## Anfragen stellen
Claude Platform on AWS verwendet dieselben API-Endpunkte wie die First-Party-Claude-API. Die Unterschiede sind die Basis-URL, die Authentifizierungsmethode und der `anthropic-workspace-id`-Header, der den [Workspace](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#workspaces) identifiziert, auf den eine Anfrage abzielt. Der Header ist bei Inferenz- und Ressourcenanfragen erforderlich, etwa bei Aufrufen der Messages API, Models API, Files API und der Endpunkte von Claude Managed Agents. Anfragen an die [Admin API](https://platform.claude.com/docs/de/manage-claude/admin-api) benötigen ihn nicht.
Bevor du diese Beispiele ausführst, schließe die Schritte unter [Bevor du API-Aufrufe durchführst](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#before-making-api-calls) ab.
```bash cURL
# Ersetze us-west-2 sowohl in der URL als auch in --aws-sigv4 durch deine AWS-Region
# Lass den Header x-amz-security-token weg, wenn du langfristige IAM-Benutzeranmeldedaten verwendest
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Ersetze us-west-2 durch deine AWS-Region
# ant liest ANTHROPIC_API_KEY. Erstelle einen Key in der AWS Console
# (siehe API-Key-Authentifizierung).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Der Client liest `AWS_REGION` (oder `AWS_DEFAULT_REGION`) und `ANTHROPIC_AWS_WORKSPACE_ID` aus der Umgebung. Du kannst beide überschreiben, indem du beim Erstellen des Clients `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) oder `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `AwsClientOptions.WorkspaceId`) übergibst. Sowohl Region als auch Workspace-ID sind erforderlich. Der Konstruktor löst einen Fehler aus, wenn eines von beiden nicht ermittelt werden kann.
Der Header `x-amz-security-token` (cURL) ist nur für temporäre Anmeldedaten wie IAM-Rollen, SSO oder STS erforderlich. Lass ihn weg, wenn du langfristige IAM-Benutzeranmeldedaten verwendest. Die SDK-Clients handhaben dies automatisch basierend auf der Quelle der Anmeldedaten.
Der Wert von `--aws-sigv4` folgt dem Format `aws:amz::`. Der SigV4-Dienstname ist `aws-external-anthropic`, und die Region muss mit der Region in deiner Endpunkt-URL übereinstimmen. Eine Abweichung bei einem der beiden führt zu einem generischen Fehler wegen abgelehnter Signatur statt zu einer spezifischen Diagnose.
### Kontextfenster
Die Größen des „context window" (Kontextfenster) auf Claude Platform on AWS sind identisch mit denen der First-Party-Claude-API. Die Limits pro Modell findest du unter [Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows).
## Unterstützte Funktionen
Claude Platform on AWS verwendet die Endpunkte der Claude API direkt, was bedeutet, dass du volle Funktionsparität mit der First-Party-Claude-API erhältst (außer wo in den [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported) anders angegeben):
* **Zugriff auf Funktionen:** Da Anthropic beide Plattformen betreibt, werden die meisten neuen Funktionen und Beta-Header auf Claude Platform on AWS ohne separaten Integrationsschritt verfügbar. Ausnahmen findest du unter [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Beta-Funktionen:** Übergib den Standard-Header `anthropic-beta`, um auf Beta-Funktionen zuzugreifen, genau wie bei der Claude API.
* **Agent Skills:** Verwende vorgefertigte und benutzerdefinierte [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) mit demselben Parameter `container.skills` wie bei der Claude API. Alle vorgefertigten Skills (PowerPoint, Excel, Word, PDF) funktionieren sofort.
* **Codeausführung:** Führe Code in der verwalteten Sandbox von Anthropic mit dem [Code-Execution-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool) aus.
* **Tool-Nutzung:** Alle Funktionen der „tool use" (Tool-Nutzung) ([Funktionen der Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview)) sind verfügbar, mit Ausnahme der Toolsets für Computer Use und Browser Use; siehe [Nicht unterstützte Funktionen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Nachdenken:** [Adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking), der [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort) und, bei den Modellen, die es unterstützen, „extended thinking" ([erweitertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking)) funktionieren mit denselben Parametern wie bei der Claude API.
* **Streaming:** Vollständige Unterstützung für SSE-„streaming" (Streaming) für Echtzeitantworten.
* **Batch-Verarbeitung:** Sende Batch-Anfragen für Workloads mit hohem Durchsatz.
* **Prompt-Caching:** Cache Tools, System-Prompts und den Nachrichtenverlauf, um Latenz und Kosten zu reduzieren. Alle Funktionen des „prompt caching" (Prompt-Caching) (5-Minuten-TTL, 1-Stunden-TTL und automatisches Caching) sind verfügbar.
* **Files API:** Lade Dateien hoch und referenziere sie über Anfragen hinweg.
* **Kundenverwaltete Verschlüsselungsschlüssel (CMEK):** [CMEK](https://platform.claude.com/docs/de/manage-claude/cmek) ist nur mit [AWS-KMS](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms)-Schlüsseln verfügbar. Schlüssel aus Google Cloud KMS und Azure Key Vault können nicht registriert werden. Der Schlüssel muss ein Single-Region-KMS-Schlüssel im selben AWS-Konto und in derselben Region wie der Workspace sein, an den er angehängt wird, und seine Schlüsselrichtlinie muss dem Service-Principal `aws-external-anthropic.amazonaws.com` Zugriff gewähren; siehe [CMEK auf Claude Platform on AWS einrichten](https://platform.claude.com/docs/de/manage-claude/cmek-claude-platform-on-aws). Registriere und hänge Schlüssel in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) an; die externen Schlüssel-Endpunkte sind ebenfalls verfügbar und werden über [IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#encryption-keys) autorisiert. Es gibt keinen separaten Validierungsschritt: Der Schlüssel wird implizit validiert, wenn du ihn an einen Workspace anhängst (der Attach-Aufruf führt einen Verschlüsselungs-/Entschlüsselungsdurchlauf durch), sodass ein Problem mit der Schlüsselrichtlinie beim Anhängen und nicht bei der Registrierung auftritt.
* **Compliance API:** Die [Compliance API](https://platform.claude.com/docs/de/manage-claude/compliance-api) ist verfügbar. Der Zugriff wird über die AWS-IAM-Aktion [`ListComplianceActivities`](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#compliance) autorisiert.
Unterschiede in der Verfügbarkeit von Funktionen gegenüber Amazon Bedrock findest du in der [Vergleichstabelle](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) ist auf Claude Platform on AWS verfügbar, einschließlich [Agents](https://platform.claude.com/docs/de/managed-agents/agent-setup), [Umgebungen](https://platform.claude.com/docs/de/managed-agents/environments), [Sessions](https://platform.claude.com/docs/de/managed-agents/sessions), [geplanten Deployments](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments), [Credential Vaults](https://platform.claude.com/docs/de/managed-agents/vaults), [Memory Stores](https://platform.claude.com/docs/de/managed-agents/memory), [Webhooks](https://platform.claude.com/docs/de/managed-agents/webhooks), [Multiagent-Orchestrierung](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration) und [selbst gehosteten Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes).
Sessions und selbst gehostete Worker auf Claude Platform on AWS unterscheiden sich in drei Punkten von First-Party-Claude Managed Agents:
* **Erneute Authentifizierung autonomer Sessions:** Eine Session kann bis zu 6 Stunden lang autonom laufen, ohne [User-Events](https://platform.claude.com/docs/de/managed-agents/reference#event-types). Nach 6 Stunden erfordert die Session eine erneute Authentifizierung, bevor sie fortgesetzt wird. Um dich erneut zu authentifizieren, sende ein beliebiges Event mit der Rolle „user" an die Session (siehe [Events und Streaming](https://platform.claude.com/docs/de/managed-agents/events-and-streaming)). First-Party-Claude Managed Agents hat kein Laufzeitlimit für autonome Sessions.
* **[Memory Stores in selbst gehosteten Umgebungen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory):** Eine Session, die in einer selbst gehosteten Umgebung läuft, kann keine Memory Stores anhängen; eine Session, die einen enthält, wird bei der Erstellung abgelehnt. Sessions in Cloud-Umgebungen hängen Memory Stores wie gewohnt an. Bei First-Party-Claude Managed Agents können Sessions sowohl in Cloud- als auch in selbst gehosteten Umgebungen Memory Stores anhängen.
* **[Worker-Authentifizierung in selbst gehosteten Umgebungen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#prerequisites):** Ein Worker authentifiziert sich mit AWS IAM (SigV4) oder einem [in der AWS Console generierten API-Key](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#api-key-authentication), nicht mit einem Environment-Key. In der Claude Console generierte Environment-Keys funktionieren nicht mit dem Endpunkt von Claude Platform on AWS.
### Nicht unterstützte Funktionen
Die folgenden Funktionen sind auf Claude Platform on AWS derzeit nicht verfügbar:
* **HIPAA-Bereitschaft:** Das HIPAA-ready-Programm von Anthropic ist nicht verfügbar. Siehe [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).
* **Toolsets für Computer Use und Browser Use:** `computer_toolset_20260801` und `browser_toolset_20260801` sind auf Claude Platform on AWS derzeit nicht verfügbar. Die Beta-Versionen des Computer-Use-Tools bleiben für die unter [Frühere Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) aufgeführten Modelle verfügbar.
- **Admin API:** Workspace-Endpunkte (Erstellen, Abrufen, Auflisten, Aktualisieren und Archivieren unter `/v1/organizations/workspaces`), Endpunkte für externe Keys (Registrieren, Abrufen, Auflisten, Aktualisieren und Löschen unter `/v1/organizations/external_keys`, für [CMEK](https://platform.claude.com/docs/de/manage-claude/cmek); Keys werden beim Anhängen an einen Workspace validiert statt über einen Validierungsendpunkt) sowie die [Endpunkte für Telemetrieziele](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#telemetry-destinations) sind verfügbar. Andere Admin-API-Endpunkte (Organisationsmitglieder, Workspace-Mitglieder, Einladungen, API-Keys, Nutzungsberichte, Kostenberichte und Ratenlimit-Berichte) sind derzeit nicht verfügbar. Sieh dir Nutzungs- und Kostendaten stattdessen in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) an. AWS IAM verwaltet die Organisationsmitgliedschaft.
- **Verwaltung von Workspace-Mitgliedern:** Das Hinzufügen oder Entfernen von Benutzern zu bzw. aus einzelnen Workspaces ist nicht verfügbar. AWS-IAM-Richtlinien auf Workspace-ARNs steuern den Zugriff.
- **Claude-Code-Workspace und Analytics API:** Der Claude-Code-Workspace mit automatischen Ratenlimits ist nicht verfügbar. Die Claude-Code-Nutzung erscheint in der allgemeinen Nutzungsansicht statt auf einer eigenen Seite.
- **OAuth-Authentifizierung:** Nicht unterstützt. Verwende SigV4- oder API-Key-Authentifizierung.
- **Fast Mode:** Auf Claude Platform on AWS nicht verfügbar.
- **OpenAI-kompatible API-Endpunkte:** Auf Claude Platform on AWS nicht verfügbar.
- **MCP-Tunnel:** Es werden nur MCP-Server unterstützt, die über das öffentliche Internet erreichbar sind.
## Datenresidenz
Claude Platform on AWS unterstützt die folgenden Inferenz-Geografien:
* **US:** Die Inferenz bleibt in US-Rechenzentren. Es gilt ein Preismultiplikator von 1,1x.
* **Global:** Die Inferenz kann an jedes von Anthropic betriebene Rechenzentrum weltweit geleitet werden. Es gelten die Standardpreise.
Die AWS-Region, an die dein Workspace gebunden ist, bestimmt, welchen Gateway-Endpunkt du aufrufst und wo AWS-seitige Ressourcen (IAM, CloudTrail, Abrechnung) angesiedelt sind. Sie legt nicht fest, wo die Modellinferenz ausgeführt wird. Um die Inferenz auf eine bestimmte Geografie festzulegen, setze `inference_geo` bei jeder Anfrage oder konfiguriere einen Workspace-Standard.
Lege die Inferenz-Geografie pro Anfrage mit dem Parameter `inference_geo` fest:
Der Parameter `inference_geo` wird von Claude 4.6 und neueren Modellen unterstützt. Anfragen mit `inference_geo` an Claude Opus 4.5, Claude Sonnet 4.5 (abgekündigt) oder Claude Haiku 4.5 geben einen 400-Fehler zurück. Details zur Modellverfügbarkeit findest du unter [Datenresidenz](https://platform.claude.com/docs/de/manage-claude/data-residency).
```bash cURL
# Ersetze us-west-2 sowohl in der URL als auch in --aws-sigv4 durch deine AWS-Region
# Lass den Header x-amz-security-token weg, wenn du langfristige IAM-Benutzeranmeldedaten verwendest
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"inference_geo": "us",
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Ersetze us-west-2 durch deine AWS-Region
# ant liest ANTHROPIC_API_KEY. Erzeuge einen Key in der AWS Console
# (siehe API-Key-Authentifizierung).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--inference-geo us \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
inference_geo="us",
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
InferenceGeo = "us",
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
InferenceGeo: anthropic.String("us"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.inferenceGeo("us")
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
inferenceGeo: 'us',
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Wenn du `inference_geo` weglässt, verwendet die Anfrage den `default_inference_geo` des Workspace, sofern einer konfiguriert ist, andernfalls `global`.
Steuerungen der Inferenz-Geografie auf Workspace-Ebene (`allowed_inference_geos` und `default_inference_geo`) sind ebenfalls auf Claude Platform on AWS verfügbar. Siehe [Einschränkungen auf Workspace-Ebene](https://platform.claude.com/docs/de/manage-claude/data-residency#workspace-level-restrictions).
## Workspaces
Inferenz- und Ressourcenanfragen auf Claude Platform on AWS richten sich an einen Workspace. Du übergibst die ID des Workspace bei diesen API-Aufrufen im Header `anthropic-workspace-id`. Workspace-IDs verwenden das getaggte Format `wrkspc_`, gefolgt von einer alphanumerischen Kennung (zum Beispiel `wrkspc_01AbCdEf23GhIj`). Siehe [Workspace-ID abrufen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id), falls du sie noch nicht hast.
### Workspace-Geltungsbereich
Workspaces sind an eine einzelne AWS-Region gebunden. Ein in `us-west-2` erstellter Workspace kann nur über den Endpunkt `us-west-2` aufgerufen werden. Nutzung, Kontingente, Kosten, Dateien, Batches und Skills werden jeweils pro Workspace zusammengefasst, sodass du in der Claude Console Aufschlüsselungen pro Region erhältst.
Workspaces dienen außerdem als primäre IAM-Ressource für Claude Platform on AWS. Du gewährst oder verweigerst den Zugriff auf bestimmte Workspaces über AWS-IAM-Richtlinien mithilfe der Workspace-ARN. Das Ressourcensegment der ARN ist dieselbe mit `wrkspc_` beginnende ID, die du im Header `anthropic-workspace-id` übergibst:
```text wrap
arn:aws:aws-external-anthropic:{region}:{account-id}:workspace/{workspace-id}
```
Zum Beispiel:
```text wrap
arn:aws:aws-external-anthropic:us-west-2:123456789012:workspace/wrkspc_01AbCdEf23GhIj
```
Richtlinienbeispiele findest du unter [IAM-Richtlinien](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#iam-policies).
### Workspaces verwalten
Erstelle zusätzliche Workspaces, benenne einen Workspace um oder archiviere einen Workspace über die Seite **Workspaces** in der AWS Console oder mit den Workspace-Endpunkten der [Admin API](https://platform.claude.com/docs/de/manage-claude/admin-api). Diese Endpunkte benötigen den Header `anthropic-workspace-id` nicht. Erstellen und Auflisten wirken auf die Organisation; Abrufen, Aktualisieren und Archivieren erwarten die Workspace-ID im URL-Pfad. Ein neuer Workspace wird an die AWS-Region des Endpunkts gebunden, den du zum Erstellen aufrufst (siehe [Workspace-Geltungsbereich](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#workspace-scoping)). Mit der Admin-Rolle kannst du Workspaces auch über die Seite **Workspaces** in der Claude Console erstellen, umbenennen und archivieren.
## Die Claude Console verwenden
Claude Platform on AWS verwendet die Standard-Claude Console unter [platform.claude.com](https://platform.claude.com). Wenn du dich über die AWS Console anmeldest, erscheint unten links in der Seitenleiste der Claude Console der Hinweis **Account managed by AWS**, und die Console ist auf deine Claude-Platform-on-AWS-Organisation beschränkt. Sie bietet Nutzungsanalysen, Kostenaufschlüsselungen, Einblick in Ratenlimits, Workspace-Verwaltung sowie Seiten zur Verwaltung von Dateien, Agent Skills, Batch-Jobs und Ressourcen von Claude Managed Agents (Agents, Sessions, Umgebungen, Credential Vaults, Memory Stores und Webhooks).
### Anmelden
Der Zugriff auf die Claude Console wird über AWS IAM föderiert. Den vollständigen Ablauf der ersten Anmeldung findest du unter [Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account). Kurz gesagt:
1. Übernimm eine IAM-Rolle mit der Berechtigung `aws-external-anthropic:AssumeConsole`. Siehe [IAM-Aktionen für Claude Platform on AWS](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#console-access).
2. Navigiere in der [AWS Console](https://console.aws.amazon.com/) zur Seite von Claude Platform on AWS.
3. Wähle **Open Claude Console**. Die AWS Console stellt ein JWT aus und leitet dich zu `platform.claude.com` weiter.
4. Bei der ersten Anmeldung wirst du nach einer E-Mail-Adresse gefragt. Gib deine geschäftliche E-Mail-Adresse ein. Die Plattform stellt deinen Claude-Console-Benutzer just-in-time bereit.
Es stehen zwei Claude-Console-Rollen zur Verfügung: **Admin** und **Developer**. Die Admin-Rolle gewährt Zugriff auf alle Seiten und Einstellungen der Claude Console, die für Claude Platform on AWS verfügbar sind. Die Developer-Rolle gewährt Lesezugriff auf Informationen zu Nutzung, Kosten, Ratenlimits und Workspaces. Wende dich an deinen Anthropic-Ansprechpartner, um einem Principal die Admin- oder Developer-Rolle zuzuweisen.
### Verfügbare Seiten
Die Spalte **Über AWS-Gateway** gibt an, ob die Seite Daten über das AWS-Gateway liest und schreibt (und daher durch [IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions) gesteuert wird). Mit **Nein** gekennzeichnete Seiten lesen Metadaten auf Organisationsebene direkt von Anthropic und umgehen IAM-Aktionsprüfungen.
| Seite | Verfügbar | Über AWS-Gateway | Hinweise |
| --------------------- | ------------------ | ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Usage** | Ja | Nein | Zeige die Token-Nutzung nach Modell, Workspace und Dimension an. Es kann einige Minuten dauern, bis Daten nach einer Anfrage erscheinen. |
| **Cost** | Ja | Nein | Zeige Kostenaufschlüsselungen nach Modell und Workspace an. AWS Cost Explorer zeigt die aggregierte Position in [Claude Consumption Units (CCU)](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#billing). |
| **Rate limits** | Ja | Nein | Zeige Ratenlimits an (schreibgeschützt). Tier-Erhöhungen laufen über deinen Anthropic-Ansprechpartner; siehe [Ratenlimits und Kontingente](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas). |
| **Workspaces** | Ja | Ja (außer Ausgabenlimits) | Zeige Workspaces pro Region an. Mit der Admin-Rolle kannst du außerdem Workspaces erstellen, umbenennen und archivieren sowie [Ausgabenlimits](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#spend-limits) pro Workspace festlegen. |
| **Encryption keys** | Ja | Ja | Ein Abschnitt der Seite [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`) in der Claude Console, der angezeigt wird, während im Dropdown-Menü oben auf der Seite **Organization** ausgewählt ist. Registriere dort AWS-KMS-Keys für [CMEK](https://platform.claude.com/docs/de/manage-claude/cmek-claude-platform-on-aws) (Admin-Rolle). Um einen registrierten Key an einen Workspace anzuhängen, wähle den Workspace in diesem Dropdown-Menü aus und wähle dann den Key unter **Encryption key** aus. |
| **Files** | Ja | Ja | Zeige hochgeladene Dateien an und verwalte sie. |
| **Skills** | Ja | Ja | Zeige Agent Skills an und verwalte sie. |
| **Batches** | Ja | Ja | Zeige Batch-Verarbeitungsjobs an und verwalte sie. |
| **Agents** | Ja | Ja | Zeige Agent-Definitionen an und verwalte sie. |
| **Sessions** | Ja | Ja | Zeige Agent-Sessions und den Event-Verlauf an. |
| **Environments** | Ja | Ja | Zeige Cloud-Sandbox-Konfigurationen für Sessions an und verwalte sie. |
| **Credential vaults** | Ja | Ja | Zeige Credential Vaults für die Session-Authentifizierung an und verwalte sie. |
| **Memory stores** | Ja | Ja | Zeige persistenten Agent-Speicher an und verwalte ihn. |
| **Webhooks** | Ja | Ja | Zeige Webhook-Endpunkte an und verwalte sie. |
| **API keys** | Nein | k. A. | Verwalte API-Keys in der AWS Console (**Claude Platform on AWS → API keys**). Siehe [API-Key-Authentifizierung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | Nein | k. A. | Nicht zutreffend. AWS IAM verwaltet den Zugriff. |
| **Billing** | Ja (eingeschränkt) | Nein | Lege ein monatliches Ausgabenlimit für die Organisation fest; siehe [Ausgabenlimits](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#spend-limits). AWS Marketplace verwaltet die Rechnungsstellung. Kostenaufschlüsselungen findest du auf der Seite Cost. |
| **Claude Code** | Nein | k. A. | Zeige die Claude-Code-Nutzung auf der Seite Usage an. |
### Organisation wechseln
Die Claude Console unterstützt für Claude Platform on AWS keinen Organisationswechsel. Um auf eine andere Organisation zuzugreifen, melde dich ab und authentifiziere dich erneut über die AWS Console mit der IAM-Rolle für das AWS-Konto dieser Organisation.
## Ratenlimits und Kontingente
Organisationen auf Claude Platform on AWS werden in den Start-Tier eingestuft. Anthropic verwaltet „rate limits" (Ratenlimits) direkt, nicht über AWS-Kontingentsysteme.
Organisationen auf Claude Platform on AWS können automatisch in einen höheren Nutzungs-Tier aufsteigen, wenn sie eine Historie bezahlter AWS-Marketplace-Rechnungen aufbauen. Der Self-Service-Ablauf **Request tier increase** in der Claude Console ist nicht verfügbar: Die Seite Rate limits verweist dich stattdessen an deinen Anthropic-Ansprechpartner.
Um höhere Limits anzufordern, wende dich an deinen Anthropic-Ansprechpartner oder den [Anthropic-Support](https://support.claude.com). Gib in deiner Anfrage Folgendes an:
* Die Modelle, deren Limits erhöht werden sollen
* Spitzenwerte für Input-Token pro Minute und Output-Token pro Minute für jedes Modell (keine Tagessummen)
* Den ungefähren Anteil deines Inputs, der aus gecachtem oder wiederholtem Kontext besteht (Cache-Lesevorgänge zählen bei den meisten Modellen nicht zu den Input-Token-Limits; siehe [Cache-bewusstes ITPM](https://platform.claude.com/docs/de/api/rate-limits#cache-aware-itpm))
Nutzungs-Tiers sind feste Stufen: Jeder Tier kombiniert Ratenlimits mit einer [monatlichen Ausgabenobergrenze](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#spend-limits), und der Wechsel in einen höheren Tier erhöht beides. Details zu den Tiers und Limits pro Modell findest du unter [Ratenlimits](https://platform.claude.com/docs/de/api/rate-limits).
## Abrechnung
Claude Platform on AWS wird über [AWS Marketplace](https://aws.amazon.com/marketplace) abgerechnet. Die Nutzung wird in Claude Consumption Units (CCUs) angegeben, stündlich gemessen und monatlich nachträglich über deine AWS-Rechnung abgerechnet. CCUs sind keine vorausbezahlten Guthaben. Es gibt kein CCU-Guthaben und keine Mindestabnahme.
Den CCU-Preis, die Umrechnungsmechanik, die Anwendung von Rabatten und die Token-Preise pro Modell findest du unter [Preise für Claude Platform on AWS](https://platform.claude.com/docs/de/about-claude/pricing#claude-platform-on-aws-pricing).
### Ausgabenlimits
Die Nutzungs-Tiers Start, Build und Scale haben jeweils eine monatliche Ausgabenobergrenze; die aktuellen Werte findest du unter [Ausgabenobergrenzen pro Tier](https://platform.claude.com/docs/de/api/rate-limits#spend-limits). Wenn die Nutzung deiner Organisation im Kalendermonat die Obergrenze ihres Tiers erreicht, schlagen API-Anfragen bis 00:00 UTC am ersten Tag des Folgemonats mit dem [Fehler für die Ausgabenobergrenze](https://platform.claude.com/docs/de/api/rate-limits#reaching-your-spend-cap) fehl, und frühere Wiederholungsversuche sind nicht erfolgreich. Die Ausgabenobergrenze und die Ratenlimits gehören zum selben Tier. Um die Obergrenze anzuheben oder den Zugriff nach Erreichen wiederherzustellen, beantrage eine Tier-Erhöhung über deinen Anthropic-Ansprechpartner oder den [Anthropic-Support](https://support.claude.com) (siehe [Ratenlimits und Kontingente](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Du kannst außerdem eigene monatliche Ausgabenlimits unterhalb der Obergrenze festlegen, nachdem du auf der Seite Billing unter **Email recipients** mindestens einen Empfänger hinzugefügt hast:
* **Ausgabenlimit der Organisation:** Gehe in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) zu [Settings > Billing](https://platform.claude.com/settings/billing), um ein monatliches Ausgabenlimit festzulegen.
* **Ausgabenlimits für Workspaces:** Wähle auf der Seite [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) in der Claude Console einen Workspace aus. Klicke im sich öffnenden Bereich auf **Spend limits**.
Wenn die Nutzung ein von dir festgelegtes Limit erreicht, schlagen Anfragen mit HTTP 400 fehl (siehe den [Fehler für Ausgabenlimits](https://platform.claude.com/docs/de/api/rate-limits#setting-your-own-spend-limit)), bis 00:00 UTC am ersten Tag des Folgemonats oder bis du das Limit anhebst oder entfernst.
Die Ausgaben werden zu Listenpreisen berechnet, und es kann etwa 2 Stunden dauern, bis aktuelle Nutzung berücksichtigt wird. Daher kann die Nutzung die Obergrenze oder ein Limit überschreiten, bevor Anfragen fehlschlagen. Die Überschreitung wird in Rechnung gestellt. Wenn die Tier-Obergrenze oder ein Ausgabenlimit der Organisation deine Anfragen stoppt, wird eine E-Mail-Benachrichtigung an die Empfänger gesendet, die auf der Seite Billing unter **Email recipients** aufgeführt sind. Rollenbasierte Empfänger, etwa alle Admins, sind auf Claude Platform on AWS nicht verfügbar. Die Benachrichtigung zur Tier-Obergrenze geht außerdem an die E-Mail-Adresse, die bei der Registrierung im AWS Marketplace verwendet wurde.
## Überwachung und Protokollierung
AWS CloudTrail kann alle Anfragen an Claude Platform on AWS erfassen. Operationen für Workspaces, externe Keys, Telemetrieziele, Compliance, Vaults und Webhooks werden standardmäßig als Management-Events protokolliert. Operationen für Inferenz, Batches, Dateien, Skills, Modelle, Benutzerprofile und Claude Managed Agents (außer Vaults und Webhooks) werden als Data-Events klassifiziert und erfordern eine explizite Konfiguration der Data-Event-Protokollierung, für die zusätzliche CloudTrail-Gebühren anfallen. Die vollständige Klassifizierung der Event-Typen findest du in der [Referenz der IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#route-to-action-mapping), Konfigurationsdetails in der [AWS-CloudTrail-Dokumentation](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
### Request-IDs
Jede Antwort enthält in den Antwort-Headern zwei Request-IDs:
* **AWS-Request-ID (`x-amzn-requestid`):** Die primäre ID, in CloudTrail indiziert. Verwende sie, wenn du Anfragen mit AWS-Tools untersuchst oder den AWS-Support kontaktierst.
* **Anthropic-Request-ID (`request-id`):** Die sekundäre ID. Verwende sie, wenn du den Anthropic-Support kontaktierst.
```bash cURL
# Ersetze us-west-2 sowohl in der URL als auch in --aws-sigv4 durch deine AWS-Region
# -i gibt die Response-Header in der Ausgabe mit aus
# Lass den Header x-amz-security-token weg, wenn du langfristige IAM-Benutzer-Credentials verwendest
curl -i "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--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" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Ersetze us-west-2 durch deine AWS-Region
# ant liest ANTHROPIC_API_KEY. Erzeuge einen Key in der AWS Console
# (siehe API-Key-Authentifizierung).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
# --debug gibt die HTTP-Antwort inklusive der Header X-Amzn-Requestid und
# Request-Id auf stderr aus
ant --debug messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
response = client.messages.with_raw_response.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.headers.get("x-amzn-requestid")) # AWS request ID
print(response.headers.get("request-id")) # Anthropic request ID
message = response.parse()
print(message.content)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const { data: message, response } = await client.messages
.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
})
.withResponse();
console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var response = await client.WithRawResponse.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello!" }]
});
Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
var response *http.Response
message, err := client.Messages.New(
context.Background(),
anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
},
option.WithResponseInto(&response),
)
if err != nil {
panic(err)
}
fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id")) // Anthropic request ID
fmt.Println(message.Content)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
HttpResponseFor response = client.messages().withRawResponse().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(response.headers().values("x-amzn-requestid").get(0)); // AWS request ID
IO.println(response.requestId().orElse(null)); // Anthropic request ID
IO.println(response.parse().content());
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$response = $client->messages->raw->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse()->content;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
# Lies Response-Header in einer Per-Request-Middleware, die die
# rohe HTTP-Antwort erhält, bevor das SDK sie parst
aws_request_id = nil
anthropic_request_id = nil
read_request_ids = lambda do |request, call_next|
response = call_next.call(request)
# Die Keys in response.headers sind kleingeschrieben
aws_request_id = response.headers["x-amzn-requestid"]
anthropic_request_id = response.headers["request-id"]
response
end
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }],
request_options: { middleware: [read_request_ids] }
)
puts aws_request_id # AWS request ID
puts anthropic_request_id # Anthropic request ID
puts message.content
```
Anthropic empfiehlt, deine Aktivitäten mindestens über einen rollierenden Zeitraum von 30 Tagen zu protokollieren, um Nutzungsmuster zu verstehen und Probleme zu untersuchen.
AWS CloudTrail wird in deinem AWS-Konto konfiguriert. Das Aktivieren der Protokollierung gewährt AWS oder Anthropic keinen Zugriff auf deine Inhalte über das hinaus, was für die Abrechnung und den Servicebetrieb erforderlich ist.
## Migration von Amazon Bedrock
Wenn du Claude derzeit auf Bedrock nutzt, erfordert die Migration zu Claude Platform on AWS Änderungen in deiner gesamten Integration. SigV4-Signierung wird weiterhin unterstützt, aber Signierkontext, Basis-URL, API-Format, Modell-IDs, SDK-Client und -Paket, Streaming-Format, Request-Header und regionale Verfügbarkeit ändern sich. Claude Platform on AWS stellt außerdem eine neue Anthropic-Organisation bereit. Die folgende Tabelle fasst die Unterschiede zusammen.
### Was sich ändert
Der Migrationsaufwand hängt davon ab, von welcher Bedrock-Integration du kommst. Die folgende Tabelle zeigt sowohl die [aktuelle Bedrock-Integration](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) (Messages API unter `bedrock-mantle.{region}.api.aws`) als auch die [veraltete InvokeModel-Integration](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy).
| Aspekt | Von [Claude in Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) | Von [Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) | Zu Claude Platform on AWS |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Basis-URL** | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` | `aws-external-anthropic.{region}.api.aws` |
| **API-Format** | Messages API unter `/anthropic/v1/messages` | Bedrock Converse / InvokeModel | Claude API (`/v1/{endpoint}`) |
| **Modell-IDs** | anthropic.claude-haiku-4-5 | anthropic.claude-haiku-4-5-20251001-v1:0 (mit einem Inferenzprofil-Präfix `us.` oder `global.`) | claude-haiku-4-5 |
| **SDK-Client** | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK | Plattformspezifischer Client (siehe [SDK installieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#install-an-sdk)), in der Beta |
| **SDK-Paket** | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) oder das AWS SDK | `anthropic[aws]` (typescript: `@anthropic-ai/aws-sdk`; csharp: `Anthropic.Aws`; go: `github.com/anthropics/anthropic-sdk-go/aws`; java: `com.anthropic:anthropic-java-aws`; php: `anthropic-ai/sdk`; ruby: `anthropic`) (siehe [SDK installieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#install-an-sdk)) |
| **SigV4-Servicename** | `bedrock-mantle` | `bedrock` | `aws-external-anthropic` |
| **Streaming-Format** | SSE | AWS EventStream | SSE (wie bei der Claude API) |
| **Workspace-Header** | Nicht zutreffend | Nicht zutreffend | `anthropic-workspace-id`, erforderlich bei Inferenz- und Ressourcenanfragen |
| **Regionale Verfügbarkeit** | Siehe [Amazon-Bedrock-Regionen](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Siehe [Amazon-Bedrock-Regionen](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Alle kommerziellen AWS-Regionen |
| **Anthropic-Organisation** | Nicht erforderlich | Nicht erforderlich | Neue Organisation, die bei der Registrierung erstellt wird. Bestehende Organisationen können nicht umgewandelt werden (siehe [Wechsel von einer bestehenden Anthropic-Organisation](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#moving-from-an-existing-anthropic-organization)) |
Wenn du die aktuelle Bedrock-Integration nutzt, entspricht das Format des Request-Bodys bereits der Messages API. Die Änderungen betreffen die Basis-URL, den SigV4-Servicenamen, die Modell-IDs und das Hinzufügen des Headers `anthropic-workspace-id`. Wenn du die veraltete InvokeModel- oder Converse-API nutzt, musst du außerdem die Request- und Response-Strukturen auf das Format der Messages API umschreiben. Die Zuordnung der Request-Strukturen findest du 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).
### Was du gewinnst
* In der Regel Zugriff auf neue Modelle und Funktionen noch am selben Tag (siehe [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported))
* Agent Skills zur Dokumenterstellung (PowerPoint, Excel, Word, PDF)
* Codeausführung in der verwalteten Sandbox von Anthropic
* Beta-Funktionen der Claude API, die Amazon Bedrock nicht anbietet, über den Header `anthropic-beta` (siehe [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported))
* Claude Console für Einblick in Kontingente und Nutzungsanalysen
* Direkter Support von Anthropic
* API-Key-Authentifizierung als Alternative zu SigV4 (siehe [API-Key-Authentifizierung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#api-key-authentication))
### Was gleich bleibt
* AWS-IAM-Authentifizierung (SigV4)
* AWS als rechnungsstellende Partei. Der Abrechnungskanal wechselt vom nativen AWS-Service zu AWS Marketplace (siehe [Kommerzielle Aspekte](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#commercial-considerations)).
* Anrechnung auf AWS-Commitments
### Fallstricke bei der Migration
**Aktiviere zuerst die ausgehende Web-Identity-Föderation.** Wenn dein AWS-Konto Claude Platform on AWS noch nicht verwendet hat, musst du einmal pro Konto die [ausgehende Web-Identity-Föderation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation), bevor du Anfragen stellst. Ohne diesen Schritt schlagen alle Anfragen mit einem Föderationsfehler fehl (den genauen Fehler und die Behebung findest du unter [Ausgehende Web-Identity-Föderation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation)). Für Bedrock ist dieser Schritt nicht erforderlich.
**Zero Data Retention (ZDR) ist auf Claude Platform on AWS optional (Opt-in).** Auf Bedrock ist AWS der Datenverarbeiter, und Anthropic speichert keine Inferenz-Inputs oder -Outputs. Das ZDR-Programm von Anthropic gilt dort nicht. Auf Claude Platform on AWS verarbeitet Anthropic Inferenzdaten als unabhängiger Datenverarbeiter, und ZDR folgt dem Modell der First-Party-Claude-API: Es ist auf Anfrage über deinen Anthropic-Ansprechpartner verfügbar. Bestätige die ZDR-Registrierung, bevor du Produktions-Workloads migrierst, die auf Garantien zur Datenaufbewahrung angewiesen sind.
### Kommerzielle Aspekte
* **Nutzungsbedingungen von Anthropic:** Die Nutzung von Claude Platform on AWS erfordert die Annahme der Commercial Terms of Service und der Usage Policy von Anthropic. Wenn deine Organisation diese noch nicht akzeptiert hat (zum Beispiel, wenn du Claude bisher nur über Bedrock genutzt hast), wirst du bei der Kontoeinrichtung dazu aufgefordert. Siehe [Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account).
* **Rabatte und Private Offers:** Ausgehandelte Rabatte und AWS-Marketplace-Private-Offers werden nicht automatisch zwischen Bedrock und Claude Platform on AWS übertragen. Arbeite mit deinem Anthropic-Ansprechpartner zusammen, um kommerzielle Bedingungen für Claude Platform on AWS festzulegen.
## IAM-Richtlinien
Claude Platform on AWS ist zur Zugriffssteuerung in AWS IAM integriert. Du gewährst oder verweigerst den Zugriff auf bestimmte API-Aktionen für bestimmte Workspaces mit der Standard-Syntax für IAM-Richtlinien.
Der SigV4-Servicename und der Namespace der IAM-Aktionen lautet `aws-external-anthropic`. Aktionen folgen dem Muster `aws-external-anthropic:` (zum Beispiel `aws-external-anthropic:CreateInference`).
### Beispiel: Batch-Inferenz verweigern
Die folgende Richtlinie erlaubt Echtzeit-Inferenz und blockiert gleichzeitig die Batch-Verarbeitung:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aws-external-anthropic:CreateInference",
"aws-external-anthropic:CountTokens",
"aws-external-anthropic:GetModel",
"aws-external-anthropic:ListModels",
"aws-external-anthropic:GetWorkspace"
],
"Resource": "arn:aws:aws-external-anthropic:*:*:workspace/*"
},
{
"Effect": "Allow",
"Action": "aws-external-anthropic:ListWorkspaces",
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"aws-external-anthropic:CreateBatchInference",
"aws-external-anthropic:GetBatchInference",
"aws-external-anthropic:ListBatchInferences"
],
"Resource": "*"
}
]
}
```
Die Aktion `GetBatchInference` autorisiert sowohl die Route für Batch-Metadaten als auch die Route für Batch-Ergebnisse. Wenn du sie verweigerst, werden beide Lesevorgänge blockiert. Eine reine Deny-Richtlinie für ZDR-sensible Workloads findest du unter [Funktionssperre für einen ZDR-sensiblen Workspace](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#feature-lockdown-for-a-zdr-sensitive-workspace).
`ListWorkspaces` ist kontobezogen und erscheint daher in einer separaten Allow-Anweisung mit `"Resource": "*"`. Die Angabe einer Workspace-ARN bei einer kontobezogenen Aktion hat keine Wirkung (siehe [Bereitstellungsautomatisierung](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#provisioning-automation)).
Diese Richtlinie setzt AWS-SigV4-Authentifizierung voraus. Wenn sich der Principal mit einem API-Key authentifiziert, füge außerdem `aws-external-anthropic:CallWithBearerToken` zur Allow-Anweisung mit `"Resource": "*"` hinzu. `CallWithBearerToken` ist eine routenlose Aktion der Authentifizierungsschicht, die nicht an eine Workspace-ARN gebunden ist. Das Muster mit zwei Anweisungen findest du unter [Workspace-Isolation pro Kunde](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#per-customer-workspace-isolation).
### Verwaltete Richtlinien
AWS stellt fünf verwaltete Richtlinien (`AnthropicFullAccess`, `AnthropicReadOnlyAccess`, `AnthropicInferenceAccess`, `AnthropicLimitedAccess` und `AnthropicSelfHostedEnvironmentAccess`) für gängige Zugriffsmuster bereit. Die Aktionen, die jede Richtlinie gewährt, die vollständige Liste der IAM-Aktionen, die Zuordnung von Routen zu Aktionen und weitere Richtlinienbeispiele findest du unter [IAM-Aktionen für Claude Platform on AWS](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#managed-policies).
## Nächste Schritte
Entdecke die erweiterten Funktionen und Fähigkeiten von Claude.
Erfahre mehr über die Preise von Claude Platform on AWS und die Tarife für Claude Consumption Units.
Wenn sicherere und leistungsfähigere Modelle erscheinen, stellt Anthropic ältere Modelle regelmäßig ein. Sieh dir alle API-Abkündigungen zusammen mit empfohlenen Ersatzmodellen an.
## Weitere Ressourcen
Zeige Nutzung, Kosten und Workspaces in der Claude Console an. Melde dich über die AWS Console an.
Verwende von AWS betriebenes Claude, wenn du AWS als alleinigen Datenverarbeiter benötigst.
Verwalte dein AWS-Marketplace-Abonnement und deine Abrechnung.