> ## 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 appeler votre propre API depuis des applications hautement fiables à l’aide du flux de mot de passe du propriétaire de la ressource.

# Appeler votre API à l’aide du flux de mot de passe du propriétaire de la ressource

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) + "*****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>;
};

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce tutoriel vous aidera à appeler votre propre API à l’aide du flux de mot de passe du propriétaire de la ressource. Si vous souhaitez comprendre le fonctionnement de ce flux et pourquoi vous devriez l’utiliser, consultez [Flux de mot de passe du propriétaire de la ressource](/fr-CA/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow).
</Callout>

<Warning>
  Comme le flux de mot de passe du propriétaire de la ressource (ROP) exige que l’application gère le mot de passe de l’utilisateur, il ne doit pas être utilisé par des applications tierces.
</Warning>

Auth0 permet à votre application d’implémenter facilement le flux de mot de passe <Tooltip tip="Resource Owner : entité (comme un utilisateur ou une application) capable d’accorder l’accès à une ressource protégée." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Resource+Owner">Resource Owner</Tooltip> (parfois appelé octroi par mot de passe du propriétaire de la ressource ou ROPG) à l’aide de l’[Authentication API](https://auth0.com/docs/api/authentication). Continuez votre lecture pour découvrir comment appeler directement notre API.

<div id="prerequisites">
  ## Prérequis
</div>

**Avant de commencer ce tutoriel :**

* [Enregistrez votre application auprès d’Auth0](/fr-CA/docs/get-started/auth0-overview/create-applications/regular-web-apps).

  * Sélectionnez un **Application Type** de **Regular Web Apps**.
  * Ajoutez une **Allowed Callback URL** de `{https://yourApp/callback}`. Ce champ ne peut pas être laissé vide, sinon un message d’erreur sera renvoyé.
  * Assurez-vous que les **Grant Types** de votre application incluent **Password**. Pour savoir comment faire, consultez [Update Grant Types](/fr-CA/docs/get-started/applications/update-grant-types).
  * Si vous souhaitez que votre application puisse utiliser des Jetons d’actualisation, assurez-vous que les **Grant Types** de l’application incluent **Refresh Token**. Pour savoir comment faire, consultez [Update Grant Types](/fr-CA/docs/get-started/applications/update-grant-types). Pour en savoir plus sur les Jetons d’actualisation, consultez [Refresh Tokens](/fr-CA/docs/secure/tokens/refresh-tokens).
* [Enregistrez votre API auprès d’Auth0](/fr-CA/docs/get-started/auth0-overview/set-up-apis)

  * Si vous souhaitez que votre API puisse recevoir des Jetons d’actualisation afin d’obtenir de nouveaux jetons lorsque les précédents expirent, activez **Allow Offline Access**.
* Configurez une connexion

  * Assurez-vous que votre connexion peut authentifier les utilisateurs à l’aide d’un nom d’utilisateur et d’un mot de passe (par exemple, les [connexions de base de données](/fr-CA/docs/get-started/applications/set-up-database-connections), ou les connexions d’entreprise AD/LDAP, ADFS ou Azure Active Directory [d’entreprise](/fr-CA/docs/authenticate/identity-providers/enterprise-identity-providers)).
* Mettez à jour ou désactivez toutes les [Rules](/fr-CA/docs/customize/rules) afin qu’elles ne s’appliquent qu’à des connexions spécifiques. Si vous obtenez une erreur `access_denied` pendant le test du Password Owner Resource Grant, cela pourrait être dû à une règle de contrôle d’accès.

<div id="steps">
  ## Étapes
</div>

1. [Configurer le locataire](#configure-tenant):Définissez la connexion par défaut du locataire.
2. [Demander des jetons](#request-tokens):
   Échangez votre code d’autorisation contre des jetons.
3. [Appeler l’API](#call-api):
   Utilisez le Jeton d’accès obtenu pour appeler votre API.
4. [Actualiser les jetons](#refresh-tokens):
   Utilisez un Jeton d’actualisation pour demander de nouveaux jetons lorsque les jetons actuels expirent.

Facultatif : [Explorer des exemples de cas d’utilisation](#sample-use-cases)

Facultatif : [Configurer la prise en charge du realm](#configure-realm-support)

Facultatif : [Configurer la MFA](#configure-mfa)

Facultatif : [Configurer la protection contre les attaques](#configure-anomaly-detection)

<div id="configure-tenant">
  ### Configurer le locataire
</div>

Le flux de mot de passe du propriétaire de la ressource repose sur une connexion capable d’authentifier les utilisateurs au moyen d’un nom d’utilisateur et d’un mot de passe; vous devez donc définir la connexion par défaut du locataire.

1. Accédez à [Auth0 Dashboard > Paramètres du locataire](https://manage.auth0.com/#/tenant), puis faites défiler la page jusqu’au paramètre **Default Directory**.
2. Saisissez le nom de la connexion que vous souhaitez utiliser. Assurez-vous qu’elle peut authentifier les utilisateurs au moyen d’un nom d’utilisateur et d’un mot de passe.

<div id="request-tokens">
  ### Obtenir des jetons
</div>

Pour appeler votre API, vous devez d’abord obtenir les identifiants de l’utilisateur, généralement au moyen d’un formulaire interactif. Une fois que votre application dispose de ces identifiants, vous devez les échanger contre des jetons. Pour ce faire, vous devez envoyer une requête `POST` à l’[URL du jeton](https://auth0.com/docs/api/authentication#resource-owner-password).

<div id="example-post-to-token-url">
  #### Exemple de requête POST vers 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=password \
    --data 'username={username}' \
    --data 'password={password}' \
    --data 'audience={yourApiIdentifier}' \
    --data scope=read:sample \
    --data 'client_id={yourClientId}' \
    --data 'client_secret={yourClientSecret}'
  ```

  ```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=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D", 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=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D")

  	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 response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D")
    .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: 'password',
      username: '{username}',
      password: '{password}',
      audience: '{yourApiIdentifier}',
      scope: 'read:sample',
      client_id: '{yourClientId}',
      client_secret: '{yourClientSecret}'
    })
  };

  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=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D",
    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=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D"

  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_NONE

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/x-www-form-urlencoded'
  request.body = "grant_type=password&username=%7Busername%7D&password=%7Bpassword%7D&audience=%7ByourApiIdentifier%7D&scope=read%3Asample&client_id={yourClientId}&client_secret=%7ByourClientSecret%7D"

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

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

| Parameter Name          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`            | Définissez cette valeur sur `password`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `username`              | Le nom d’utilisateur saisi par l’utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `password`              | Le mot de passe saisi par l’utilisateur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `client_id`             | L’ID client de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `client_assertion`      | Un JWT contenant une assertion signée avec les identifiants de votre application. Obligatoire lorsque JWT à clé privée est la méthode d’authentification de votre application.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `client_assertion_type` | La valeur est `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`. Obligatoire lorsque JWT à clé privée est la méthode d’authentification de l’application.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `client_secret`         | Le Secret client de votre application. Obligatoire lorsque Secret client est la méthode d’authentification de l’application. Dans les [paramètres de l’application](https://manage.auth0.com/#/applications/\{yourClientId}/settings), cette valeur est `Post` ou `Basic`. Si votre application n’est pas hautement fiable (par exemple, une SPA), ne définissez pas ce paramètre.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `audience`              | L’audience du jeton, qui correspond à votre API. Vous la trouverez dans le champ **Identifiant** de l’onglet des [paramètres de votre API](https://manage.auth0.com/#/apis).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `scope`                 | Indique les [scopes](/fr-CA/docs/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation, ce qui détermine quelles claims (ou quels attributs utilisateur) seront renvoyés. Ils doivent être séparés par une espace. Vous pouvez demander n’importe lequel des [scopes OpenID Connect (OIDC) standards](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` ou `email`, des [custom claims](/fr-CA/docs/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format avec espace de noms](/fr-CA/docs/secure/tokens/json-web-tokens/create-custom-claims), ou tout scope pris en charge par l’API cible (par exemple, `read:contacts`). Incluez `offline_access` pour obtenir un [Jeton d’actualisation](/fr-CA/docs/glossary?term=Refresh+Token) (assurez-vous que le champ **Allow Offline Access** est activé dans les [paramètres de l’application](https://manage.auth0.com/#/applications)). |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant les valeurs `access_token`, `refresh_token`, `id_token`, `token_type` et `expires_in` :

```json lines theme={null}
{
  "access_token": "eyJz93a...k4laUWw",
  "refresh_token": "GEbRxBN...edjnXbL",
  "id_token": "eyJ0XAi...4faeEoQ",
  "token_type": "Bearer",
  "expires_in": 36000
}
```

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

<Warning>
  Les jetons d’actualisation doivent être stockés de façon sécurisée, puisqu’ils permettent à un utilisateur de rester authentifié pratiquement indéfiniment.
</Warning>

<Card title="Flux de mot de passe du propriétaire de la ressource et scopes standard">
  Comme la fourniture d’un mot de passe donne un accès complet, tout échange fondé sur un mot de passe donne accès à tous les scopes. Par exemple, si vous n’incluez aucun [scope d’API](/fr-CA/docs/get-started/apis/scopes/api-scopes) dans la requête, tous les scopes d’API seront inclus dans le Jeton d’accès. De même, si vous incluez seulement le scope `openid` dans la requête, tous les [scopes OpenID Connect](/fr-CA/docs/get-started/apis/scopes/openid-connect-scopes) standard seront renvoyés. Dans ces cas, le paramètre `scope` sera inclus dans la réponse et listera les scopes émis.
</Card>

<Card title="Obtenir les renseignements de l’utilisateur sans ID Token">
  Si vous avez besoin des renseignements de l’utilisateur, incluez le scope `openid` dans votre requête. Si l’API utilise `RS256` comme [algorithme de signature](/fr-CA/docs/get-started/applications/signing-algorithms), le Jeton d’accès inclura `/userinfo` comme audience valide, ce qui signifie que vous pouvez l’utiliser pour appeler le point de terminaison [/userinfo](https://auth0.com/docs/api/authentication#get-user-info) et récupérer les claims de l’utilisateur.
</Card>

<div id="call-api">
  ### Appeler l’API
</div>

Pour appeler votre API, l’application doit transmettre le <Tooltip tip="Jeton d’accès : information d’autorisation prenant la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Access+Token">Jeton d’accès</Tooltip> récupéré dans l’en-tête Authorization de sa requête HTTP en tant que jeton Bearer.

<AuthCodeGroup>
  ```bash cURL lines theme={null}
  curl --request GET \
    --url https://myapi.com/api \
    --header 'authorization: Bearer {accessToken}' \
    --header 'content-type: application/json'
  ```

  ```csharp C# lines theme={null}
  var client = new RestClient("https://myapi.com/api");
  var request = new RestRequest(Method.GET);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer {accessToken}");
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://myapi.com/api"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer {accessToken}")

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

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

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

  }
  ```

  ```java Java lines theme={null}
  HttpResponse response = Unirest.get("https://myapi.com/api")
    .header("content-type", "application/json")
    .header("authorization", "Bearer {accessToken}")
    .asString();
  ```

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

  var options = {
    method: 'GET',
    url: 'https://myapi.com/api',
    headers: {'content-type': 'application/json', authorization: 'Bearer {accessToken}'}
  };

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

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

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://myapi.com/api",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {accessToken}",
      "content-type: application/json"
    ],
  ]);

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

  curl_close($curl);

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

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

  conn = http.client.HTTPSConnection("myapi.com")

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer {accessToken}"
      }

  conn.request("GET", "/api", headers=headers)

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

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

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

  url = URI("https://myapi.com/api")

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

  request = Net::HTTP::Get.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer {accessToken}'

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

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

Vous avez déjà reçu un [jeton d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) si vous avez suivi ce tutoriel et effectué les étapes suivantes :

* configuré votre API pour autoriser l’accès hors ligne
* inclus le scope `offline_access` lorsque vous avez lancé la demande d’authentification au moyen du [point de terminaison authorize](https://auth0.com/docs/api/authentication/reference#authorize-application).

Vous pouvez utiliser le <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+Token">Jeton d’actualisation</Tooltip> pour obtenir un nouveau jeton d’accès. Habituellement, un utilisateur n’a besoin d’un nouveau jeton d’accès qu’après l’expiration du précédent ou lorsqu’il accède à une nouvelle ressource pour la première fois. Il est déconseillé d’appeler le point de terminaison pour obtenir un nouveau jeton d’accès chaque fois que vous appelez une API, et Auth0 applique des limites de débit qui limiteront le nombre de requêtes au point de terminaison pouvant être exécutées avec le même jeton à partir de la même adresse IP.

Pour actualiser votre jeton, envoyez une requête `POST` au point de terminaison `/oauth/token` de l’Authentication API, en utilisant `grant_type=refresh_token`.

#### Exemple de requête POST à l’URL du jeton

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

  ```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=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D", 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=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")

  	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 response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")
    .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: 'refresh_token',
      client_id: '{yourClientId}',
      refresh_token: '{yourRefreshToken}'
    })
  };

  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=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D",
    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=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"

  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_NONE

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/x-www-form-urlencoded'
  request.body = "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"

  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 `refresh_token`.                                                                                                                                                                                                                                      |
| `client_id`      | L’ID client de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                                                           |
| `refresh_token`  | Le jeton d’actualisation à utiliser.                                                                                                                                                                                                                                              |
| `scope`          | (facultatif) Une liste des scopes demandés, séparés par des espaces. Si cette valeur n’est pas envoyée, les scopes d’origine seront utilisés; sinon, vous pouvez demander un ensemble réduit de scopes. Notez que cette valeur doit être encodée pour être utilisée dans une URL. |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant un nouvel `access_token`, sa durée de validité en secondes (`expires_in`), les valeurs de `scope` accordées et le `token_type`.

```json lines theme={null}
{
  "access_token": "eyJ...MoQ",
  "expires_in": 86400,
  "scope": "openid offline_access",
  "token_type": "Bearer"
}
```

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

<div id="sample-use-cases">
  ### Exemples de cas d’utilisation
</div>

<div id="customize-tokens">
  #### Personnaliser les jetons
</div>

Vous pouvez utiliser Actions pour modifier les scopes renvoyés avec les jetons d’accès et/ou ajouter des claims aux jetons d’accès et aux <Tooltip tip="ID Token : informations d’identification destinées à l’application cliente 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>. (Pour en savoir plus sur Actions, consultez [Auth0 Actions](/fr-CA/docs/customize/actions).) Pour ce faire, ajoutez l’Action suivante, qui s’exécutera une fois l’utilisateur authentifié :

```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
  // Ajouter des revendications personnalisées au jeton d'accès et à l'ID Token
  api.accessToken.setCustomClaim('https://foo/bar', 'value');
  api.idToken.setCustomClaim('https://fiz/baz', 'some other value');

  // Modifier le scope du jeton d'accès
  api.accessToken.addScope('foo');
  api.accessToken.addScope('bar');
};
```

Les scopes seront disponibles dans le jeton une fois l’Action exécutée.

<Warning>
  Auth0 renvoie les informations de profil dans un format structuré de claims, tel que défini par la [spécification OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Cela signifie que les claims personnalisées ajoutées aux ID tokens ou aux jetons d’accès doivent [respecter les directives et les restrictions](/fr-CA/docs/secure/tokens/json-web-tokens/create-custom-claims) afin d’éviter d’éventuelles collisions.
</Warning>

<div id="configure-realm-support">
  ### Configurer la prise en charge des realms
</div>

Auth0 fournit un octroi d’extension offrant une fonctionnalité semblable à celle de l’octroi Resource Owner Password, tout en vous permettant de conserver des répertoires d’utilisateurs distincts (qui correspondent à des connexions distinctes) et de préciser lequel utiliser durant le flux.

Pour utiliser cette variante, vous devez :

* Définir le paramètre de requête `grant_type` sur `http://auth0.com/oauth/grant-type/password-realm`.
* Envoyer un paramètre de requête supplémentaire appelé `realm` et lui attribuer le nom du realm auquel l’utilisateur appartient. Par exemple, si vous avez configuré une connexion de base de données pour les employés internes nommée `employees`, et que votre utilisateur en fait partie, définissez `realm` sur `employees`.

<Card title="Connexions en tant que realms">
  Toute connexion qui prend en charge l’authentification active peut être configurée comme un realm, y compris les [connexions de base de données](/fr-CA/docs/get-started/applications/set-up-database-connections), les [connexions Passwordless](/fr-CA/docs/authenticate/passwordless) et les connexions d’entreprise [AD/LDAP](/fr-CA/docs/authenticate/identity-providers/enterprise-identity-providers/active-directory-ldap), [ADFS](/fr-CA/docs/authenticate/identity-providers/enterprise-identity-providers/adfs) et [Azure Active Directory](/fr-CA/docs/authenticate/identity-providers/enterprise-identity-providers/azure-active-directory/v2).
</Card>

<div id="configure-mfa">
  ### Configurer l’authentification multifacteur
</div>

Si vous devez utiliser le flux de mot de passe du propriétaire de la ressource, mais que vous avez besoin d’une authentification plus forte, vous pouvez ajouter l’<Tooltip tip="authentification multifacteur (MFA) : processus d’authentification qui utilise un facteur en plus du nom d’utilisateur et du mot de passe, comme un code envoyé par SMS." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=multi-factor+authentication">authentification multifacteur</Tooltip> (MFA). Pour savoir comment procéder, consultez [S’authentifier à l’aide du flux de mot de passe du propriétaire de la ressource avec MFA](/fr-CA/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa).

<div id="configure-attack-protection">
  ### Configurer la protection contre les attaques
</div>

Lorsque vous utilisez le flux de mot de passe du propriétaire de la ressource avec la <Tooltip tip="Protection contre la force brute : forme de protection contre les attaques qui prévient les attaques par force brute provenant d’une seule adresse IP et visant un seul compte utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=brute-force+protection">protection contre la force brute</Tooltip>, certaines fonctionnalités de la <Tooltip tip="Protection contre la force brute : forme de protection contre les attaques qui prévient les attaques par force brute provenant d’une seule adresse IP et visant un seul compte utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=attack+protection">protection contre les attaques</Tooltip> peuvent ne pas fonctionner. Toutefois, vous pouvez éviter certains problèmes courants. Pour en savoir plus, consultez [Éviter les problèmes courants avec le flux de mot de passe du propriétaire de la ressource et la protection contre les attaques](/fr-CA/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/avoid-common-issues-with-resource-owner-password-flow-and-attack-protection).

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

* [Cadre d’autorisation OAuth 2.0](/fr-CA/docs/authenticate/protocols/oauth)
* [Protocole OpenID Connect](/fr-CA/docs/authenticate/protocols/openid-connect-protocol)
* [Jetons](/fr-CA/docs/secure/tokens)