> ## 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) + "*****MASKED*****";
          }
          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é : les <Tooltip tip="ID Token : jeton destiné à l’application elle-même plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+tokens">ID tokens</Tooltip> et les <Tooltip tip="ID Token : jeton destiné à l’application elle-même plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+tokens">jetons d’accès</Tooltip>.

<div id="id-tokens">
  ## ID tokens
</div>

Les [ID tokens](/fr-CA/docs/secure/tokens/id-tokens) sont des [JSON web tokens (JWTs)](/fr-CA/docs/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 un ID token à l’application qui contient des informations 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 informations (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 ID tokens](/fr-CA/docs/secure/tokens/id-tokens/validate-id-tokens) avant d’utiliser les informations 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 ID tokens pour accéder à une API. Chaque jeton contient des informations sur l’<Tooltip tip="Audience : identifiant unique de l’audience pour un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (identifiant d’API) pour un Jeton d’accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=audience">audience</Tooltip> visée (qui est généralement le destinataire). Selon la spécification <Tooltip tip="Audience: Unique identifier of the audience for an issued token. Named aud in a token, its value contains the ID of either an application (Client ID) for an ID Token or an API (API Identifier) for an Access Token." cta="View Glossary" href="/fr-CA/docs/glossary?term=OpenID">OpenID</Tooltip> Connect, l’audience de l’ID token (indiquée par la revendication **aud**) doit être l’<Tooltip tip="ID client : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=client+ID">ID client</Tooltip> de l’application qui effectue la demande d’authentification. Si ce n’est pas le cas, vous ne devriez pas faire confiance au jeton.

Le contenu décodé d’un ID token ressemble à ce qui suit :

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 jeton sert à authentifier l’utilisateur auprès de l’application. L’audience (la revendication **aud**) du jeton correspond à l’identifiant de l’application, ce qui signifie que seule cette application devrait utiliser ce jeton.

À l’inverse, une API s’attend à ce que la valeur **aud** d’un jeton corresponde à l’identifiant unique de l’API. Par conséquent, à moins que vous ne contrôliez à la fois l’application et l’API, l’envoi d’un jeton d’identité à une API ne fonctionnera généralement pas. Comme le ID Token n’est pas signé par l’API, celle-ci n’aurait aucun moyen de savoir si l’application avait modifié le jeton (p. ex., en y ajoutant des scopes) si elle acceptait le ID Token. 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](/fr-CA/docs/secure/tokens/access-tokens) (qui ne sont pas toujours des <Tooltip tip="JSON Web Token (JWT) : format standard d’ID Token (et souvent de jeton d’accès) utilisé pour représenter des revendications de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=JWTs">JWTs</Tooltip>) servent à indiquer à une API que le porteur du jeton a été autorisé à y accéder et à effectuer un ensemble prédéfini d’actions (précisé par les **scopes** accordés).

Dans l’exemple Google ci-dessus, Google envoie un jeton d’accès à l’application une fois que l’utilisateur s’est connecté et a donné son consentement pour que l’application lise ou modifie son Google Calendar. Chaque fois que l’application veut apporter des modifications à 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](/fr-CA/docs/authenticate). Les jetons d’accès ne permettent pas de déterminer si l’utilisateur s’est authentifié. La seule information sur l’utilisateur contenue dans le jeton d’accès est l’ID de l’utilisateur, situé dans la revendication **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 identifiant (revendication **sub**). Il contient uniquement des informations d’autorisation sur les actions que l’application est autorisée à effectuer dans l’API (revendication **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’inclure dans le jeton d’accès des renseignements supplémentaires sur l’utilisateur ou d’autres revendications personnalisées, en plus de la revendication sub, afin d’éviter à l’API d’avoir à faire un travail supplémentaire pour récupérer des détails sur l’utilisateur. Si vous choisissez de le faire, gardez à l’esprit que ces revendications supplémentaires seront lisibles dans le jeton d’accès. Pour en savoir plus, consultez [Create Custom Claims](/fr-CA/docs/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="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau Jeton d’accès sans obliger les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Refresh+tokens">Jetons d’actualisation</Tooltip>**: Jeton utilisé pour obtenir un nouveau jeton d’accès sans que l’utilisateur ait à se réauthentifier.
* **<Tooltip tip="fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/fr-CA/docs/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 appeler des API tierces.
* **Auth0 <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip> jetons d’accès**: Jetons à courte durée de vie contenant des revendications précises (scopes) qui vous permettent d’appeler des points de terminaison de la Management API.

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

* [JSON Web Tokens](/fr-CA/docs/secure/tokens/json-web-tokens)
* [ID Tokens](/fr-CA/docs/secure/tokens/id-tokens)
* [Jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens)
* [Jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens)
* [Stockage des jetons](/fr-CA/docs/secure/security-guidance/data-security/token-storage)
* [Bonnes pratiques relatives aux jetons](/fr-CA/docs/secure/tokens/token-best-practices)