> ## 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.

# Obtenir un jeton

> Échanger un jeton d’identité existant contre un jeton Auth0 à l’aide du type d’autorisation Échange de jeton personnalisé.

export const ResponseSchema = ({statusCode, type = "{}", children}) => {
  const [open, setOpen] = useState(false);
  return <div className="border border-gray-100 dark:border-gray-800 rounded-lg mb-3 overflow-hidden">
      <div className={`flex items-center gap-2.5 px-4 py-2.5 cursor-pointer select-none ${open ? "bg-gray-50 dark:bg-gray-800" : ""}`} onClick={() => setOpen(!open)}>
        {statusCode && <span className="border border-gray-300 dark:border-gray-600 text-gray-700 dark:text-gray-300 font-mono text-xs px-1.5 py-0.5 rounded">
            {statusCode.startsWith("default") ? "default" : statusCode}
          </span>}
        <span className="text-gray-500 dark:text-gray-400 text-sm font-mono">
          {type}
        </span>
        <span className="text-gray-400 dark:text-gray-500 text-sm italic">
          application/json
        </span>
        <svg className={`ml-auto opacity-50 transition-transform duration-200 ${open ? "rotate-180" : ""}`} width="16" height="16" viewBox="0 0 16 16" fill="none">
          <path d="M4 6l4 4 4-4" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
        </svg>
      </div>
      {open && <div className="px-4 pt-1 pb-3 border-t border-gray-100 dark:border-gray-800">
          {children}
        </div>}
    </div>;
};

<div id="endpoint">
  ## Point de terminaison
</div>

`POST /oauth/token`

L’Échange de jeton personnalisé (CTE) offre aux applications un mécanisme leur permettant d’échanger des jetons d’identité existants contre des jetons Auth0 en appelant le point de terminaison `/oauth/token`, conformément aux spécifications de la [RFC 8693](https://datatracker.ietf.org/doc/html/rfc8693). Cette fonctionnalité est particulièrement utile pour répondre à des besoins d’intégration avancés, par exemple échanger des jetons Auth0 existants pour accéder à une autre audience au nom du même utilisateur, faciliter l’intégration de fournisseurs d’identité externes ou permettre une migration fluide des utilisateurs vers la plateforme Auth0. Le processus d’échange est entièrement contrôlable, puisque les développeurs peuvent en définir les détails à l’aide de leur logique personnalisée exécutée dans une Action Auth0 dédiée au cas d’utilisation concerné.

<Note>
  L’Échange de jeton personnalisé est actuellement offert en accès anticipé. En utilisant cette fonctionnalité, vous acceptez les conditions applicables de l’essai gratuit énoncées dans le [Master Subscription Agreement d’Okta](https://www.okta.com/legal/). Il vous incombe de valider de manière sécuritaire le `subject_token` de l’utilisateur. Consultez le [guide de l’utilisateur](https://auth0.com/docs/authenticate/custom-token-exchange) pour en savoir plus.
</Note>

<div id="remarks">
  ### Remarques
</div>

Consultez [Échange de jeton personnalisé](/docs/fr-ca/authenticate/custom-token-exchange) pour comprendre les profils d’échange de jetons personnalisés, la façon dont un profil est mappé à une Action et comment activer ce flux pour votre application.

* Les portées accordées à l’application peuvent différer des portées demandées. Dans ce cas, un paramètre `scope` sera inclus dans la réponse JSON. Les portées sont filtrées comme expliqué dans [Politiques d’accès aux API pour les applications](/docs/fr-ca/get-started/apis/api-access-policies-for-applications).

* La MFA n’est pas compatible avec les transactions où un acteur est défini à l’aide de `setActor()`. Dans ces cas, la requête renvoie une erreur `400` : `MFA is not supported using actor_token with the requested token exchange profile.`

* Lorsque l’Action appelle `setActor()`, les jetons d’accès et les jetons ID émis incluent une revendication `act` qui représente la [chaîne de délégation](/docs/fr-ca/secure/call-apis-on-users-behalf/on-behalf-of-token-exchange#the-act-claim). La revendication `act` est également incluse dans la réponse `userinfo`.

* Pour demander un jeton de transfert de session plutôt qu’un jeton d’accès, définissez `audience` sur `urn:YOUR_AUTH0_TENANT_DOMAIN:session_transfer`. L’appel à `setActor()` est requis pour cette requête. Consultez [Délégation de session](/docs/fr-ca/authenticate/single-sign-on/session-delegation) pour savoir comment échanger le jeton obtenu afin d’établir une session au nom de l’utilisateur concerné.

* Pour inclure des revendications standard (comme `email`) dans le ou les jetons émis, la portée correspondante (`email`) doit être incluse dans la requête, même si votre Action définit explicitement la revendication. Pour en savoir plus, consultez [Portées OpenID Connect : revendications standard](/docs/fr-ca/get-started/apis/scopes/openid-connect-scopes#standard-claims).

* L’échange de jeton personnalisé n’ajoute pas d’acteur agent. Même lorsque Agents as Principal est activé, la revendication `act` est entièrement contrôlée par l’Action à l’aide de `setActor()` ; Auth0 n’ajoute pas automatiquement de revendication `act` d’agent pour cette autorisation.

<div id="headers">
  ## En-têtes
</div>

<ParamField header="DPoP" type="string">
  Une preuve DPoP pour la requête. Ce champ est facultatif et n’est requis que si votre application utilise Demonstrating Proof-of-Possession.
</ParamField>

<ParamField header="auth0-forwarded-for" type="string">
  L’adresse IP de l’utilisateur final sous forme de chaîne de caractères. Définissez ce champ si vous voulez que la protection Suspicious IP Throttling fonctionne dans des scénarios côté serveur.
</ParamField>

<div id="body-parameters">
  ## Paramètres du corps
</div>

<div className="prose-sm prose-gray dark:prose-invert">
  <span data-as="p">Le corps de la requête est au format `application/x-www-form-urlencoded`.</span>
</div>

<ParamField body="grant_type" type="string" required>
  Indique le flux que vous utilisez. Pour Échange de jeton personnalisé, utilisez `urn:ietf:params:oauth:grant-type:token-exchange`.

  Valeurs autorisées : `urn:ietf:params:oauth:grant-type:token-exchange`
</ParamField>

<ParamField body="subject_token_type" type="string" required>
  Le type du subject token. Pour Échange de jeton personnalisé, il peut s’agir de n’importe quel URI dans votre propre espace de noms, par exemple `http://acme.com/legacy-token` ou `urn:acme:legacy-token`. Les espaces de noms suivants sont réservés et ne peuvent pas être utilisés : `http://auth0.com`, `https://auth0.com`, `http://okta.com`, `https://okta.com`, `urn:ietf`, `urn:auth0`, `urn:okta`.
</ParamField>

<ParamField body="subject_token" type="string" required>
  Le subject token, que votre action doit valider et utiliser pour identifier l’utilisateur.
</ParamField>

<ParamField body="client_id" type="string" required>
  Le Client ID de votre application. Comme pour les autres grant types, vous pouvez aussi transmettre le client ID dans l’en-tête Authorization à l’aide de l’authentification Basic HTTP.
</ParamField>

<ParamField body="client_secret" type="string">
  (Facultatif) Le Client Secret de votre application. Comme pour les autres grant types, vous pouvez aussi transmettre le client secret dans l’en-tête Authorization à l’aide de l’authentification Basic HTTP. D’autres options sont également offertes, comme expliqué dans la [documentation de référence de l’Auth0 Authentication API](https://auth0.com/docs/api/authentication#authentication-methods). Comme Échange de jeton personnalisé peut être utilisé par des Public applications, consultez [Attack Protection](https://auth0.com/docs/authenticate/custom-token-exchange/cte-attack-protection) pour mettre en place des mesures de sécurité supplémentaires.
</ParamField>

<ParamField body="audience" type="string">
  (Facultatif) L’identifiant unique de l’API cible à laquelle vous voulez accéder. L’audience par défaut du tenant sera utilisée si ce paramètre n’est pas fourni, comme configuré dans [Tenant Settings](https://auth0.com/docs/get-started/tenant-settings). Pour demander un [jeton de transfert de session](/docs/fr-ca/authenticate/single-sign-on/session-delegation) afin d’établir une session déléguée plutôt qu’un jeton d’accès, utilisez `urn:YOUR_AUTH0_TENANT_DOMAIN:session_transfer`.
</ParamField>

<ParamField body="resource" type="string">
  (Facultatif) L’identifiant de l’API cible (resource server) à laquelle vous voulez accéder. Il doit correspondre à un API identifier enregistré dans votre Auth0 tenant. Utilisé comme solution de rechange à `audience` lorsque le [Resource Parameter Compatibility Profile](https://auth0.com/docs/get-started/tenant-settings#settings-advanced) du tenant est défini à `compatibility`.
</ParamField>

<ParamField body="scope" type="string">
  (Facultatif) Le paramètre portée d’OAuth2.
</ParamField>

<ParamField body="organization" type="string">
  (Facultatif) L’organization ou l’identifiant auquel vous voulez associer la requête. Vous pouvez aussi préciser un organization name si [Use Organization Names in Authentication API](https://auth0.com/docs/manage-users/organizations/configure-organizations/use-org-name-authentication-api) est activé.
</ParamField>

<ParamField body="actor_token" type="string">
  (Facultatif) Un token qui identifie l’actor effectuant une délégation au nom de l’utilisateur subject. Doit être fourni avec `actor_token_type`. S’il est présent, aucun jeton d’actualisation ne sera émis.
</ParamField>

<ParamField body="actor_token_type" type="string">
  (Facultatif) Le type de l’actor token. Doit être fourni avec `actor_token`. Pour les jetons d’ID Auth0, utilisez `urn:ietf:params:oauth:token-type:id_token` pour une validation automatique côté serveur (signature, expiration, émetteur, recherche de l’utilisateur). Pour les autres valeurs, appliquez les mêmes restrictions d’espace de noms que pour `subject_token_type`.
</ParamField>

<div id="response-schema">
  ## Schéma de réponse
</div>

<ResponseSchema>
  <ResponseField name="access_token" type="string">
    Le jeton d’accès.
  </ResponseField>

  <ResponseField name="refresh_token" type="string">
    Le jeton d’actualisation.
  </ResponseField>

  <ResponseField name="id_token" type="string">
    Le jeton d’ID.
  </ResponseField>

  <ResponseField name="token_type" type="string">
    Le type de jeton.
  </ResponseField>

  <ResponseField name="issued_token_type" type="string">
    Le type de jeton émis. Pour un échange standard, il s’agit de `urn:ietf:params:oauth:token-type:access_token`. Lors de la demande d’un jeton de transfert de session, il s’agit de `urn:auth0:params:oauth:token-type:session_transfer_token` et le jeton lui-même est renvoyé dans `access_token`.
  </ResponseField>

  <ResponseField name="expires_in" type="integer">
    La durée de vie du jeton d’accès, en secondes.
  </ResponseField>
</ResponseSchema>

<div id="response-messages">
  ## Messages de réponse
</div>

| Statut | Description                                                                                                                                                                                                                                                                       |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 200    | Réponse réussie                                                                                                                                                                                                                                                                   |
| 400    | Requête incorrecte. Cela peut se produire si des paramètres obligatoires sont manquants ou incohérents (par exemple, si un seul de `actor_token` et `actor_token_type` est présent), ou si `setActor()` n’a pas été appelé lors de la demande d’un jeton de transfert de session. |