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

> Décrit les types de jetons liés à l’identité et à l’authentification, ainsi que la façon dont Auth0 les utilise.

# Jetons

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Il existe deux types de jetons liés à l’identité : <Tooltip tip="Jeton d’ID : justificatif destiné au client lui-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+tokens">jetons d’ID</Tooltip> et <Tooltip tip="Jeton d’ID : justificatif destiné au client lui-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+tokens">jetons d’accès</Tooltip>.

<div id="id-tokens">
  ## Jetons d’ID
</div>

Les [jetons d’ID](/docs/fr-ca/secure/tokens/id-tokens) sont des [JSON Web Tokens (JWTs)](/docs/fr-ca/secure/tokens/json-web-tokens) destinés à être utilisés uniquement par l’application. Par exemple, si une application utilise Google pour permettre aux utilisateurs de se connecter et synchroniser leurs calendriers, Google envoie à l’application un jeton d’ID qui contient des renseignements sur l’utilisateur. L’application analyse ensuite le [contenu du jeton](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) et utilise ces renseignements (y compris des détails comme le nom et la photo de profil) pour personnaliser l’expérience utilisateur.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Assurez-vous de [valider les jetons d’ID](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) avant d’utiliser les renseignements qu’ils contiennent. Vous pouvez utiliser une [bibliothèque](https://jwt.io/#libraries-io) pour vous aider dans cette tâche.
</Callout>

N’utilisez **pas** les jetons d’ID pour accéder à une API. Chaque jeton contient des renseignements sur l’<Tooltip tip="Audience : identificateur unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un jeton d’identité ou d’une API (identificateur d’API) pour un jeton d’accès." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip> visée (qui est habituellement le destinataire). Selon la spécification <Tooltip tip="Audience : identificateur unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un jeton d’identité ou d’une API (identificateur d’API) pour un jeton d’accès." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> Connect, l’audience du jeton d’ID (indiquée par le claim **aud**) doit être l’<Tooltip tip="Client ID : valeur d’identification donnée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=client+ID">ID client</Tooltip> de l’application qui effectue la requête d’authentification. Si ce n’est pas le cas, vous ne devriez pas vous fier à ce jeton.

Le contenu décodé d’un jeton d’ID ressemble à ceci :

export const codeExample1 = `{
  "iss": "http://{yourDomain}/",
  "sub": "auth0|123456",
  "aud": "{yourClientId}",
  "exp": 1311281970,
  "iat": 1311280970,
  "name": "Jane Doe",
  "given_name": "Jane",
  "family_name": "Doe",
  "gender": "female",
  "birthdate": "0000-10-31",
  "email": "janedoe@example.com",
  "picture": "http://example.com/janedoe/me.jpg"
}`;

<AuthCodeBlock children={codeExample1} language="json" />

Ce token authentifie l’utilisateur auprès de l’application. L’audience (la claim **aud**) du token correspond à l’identifiant de l’application, ce qui signifie que seule cette application doit utiliser ce token.

À l’inverse, une API s’attend à recevoir un token dont la valeur **aud** correspond à l’identifiant unique de l’API. Par conséquent, à moins que vous n’ayez le contrôle à la fois de l’application et de l’API, l’envoi d’un jeton d’ID à une API ne fonctionnera généralement pas. Comme le jeton d’ID n’est pas signé par l’API, celle-ci n’aurait aucun moyen de savoir si l’application avait modifié le token (par exemple, en ajoutant des scopes supplémentaires) si elle acceptait le jeton d’ID. Consultez le [JWT Handbook](https://auth0.com/resources/ebooks/jwt-handbook) pour en savoir plus.

<div id="access-tokens">
  ## Jetons d’accès
</div>

Les [jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens) (qui ne sont pas toujours des <Tooltip tip="JSON Web Token (JWT) : format standard des ID Token (et souvent des jetons d’accès) utilisé pour représenter des claims de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=JWTs">JWTs</Tooltip>) servent à indiquer à une API que le porteur du jeton est autorisé à accéder à l’API et à effectuer un ensemble prédéterminé d’actions (défini par les **portées** accordées).

Dans l’exemple Google ci-dessus, Google envoie un jeton d’accès à l’application une fois que l’utilisateur a ouvert une session et a donné son consentement pour que l’application puisse lire ou écrire dans son Google Calendar. Chaque fois que l’application veut écrire dans Google Calendar, elle envoie une requête à l’API Google Calendar en incluant le jeton d’accès dans l’en-tête HTTP **Authorization**.

Les jetons d’accès ne doivent **jamais** être utilisés pour l’[authentification](/docs/fr-ca/authenticate). Les jetons d’accès ne permettent pas de savoir si l’utilisateur s’est authentifié. La seule information sur l’utilisateur que contient le jeton d’accès est l’ID utilisateur, situé dans le claim **sub**. Dans vos applications, traitez les jetons d’accès comme des chaînes opaques puisqu’ils sont destinés aux API. Votre application ne devrait pas tenter de les décoder ni s’attendre à recevoir des jetons dans un format particulier.

Voici un exemple de jeton d’accès :

export const codeExample2 = `{
  "iss": "https://{yourDomain}/",
  "sub": "auth0|123456",
  "aud": [
    "my-api-identifier",
    "https://{yourDomain}/userinfo"
  ],
  "azp": "{yourClientId}",
  "exp": 1489179954,
  "iat": 1489143954,
  "scope": "openid profile email address phone read:appointments"
}`;

<AuthCodeBlock children={codeExample2} language="json" />

Notez que le jeton ne contient aucune information sur l’utilisateur, à part son ID (claim **sub**). Il contient uniquement des renseignements d’autorisation sur les actions que l’application est autorisée à effectuer dans l’API (claim **scope**). C’est ce qui le rend utile pour sécuriser une API, mais pas pour authentifier un utilisateur.

Dans certaines situations, il peut être utile d’ajouter au jeton d’accès des renseignements supplémentaires sur l’utilisateur ou d’autres custom claims, en plus du claim sub, afin d’éviter à l’API d’avoir à faire du travail supplémentaire pour récupérer des détails sur l’utilisateur. Si vous choisissez de le faire, gardez à l’esprit que ces claims supplémentaires seront lisibles dans le jeton d’accès. Pour en savoir plus, consultez [Créer des custom claims](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims).

<div id="specialized-tokens">
  ## Jetons spécialisés
</div>

Il existe trois jetons spécialisés utilisés dans les scénarios d’authentification par jeton d’Auth0 :

* **<Tooltip tip="Refresh Token : jeton utilisé pour obtenir un Access Token renouvelé sans obliger les utilisateurs à se connecter de nouveau." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Refresh+tokens">Jetons d’actualisation</Tooltip>** : Jeton utilisé pour obtenir un nouveau jeton d’accès sans avoir à réauthentifier l’utilisateur.
* **<Tooltip tip="Identity Provider (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=IDP">IDP</Tooltip> jetons d’accès** : Jetons d’accès émis par des fournisseurs d’identité après l’authentification de l’utilisateur, que vous pouvez utiliser pour faire des requêtes aux API tierces.
* **Jetons d’accès de la <Tooltip tip="Management API : produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> d’Auth0** : Jetons de courte durée contenant des claims précis (scopes) qui vous permettent de faire des requêtes aux points de terminaison de la Management API.

<div id="learn-more">
  ## En savoir plus
</div>

* [JSON Web Tokens](/docs/fr-ca/secure/tokens/json-web-tokens)
* [Jetons d’ID](/docs/fr-ca/secure/tokens/id-tokens)
* [Jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens)
* [Jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens)
* [Stockage des jetons](/docs/fr-ca/secure/security-guidance/data-security/token-storage)
* [Pratiques exemplaires pour les jetons](/docs/fr-ca/secure/tokens/token-best-practices)