> ## Documentation Index
> Fetch the complete documentation index at: https://docs.replit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Jetons d'accès externes

> Permettez aux pipelines CI, aux webhooks et autres services automatisés d'atteindre votre application Replit privée sans se connecter.

Les jetons d'accès externes sont des jetons porteurs que vous créez pour une application Replit spécifique.
Ils permettent aux services automatisés — pipelines CI, webhooks, moniteurs de statut, bots Slack,
scripts internes — d'atteindre l'application même lorsque son URL est verrouillée par
[une URL de développement privée](/references/publishing/private-deployments)
ou par un [Déploiement privé](/references/publishing/private-deployments).

Traitez chaque jeton comme un mot de passe : quiconque le possède peut accéder à votre application jusqu'à
ce que le jeton expire ou que vous le révoquiez.

<Note>
  Les jetons d'accès externes sont disponibles avec les plans Replit Core et Pro.
  Les clients Enterprise doivent demander l'activation à Replit avant que la fonctionnalité soit
  activée pour leur espace de travail. Les jetons n'apparaissent dans les paramètres de publication
  qu'une fois que le déploiement est rendu privé.
</Note>

## Quand utiliser un jeton

Utilisez un jeton d'accès externe lorsqu'un service *extérieur* à votre navigateur doit
appeler votre application Replit privée. Cas courants :

* Un workflow GitHub Actions qui exécute un test de smoke sur votre URL de développement à
  chaque commit.
* Un moniteur de disponibilité (Better Stack, Pingdom, UptimeRobot) qui interroge un point de terminaison de santé
  sur votre application publiée.
* Un récepteur de webhook — Stripe, Slack, GitHub — envoyant des requêtes POST vers un Déploiement privé.
* Un appel `curl` ou `fetch` depuis la machine d'un collègue lors d'un débogage.

Les jetons d'accès externes sont conçus pour le **trafic API**, pas pour ouvrir des pages d'interface
dans un navigateur. Les applications monopage (Vite, Next.js, etc.) chargent des bundles JavaScript dans des
requêtes de suivi qui ne transporteront pas votre jeton, ces requêtes échoueront donc. Pour une navigation
interactive, connectez-vous normalement à la place.

## Environnements de jetons

Chaque jeton est lié à un environnement :

| Environnement | Où il fonctionne                                                                  | Utilisation                                                     |
| :------------ | :-------------------------------------------------------------------------------- | :-------------------------------------------------------------- |
| `Development` | L'URL de développement de l'espace de travail (`*.replit.dev`)                    | Accéder à un Repl en cours d'exécution pendant le développement |
| `Production`  | Le déploiement publié de l'application (`*.replit.app` et domaines personnalisés) | Accéder à un Déploiement privé depuis des services externes     |

Un jeton `Production` est lié au déploiement *actuellement publié*. Si vous
re-publiez sur un nouveau déploiement, les jetons de production existants cessent de fonctionner
et vous devez en créer de nouveaux.

## Créer un jeton d'accès externe

<Steps>
  <Step>
    Ouvrez l'application que vous souhaitez exposer, puis ouvrez l'outil **Publication**.
  </Step>

  <Step>
    Sélectionnez **Ajuster les paramètres** pour développer les options de re-publication.
  </Step>

  <Step>
    Dans la section **Sécurité**, trouvez **Jetons d'accès externes**.
  </Step>

  <Step>
    Sélectionnez **Créer un jeton d'accès** et remplissez :

    * **Étiquette** (optionnel) : un nom court pour reconnaître le jeton plus tard,
      comme `CI` ou `webhook Stripe`. Maximum 120 caractères.
    * **Environnement** : choisissez `Development` ou `Production` selon l'endroit où
      le service appelant doit atteindre l'application.
    * **Expire après** : choisissez une durée de vie — `1 heure`, `24 heures`, `7 jours`,
      `30 jours`, `3 mois`, `1 an`, ou `5 ans`. Choisissez la fenêtre la plus courte
      qui convient à l'usage. Il n'y a pas d'option "n'expire jamais".
  </Step>

  <Step>
    Sélectionnez **Créer**.
  </Step>
</Steps>

Replit affiche le jeton **une seule fois**. Copiez-le maintenant — une fois la boîte de dialogue fermée,
il n'y a plus moyen de voir le jeton. Si vous le perdez, révoquez ce jeton et créez-en
un nouveau.

L'écran de révélation propose deux actions de copie :

* **Copier le paramètre de requête** — copie `?project-protection-bypass=<jeton>` pour
  l'ajouter à une URL. Pratique pour des vérifications rapides avec `curl`.
* **Copier le jeton uniquement** — copie le jeton brut, adapté pour l'envoyer dans un
  en-tête `Authorization: Bearer`.

<Info>
  La création de votre premier jeton active automatiquement l'accès externe pour l'application,
  si ce n'était pas déjà le cas. Sans protection, le jeton n'a rien à contourner.
</Info>

## Utiliser un jeton

Présentez le jeton de l'une des deux façons suivantes :

### En-tête d'autorisation (recommandé)

```bash theme={null}
curl -H "Authorization: Bearer <token>" https://your-app.replit.app/health
```

C'est le bon choix pour presque tout — webhooks, scripts CI,
appels backend-to-backend. Le jeton n'apparaît jamais dans les journaux qui capturent les URL
et n'atterrit jamais dans votre historique de navigateur.

### Paramètre de requête

```bash theme={null}
curl "https://your-app.replit.app/health?project-protection-bypass=<token>"
```

Utilisez le formulaire de paramètre de requête uniquement lorsque vous ne pouvez pas définir des en-têtes — par exemple, un
service qui ne prend qu'une URL. Les URL avec des jetons finissent souvent dans les journaux proxy,
l'historique du shell et les captures d'écran, préférez donc la forme d'en-tête chaque fois que vous le pouvez.

## Gérer les jetons existants

La section **Jetons d'accès externes** liste tous les jetons que vous avez créés pour
l'application — du plus récent au plus ancien — avec leur étiquette, environnement, date de création,
expiration et statut de révocation. Les derniers caractères du jeton sont affichés
sur chaque ligne pour vous aider à distinguer les jetons, puisque la valeur complète n'est affichée
qu'au moment de la création.

Vous ne voyez que les jetons que *vous* avez créés. Les jetons des autres collaborateurs leur sont privés,
même si vous êtes propriétaire de l'application.

## Révoquer un jeton

Révoquez un jeton dès qu'il n'est plus nécessaire, ou dès que vous soupçonnez qu'il
a pu être compromis. Pour révoquer :

<Steps>
  <Step>
    Ouvrez la section **Jetons d'accès externes** dans les paramètres de publication de l'application.
  </Step>

  <Step>
    Trouvez le jeton dans la liste et sélectionnez l'icône de corbeille.
  </Step>

  <Step>
    Confirmez la révocation.
  </Step>
</Steps>

La révocation est **immédiate et irréversible**. Tout trafic utilisant encore le
jeton commence à être rejeté en quelques secondes. Si vous avez à nouveau besoin d'accès, créez un
nouveau jeton.

Vous ne pouvez révoquer que les jetons que vous avez créés vous-même. La suppression d'un collaborateur de
l'espace de travail révoque automatiquement les jetons qu'il a créés pour cette application.

## Protéger vos jetons

Les jetons d'accès externes sont des identifiants. Traitez-les avec le même soin que vous donneriez
à une clé API ou un mot de passe.

### À faire

* **Stockez les jetons dans un gestionnaire de secrets** — les secrets GitHub Actions, le coffre de votre
  fournisseur CI, le magasin de secrets de votre fournisseur cloud, ou un gestionnaire de mots de passe.
  Ne les commitez jamais dans un dépôt.
* **Utilisez des durées de vie courtes** quand vous le pouvez. Un jeton de 7 jours pour une intégration
  ponctuelle est plus sûr qu'un jeton de 5 ans laissé traîner.
* **Étiquetez chaque jeton** pour que vous-même dans le futur sachiez à quoi il sert et s'il est
  encore utilisé. Les jetons sans étiquette sont les premiers à fuiter et les derniers à être révoqués.
* **Créez un jeton séparé par consommateur.** Un jeton par tâche CI, un par
  source de webhook, un par vérification de disponibilité. Lorsque quelque chose est compromis — ou
  qu'un fournisseur n'est plus nécessaire — vous révoquez uniquement celui-là.
* **Préférez l'en-tête `Authorization`** aux paramètres de requête pour que le jeton
  ne fuite pas dans les journaux d'URL, l'historique du navigateur ou les en-têtes de référent.
* **Révoquez immédiatement** si un jeton a pu être exposé — un journal divulgué,
  un commit dans un dépôt public, un partage d'écran, l'ordinateur d'un ancien employé.
  La révocation prend effet immédiatement ; créez un remplacement ensuite.

### À ne pas faire

* **Ne partagez pas un jeton entre collègues ou services.** Si deux systèmes partagent
  un jeton, vous ne pouvez pas en révoquer un sans bloquer l'autre.
* **Ne collez pas les jetons dans des chats, emails, captures d'écran ou systèmes de suivi.**
  Ces canaux sont archivés, indexés et partagés de façons que vous ne pouvez pas prévoir.
* **N'intégrez pas les jetons dans du code côté client** — applications de navigateur, applications mobiles,
  binaires de bureau. Tout ce qui est envoyé sur l'appareil d'un utilisateur doit être considéré
  comme public.
* **Ne comptez pas sur les jetons pour les sessions de navigateur.** Les jetons fonctionnent pour les appels API,
  pas pour charger des SPA dans un onglet de navigateur. Utilisez une connexion Replit normale pour cela.
* **Ne choisissez pas une expiration de 5 ans par défaut.** Adaptez la durée de vie à la durée pendant laquelle
  le consommateur a réellement besoin d'accès.

## Dépannage

<Accordion title="Mon jeton de production a soudainement cessé de fonctionner">
  Les jetons de production sont liés à un déploiement publié spécifique. Si vous avez
  re-publié l'application — par exemple, en changeant le type de déploiement ou en
  détruisant et recréant le déploiement — les jetons de production existants sont
  invalidés. Créez un nouveau jeton depuis les paramètres du nouveau déploiement.
</Accordion>

<Accordion title="Mon jeton fonctionne avec `curl` mais mon navigateur affiche toujours la page de connexion">
  Les jetons d'accès externes sont destinés au trafic API, pas aux sessions de navigateur.
  Lorsqu'une application monopage se charge dans un navigateur, la requête HTML initiale
  peut transporter le jeton via un paramètre de requête, mais les requêtes de suivi pour
  les bundles JavaScript, CSS et les appels API ne l'incluront pas et seront
  rejetées. Pour naviguer dans l'application de manière interactive, connectez-vous normalement à Replit.
</Accordion>

<Accordion title="J'ai perdu le jeton — puis-je le voir à nouveau ?">
  Non. Replit n'affiche le jeton qu'une seule fois, au moment de la création. La vue liste affiche
  les métadonnées (étiquette, environnement, expiration, derniers caractères) mais jamais la
  valeur complète du jeton. Si vous l'avez perdu, révoquez ce jeton et créez-en un nouveau.
</Accordion>

## Prochaines étapes

* [Déploiements privés](/references/publishing/private-deployments) :
  la fonctionnalité de contrôle d'accès sous-jacente que ces jetons contournent.
* [Gestion des accès aux applications Replit](/teams/identity-and-access-management/repl-access-management) :
  gérez quels utilisateurs Replit peuvent se connecter à vos applications privées.
