# General Translation Platform: Clés API
URL: https://generaltranslation.com/fr/docs/platform/dashboard/reference/api-keys.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Créez et gérez les clés API de projet et d’organisation pour les applications, le développement local et l’automatisation. Référence des clés API.

Les clés API permettent d’authentifier vos applications, le CLI et vos automatisations auprès de General Translation. Utilisez le niveau de clé le plus restreint compatible avec le workflow.

## Niveaux de clé [#key-scopes]

General Translation prend en charge deux niveaux de clé API :

* **Clés d’organisation** pour l’automatisation au niveau de l’organisation. Utilisez-les pour l’automatisation à l’échelle de l’organisation ou pour les workflows qui doivent s’exécuter sur plusieurs projets de l’organisation.
* **Clés de projet** pour un seul projet. Utilisez-les dans les environnements serveur, le développement local et les outils limités au niveau du projet. Ne les incluez jamais dans les bundles d’applications navigateur ou mobiles déployés.

Dans le Dashboard, les deux niveaux prennent en charge les autorisations **All** ou **Custom**. **All** accorde toutes les autorisations que vous pouvez déléguer à ce niveau. **Custom** vous permet d’en sélectionner un sous-ensemble plus restreint ; sélectionnez au moins une autorisation. Vous ne pouvez accorder que les autorisations que vous détenez.

## Créer des clés d’organisation [#create-organization-keys]

Créez des clés d’organisation depuis **organisation &gt; Developer &gt; clés API**. Les clés d’organisation utilisent le préfixe `gtx-org-` et peuvent être configurées avec un ensemble de permissions personnalisé.

Dans ces contrôles du Dashboard, les permissions sont configurées par ressource. `Write` inclut `Read`.

| Ressource                        | Read                                            | Write ou activé                                                                                    |
| -------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Création de projet**           | Non applicable                                  | Créer de nouveaux projets dans l’organisation                                                      |
| **Clés API de projet**           | Voir les clés API des projets                   | Voir et créer des clés API de projet                                                               |
| **Files**                        | Lire les fichiers et les traductions du projet  | Téléverser le contenu source et écrire les fichiers traduits                                       |
| **Contexte**                     | Lire le contexte du projet et de l’organisation | Gérer les Context Groups, le Glossary et les instructions personnalisées                           |
| **Traduction à l’exécution**     | Non applicable                                  | Traduire le contenu à la demande                                                                   |
| **File d’attente de traduction** | Non applicable                                  | Mettre en file d’attente des tâches de traduction de fichiers pour un traitement en arrière-plan   |
| **Paramètres du projet**         | Non applicable                                  | Mettre à jour les paramètres du projet, comme le paramètre régional par défaut et la livraison CDN |

Activez **Création de projet** pour les automatisations qui appellent l’endpoint [Créer un projet](/docs/platform/openapi/reference/project/create-project). Sa permission `org:projects:create` permet également de créer des projets avec la livraison CDN activée ; **Paramètres du projet** (`project:write`) n’est nécessaire que pour modifier ultérieurement les paramètres. N’accordez à chaque clé que les permissions dont elle a besoin.

Définissez **Contexte** sur **Read** ou **Write** pour les automatisations qui appellent l’[API de gestion du contexte](/docs/platform/openapi/reference/context-management/list-groups) (`org:context:read` / `org:context:write`). Les clés de projet ne peuvent pas gérer les Context Groups.

Définissez **Clés API de projet** sur **Write** pour les automatisations qui appellent [Créer une clé API de projet](/docs/platform/openapi/reference/project/create-api-key). Pour un projet donné, utilisez une clé de son organisation dotée des permissions requises. Les clés de projet ne peuvent pas créer d’autres clés.

Lorsque vous créez des clés via l’[API HTTP](/docs/platform/openapi/reference/project/create-api-key), sélectionnez explicitement les permissions, ou omettez toute sélection pour accorder l’ensemble des permissions de projet que vous pouvez déléguer. Contrairement aux contrôles du Dashboard, une permission Write accordée explicitement via HTTP n’inclut pas Read.

## Créer des clés de projet [#create-project-keys]

Créez des clés de projet depuis **projet &gt; clés API**. Les nouvelles clés commencent par `gtx-api-` et fonctionnent en développement, en préproduction et en production. Leurs autorisations déterminent les opérations qu&#39;elles peuvent effectuer.

1. Créez une clé et saisissez un **Name** descriptif.
2. Sous **Autorisations**, choisissez **All** ou **Custom**.
3. Pour **Custom**, sélectionnez l&#39;accès nécessaire à chaque ressource.
4. Sélectionnez **Create**, puis copiez immédiatement la clé complète. Conservez-la dans des variables d&#39;environnement ou un gestionnaire de secrets.

Les clés de projet prennent en charge ces ressources :

| Resource                         | Read                                    | Write ou activation                                            |
| -------------------------------- | ------------------------------------------ | ----------------------------------------------------------------- |
| **Files**                        | Lire les fichiers et traductions du projet | Téléverser du contenu source et écrire les fichiers traduits      |
| **contexte**                     | Lire le contexte du projet                 | Gérer le contexte du projet                                       |
| **traduction à l’exécution**     | Non applicable                             | Traduire du contenu à la demande                                  |
| **file d’attente de traduction** | Non applicable                             | Mettre en file d&#39;attente des tâches de traduction de fichiers |
| **paramètres du projet**         | Non applicable                             | Mettre à jour les paramètres du projet                            |

Pour la traduction à la demande en local, toute clé de projet disposant de `project:translations:generate` convient, y compris une clé à accès complet. Pour limiter les risques, nous recommandons d&#39;utiliser une clé distincte avec des autorisations **Custom** : définissez **traduction à l’exécution** sur **Enabled** et laissez les autres ressources sur **None**. Pour un pipeline de traduction de fichiers, accordez **Files &gt; Write** et **file d’attente de traduction &gt; Enabled** ; ajoutez **contexte &gt; Write** si le pipeline génère du contexte.

Le paramètre du SDK `devApiKey` et la variable d&#39;environnement `GT_DEV_API_KEY` activent toujours la traduction en développement et le hot reload. Fournissez dans ce paramètre une clé de projet disposant de l'autorisation de traduction à l&#39;exécution. Le nom du paramètre ne désigne pas un type de clé distinct.

Dans la plupart des workflows SDK et CLI, utilisez la clé avec votre project ID :

```bash
GT_API_KEY=gtx-api-...
GT_PROJECT_ID=...
```

Pour un accès à la CLI associé à un compte, utilisez [`gt login`](/docs/cli/reference/commands/login). Pour créer une clé de projet avec des autorisations explicites depuis la CLI, utilisez [`gt api-key create`](/docs/cli/reference/commands/api-key-create).

## Gérer les clés [#manage-keys]

Utilisez des noms explicites pour que les clés soient faciles à retrouver par la suite.

Ouvrez la liste des clés du projet ou de l’organisation pour réviser les clés existantes. La liste des clés affiche :

* **Name** et **Key**, incluant une clé tronquée pour aider à l’identifier
* **Autorisations**, pour les clés de projet comme pour les clés d’organisation
* **Created**, la date à laquelle la clé a été générée
* **Last Used**, la date à laquelle la clé a été utilisée pour la dernière fois

Si vous disposez de l’autorisation de gérer les clés, utilisez **Edit key** pour renommer une clé ou modifier ses autorisations, et **Delete** pour la révoquer. Le secret complet n’est affiché qu’au moment de la création de la clé.

Révoquez les clés qui ne sont plus utilisées et créez des clés de remplacement lors de la rotation des identifiants.

## Clés de développement existantes [#existing-keys]

Les clés `gtx-dev-` existantes continuent de s&#39;authentifier en tant que clés de projet. Les clés dotées de l&#39;ancienne permission par défaut limitée à l&#39;exécution reçoivent désormais les permissions de projet par défaut, à savoir les fichiers, le contexte, la file d&#39;attente de traduction et les paramètres du projet. Les autres ensembles de permissions personnalisés sont préservés.

Révisez les clés existantes dans **Projet &gt; clés API**. Pour le développement local, nous recommandons de les restreindre à **traduction à l’exécution** ou de les remplacer par de nouvelles clés limitées à l&#39;exécution. Les clés à accès complet fonctionnent toujours, mais un préfixe `gtx-dev-` ne signifie plus que les permissions sont limitées. N&#39;incluez jamais ces clés dans les bundles clients déployés.

## Bonnes pratiques de sécurité [#security-practices]

* N’enregistrez jamais de clés dans la gestion de versions.
* N’incluez jamais de clé API dans les bundles déployés d’applications navigateur ou mobiles, quelles que soient ses permissions. Conservez les credentials déployés dans des variables d’environnement côté serveur ou un gestionnaire de secrets.
* Les clés API peuvent être utilisées dans du code client servi uniquement par votre serveur de développement local. Les clés de projet à accès complet fonctionnent, mais nous recommandons de restreindre les clés de développement local à la **traduction à l’exécution** (`project:translations:generate`) afin de limiter les risques.
* Stockez les clés dans des variables d’environnement ou un gestionnaire de secrets.
* Utilisez des clés distinctes pour le développement, la préproduction et la production.
* Effectuez régulièrement une rotation des clés.
* Révoquez les clés inutilisées.
* Préférez le niveau le plus restreint compatible avec l’intégration.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.
