> ## 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écouvrez comment demander des jetons d’accès à l’aide du point de terminaison Authorize lors de l’authentification des utilisateurs, en incluant l’audience cible et la portée de l’accès demandé par l’application et accordé par l’utilisateur.

# Obtenir des jetons d’accès

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

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>;
};

Pour accéder à votre API, vous devez demander un [jeton d'accès](/docs/fr-ca/secure/tokens/access-tokens) lors de l'authentification d'un utilisateur.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ces outils Auth0 vous aident à adapter votre application pour authentifier les utilisateurs :

  * Les [Quickstarts](/docs/fr-ca/quickstarts) constituent la façon la plus simple de mettre en œuvre l'authentification. Ils vous montrent comment utiliser [Universal Login](/docs/fr-ca/authenticate/login/auth0-universal-login/universal-login-vs-classic-login) et les SDKs d'Auth0 propres à chaque langage et framework.
  * L'[Auth0 Authentication API](https://auth0.com/docs/api/authentication) est une référence pour ceux qui préfèrent écrire leur code eux-mêmes. Commencez par déterminer [quel flux utiliser](/docs/fr-ca/get-started/authentication-and-authorization-flow/which-oauth-2-0-flow-should-i-use). Suivez ensuite les instructions pour mettre en œuvre ce flux.
</Callout>

Pour demander un <Tooltip tip="Jeton d'accès : information d'autorisation, sous la forme d'une chaîne opaque ou d'un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+token">jeton d'accès</Tooltip>, effectuez une requête POST à l'[URL du jeton](https://auth0.com/docs/api/authentication#client-credentials-flow).

<div id="example-post-to-token-url">
  #### Exemple de requête POST à l’URL du jeton
</div>

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oauth/token' \
    --header 'content-type: application/x-www-form-urlencoded' \
    --data grant_type=client_credentials \
    --data client_id={yourClientId} \
    --data client_secret={yourClientSecret} \
    --data audience=YOUR_API_IDENTIFIER
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/token");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/x-www-form-urlencoded");
  request.AddParameter("application/x-www-form-urlencoded", "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/oauth/token"

  	payload := strings.NewReader("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("content-type", "application/x-www-form-urlencoded")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {'content-type': 'application/x-www-form-urlencoded'},
    data: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: '{yourClientId}',
      client_secret: '{yourClientSecret}',
      audience: 'YOUR_API_IDENTIFIER'
    })
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/oauth/token",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER",
    CURLOPT_HTTPHEADER => [
      "content-type: application/x-www-form-urlencoded"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

  headers = { 'content-type': "application/x-www-form-urlencoded" }

  conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/oauth/token")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/x-www-form-urlencoded'
  request.body = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

<div id="parameters">
  ##### Paramètres
</div>

| Nom du paramètre | Description                                                                                                                                                                                                                                                                                                                                             |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez cette valeur sur « client\_credentials ».                                                                                                                                                                                                                                                                                                    |
| `client_id`      | L’ID client de votre application. Vous trouverez cette valeur dans l’[onglet des paramètres de l’application](https://manage.auth0.com/#/applications).                                                                                                                                                                                                 |
| `client_secret`  | Le secret client de votre application. Vous trouverez cette valeur dans l’[onglet des paramètres de l’application](https://manage.auth0.com/#/applications). Pour en savoir plus sur les méthodes d’authentification des applications offertes, consultez [Informations d’identification de l’application](/docs/fr-ca/secure/application-credentials). |
| `audience`       | L’audience du jeton, c’est-à-dire votre API. Vous trouverez cette valeur dans le champ **Identifiant** de l’[onglet des paramètres de l’API](https://manage.auth0.com/#/apis).                                                                                                                                                                          |
| `organization`   | Facultatif. Le nom ou l’identifiant de l’organisation auquel vous voulez associer la requête. Pour en savoir plus, consultez [Accès machine à machine pour les organisations](/docs/fr-ca/manage-users/organizations/organizations-for-m2m-applications).                                                                                               |

<div id="response">
  #### Réponse
</div>

Vous recevez une réponse `HTTP 200` dont la charge utile contient les valeurs `access_token`, `token_type` et `expires_in` :

```json lines theme={null}
{
  "access_token":"eyJz93a...k4laUWw",
  "token_type":"Bearer",
  "expires_in":86400
}
```

<Warning>
  Validez vos jetons avant de les enregistrer. Pour savoir comment faire, consultez [Valider le jeton d’identité](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
</Warning>

<div id="control-access-token-audience">
  ## Contrôler l’audience du jeton d’accès
</div>

Lorsqu’un utilisateur s’authentifie, vous demandez un jeton d’accès et incluez l’<Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Appelée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (API Identifier) pour un Access Token." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip> cible et la portée d’accès dans votre requête. L’application utilise le point de terminaison `/authorize` pour demander l’accès. Cet accès est à la fois demandé par l’application et accordé par l’utilisateur pendant l’authentification

Vous pouvez configurer votre tenant pour qu’il inclue toujours une audience par défaut.

| Utilisation du jeton           | Format | Audience demandée                                                                                                | Scope demandé |
| ------------------------------ | ------ | ---------------------------------------------------------------------------------------------------------------- | ------------- |
| point de terminaison /userinfo | Opaque | nom du tenant (`\{yourDomain}`), aucune valeur pour le paramètre `audience`, aucun paramètre `audience` transmis | `openid`      |
| Auth0 Management API           | JWT    | identifiant de la Management API v2 (`https://{tenant}.auth0.com/api/v2/`)                                       |               |
| Votre propre API personnalisée | JWT    | l’API Identifier de votre API personnalisée enregistrée dans l’Auth0 Dashboard                                   |               |

Dans un seul cas précis, les jetons d’accès peuvent avoir plusieurs audiences cibles. Cela exige que l’<Tooltip tip="Signing Algorithm : algorithme utilisé pour signer numériquement des jetons afin de garantir que le jeton n’a pas été altéré." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=signing+algorithm">algorithme de signature</Tooltip> de votre API personnalisée soit défini sur **RS256**. Pour en savoir plus, consultez [Token Best Practices](/docs/fr-ca/secure/tokens/token-best-practices).

<div id="multiple-audiences">
  ### Audiences multiples
</div>

Si vous indiquez comme audience l’identifiant de votre API personnalisée et comme portée `openid`, la `revendication` `aud` du jeton d’accès obtenu sera un tableau plutôt qu’une chaîne de caractères, et le jeton d’accès sera valide à la fois pour votre API personnalisée et pour le point de terminaison `/userinfo`. Vos jetons d’accès ne peuvent avoir deux audiences ou plus que si vous utilisez à la fois une seule API personnalisée et le point de terminaison `/userinfo` d’Auth0.

<div id="custom-domains-and-the-auth0-management-api">
  ### Domaines personnalisés et l’Auth0 Management API
</div>

Auth0 émet des jetons avec une revendication d’émetteur (`iss)` correspondant au domaine utilisé pour demander le jeton. Les utilisateurs de [domaine personnalisé](/docs/fr-ca/customize/custom-domains) peuvent utiliser soit leur <Tooltip tip="Domaine personnalisé : domaine tiers avec un nom spécialisé ou personnalisé." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=custom+domain">domaine personnalisé</Tooltip>, soit leur domaine Auth0.

Par exemple, supposons que vous ayez un domaine personnalisé, `https://login.northwind.com`. Si vous demandez un jeton d’accès à `https://login.northwind.com/authorize`, la revendication `iss` de votre jeton sera `https://login.northwind.com/`. Toutefois, si vous demandez un jeton d’accès à `https://northwind.auth0.com/authorize`, la revendication `iss` de votre jeton sera `https://northwind.auth0.com/`.

Si vous demandez un jeton d’accès depuis votre domaine personnalisé en utilisant l’Auth0 <Tooltip tip="Management API : un 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> comme audience, vous **devez** appeler l’Auth0 Management API depuis votre domaine personnalisé. Sinon, votre jeton d’accès sera considéré comme invalide.

<div id="renew-access-tokens">
  ## Renouveler les jetons d’accès
</div>

Par défaut, un jeton d’accès pour une API personnalisée est valide pendant 86 400 secondes (24 heures). Vous pouvez [raccourcir la durée de validité du jeton](/docs/fr-ca/secure/tokens/access-tokens/update-access-token-lifetime).

Une fois qu’un jeton d’accès a expiré, vous pouvez le renouveler. Pour ce faire, réauthentifiez l’utilisateur avec Auth0 ou utilisez un [jeton d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).

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

* [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens)
* [Utiliser les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/use-access-tokens)
* [JSON Web Tokens](/docs/fr-ca/secure/tokens/json-web-tokens)
* [Jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens)
* [Jetons d’accès du fournisseur d’identité](/docs/fr-ca/secure/tokens/access-tokens/identity-provider-access-tokens)
* [Jetons d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens)