> ## 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 effectuer une requête vers votre propre API depuis des applications hautement fiables à l’aide du flux Resource Owner Password.

# Effectuer une requête vers votre API à l’aide du flux Resource Owner Password

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce tutoriel vous aidera à appeler votre propre API à l’aide du Resource Owner Password Flow. Si vous souhaitez comprendre le fonctionnement de ce flux et pourquoi l’utiliser, consultez [Resource Owner Password Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow).
</Callout>

<Warning>
  Comme le flux Resource Owner Password (ROP) exige que l’application gère le mot de passe de l’utilisateur, il ne doit pas être utilisé par des clients tiers.
</Warning>

Auth0 permet à votre application d’implémenter facilement le <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="/docs/fr-ca/glossary?term=Resource+Owner">Resource Owner</Tooltip> Password Flow (parfois appelé Resource Owner Password Grant ou ROPG) à l’aide de l’[Authentication API](https://auth0.com/docs/api/authentication). Lisez la suite pour savoir comment appeler directement notre API.

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

**Avant de commencer ce tutoriel :**

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

  * Sélectionnez **Regular Web Apps** comme **Application Type**.
  * Ajoutez `{https://yourApp/callback}` comme **Allowed Callback URL**. Ce champ ne peut pas rester indéfini, sinon un message d’erreur sera renvoyé.
  * Assurez-vous que les **Grant Types** de votre Application incluent **Password**. Pour savoir comment faire, consultez [Mettre à jour les type d’octroi](/docs/fr-ca/get-started/applications/update-grant-types).
  * Si vous voulez que votre Application puisse utiliser des jetons d’actualisation, assurez-vous que les **Grant Types** de l’Application incluent **jeton d’actualisation**. Pour savoir comment faire, consultez [Mettre à jour les type d’octroi](/docs/fr-ca/get-started/applications/update-grant-types). Pour en savoir plus sur les **jetons d’actualisation**, consultez [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).
* [Enregistrez votre API auprès d’Auth0](/docs/fr-ca/get-started/auth0-overview/set-up-apis)

  * Si vous voulez que votre API reçoive des jetons d’actualisation pour pouvoir 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 avec un nom d’utilisateur et un mot de passe (par exemple, les [connexions de base de données](/docs/fr-ca/get-started/applications/set-up-database-connections), ou les [connexions d’entreprise](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers) AD/LDAP, ADFS ou Azure Active Directory).
* Mettez à jour ou désactivez les [rules](/docs/fr-ca/customize/rules) afin qu’elles n’affectent que des connexions précises. Si vous obtenez une erreur `access_denied` en testant le Password Owner Resource Grant, cela peut être dû à une règle de contrôle d’accès.

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

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

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

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

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

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

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

Le Resource Owner Password Flow s’appuie sur une connexion capable d’authentifier les utilisateurs avec un nom d’utilisateur et un mot de passe. Vous devez donc définir la connexion par défaut du tenant.

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

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

Pour appeler votre API, vous devez d’abord obtenir les identifiants de l’utilisateur, généralement à l’aide d’un formulaire interactif. Une fois que votre application a 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_PEER

  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>

| Nom du paramètre        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`            | Définissez ce paramètre 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 informations d’authentification de votre application. Obligatoire lorsque Private Key JWT est votre méthode d’authentification de l’application.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `client_assertion_type` | La valeur est `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`. Obligatoire lorsque Private Key JWT est la méthode d’authentification de l’application.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `client_secret`         | Le secret client de votre application. Obligatoire lorsque Client Secret est la méthode d’authentification de l’application et que, dans les [Paramètres de l’application](https://manage.auth0.com/#/applications/\{yourClientId}/settings), la 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, c’est-à-dire 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](/docs/fr-ca/get-started/apis/scopes) pour lesquelles vous souhaitez demander une autorisation, ce qui détermine quels claims (ou attributs utilisateur) vous voulez voir renvoyés. Elles doivent être séparées par un espace. Vous pouvez demander n’importe laquelle des [scopes OpenID Connect (OIDC) standard](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` ou `email`, des [claims personnalisés](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format avec espace de noms](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims), ou tout scope pris en charge par l’API cible (par ex. `read:contacts`). Incluez `offline_access` pour obtenir un [Refresh Token](/docs/fr-ca/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 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>

<Warning>
  Les jetons d’actualisation doivent être stockés de manière sécuritaire, puisqu’ils permettent à un utilisateur de rester authentifié pratiquement indéfiniment.
</Warning>

<Card title="Flux Resource Owner Password et scopes standard">
  Comme le fait de fournir un mot de passe donne un accès complet, tout échange basé sur un mot de passe donne accès à tous les scopes. Par exemple, si vous n’incluez aucun [scope d’API](/docs/fr-ca/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](/docs/fr-ca/get-started/apis/scopes/openid-connect-scopes) standard de `openid` seront renvoyés. Dans ces cas, le paramètre `scope` sera inclus dans la réponse et énumérera les scopes émis.
</Card>

<Card title="Obtenir les informations de l’utilisateur sans jeton d’identité">
  Si vous avez besoin des informations de l’utilisateur, incluez la portée `openid` dans votre requête. Si l’API utilise `RS256` comme [algorithme de signature](/docs/fr-ca/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 : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip> récupéré comme jeton Bearer dans l’en-tête Authorization de votre requête HTTP.

<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_PEER

  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](/docs/fr-ca/secure/tokens/refresh-tokens) si vous suivez ce tutoriel et avez effectué les étapes suivantes :

* configuré votre API pour autoriser l’accès hors ligne
* inclus le scope `offline_access` lorsque vous avez lancé la requête 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 connecter de nouveau." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Refresh+Token">jeton d’actualisation</Tooltip> pour obtenir un nouveau jeton d’accès. En général, 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. Ce n’est pas une bonne pratique d’appeler le point de terminaison pour obtenir un nouveau jeton d’accès chaque fois que vous faites une requête à une API, et Auth0 applique des limites de taux qui restreignent le nombre de requêtes vers ce point de terminaison pouvant être exécutées avec le même jeton à partir de la même adresse IP.

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

<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=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_PEER

  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`      | Le Client ID de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                                           |
| `refresh_token`  | Le refresh token à utiliser.                                                                                                                                                                                                                                       |
| `scope`          | (facultatif) Liste des autorisations de scope demandées, séparées par des espaces. Si elle 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 dans l’URL. |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec une charge utile contenant un nouvel `access_token`, sa durée de validité en secondes (`expires_in`), les valeurs `scope` accordées et `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 stocker. 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="sample-use-cases">
  ### Exemples de scénarios d’utilisation
</div>

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

Vous pouvez utiliser Actions pour modifier les scopes renvoyés dans les jetons d’accès et/ou ajouter des claims aux jetons d’accès et aux <Tooltip tip="ID Token : justificatif destiné au client lui-même plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+Tokens">jetons ID</Tooltip>. (Pour en savoir plus sur Actions, consultez [Auth0 Actions](/docs/fr-ca/customize/actions).) Pour ce faire, ajoutez l’Action suivante, qui s’exécutera après l’authentification de l’utilisateur :

```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
  // Ajouter des claims personnalisés au jeton d'accès et au jeton d'identité
  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 claim, comme le définit la [spécification OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Cela signifie que les claims personnalisés ajoutés aux jetons d’identité ou aux jetons d’accès doivent [respecter certaines directives et restrictions](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims) afin d’éviter d’éventuels conflits.
</Warning>

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

Auth0 fournit un grant d’extension offrant une fonctionnalité semblable à celle du grant Resource Owner Password, mais qui vous permet de conserver des annuaires d’utilisateurs distincts (correspondant à des connexions distinctes) et de préciser lequel utiliser pendant le flux.

Pour utiliser cette variation, 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 nommé `realm` et le définir sur le nom du realm auquel l’utilisateur appartient. Par exemple, si vous avez configuré une connexion de base de données pour des employés internes nommée `employees` et que votre utilisateur en fait partie, définissez `realm` sur `employees`.

<Card title="Connexions utilisées comme 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](/docs/fr-ca/get-started/applications/set-up-database-connections), les [connexions sans mot de passe](/docs/fr-ca/authenticate/passwordless), ainsi que les connexions d’entreprise [AD/LDAP](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/active-directory-ldap), [ADFS](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/adfs) et [Azure Active Directory](/docs/fr-ca/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 Resource Owner Password, mais que vous avez besoin d’une authentification plus robuste, vous pouvez ajouter l’<Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification des utilisateurs qui utilise un facteur en plus du nom d’utilisateur et du mot de passe, par exemple un code envoyé par SMS." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=multi-factor+authentication">authentification multifacteur</Tooltip> (MFA). Pour savoir comment faire, consultez [S’authentifier à l’aide du flux Resource Owner Password avec l’authentification multifacteur](/docs/fr-ca/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 Resource Owner Password Flow avec la <Tooltip tip="Brute-force Protection : forme de protection contre les attaques qui protège contre les attaques par force brute provenant d’une seule adresse IP et visant un seul compte d’utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=brute-force+protection">protection contre les attaques par force brute</Tooltip>, certaines fonctionnalités de la <Tooltip tip="Brute-force Protection : forme de protection contre les attaques qui protège contre les attaques par force brute provenant d’une seule adresse IP et visant un seul compte d’utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=attack+protection">protection contre les attaques</Tooltip> peuvent ne pas fonctionner correctement. Il est toutefois possible d’éviter certains problèmes courants. Pour en savoir plus, consultez [Avoid Common Issues with Resource Owner Password Flow and Attack Protection](/docs/fr-ca/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](/docs/fr-ca/authenticate/protocols/oauth)
* [Protocole OpenID Connect](/docs/fr-ca/authenticate/protocols/openid-connect-protocol)
* [Jetons](/docs/fr-ca/secure/tokens)