--- 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 permissions | 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 ou, pour une clé à espace de travail unique, à cet espace de travail. Les clés personnelles sont archivées lorsque vous êtes retiré de l'organisation. Si vous êtes réinvité, 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 à l'espace de travail par défaut et aux espaces de travail auxquels il a été ajouté | Le compte de service est archivé ou, pour une clé à espace de travail unique, est retiré de cet espace de travail | | **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 comme cette identité. Lorsque cette identité est retirée de l'organisation, la clé cesse de fonctionner. Cela signifie que les clés ne survivront pas accidentellement aux personnes ou aux charges de travail qui les possèdent. Préférez-les 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 **Créer une clé**. Nommez la clé et choisissez une [expiration](https://platform.claude.com/docs/fr/manage-claude/authentication#key-expiration). Définissez **Compte lié** 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 comme `Authorization: Bearer ` sur les requêtes HTTP directes, ou définissez la variable d'environnement `ANTHROPIC_API_KEY` et les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) la récupèrent 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 leur rotation périodiquement, et désactivez ou supprimez toute clé que vous soupçonnez d'avoir fuité. Sur la [page des clés API](https://platform.claude.com/settings/keys) de la Claude Console, **Désactiver** est réversible (l'Admin API indique le `status` de la clé comme `"inactive"`, et **Réactiver** le remet à `"active"`), tandis que **Supprimer** 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é afin de 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"}] }' ``` ```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(); ``` ```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(); ``` ```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(); ``` ```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 ``` ```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-... ``` ### 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 les 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 sur chaque requête pour une clé multi-espaces de travail. # Omettez l'en-tête anthropic-workspace-id pour une clé à espace de travail unique. 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 sur chaque commande pour une clé multi-espaces de travail. # Omettez --workspace-id pour une clé à espace de travail unique. 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 sur chaque requête pour une clé multi-espaces de travail. # Omettez extra_headers pour une clé à espace de travail unique. 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 // Requis sur chaque requête pour une clé multi-espaces de travail. // Omettez le second argument pour une clé à espace de travail unique. 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() { Role = Role.User, Content = "Hello, Claude" }], }; // Requis sur chaque requête pour une clé multi-espaces de travail. // Appelez directement client.Messages.Create(parameters) pour une clé à espace de travail unique. 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 sur chaque requête pour une clé multi-espaces de travail. // Omettez l'option pour une clé à espace de travail unique. 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 sur chaque requête pour une clé multi-espaces de travail. // Omettez putAdditionalHeader pour une clé à espace de travail unique. 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 sur chaque requête pour une clé multi-espaces de travail. // Omettez requestOptions pour une clé à espace de travail unique. $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 sur chaque requête pour une clé multi-espaces de travail. # Omettez request_options pour une clé à espace de travail unique. 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": "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" } ``` 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 des clés API](https://platform.claude.com/settings/keys) dans la Claude Console, vous choisissez une expiration : un préréglage (3 heures, 1 jour, 7 jours ou 30 jours), une durée personnalisée, ou **Jamais** pour les clés que vous stockez dans un gestionnaire de secrets et faites tourner vous-même. Si votre organisation a une politique d'expiration maximale, la Console limite les préréglages et les durées personnalisées au maximum de la politique, et **Jamais** 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 [Workload Identity Federation](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érée aux clés à longue durée de vie. 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 [Comptes de service](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 plusieurs espaces de travail sont nécessaires. 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 de gestionnaire de secrets. Pour une clé multi-espaces 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, tel qu'AWS IAM, Google Cloud, ou 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 à `POST /v1/oauth/token` contre un jeton d'accès de courte durée à l'API Claude, et le SDK rafraîchit ce jeton automatiquement avant son expiration. Il n'y a aucune chaîne `sk-ant-api...` à générer, distribuer ou faire tourner. La fédération supprime les clés API Claude à longue durée de vie de votre environnement, ce qui réduit le rayon d'impact d'un identifiant ayant fuité et vous permet de gérer l'accès avec les mêmes contrôles 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 aussi solide que la configuration de votre fournisseur d'identité, et un secret à longue durée de vie situé un saut en amont (par exemple, un identifiant cloud statique capable de générer des jetons IdP) peut toujours la compromettre. Associez la fédération aux contrôles de votre fournisseur, tels que les listes d'autorisation d'adresses IP, 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'elle est une version authentique et non modifiée d'une application que vous avez enregistrée dans la Claude Console, en utilisant le service App Attest d'Apple. Anthropic délivre ensuite à 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 une heure et n'autorisent que les appels à l'[API Messages](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