--- 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 Nutzer, mit deinen Rollen und Berechtigungen | Entweder einem einzelnen Workspace oder den Workspaces, in denen deine Rolle die API-Nutzung erlaubt, ausgewählt bei der Erstellung des Keys | Du den Zugriff auf die Organisation oder, bei einem Single-Workspace-Key, auf diesen Workspace verlierst. 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 einem einzelnen Workspace oder allem, worauf der Service-Account Zugriff hat, ausgewählt 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 oder, bei einem Single-Workspace-Key, aus diesem Workspace entfernt 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ätsgestützt: Jeder gehört zu einem Nutzer oder Service-Account, den deine Organisation bereits verwaltet, und jede Anfrage agiert als diese Identität. Wenn diese Identität aus der Organisation entfernt wird, hört der Key auf zu funktionieren. Das bedeutet, dass Keys nicht versehentlich die Personen oder Workloads überdauern, denen sie gehören. Bevorzuge sie gegenüber Workspace-Keys für neue Integrationen. 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 **Key erstellen**. Benenne den Key und wähle eine [Ablaufzeit](https://platform.claude.com/docs/de/manage-claude/authentication#key-expiration). Setze **Verknüpftes Konto** auf dich selbst für einen persönlichen Key oder auf einen Service-Account für einen Key, der von mehreren Nutzern geteilt wird. Du kannst den Key auch auf einen bestimmten Workspace beschränken, sodass du in zukünftigen Anfragen keine Workspace-ID manuell festlegen musst. * **Den Key verwenden:** Sende ihn als `Authorization: Bearer ` bei direkten HTTP-Anfragen oder setze die Umgebungsvariable `ANTHROPIC_API_KEY`, und die [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) übernehmen 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 [API-Keys-Seite](https://platform.claude.com/settings/keys) in der Claude Console ist **Deaktivieren** umkehrbar (die Admin-API meldet den `status` des Keys als `"inactive"`, und **Reaktivieren** setzt ihn wieder auf `"active"`), während **Löschen** 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 eine [Ablaufzeit](https://platform.claude.com/docs/de/manage-claude/authentication#key-expiration) festlegen, um zu begrenzen, wie lange geleakte Anmeldedaten nutzbar 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"}] }' ``` ```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(); ``` ```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(); ``` ```csharp C# using Anthropic; AnthropicClient client = new() { ApiKey = "my-anthropic-api-key" }; // Oder, mit ANTHROPIC_API_KEY in der Umgebung gesetzt: // AnthropicClient client = new(); ``` ```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 ``` ```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-... ``` ### 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 im `anthropic-workspace-id`-Header für jede Anfrage angeben. Siehe das folgende Beispiel, wie du diesen Header in einer Anfrage oder in SDKs 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 für einen Multi-Workspace-Key erforderlich. # Lasse den anthropic-workspace-id-Header für einen Single-Workspace-Key weg. 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 für einen Multi-Workspace-Key erforderlich. # Lasse --workspace-id für einen Single-Workspace-Key weg. 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 für einen Multi-Workspace-Key erforderlich. # Lasse extra_headers für einen Single-Workspace-Key weg. 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 für einen Multi-Workspace-Key erforderlich. // Lass das zweite Argument für einen Single-Workspace-Key weg. 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() { Role = Role.User, 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 für einen Multi-Workspace-Key erforderlich. // Lasse die Option für einen Single-Workspace-Key weg. 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 für einen Multi-Workspace-Key erforderlich. // Lasse putAdditionalHeader für einen Single-Workspace-Key weg. 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 // Bei jeder Anfrage für einen Multi-Workspace-Key erforderlich. // Lasse requestOptions für einen Single-Workspace-Key weg. $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 # Bei jeder Anfrage für einen Multi-Workspace-Key erforderlich. # Lasse request_options für einen Single-Workspace-Key weg. 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": "anthropic-workspace-id is required when authenticating with an identity-linked API key; send the id of the workspace this request acts in." }, "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 [API-Keys-Seite](https://platform.claude.com/settings/keys) in der Claude Console erstellst, wählst du eine Ablaufzeit: eine Voreinstellung (3 Stunden, 1 Tag, 7 Tage oder 30 Tage), eine benutzerdefinierte Dauer oder **Nie** für Keys, die du in einem Secrets-Manager speicherst und selbst rotierst. Wenn deine Organisation eine maximale Ablaufrichtlinie hat, begrenzt die Console Voreinstellungen und benutzerdefinierte Dauern auf das Richtlinienmaximum, und **Nie** ist nicht verfügbar. Bestehende Keys behalten ihr aktuelles Verhalten; die Ablaufzeit wird bei der Erstellung festgelegt und kann danach nicht mehr geändert werden. Dieselbe Ablaufwahl gilt, wenn du einen [Admin-API-Key erstellst](https://platform.claude.com/docs/de/manage-claude/admin-api-keys) in der Claude Console. 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. Siehe [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/wif-reference) für Details zur Konfiguration von Workload Identity Federation, die gegenüber langlebigen Keys bevorzugt wird. 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, auf der Seite [Service-Accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) in der Claude Console einen zu erstellen und ihn dem entsprechenden Workspace hinzuzufügen. 3. **Erstelle den neuen Key.** Erstelle ihn speziell für den Workspace der Integration, es sei denn, mehrere Workspaces werden benötigt. 4. **Stelle den neuen Key bereit.** Ersetze den alten Key überall dort, wo die Integration ihn liest, typischerweise die Umgebungsvariable `ANTHROPIC_API_KEY` oder ein Secrets-Manager-Eintrag. Sende bei einem Multi-Workspace-Key auch den `anthropic-workspace-id`-Header, wie in [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 Identitätsanbieter (IdP) ausgestellt wird, dem du bereits vertraust, wie AWS IAM, Google Cloud oder einem beliebigen standardkonformen 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 aus, und das SDK aktualisiert dieses Token automatisch, bevor es abläuft. Es gibt keine `sk-ant-api...`-Zeichenkette zu erstellen, zu verteilen oder zu rotieren. Federation entfernt langlebige Claude-API-Keys aus deiner Umgebung, was den Schadensradius eines geleakten Anmeldedatums verkleinert und es dir ermöglicht, den Zugriff mit denselben IdP-Kontrollen zu verwalten, die du bereits für Cloud-Ressourcen verwendest. Sie garantiert für sich genommen keine End-to-End-Sicherheit: Die Vertrauenskette ist nur so stark wie die Konfiguration deines Identitätsanbieters, und ein langlebiges Geheimnis einen Schritt weiter oben (zum Beispiel ein statisches Cloud-Anmeldedatum, das IdP-Tokens erstellen kann) kann sie dennoch untergraben. Kombiniere Federation mit den Kontrollen deines Anbieters, wie IP-Zulassungslisten, 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 beweist, dass sie ein echter, unveränderter Build einer App ist, die du in der Claude Console registriert hast, unter Verwendung von Apples App-Attest-Dienst. 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 einer Stunde ab und autorisieren nur [Messages-API](https://platform.claude.com/docs/de/api/messages/create)-Aufrufe. 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