--- title: Authentifizierung url: https://platform.claude.com/docs/de/manage-claude/authentication description: Authentifiziere dich bei der Claude API mit API-Keys, Workload Identity Federation oder App Attest. --- Die Claude API unterstützt drei Möglichkeiten, Anfragen zu authentifizieren: | Methode | Anmeldedaten | Am besten geeignet für | | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [API-Key](https://platform.claude.com/docs/de/manage-claude/authentication#api-keys) | Statisches `sk-ant-api...`-Geheimnis, das als Bearer-Token im `Authorization`-Header gesendet wird | Lokale Entwicklung, Prototyping, Skripte und Server, bei denen du die Geheimnisspeicherung kontrollierst | | [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/authentication#workload-identity-federation) | Kurzlebiges Bearer-Token, das aus dem Identitätstoken deines Identitätsanbieters ausgetauscht wird | Produktions-Workloads auf Cloud-Plattformen (AWS, Google Cloud, Azure), CI/CD-Pipelines und Kubernetes, bei denen du statische Geheimnisse eliminieren möchtest | | [App Attest](https://platform.claude.com/docs/de/manage-claude/authentication#app-attest) | Kurzlebiges Zugriffstoken, das an eine echte, attestierte Installation deiner registrierten iOS- oder macOS-App ausgegeben wird | iOS- und macOS-Apps, die an Endnutzer verteilt werden, bei denen die App die Claude API direkt ohne Backend oder Proxy aufruft | API-Keys und Workload Identity Federation gewähren denselben Zugriff auf Claude-API-Endpunkte. Wähle API-Keys, um schnell loszulegen: einen persönlichen Key für deine eigene Entwicklung oder einen Service-Account-Key für alles Geteilte. Wechsle zu Workload Identity Federation, wenn dein Workload bereits über eine plattformausgestellte Identität verfügt, die du föderieren kannst. Verwende App Attest für iOS- und macOS-Apps, die du an Endnutzer verteilst. ## API-Keys API-Keys sind statische Geheimnisse, die du in der Claude Console generierst und bei jeder Anfrage als Bearer-Token im `Authorization`-Header sendest. ### Key-Typen Wenn du einen Key erstellst, wählst du seinen Typ, der bestimmt, was der Key tun kann, wo er funktioniert und wann er aufhört zu funktionieren: | Key-Typ | Agiert als | Funktioniert in | Hört auf zu funktionieren, wenn | | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Persönlicher Key** | Du, der Benutzer, mit deinen Rollen und Berechtigungen | Entweder ein einzelner Workspace oder die Workspaces, in denen deine Rolle die API-Nutzung erlaubt, festgelegt bei der Erstellung des Keys | Du den Zugriff auf die Organisation verlierst. Ein Key für einen einzelnen Workspace funktioniert außerdem nicht mehr, wenn du den Zugriff auf diesen Workspace verlierst oder dieser Workspace archiviert wird. Persönliche Keys werden archiviert, wenn du aus der Organisation entfernt wirst. Wenn du erneut eingeladen wirst, erstelle neue Keys; archivierte Keys werden nicht wiederhergestellt | | **Service-Account-Key** | Ein [Service-Account](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation#service-accounts) | Entweder ein einzelner Workspace oder alles, worauf der Service-Account Zugriff hat, festgelegt bei der Erstellung des Keys. Ein Service-Account hat Zugriff auf den Default Workspace und auf Workspaces, zu denen er hinzugefügt wurde | Der Service-Account archiviert wird. Ein Key für einen einzelnen Workspace funktioniert außerdem nicht mehr, wenn der Service-Account aus diesem Workspace entfernt oder dieser Workspace archiviert wird | | **Workspace-Key** (veraltet) | Niemanden: Er gehört zu dem Workspace, in dem er erstellt wurde | Diesem Workspace | Er abläuft, deaktiviert oder gelöscht wird oder sein Workspace archiviert wird, unabhängig davon, ob sein Ersteller die Organisation verlässt | Persönliche Keys und Service-Account-Keys sind identitätsgebunden: Jeder gehört zu einem Benutzer oder Service-Account, den deine Organisation bereits verwaltet, und jede Anfrage handelt als diese Identität. Wenn diese Identität aus der Organisation entfernt wird, funktioniert der Key nicht mehr. Das bedeutet, dass Keys die Personen oder Workloads, denen sie gehören, nicht versehentlich überdauern. Bevorzuge sie bei neuen Integrationen gegenüber Workspace-Keys. Verwende einen persönlichen Key für deine eigene Entwicklung und Skripte. Ein geteilter persönlicher Key agiert als eine Person und funktioniert nicht mehr, wenn diese geht. Lass für geteilte oder automatisierte Workloads (CI, Produktionsdienste) einen Organisationsadministrator einen Service-Account erstellen, damit der Workload seine eigene Identität hat. Workspace-API-Keys funktionieren weiterhin, sollten aber als veraltet betrachtet werden; identitätsgestützte Keys oder [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation) werden bevorzugt. Zum Migrieren siehe [Workspace-API-Keys ersetzen](https://platform.claude.com/docs/de/manage-claude/authentication#replacing-workspace-api-keys). ### Einen Key erstellen und verwenden * **Einen Key erstellen:** Gehe in der Claude Console zur Seite [API keys](https://platform.claude.com/settings/keys) (`platform.claude.com/settings/keys`) und klicke auf **Create key**. Benenne den Key und wähle ein [Ablaufdatum](https://platform.claude.com/docs/de/manage-claude/authentication#key-expiration). Setze **Linked account** für einen persönlichen Key auf dich selbst oder für einen Key, der von mehreren Benutzern geteilt wird, auf einen Service-Account. Du kannst den Key auch auf einen bestimmten Workspace beschränken, wodurch du in zukünftigen Anfragen keine Workspace-ID manuell festlegen musst. * **Den Key verwenden:** Sende ihn bei direkten HTTP-Anfragen als `Authorization: Bearer ` oder setze die Umgebungsvariable `ANTHROPIC_API_KEY`, dann übernimmt das [Client-SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) ihn automatisch. ```http POST /v1/messages Authorization: Bearer YOUR_API_KEY anthropic-version: 2023-06-01 content-type: application/json ``` Der veraltete `x-api-key: YOUR_API_KEY`-Header wird weiterhin anstelle von `Authorization` unterstützt. Speichere API-Keys in einem Secrets-Manager, rotiere sie regelmäßig und deaktiviere oder lösche jeden Key, bei dem du vermutest, dass er geleakt wurde. Auf der Seite [API keys](https://platform.claude.com/settings/keys) in der Claude Console ist **Disable** umkehrbar (die Admin API meldet den `status` des Keys als `"inactive"`, und **Re-enable** setzt ihn wieder auf `"active"`), während **Delete** dauerhaft ist: Der Key wird archiviert und erscheint weiterhin in [List API Keys](https://platform.claude.com/docs/de/api/organization/api_keys/list) mit `status: "archived"`. Abgelaufene Keys können nur gelöscht werden. Du kannst beim Erstellen eines Keys auch ein [Ablaufdatum](https://platform.claude.com/docs/de/manage-claude/authentication#key-expiration) festlegen, um zu begrenzen, wie lange geleakte Anmeldedaten verwendbar bleiben. ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Hello, Claude"}] }' ``` ```bash CLI # Siehe /docs/en/cli-sdks-libraries/cli/authentication#api-key für zsh-, bash- und Windows-Varianten export ANTHROPIC_API_KEY=sk-ant-api03-... ``` ```python Python client = Anthropic(api_key="my-anthropic-api-key") # oder, mit ANTHROPIC_API_KEY in der Umgebung gesetzt: client = Anthropic() ``` ```typescript TypeScript const client = new Anthropic({ apiKey: "my-anthropic-api-key" }); // oder, mit ANTHROPIC_API_KEY in der Umgebung gesetzt: // const client = new Anthropic(); ``` ```csharp C# using Anthropic; AnthropicClient client = new() { ApiKey = "my-anthropic-api-key" }; // Oder, wenn ANTHROPIC_API_KEY in der Umgebung gesetzt ist: // AnthropicClient client = new(); ``` ```go Go client := anthropic.NewClient( option.WithAPIKey("sk-ant-api03-..."), // defaults to os.LookupEnv("ANTHROPIC_API_KEY") ) ``` ```java Java import com.anthropic.client.AnthropicClient; import com.anthropic.client.okhttp.AnthropicOkHttpClient; // Explizit AnthropicClient client = AnthropicOkHttpClient.builder() .apiKey("my-anthropic-api-key") .build(); // Aus ANTHROPIC_API_KEY (oder anthropic.apiKey Systemeigenschaft) AnthropicClient clientFromEnv = AnthropicOkHttpClient.fromEnv(); ``` ```php PHP // Liest ANTHROPIC_API_KEY aus der Umgebung $client = new Client(); // Oder übergib den Key explizit: $client = new Client(apiKey: 'my-anthropic-api-key'); ``` ```ruby Ruby anthropic = Anthropic::Client.new(api_key: "my-anthropic-api-key") # oder, mit ANTHROPIC_API_KEY in der Umgebung gesetzt: anthropic = Anthropic::Client.new ``` ### Einen Workspace auswählen API-Keys, die für einen bestimmten Workspace erstellt werden, funktionieren nur in diesem Workspace, und API-Anfragen, die diese Keys verwenden, können die Workspace-ID weglassen. Wenn dein API-Key nicht auf einen Workspace beschränkt ist, musst du die Workspace-ID bei jeder Anfrage im Header `anthropic-workspace-id` angeben. Im folgenden Beispiel siehst du, wie du diesen Header in einer Anfrage oder im SDK setzt. Die [Admin-API](https://platform.claude.com/docs/de/manage-claude/admin-api) akzeptiert einen persönlichen Key oder Service-Account-Key nur, wenn der Key nicht auf einen bestimmten Workspace beschränkt ist. Die ID eines Workspace findest du in der Spalte **ID** auf der Seite [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) in der Claude Console oder durch Aufruf des Endpunkts [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list). List Workspaces enthält den Default Workspace nur, wenn du `include_default=true` übergibst; seine ID steht außerdem im [Antwort-Header](https://platform.claude.com/docs/de/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) `anthropic-workspace-id` jeder Anfrage, die dort ausgeführt wird. ```bash cURL # Bei jeder Anfrage erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. # Lass den Header anthropic-workspace-id bei einem Key weg, der auf einen Workspace beschränkt ist. curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-workspace-id: wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Hello, Claude"}] }' ``` ```bash CLI # Bei jedem Befehl erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. # Lass --workspace-id weg, wenn der Key auf einen Workspace beschränkt ist. ant messages create \ --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \ --model claude-opus-5-5 \ --max-tokens 1024 \ --message '{role: user, content: "Hello, Claude"}' ``` ```python Python client = Anthropic() # reads ANTHROPIC_API_KEY # Bei jeder Anfrage erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. # Lass extra_headers bei einem Key weg, der auf einen Workspace beschränkt ist. message = client.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello, Claude"}], extra_headers={"anthropic-workspace-id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"}, ) print(message.content) # Oder setze es einmal für jede Anfrage von diesem Client: workspace_client = Anthropic( default_headers={"anthropic-workspace-id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"}, ) ``` ```typescript TypeScript const client = new Anthropic(); // reads ANTHROPIC_API_KEY // Bei jeder Anfrage erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. // Lass das zweite Argument weg, wenn der Key auf einen Workspace beschränkt ist. const message = await client.messages.create( { model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }] }, { headers: { "anthropic-workspace-id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" } } ); console.log(message.content); // Oder setze es einmal für jede Anfrage von diesem Client: const workspaceClient = new Anthropic({ defaultHeaders: { "anthropic-workspace-id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" } }); ``` ```csharp C# AnthropicClient client = new(); // reads ANTHROPIC_API_KEY MessageCreateParams parameters = new() { Model = Model.ClaudeOpus5_5, MaxTokens = 1024, Messages = [new UserMessageParam { Content = "Hello, Claude" }], }; // Bei jeder Anfrage für einen Multi-Workspace-Key erforderlich. // Rufe client.Messages.Create(parameters) direkt für einen Single-Workspace-Key auf. var message = await client .WithOptions(options => options with { ExtraHeaders = new Dictionary { ["anthropic-workspace-id"] = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", }, } ) .Messages.Create(parameters); Console.WriteLine(message); // Oder setze ihn einmal für jede Anfrage von diesem Client: AnthropicClient workspaceClient = new(new ClientOptions { ExtraHeaders = new Dictionary { ["anthropic-workspace-id"] = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", }, }); ``` ```go Go client := anthropic.NewClient() // reads ANTHROPIC_API_KEY // Bei jeder Anfrage erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. // Lass die Option bei einem Key weg, der auf einen Workspace beschränkt ist. message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")), }, }, option.WithHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")) if err != nil { log.Fatal(err) } fmt.Println(message.Content) // Oder setze ihn einmal für jede Anfrage von diesem Client: workspaceClient := anthropic.NewClient( option.WithHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"), ) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // reads ANTHROPIC_API_KEY // Bei jeder Anfrage erforderlich, wenn der Key nicht auf einen Workspace beschränkt ist. // Lass putAdditionalHeader weg, wenn der Key auf einen Workspace beschränkt ist. Message message = client.messages().create(MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(1024) .addUserMessage("Hello, Claude") .putAdditionalHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ") .build()); IO.println(message.content()); // Oder setze es einmal für jede Anfrage von diesem Client: AnthropicClient workspaceClient = AnthropicOkHttpClient.builder() .fromEnv() .putHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ") .build(); ``` ```php PHP $client = new Client(); // reads ANTHROPIC_API_KEY // Erforderlich bei jeder Anfrage für einen Key, der nicht auf einen Workspace beschränkt ist. // Lass requestOptions bei einem Key weg, der auf einen Workspace beschränkt ist. $message = $client->messages->create( model: Model::CLAUDE_OPUS_5_5, maxTokens: 1024, messages: [['role' => 'user', 'content' => 'Hello, Claude']], requestOptions: [ 'extraHeaders' => ['anthropic-workspace-id' => 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ'], ], ); echo json_encode($message->content), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new # reads ANTHROPIC_API_KEY # Erforderlich bei jeder Anfrage für einen Key, der nicht auf einen Workspace beschränkt ist. # Lass request_options bei einem Key weg, der auf einen Workspace beschränkt ist. message = client.messages.create( model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 1024, messages: [{role: "user", content: "Hello, Claude"}], request_options: {extra_headers: {"anthropic-workspace-id" => "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"}} ) puts message.content ``` Wenn eine Anfrage, die mit einem nicht auf einen Workspace beschränkten Key gestellt wird, den Header weglässt, gibt die API einen 400 `invalid_request_error` zurück: ```json JSON { "type": "error", "error": { "type": "invalid_request_error", "message": "This API key is not scoped to a workspace, so this request must include the anthropic-workspace-id header with the ID of the workspace to use. Add the header, or use an API key that is scoped to a workspace." }, "request_id": "req_011CSHoEeqs5C35K2UUqR7Fy" } ``` Ein Header-Wert, der keine gültige Workspace-ID ist, gibt einen 400 `invalid_request_error` mit der Meldung `anthropic-workspace-id header must be a valid workspace ID.` zurück. Wenn der Workspace nicht existiert oder der Nutzer oder Service-Account des Keys keinen Zugriff darauf hat, gibt die API einen 404 `not_found_error` mit der Meldung ``Workspace `` not found.`` zurück, dieselbe Antwort wie für jeden unbekannten Workspace. Workload Identity Federation wählt stattdessen einen Workspace beim Token-Austausch aus; siehe die [WIF-Referenz](https://platform.claude.com/docs/de/manage-claude/wif-reference) für Details. ### Key-Ablauf Wenn du einen API-Key auf der Seite [API keys](https://platform.claude.com/settings/keys) in der Claude Console erstellst, wählst du ein Ablaufdatum: eine Voreinstellung (3 Stunden, 1 Tag, 7 Tage oder 30 Tage), eine benutzerdefinierte Dauer oder **Never** für Keys, die du in einem Secrets-Manager speicherst und selbst rotierst. Wenn deine Organisation eine Richtlinie für ein maximales Ablaufdatum hat, begrenzt die Console Voreinstellungen und benutzerdefinierte Dauern auf das Maximum der Richtlinie, und **Never** ist nicht verfügbar. Bestehende Keys behalten ihr aktuelles Verhalten; das Ablaufdatum wird bei der Erstellung festgelegt und kann danach nicht mehr geändert werden. Dieselbe Wahl des Ablaufdatums gilt, wenn du in der Claude Console [einen Admin-API-Key erstellst](https://platform.claude.com/docs/de/manage-claude/admin-api-keys). Anthropic sendet dem Ersteller des Keys eine E-Mail, wenn sich der Ablauf nähert: 7 Tage vor Ablauf für Keys, die mit einer Lebensdauer von mindestens 14 Tagen erstellt wurden, und 1 Tag vorher für Keys mit einer Lebensdauer von mindestens 7 Tagen. Keys mit kürzeren Lebensdauern laufen ohne Warn-E-Mail ab. Nachdem ein Key abgelaufen ist, geben damit gestellte Anfragen einen `401 authentication_error` zurück. Erstelle einen neuen Key, um den Zugriff wiederherzustellen; abgelaufene Keys können nicht reaktiviert werden. Die API-Keys-Tabelle in der Console zeigt die Ablaufzeit jedes Keys, und die Admin-API meldet den `expires_at`-Zeitstempel jedes Keys an den Endpunkten [List API Keys](https://platform.claude.com/docs/de/api/organization/api_keys/list) und [Retrieve API Key](https://platform.claude.com/docs/de/api/organization/api_keys/retrieve), sodass du Keys prüfen und rotieren kannst, bevor sie ablaufen. Das Feld ist `null` für Keys ohne Ablaufzeit. Die Ablaufzeit begrenzt die Lebensdauer eines geleakten Anmeldedatums, ist aber kein Ersatz für Geheimnishygiene. Unabhängig von der Ablaufzeit solltest du Keys in einem Secrets-Manager speichern und jeden Key deaktivieren oder löschen, bei dem du einen Leak vermutest. ### Workspace-API-Keys ersetzen Wenn du einen Workspace-Key hast, möchtest du ihn möglicherweise durch [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/wif-reference) oder einen persönlichen oder Service-Account-Key ersetzen. Dies bietet bessere Sicherheit und Beobachtbarkeit. Details zur Konfiguration von Workload Identity Federation, die gegenüber langlebigen Keys bevorzugt wird, findest du in der [WIF-Referenz](https://platform.claude.com/docs/de/manage-claude/wif-reference). So ersetzt du einen Workspace-Key durch einen persönlichen oder Service-Account-Key: 1. **Entscheide den Key-Typ.** Dein eigenes Tooling sollte einen persönlichen Key verwenden. Ein geteilter oder unbeaufsichtigter Workload sollte einen Service-Account-Key verwenden. 2. **Erstelle bei Bedarf einen Service-Account.** Möglicherweise musst du einen Organisationsadministrator bitten, einen auf der Seite [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) in der Claude Console zu erstellen und ihn zum relevanten Workspace hinzuzufügen. 3. **Erstelle den neuen Key.** Erstelle ihn speziell für den Workspace der Integration, es sei denn, die Integration benötigt mehrere Workspaces. 4. **Stelle den neuen Key bereit.** Ersetze den alten Key überall, wo die Integration ihn ausliest, typischerweise die Umgebungsvariable `ANTHROPIC_API_KEY` oder einen Eintrag in einem Secrets-Manager. Bei einem Key, der nicht auf einen Workspace beschränkt ist, sende außerdem den Header `anthropic-workspace-id`, wie unter [Einen Workspace auswählen](https://platform.claude.com/docs/de/manage-claude/authentication#select-a-workspace) gezeigt. 5. **Lösche den alten Key.** Vergewissere dich, dass Anfragen erfolgreich sind, und lösche dann den Workspace-Key auf der [API-Keys-Seite](https://platform.claude.com/settings/keys) in der Claude Console. ## Workload Identity Federation Workload Identity Federation (WIF) ermöglicht es einem Workload, sich mit einem kurzlebigen Identitätstoken zu authentifizieren, das von einem „identity provider" (Identitätsanbieter), oder IdP, ausgestellt wird, dem du bereits vertraust. Zu solchen IdPs gehören AWS IAM, Google Cloud und jeder standardkonforme OIDC-Aussteller (wie GitHub Actions, Kubernetes-Service-Accounts, SPIFFE, Microsoft Entra ID oder Okta). Der Workload tauscht sein vom IdP ausgestelltes JWT bei `POST /v1/oauth/token` gegen ein kurzlebiges Claude-API-Zugriffstoken ein, und das SDK aktualisiert dieses Token automatisch, bevor es abläuft. Es gibt keinen `sk-ant-api...`-String, der erstellt, verteilt oder rotiert werden muss. Föderation entfernt langlebige Claude-API-Keys aus deiner Umgebung, was den Schaden begrenzt, den geleakte Anmeldedaten verursachen können, und ermöglicht dir, den Zugriff mit denselben IdP-Kontrollen zu verwalten, die du bereits für Cloud-Ressourcen verwendest. Sie garantiert für sich allein jedoch keine durchgängige Sicherheit: Die Vertrauenskette ist nur so stark wie die Konfiguration deines Identitätsanbieters, und ein langlebiges Secret einen Schritt früher in dieser Kette (zum Beispiel statische Cloud-Anmeldedaten, mit denen IdP-Tokens erstellt werden können) kann sie dennoch untergraben. Kombiniere Föderation mit den Kontrollen deines Anbieters, wie IP-Allowlists, MFA und Audit-Logging. Um Federation zu konfigurieren, erstellst du drei Ressourcen in der Claude Console (einen Service-Account, einen Federation-Aussteller und eine Federation-Regel) und richtest dann dein SDK auf die Regel aus. Siehe [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation) für die vollständige Einrichtungsanleitung. ## App Attest App Attest authentifiziert iOS- und macOS-Apps, die die Claude API direkt vom Gerät aus aufrufen. Jede Installation weist mithilfe von Apples App-Attest-Dienst nach, dass sie ein echter, unveränderter Build einer App ist, die du in der Claude Console registriert hast. Anthropic stellt dem Gerät dann ein kurzlebiges Zugriffstoken aus, das die Nutzung deinem Workspace in Rechnung stellt. Tokens sind auf deinen Workspace beschränkt, laufen nach 1 Stunde ab und autorisieren nur Aufrufe der [Messages API](https://platform.claude.com/docs/de/api/messages/create). Um deine App zu registrieren und eine Client-ID zu erhalten, siehe [App Attest für iOS- und macOS-Apps](https://platform.claude.com/docs/de/manage-claude/app-attest). ## Nächste Schritte Konfiguriere Aussteller, Regeln und Service-Accounts und tausche dann Tokens aus Schritt-für-Schritt-Anleitungen für AWS, Google Cloud, Azure, GitHub Actions, Kubernetes, SPIFFE und Okta Umgebungsvariablen, Validierungsregeln, Profilkonfiguration und Fehlerreferenz Lass echte Installationen deiner App die Claude API aufrufen, ohne einen API-Key auszuliefern Python, TypeScript, C#, Go, Java, PHP, Ruby und die CLI