--- title: Authentification url: https://platform.claude.com/docs/fr/manage-claude/authentication description: Authentifiez-vous auprès de l'API Claude avec des clés API, Workload Identity Federation ou App Attest. --- L'API Claude prend en charge trois façons d'authentifier les requêtes : | Méthode | Identifiant | Idéal pour | | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Clé API](https://platform.claude.com/docs/fr/manage-claude/authentication#api-keys) | Secret statique `sk-ant-api...` envoyé comme jeton bearer dans l'en-tête `Authorization` | Développement local, prototypage, scripts et serveurs où vous contrôlez le stockage des secrets | | [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/authentication#workload-identity-federation) | Jeton bearer de courte durée échangé à partir du jeton d'identité de votre fournisseur d'identité | Charges de travail en production sur des plateformes cloud (AWS, Google Cloud, Azure), pipelines CI/CD et Kubernetes, où vous souhaitez éliminer les secrets statiques | | [App Attest](https://platform.claude.com/docs/fr/manage-claude/authentication#app-attest) | Jeton d'accès de courte durée délivré à une installation authentique et attestée de votre application iOS ou macOS enregistrée | Applications iOS et macOS distribuées aux utilisateurs finaux, où l'application appelle directement l'API Claude sans back end ni proxy | Les clés API et Workload Identity Federation accordent le même accès aux points de terminaison de l'API Claude. Choisissez les clés API pour démarrer rapidement : une clé personnelle pour votre propre développement, ou une clé de compte de service pour tout ce qui est partagé. Passez à Workload Identity Federation lorsque votre charge de travail dispose déjà d'une identité émise par la plateforme que vous pouvez fédérer. Utilisez App Attest pour les applications iOS et macOS que vous distribuez aux utilisateurs finaux. ## Clés API Les clés API sont des secrets statiques que vous générez dans la Claude Console et envoyez à chaque requête comme jeton bearer dans l'en-tête `Authorization`. ### Types de clés Lorsque vous créez une clé, vous choisissez son type, qui détermine ce que la clé peut faire, où elle fonctionne et quand elle cesse de fonctionner : | Type de clé | Agit comme | Fonctionne dans | Cesse de fonctionner lorsque | | ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Clé personnelle** | Vous, l'utilisateur, avec vos rôles et autorisations | Soit un seul espace de travail, soit les espaces de travail où votre rôle autorise l'utilisation de l'API, choisi lors de la création de la clé | Vous perdez l'accès à l'organisation. Une clé limitée à un seul espace de travail cesse également de fonctionner lorsque vous perdez l'accès à cet espace de travail ou que cet espace de travail est archivé. Les clés personnelles sont archivées lorsque vous êtes retiré de l'organisation. Si vous êtes invité à nouveau, créez de nouvelles clés ; les clés archivées ne sont pas restaurées | | **Clé de compte de service** | Un [compte de service](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#service-accounts) | Soit un seul espace de travail, soit tout ce à quoi le compte de service a accès, choisi lors de la création de la clé. Un compte de service a accès au Default Workspace et aux espaces de travail auxquels il a été ajouté | Le compte de service est archivé. Une clé limitée à un seul espace de travail cesse également de fonctionner lorsque le compte de service est retiré de cet espace de travail ou que cet espace de travail est archivé | | **Clé d'espace de travail** (héritée) | Personne : elle appartient à l'espace de travail dans lequel elle a été créée | Cet espace de travail | Elle expire, est désactivée ou supprimée, ou son espace de travail est archivé, que son créateur quitte ou non l'organisation | Les clés personnelles et les clés de compte de service sont adossées à une identité : chacune appartient à un utilisateur ou à un compte de service que votre organisation gère déjà, et chaque requête agit en tant que cette identité. Lorsque cette identité est retirée de l'organisation, la clé cesse de fonctionner. Ainsi, les clés ne survivent pas accidentellement aux personnes ou aux charges de travail qui les possèdent. Privilégiez-les par rapport aux clés d'espace de travail pour les nouvelles intégrations. Utilisez une clé personnelle pour votre propre développement et vos scripts. Une clé personnelle partagée agit comme une seule personne et cesse de fonctionner lorsqu'elle part. Pour les charges de travail partagées ou automatisées (CI, services de production), demandez à un administrateur de l'organisation de créer un compte de service afin que la charge de travail dispose de sa propre identité. Les clés API d'espace de travail fonctionnent toujours mais doivent être considérées comme héritées ; les clés adossées à une identité ou [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) sont préférées. Pour migrer, consultez [Remplacer les clés API d'espace de travail](https://platform.claude.com/docs/fr/manage-claude/authentication#replacing-workspace-api-keys). ### Créer et utiliser une clé * **Créer une clé :** Dans la Claude Console, accédez à la page [Clés API](https://platform.claude.com/settings/keys) (`platform.claude.com/settings/keys`) et cliquez sur **Create key**. Nommez la clé et sélectionnez une [expiration](https://platform.claude.com/docs/fr/manage-claude/authentication#key-expiration). Définissez **Linked account** sur vous-même pour une clé personnelle, ou sur un compte de service pour une clé partagée entre plusieurs utilisateurs. Vous pouvez également limiter la clé à un espace de travail spécifique, ce qui vous évite de définir manuellement un ID d'espace de travail dans les requêtes futures. * **Utiliser la clé :** Envoyez-la sous la forme `Authorization: Bearer ` dans les requêtes HTTP directes, ou définissez la variable d'environnement `ANTHROPIC_API_KEY` et le [SDK client](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) la récupère automatiquement. ```http POST /v1/messages Authorization: Bearer YOUR_API_KEY anthropic-version: 2023-06-01 content-type: application/json ``` L'en-tête hérité `x-api-key: YOUR_API_KEY` est toujours pris en charge à la place de `Authorization`. Stockez les clés API dans un gestionnaire de secrets, effectuez-en la rotation périodiquement, et désactivez ou supprimez toute clé que vous soupçonnez d'avoir fuité. Sur la page [Clés API](https://platform.claude.com/settings/keys) de la Claude Console, **Disable** est réversible (l'Admin API indique le `status` de la clé comme `"inactive"`, et **Re-enable** le rétablit à `"active"`), tandis que **Delete** est définitif : la clé est archivée et apparaît toujours dans [List API Keys](https://platform.claude.com/docs/fr/api/organization/api_keys/list) avec `status: "archived"`. Les clés expirées peuvent uniquement être supprimées. Vous pouvez également définir une [expiration](https://platform.claude.com/docs/fr/manage-claude/authentication#key-expiration) lors de la création d'une clé pour limiter la durée pendant laquelle un identifiant ayant fuité reste utilisable. ```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 # Voir /docs/en/cli-sdks-libraries/cli/authentication#api-key pour les variantes zsh, bash et Windows. export ANTHROPIC_API_KEY=sk-ant-api03-... ``` ```python Python client = Anthropic(api_key="my-anthropic-api-key") # ou, avec ANTHROPIC_API_KEY défini dans l'environnement : client = Anthropic() ``` ```typescript TypeScript const client = new Anthropic({ apiKey: "my-anthropic-api-key" }); // ou, avec ANTHROPIC_API_KEY défini dans l'environnement : // const client = new Anthropic(); ``` ```csharp C# using Anthropic; AnthropicClient client = new() { ApiKey = "my-anthropic-api-key" }; // Ou, avec ANTHROPIC_API_KEY défini dans l'environnement : // 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; // Explicite AnthropicClient client = AnthropicOkHttpClient.builder() .apiKey("my-anthropic-api-key") .build(); // Depuis ANTHROPIC_API_KEY (ou la propriété système anthropic.apiKey) AnthropicClient clientFromEnv = AnthropicOkHttpClient.fromEnv(); ``` ```php PHP // Lit ANTHROPIC_API_KEY depuis l'environnement $client = new Client(); // Ou passez la clé explicitement : $client = new Client(apiKey: 'my-anthropic-api-key'); ``` ```ruby Ruby anthropic = Anthropic::Client.new(api_key: "my-anthropic-api-key") # ou, avec ANTHROPIC_API_KEY défini dans l'environnement : anthropic = Anthropic::Client.new ``` ### Sélectionner un espace de travail Les clés API créées pour un espace de travail spécifique ne fonctionnent que dans cet espace de travail, et les requêtes API utilisant ces clés peuvent omettre l'ID de l'espace de travail. Si votre clé API n'est pas limitée à un espace de travail, vous devez spécifier l'ID de l'espace de travail dans l'en-tête `anthropic-workspace-id` pour chaque requête. Consultez l'exemple suivant pour savoir comment définir cet en-tête dans une requête ou dans le SDK. L'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) accepte une clé personnelle ou une clé de compte de service uniquement si la clé n'est pas limitée à un espace de travail spécifique. Vous pouvez trouver l'ID d'un espace de travail dans la colonne **ID** de la page [Espaces de travail](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) de la Claude Console, ou en appelant le point de terminaison [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list). List Workspaces inclut l'espace de travail par défaut uniquement lorsque vous passez `include_default=true` ; son ID figure également dans l'[en-tête de réponse](https://platform.claude.com/docs/fr/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) `anthropic-workspace-id` de toute requête qui s'y exécute. ```bash cURL # Requis pour chaque requête avec une clé non limitée à un espace de travail. # Omettez l'en-tête anthropic-workspace-id pour une clé limitée à un espace de travail. 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 # Requis pour chaque commande avec une clé non limitée à un espace de travail. # Omettez --workspace-id pour une clé limitée à un seul espace de travail. 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 # Requis pour chaque requête avec une clé qui n'est pas limitée à un espace de travail. # Omettez extra_headers pour une clé limitée à un seul espace de travail. 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) # Ou définissez-le une fois pour chaque requête de ce client : workspace_client = Anthropic( default_headers={"anthropic-workspace-id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"}, ) ``` ```typescript TypeScript const client = new Anthropic(); // reads ANTHROPIC_API_KEY // Obligatoire à chaque requête pour une clé qui n'est pas limitée à un espace de travail. // Omettez le second argument pour une clé limitée à un seul espace de travail. 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); // Ou définissez-le une fois pour chaque requête de ce 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" }], }; // Requis sur chaque requête pour une clé qui n'est pas limitée à un espace de travail. // Appelez directement client.Messages.Create(parameters) pour une clé limitée à un seul espace de travail. var message = await client .WithOptions(options => options with { ExtraHeaders = new Dictionary { ["anthropic-workspace-id"] = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", }, } ) .Messages.Create(parameters); Console.WriteLine(message); // Ou définissez-le une fois pour chaque requête de ce client : AnthropicClient workspaceClient = new(new ClientOptions { ExtraHeaders = new Dictionary { ["anthropic-workspace-id"] = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", }, }); ``` ```go Go client := anthropic.NewClient() // reads ANTHROPIC_API_KEY // Requis pour chaque requête avec une clé non limitée à un espace de travail. // Omettez l'option pour une clé limitée à un seul espace de travail. 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) // Ou définissez-le une fois pour chaque requête de ce client : workspaceClient := anthropic.NewClient( option.WithHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"), ) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // reads ANTHROPIC_API_KEY // Requis pour chaque requête avec une clé qui n'est pas limitée à un espace de travail. // Omettez putAdditionalHeader pour une clé limitée à un seul espace de travail. 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()); // Ou définissez-le une fois pour chaque requête de ce client : AnthropicClient workspaceClient = AnthropicOkHttpClient.builder() .fromEnv() .putHeader("anthropic-workspace-id", "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ") .build(); ``` ```php PHP $client = new Client(); // reads ANTHROPIC_API_KEY // Requis pour chaque requête avec une clé qui n'est pas limitée à un espace de travail. // Omettez requestOptions pour une clé limitée à un seul espace de travail. $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 # Requis pour chaque requête avec une clé non limitée à un espace de travail. # Omettez request_options pour une clé limitée à un seul espace de travail. 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 ``` Si une requête effectuée avec une clé qui n'est pas limitée à un espace de travail omet l'en-tête, l'API renvoie une erreur 400 `invalid_request_error` : ```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" } ``` Une valeur d'en-tête qui n'est pas un ID d'espace de travail valide renvoie une erreur 400 `invalid_request_error` avec le message `anthropic-workspace-id header must be a valid workspace ID.` Si l'espace de travail n'existe pas, ou si l'utilisateur ou le compte de service de la clé n'y a pas accès, l'API renvoie une erreur 404 `not_found_error` avec le message ``Workspace `` not found.``, la même réponse que pour tout espace de travail inconnu. Workload Identity Federation sélectionne plutôt un espace de travail lors de l'échange de jetons ; consultez la [référence WIF](https://platform.claude.com/docs/fr/manage-claude/wif-reference) pour plus de détails. ### Expiration des clés Lorsque vous créez une clé API depuis la page [Clés API](https://platform.claude.com/settings/keys) de la Claude Console, vous choisissez une expiration : une valeur prédéfinie (3 heures, 1 jour, 7 jours ou 30 jours), une durée personnalisée, ou **Never** pour les clés que vous stockez dans un gestionnaire de secrets et dont vous effectuez vous-même la rotation. Si votre organisation applique une politique d'expiration maximale, la Console limite les valeurs prédéfinies et les durées personnalisées au maximum de la politique, et **Never** n'est pas disponible. Les clés existantes conservent leur comportement actuel ; l'expiration est définie au moment de la création et ne peut pas être modifiée par la suite. Le même choix d'expiration s'applique lorsque vous [créez une clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys) dans la Claude Console. Anthropic envoie un e-mail au créateur de la clé à l'approche de l'expiration : 7 jours avant l'expiration pour les clés créées avec une durée de vie d'au moins 14 jours, et 1 jour avant pour les clés avec une durée de vie d'au moins 7 jours. Les clés avec des durées de vie plus courtes expirent sans e-mail d'avertissement. Après l'expiration d'une clé, les requêtes effectuées avec elle renvoient une erreur `401 authentication_error`. Créez une nouvelle clé pour restaurer l'accès ; les clés expirées ne peuvent pas être réactivées. Le tableau des clés API de la Console affiche l'expiration de chaque clé, et l'Admin API indique l'horodatage `expires_at` de chaque clé sur les points de terminaison [List API Keys](https://platform.claude.com/docs/fr/api/organization/api_keys/list) et [Retrieve API Key](https://platform.claude.com/docs/fr/api/organization/api_keys/retrieve), afin que vous puissiez auditer les clés et effectuer leur rotation avant leur expiration. Le champ vaut `null` pour les clés sans expiration. L'expiration limite la durée de vie d'un identifiant ayant fuité, mais elle ne remplace pas une bonne hygiène des secrets. Quelle que soit l'expiration, stockez les clés dans un gestionnaire de secrets et désactivez ou supprimez toute clé que vous soupçonnez d'avoir fuité. ### Remplacer les clés API d'espace de travail Si vous avez une clé d'espace de travail, vous pouvez vouloir la remplacer par [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/wif-reference) ou par une clé personnelle ou de compte de service. Cela offre une meilleure sécurité et une meilleure observabilité. Consultez la [référence WIF](https://platform.claude.com/docs/fr/manage-claude/wif-reference) pour plus de détails sur la configuration de Workload Identity Federation, qui est préférable aux clés de longue durée. Pour remplacer une clé d'espace de travail par une clé personnelle ou de compte de service : 1. **Décidez du type de clé.** Votre propre outillage doit utiliser une clé personnelle. Une charge de travail partagée ou sans surveillance doit utiliser une clé de compte de service. 2. **Créez un compte de service** si nécessaire. Vous devrez peut-être demander à un administrateur de l'organisation d'en créer un sur la page [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) de la Claude Console et de l'ajouter à l'espace de travail concerné. 3. **Créez la nouvelle clé.** Créez-la spécifiquement pour l'espace de travail de l'intégration, sauf si l'intégration nécessite plusieurs espaces de travail. 4. **Déployez la nouvelle clé.** Remplacez l'ancienne clé partout où l'intégration la lit, généralement la variable d'environnement `ANTHROPIC_API_KEY` ou une entrée du gestionnaire de secrets. Pour une clé non limitée à un espace de travail, envoyez également l'en-tête `anthropic-workspace-id` comme indiqué dans [Sélectionner un espace de travail](https://platform.claude.com/docs/fr/manage-claude/authentication#select-a-workspace). 5. **Supprimez l'ancienne clé.** Vérifiez que les requêtes aboutissent, puis supprimez la clé d'espace de travail sur la [page des clés API](https://platform.claude.com/settings/keys) de la Claude Console. ## Workload Identity Federation Workload Identity Federation (WIF) permet à une charge de travail de s'authentifier avec un jeton d'identité de courte durée émis par un fournisseur d'identité (IdP) auquel vous faites déjà confiance. Ces IdP incluent AWS IAM, Google Cloud et tout émetteur OIDC conforme aux normes (comme GitHub Actions, les comptes de service Kubernetes, SPIFFE, Microsoft Entra ID ou Okta). La charge de travail échange son JWT émis par l'IdP sur `POST /v1/oauth/token` contre un jeton d'accès de courte durée à l'API Claude, et le SDK actualise automatiquement ce jeton avant son expiration. Il n'y a aucune chaîne `sk-ant-api...` à générer, distribuer ou renouveler. La fédération supprime les clés API Claude de longue durée de votre environnement, ce qui limite les dommages qu'un identifiant ayant fuité peut causer et vous permet de gérer l'accès avec les mêmes contrôles d'IdP que vous utilisez déjà pour les ressources cloud. Elle ne garantit pas, à elle seule, une sécurité de bout en bout : la chaîne de confiance n'est pas plus solide que la configuration de votre fournisseur d'identité, et un secret de longue durée situé une étape plus tôt dans cette chaîne (par exemple, un identifiant cloud statique capable de générer des jetons d'IdP) peut encore la compromettre. Associez la fédération aux contrôles de votre fournisseur, tels que les listes d'adresses IP autorisées, la MFA et la journalisation d'audit. Pour configurer la fédération, vous créez trois ressources dans la Claude Console (un compte de service, un émetteur de fédération et une règle de fédération), puis vous pointez votre SDK vers la règle. Consultez [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) pour le guide de configuration complet. ## App Attest App Attest authentifie les applications iOS et macOS qui appellent l'API Claude directement depuis l'appareil. Chaque installation prouve qu'il s'agit d'une build authentique et non modifiée d'une application que vous avez enregistrée dans la Claude Console, à l'aide du service App Attest d'Apple. Anthropic émet ensuite pour l'appareil un jeton d'accès de courte durée qui facture l'utilisation à votre espace de travail. Les jetons sont limités à votre espace de travail, expirent après 1 heure et n'autorisent que les appels à la [Messages API](https://platform.claude.com/docs/fr/api/messages/create). Pour enregistrer votre application et obtenir un ID client, consultez [App Attest pour les applications iOS et macOS](https://platform.claude.com/docs/fr/manage-claude/app-attest). ## Étapes suivantes Configurez les émetteurs, les règles et les comptes de service, puis échangez des jetons Guides étape par étape pour AWS, Google Cloud, Azure, GitHub Actions, Kubernetes, SPIFFE et Okta Variables d'environnement, règles de validation, configuration de profil et référence des erreurs Laissez les installations authentiques de votre application appeler l'API Claude sans livrer de clé API Python, TypeScript, C#, Go, Java, PHP, Ruby et la CLI