---
title: Claude Platform on AWS
url: https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws
description: Greife über AWS auf die vollständigen Plattformfunktionen von Claude zu, mit von Anthropic verwalteter Infrastruktur.
---
Claude Platform on AWS bietet dir das vollständige Erlebnis der Anthropic-Plattform über dein AWS-Konto, einschließlich der Messages API, Agent Skills, Code-Ausführung und Beta-Funktionen. Bei [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) betreibt AWS den Inferenz-Stack. Claude Platform on AWS wird dagegen von Anthropic betrieben. AWS stellt die Authentifizierungsschicht (SigV4 oder API-Key), die IAM-basierte Zugriffskontrolle und die Abrechnungsintegration über AWS Marketplace bereit.
Die Anthropic SDKs unterstützen Claude Platform on AWS.
## So funktioniert die Plattformintegration
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 die Inhalte deines „workspace" (Arbeitsbereich) zu speichern (z. B. Prompts, Ausgaben, Dateien, Skills und Batches). Für Workspaces, die vor dem 18. September 2026, 00:00 UTC, erstellt wurden, kann Anthropic Anfragen auch außerhalb von AWS verarbeiten, Daten dort speichern und Inferenz dort 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 an eine bestimmte geografische Region zu binden.
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-Kundenbetreuer, um ZDR 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 aber in Architektur, API-Oberfläche und Funktionsverfügbarkeit.
| 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 |
| **Funktionsverfügbarkeit** | 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 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 unterstützt, um deine VPC mit dem Endpunkt von Claude Platform on AWS zu verbinden.
**Wann du Bedrock wählen solltest:** Organisationen in regulierten Branchen, die FedRAMP High, IL4, IL5 oder HIPAA-ready-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 abgerechnet als AWS-Dienstnutzung.
* **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.
## Konto einrichten
Die Einrichtung von Claude Platform on AWS erfolgt in vier Phasen:
1. Registrierung auf der Dienstseite der AWS Console
2. Einrichtung deiner Anthropic-Organisation
3. Notieren deiner Workspace-ID
4. 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 deines Unternehmens bei Anthropic getrennt, auch von 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 privates Angebot für Amazon Bedrock hast, wende dich vor der Registrierung an deinen Anthropic- oder AWS-Kundenbetreuer. So gilt dein Rabatt ab deiner ersten Anfrage. Rabatte können nicht rückwirkend auf Nutzung angewendet werden, die vor der Annahme deines privaten Angebots angefallen ist. Siehe [Private Angebote](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 Sign-up-Seite die Bedingungen (die Endbenutzer-Lizenzvereinbarung von Anthropic, den AWS-Datenschutzhinweis und die AWS-Kundenvereinbarung) und aktiviere das Kontrollkästchen zur Zustimmung.
4. Wähle **Continue**.
Die Seite zeigt das 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. Danach wirst du automatisch weitergeleitet.
Wenn deine Organisation ein privates Angebot von Anthropic hat, findet die Console es und fordert dich auf, es in AWS Marketplace anzunehmen. Details findest du unter [Private Angebote](https://platform.claude.com/docs/de/about-claude/pricing#private-offers).
Wenn du Claude Platform on AWS nutzt, verarbeitet und speichert Anthropic deine Inhalte (z. B. Prompts und Ausgaben) auf AWS-Infrastruktur. Für Workspaces, die vor dem 18. September 2026, 00:00 UTC, erstellt wurden, kann Anthropic diese Inhalte auch 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 Inhabers deiner Organisation ein und wähle **Get started**.
2. Suche in diesem E-Mail-Postfach nach einem Einrichtungslink und öffne ihn. Wenn dein Browser die 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. Gleichzeitig akzeptierst du die kommerziellen Nutzungsbedingungen und die Nutzungsrichtlinie von Anthropic. Die Dienstseite in der AWS Console zeigt nun links eine Navigation mit **Home**, **API keys**, **Quickstart** und **Workspaces**.
Nach Abschluss der Einrichtung fordert dich die AWS Console auf, einen Workspace zu erstellen. Unter [Workspaces](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#workspaces) findest du Details zur Regionsbindung, zur Eingrenzung von IAM-Ressourcen und zum Erstellen weiterer Workspaces.
Die Workspace-ID findest du an zwei Stellen: 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 erfolgt per Föderation über AWS IAM:
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 legt deinen Claude Console-Benutzer dann automatisch an (Just-in-Time-Bereitstellung).
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 der Hinweis **Account managed by AWS**.
### Umstieg 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. Eine direkte Umwandlung gibt es nicht: Eine bestehende Organisation, etwa eine First-Party-Claude API-Organisation, kann nicht zu einer Claude Platform on AWS-Organisation werden.
Plane den Umstieg daher als Wechsel zu einer neuen Organisation:
* **Erstelle zuerst die neue Organisation.** Registriere dich über die AWS Console (siehe [Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account)). Wenn dein Umstieg ein privates Angebot umfasst, schließe die Registrierung ab, bevor das Angebot angenommen wird. Rabatte gelten erst ab der Annahme, nicht rückwirkend. Siehe [Private Angebote](https://platform.claude.com/docs/de/about-claude/pricing#private-offers).
* **Richte Zugriff und Konfiguration neu ein.** 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. Die Struktur von Anfragen und Antworten bleibt daher gegenüber der First-Party-Claude API unverändert. Es ändern sich nur die Basis-URL, die Authentifizierungsmethode und der Header `anthropic-workspace-id` 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 über die neue Organisation läuft.
Sobald die neue Organisation läuft, betreffen die Unterschiede vor allem Abrechnung und Authentifizierung, die beide über AWS abgewickelt werden:
* **Abrechnung** wechselt zu AWS Marketplace. Die Nutzung wird in Claude Consumption Units statt über Prepaid-Guthaben abgerechnet (siehe [Abrechnung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#billing)). Ausgabenlimits legst du auf der Billing-Seite 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 wie bisher abgerechnet.
* **Authentifizierung und Zugriff** wechseln zu AWS. Anfragen authentifizieren sich mit AWS-Anmeldedaten oder mit API-Keys, die in der AWS Console generiert werden, nicht in der Claude Console (siehe [Authentifizierung](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#authentication)). Die Organisationsmitgliedschaft 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)). Die Client-SDKs von Anthropic bieten dafür plattformspezifische Client-Klassen (siehe [SDK installieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **Die alltägliche API-Nutzung** funktioniert wie bei der First-Party-Claude API, mit den in den [Funktionseinschränkungen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#features-not-supported) genannten Ausnahmen. Prüfe deine Ratenlimits, bevor du Produktions-Traffic verlagerst. Neue Organisationen starten in der Start-Stufe, und Erhöhungen der Limits laufen über deinen Anthropic-Kundenbetreuer (siehe [Ratenlimits und Kontingente](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Claude Enterprise-Organisationen (claude.ai) verhalten sich anders. Details dazu findest du im [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 dieses Banner beim ersten Absenden erscheint, 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. Während AWS dein Konto bereitstellt, zeigt die Seite nur das statische Banner **Sign-up in progress** ohne Fortschrittsbalken an.
* **"Signed in as a different account" nach dem Öffnen 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 Usage-Seite zeigt nach deinem ersten API-Aufruf keine Daten an:** 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 einmalig pro Konto. Siehe [Ausgehende Web-Identitätsföderation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Vor den ersten API-Aufrufen
Stelle sicher, dass Folgendes vorhanden ist:
1. Ein aktives AWS-Konto mit einem Abonnement für Claude Platform on AWS (siehe [Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account))
2. Die installierte und konfigurierte [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)
3. **Aktivierte ausgehende Web-Identitätsföderation** in deinem AWS-Konto, ein einmaliger Einrichtungsschritt (siehe [Ausgehende Web-Identitätsföderation aktivieren](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation))
4. Deine Workspace-ID (siehe [Workspace-ID abrufen](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 und zusätzlich `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))
### Ausgehende Web-Identitätsföderation aktivieren
Das Gateway von Claude Platform on AWS ruft serverseitig `sts:GetWebIdentityToken` auf. Damit erzeugt es ein JWT, das es an Anthropic weiterleitet. Diese STS-Funktion ist in jedem AWS-Konto **standardmäßig deaktiviert**. Aktiviere sie einmalig pro Konto:
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Lautet die Antwort `[ERROR] (FeatureEnabled) ... already enabled`, ist die Einstellung für dein Konto bereits aktiv, und du kannst fortfahren. Überprüfe die Einstellung und rufe die Issuer-URL deines Kontos 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. Das ist der häufigste Einrichtungsfehler.
### Workspace-ID abrufen
Du erstellst einen Workspace in der AWS Console, nachdem du die Kontoeinrichtung abgeschlossen hast (siehe [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 auslesen:
```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 Request-Signierung per Signature Version 4 (SigV4) als primäre Methode
* Authentifizierung per API-Key
Beide verwenden dieselbe Basis-URL und dasselbe Anfrageformat.
### SigV4-Authentifizierung
SigV4 ist der native Weg für Unternehmen und lässt sich in deine bestehenden AWS IAM-Richtlinien, -Rollen und dein Auditing integrieren. 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`)
* Gemeinsam genutzte Anmeldedatendatei (`~/.aws/credentials`)
* Gemeinsam genutzte Konfigurationsdatei (`~/.aws/config`), einschließlich SSO und `credential_process`
* Web-Identität (`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 statt mit SigV4 mit einem API-Key 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 den First-Party-API-Zugriff) erstellt wurden, funktionieren nicht mit dem Endpunkt von Claude Platform on AWS.
#### Kurzlebige API-Keys
Manche Workloads müssen eine Anmeldeinformation an einen separaten Prozess übergeben. Beispiele sind ein LLM-Gateway (ein Gateway für „large language models" (große Sprachmodelle), oder LLMs), eine Serverless-Funktion oder ein Tool, das Bearer-Token-Authentifizierung, aber kein SigV4 unterstützt. Generiere in diesen Fällen einen kurzlebigen API-Key aus deinen AWS-Anmeldedaten, statt einen langlebigen Key in der AWS Console anzulegen.
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 standardmäßige Provider-Chain und gibt ein zeitlich begrenztes Token zurück, das mit dem Header `x-api-key` funktioniert.
Die Token-Lebensdauer beträgt standardmäßig 12 Stunden. Sie ist auf den kleinsten dieser Werte begrenzt: deine angeforderte Dauer, die Ablaufzeit deiner AWS-Anmeldedaten oder 12 Stunden. Installation und alle Konfigurationsoptionen findest du in den READMEs der verlinkten Repositorys.
Übergib das generierte Token genauso 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, hat dein Prozess bereits SigV4-Anmeldedaten. Dann ist die SigV4-Authentifizierung meist die einfachere Wahl. Verwende kurzlebige Keys, wenn der Prozess, der die API aufruft, nicht derselbe ist wie der Prozess mit den AWS-Anmeldedaten.
Das SDK erneuert 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 löst die Authentifizierung in der folgenden Reihenfolge auf, beginnend mit dem, was du beim Erstellen übergibst:
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → `x-api-key`-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` → `x-api-key`-Header
5. Standard-AWS-Credential-Provider-Chain → AWS SigV4
### Auflösung 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 zur Kompatibilität 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.
## 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 die SigV4-Signierung, die regionsbasierte Konstruktion 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:2.73.0")
implementation("com.anthropic:anthropic-java-aws:2.73.0")
```
```xml Maven
com.anthropic
anthropic-java
2.73.0
com.anthropic
anthropic-java-aws
2.73.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? 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).
## 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, der Models API, der 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 [Vor den ersten API-Aufrufen](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 und sendet ihn als x-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 \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```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() { Role = Role.User, 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 aufgelöst werden kann.
Der `x-amz-security-token`-Header (cURL) ist nur für temporäre Anmeldedaten wie IAM-Rollen, SSO oder STS erforderlich. Lass ihn weg, wenn du langfristige IAM-Benutzer-Anmeldedaten verwendest. Die SDK-Clients handhaben dies automatisch anhand 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).
## Funktionsunterstützung
Claude Platform on AWS verwendet die Claude-API-Endpunkte 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):
* **Funktionszugriff:** 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.
* **Code-Ausführung:** Führe Code in der verwalteten Sandbox von Anthropic mit dem [Code-Ausführungstool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool) aus.
* **Tool-Nutzung:** Alle Funktionen der [„tool use" (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:** Volle SSE-Streaming-Unterstützung für Antworten in Echtzeit.
* **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) sind verfügbar: 5-Minuten-TTL, 1-Stunden-TTL und automatisches Caching.
* **Files API:** Lade Dateien hoch und referenziere sie über Anfragen hinweg.
* **„Customer-managed encryption keys" (kundenverwaltete Verschlüsselungsschlüssel), oder 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. Google Cloud KMS- und Azure Key Vault-Schlüssel 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-aws-kms#claude-platform-on-aws). Registriere Schlüssel in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console) und hänge sie dort an; die External-Key-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 Anhängeaufruf führt einen Verschlüsselungs-/Entschlüsselungsdurchlauf aus), sodass ein Problem mit der Schlüsselrichtlinie beim Anhängen statt bei der Registrierung zutage tritt.
* **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 Funktionsverfügbarkeit 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), [Multiagenten-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 autonom laufen, ohne [Benutzer-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 Benutzerrolle an die Session (siehe [Events und Streaming](https://platform.claude.com/docs/de/managed-agents/events-and-streaming)). Bei First-Party-Claude Managed Agents gibt es 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 Umgebungsschlüssel. In der Claude Console generierte Umgebungsschlüssel 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 (create, get, list, update und archive auf `/v1/organizations/workspaces`), External-Key-Endpunkte (register, get, list, update und delete auf `/v1/organizations/external_keys`, für [CMEK](https://platform.claude.com/docs/de/manage-claude/cmek); Schlüssel werden beim Anhängen an einen Workspace validiert statt über einen Validierungsendpunkt) und die [Endpunkte für Telemetrie-Ziele](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 auf 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 und sendet ihn als x-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 \
--inference-geo us \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```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() { Role = Role.User, 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 die `default_inference_geo` des Workspace, sofern eine konfiguriert ist, andernfalls `global`.
Steuerungen der Inferenz-Geografie auf Workspace-Ebene (`allowed_inference_geos` und `default_inference_geo`) sind auch 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 des Workspace-ARN. Das Ressourcensegment des 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
```
Beispiele für Richtlinien 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 ein 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 Erstanmeldung findest du unter [Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#set-up-your-account). Kurz zusammengefasst:
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 den [IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions) unterliegt). Mit **Nein** gekennzeichnete Seiten lesen Metadaten auf Organisationsebene direkt von Anthropic und umgehen die Prüfung von IAM-Aktionen.
| 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 [Claude Consumption Unit (CCU)](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#billing) an. |
| **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 Workspaces außerdem 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, solange im Dropdown-Menü oben auf der Seite **Organization** ausgewählt ist. Registriere dort AWS-KMS-Schlüssel für [CMEK](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#claude-platform-on-aws) (Admin-Rolle). Um einen registrierten Schlüssel an einen Workspace anzuhängen, wähle den Workspace in diesem Dropdown-Menü aus und wähle dann den Schlüssel 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 Ereignisverlauf 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 | N/A | Verwalte API-Keys in der AWS Console (**Claude Platform on AWS → API keys**). Siehe [Authentifizierung per API-Key](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | Nein | N/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 | N/A | Zeige die Nutzung von Claude Code auf der Seite Usage an. |
### Organisation wechseln
Die Claude Console unterstützt für Claude Platform on AWS keinen Wechsel der Organisation. 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 dem Start-Tier zugeordnet. Anthropic verwaltet Ratenlimits direkt, nicht über AWS-Kontingentsysteme.
Organisationen auf Claude Platform on AWS können automatisch in ein höheres Nutzungs-Tier wechseln, 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 gecachter oder wiederholter Kontext ist (Cache-Lesevorgänge zählen bei den meisten Modellen nicht zu den Input-Token-Limits; siehe [Cache-bewusste ITPM](https://platform.claude.com/docs/de/api/rate-limits#cache-aware-itpm))
Nutzungs-Tiers sind feste Stufen: Jedes 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 ein höheres Tier erhöht beides. Details zu 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 in Rechnung gestellt. CCUs sind keine vorausbezahlten Guthaben. Es gibt weder ein CCU-Guthaben noch eine Abnahmeverpflichtung.
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; aktuelle 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 „spend limits" (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, wie 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 Schlüssel, Telemetrie-Ziele, Compliance, Vaults und Webhooks werden standardmäßig als Management-Ereignisse protokolliert. Operationen für Inferenz, Batches, Dateien, Skills, Modelle, Benutzerprofile und Claude Managed Agents (außer Vaults und Webhooks) werden als Datenereignisse klassifiziert und erfordern eine explizite Konfiguration der Datenereignisprotokollierung, für die zusätzliche CloudTrail-Gebühren anfallen. Die vollständige Klassifizierung der Ereignistypen 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/).
### Anfrage-IDs
Jede Antwort enthält in den Antwort-Headern zwei Anfrage-IDs:
* **AWS-Anfrage-ID (`x-amzn-requestid`):** Die primäre ID, die in CloudTrail indiziert wird. Verwende sie, wenn du Anfragen mit AWS-Tools untersuchst oder den AWS-Support kontaktierst.
* **Anthropic-Anfrage-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 nimmt die Response-Header in die Ausgabe auf
# Lass den Header x-amz-security-token weg, wenn du langfristige IAM-Benutzeranmeldedaten 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 und sendet ihn als x-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() { Role = Role.User, 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 innerhalb deines AWS-Kontos 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 verwendest, 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, Anfrage-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 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 wird bei der Registrierung erstellt. 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 verwendest, 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 verwendest, 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 Anthropic-Support
* API-Key-Authentifizierung als Alternative zu SigV4 (siehe [Authentifizierung per API-Key](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-Abnahmeverpflichtungen
### Fallstricke bei der Migration
**Aktiviere zuerst die ausgehende Web-Identity-Föderation.** Wenn dein AWS-Konto Claude Platform on AWS bisher nicht verwendet hat, musst du 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), und zwar einmal pro Konto, 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 und muss aktiviert werden.** Auf Bedrock ist AWS der Datenverarbeiter, und Anthropic speichert keine Inferenz-Eingaben oder -Ausgaben. 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 Zusicherungen 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 verwendet hast), wirst du während 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 Angebote:** Ausgehandelte Rabatte und private Angebote im AWS Marketplace 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 Zugriffskontrolle 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. Wird sie verweigert, sind 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 auf Kontoebene gültig und erscheint daher in einer separaten Allow-Anweisung mit `"Resource": "*"`. Die Angabe eines Workspace-ARN bei einer Aktion auf Kontoebene hat keine Wirkung (siehe [Automatisierung der Bereitstellung](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 einen 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 von jeder Richtlinie gewährten Aktionen, 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.