> ## 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 configurer et mettre en œuvre le jeton d’actualisation multiresource

# Configurer et mettre en œuvre le jeton d’actualisation multiresource

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

<div id="configure-applications-for-mrrt">
  ## Configurer les applications pour MRRT
</div>

Pour utiliser les <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau Jeton d’accès sans obliger les utilisateurs à ouvrir une nouvelle session." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Refresh+Tokens">jetons d’actualisation multirésource</Tooltip> (MRRT), configurez les politiques de jeton d’actualisation de votre application à l’aide de la [Management API](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id) d’Auth0. Ces politiques précisent quelle API et quels scopes l’application peut demander lors d’un échange de jeton d’actualisation.

Vous pouvez définir des politiques MRRT dans la propriété `refresh_token.policies` de l’application.

| Propriété  | Type               | Description                                                                                                                                                              |
| ---------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `audience` | string             | L’[identifiant](/fr-CA/docs/get-started/apis/api-settings#general-settings) d’API Auth0 de l’application autorisée à utiliser le jeton d’actualisation.                  |
| `scope`    | tableau de chaînes | La liste des scopes autorisés lors de la demande d’un jeton d’accès pour l’audience spécifiée. Le scope doit être identique à celui défini sur l’API ou plus restrictif. |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les propriétés audience et scope doivent correspondre à une application existante dans votre locataire; sinon, l’échange de jeton d’actualisation les ignorera silencieusement.
</Callout>

Pour les applications existantes, effectuez un appel PATCH au point de terminaison [Update a Client](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id). Pour créer une nouvelle application, effectuez un appel POST au point de terminaison [Create a Client](https://auth0.com/docs/api/management/v2/clients/post-clients) :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/clients//{yourClientId}' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}' \
    --header 'content-type: application/json' \
    --data '{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/clients//{yourClientId}");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer {yourMgmtApiAccessToken}");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }", 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}/api/v2/clients//{yourClientId}"

  	payload := strings.NewReader("{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }")

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

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

  	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.patch("https://{yourDomain}/api/v2/clients//{yourClientId}")
    .header("authorization", "Bearer {yourMgmtApiAccessToken}")
    .header("content-type", "application/json")
    .body("{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/clients//{yourClientId}',
    headers: {
      authorization: 'Bearer {yourMgmtApiAccessToken}',
      'content-type': 'application/json'
    },
    data: {
      refresh_token: {
        expiration_type: 'expiring',
        rotation_type: 'rotating',
        token_lifetime: 31557600,
        idle_token_lifetime: 2592000,
        leeway: 0,
        infinite_token_lifetime: false,
        infinite_idle_token_lifetime: false,
        policies: [
          {audience: 'https://api.example.com', scope: ['read:data']},
          {audience: 'https://billing.example.com', scope: ['read:billing']}
        ]
      }
    }
  };

  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}/api/v2/clients//{yourClientId}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {yourMgmtApiAccessToken}",
      "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 theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }"

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

  conn.request("PATCH", "/{yourDomain}/api/v2/clients//{yourClientId}", 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}/api/v2/clients//{yourClientId}")

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

  request = Net::HTTP::Patch.new(url)
  request["authorization"] = 'Bearer {yourMgmtApiAccessToken}'
  request["content-type"] = 'application/json'
  request.body = "{
    "refresh_token": {
      "expiration_type": "expiring",
      "rotation_type": "rotating",
      "token_lifetime": 31557600,
      "idle_token_lifetime": 2592000,
      "leeway": 0,
      "infinite_token_lifetime": false,
      "infinite_idle_token_lifetime": false,
      "policies": [
        {
          "audience": "https://api.example.com",
          "scope": ["read:data"]
        },
        {
          "audience": "https://billing.example.com",
          "scope": ["read:billing"]
        }
      ]
    }
  }"

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

Exemple de réponse :

```json lines theme={null}
{
  "client_id": "abc123xyz",
  "name": "My Native App",
  "refresh_token": {
    "rotation_type": "rotating",
    "policies": [
      {
        "audience": "https://api.example.com",
        "scope": ["read:data"]
      },
      {
        "audience": "https://billing.example.com",
        "scope": ["read:billing"]
      }
    ]
  }
}
```

<div id="implement-multi-resource-refresh-token">
  ## Implémenter un jeton d’actualisation multiresource
</div>

Une fois le jeton d’actualisation de votre application configuré avec des politiques MRRT, vous pouvez commencer à échanger un seul jeton d’actualisation contre des <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="/fr-CA/docs/glossary?term=access+tokens">jetons d’accès</Tooltip> pour plusieurs API.
Pour ce faire, votre application doit amorcer un flux de connexion à l’aide du [flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow) ou de l’[octroi de mot de passe du propriétaire de la ressource](/fr-CA/docs/authenticate/login/oidc-conformant-authentication/oidc-adoption-rop-flow).

<div id="step-1-authenticate-and-request-a-refresh-token">
  ### Étape 1 : S’authentifier et demander un jeton d’actualisation
</div>

Pour recevoir un jeton d’actualisation, incluez le scope `offline_access` lors de l’envoi de la demande d’authentification. Pour en savoir plus, consultez [Obtenir des jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens/get-refresh-tokens).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous ne recevez pas de jeton d’actualisation, vérifiez que :

  * L’option [Allow Offline Access](/fr-CA/docs/get-started/apis/api-settings#access-settings) est activée dans les paramètres de l’API.
  * `offline_access` est inclus dans le scope.
  * L’`audience` utilisée dans la demande correspond à une API configurée dans votre locataire.
</Callout>

<div id="step-2-exchange-the-refresh-token-for-a-different-api">
  ### Étape 2 : Échanger le jeton d’actualisation pour une autre API
</div>

Une fois le jeton d’actualisation émis, vous pouvez demander des jetons d’accès pour n’importe quelle API et les scopes définis à la fois dans l’authentification initiale et dans la stratégie MRRT. Par exemple :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oauth/token' \
    --header 'content-type: application/json' \
    --data '{
    "grant_type": "refresh_token",
    "client_id": "{yourClientId}",
    "refresh_token": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/token");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{
    "grant_type": "refresh_token",
    "client_id": "{yourClientId}",
    "refresh_token": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }", 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": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }")

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

  	req.Header.Add("content-type", "application/json")

  	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/json")
    .body("{
    "grant_type": "refresh_token",
    "client_id": "{yourClientId}",
    "refresh_token": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {'content-type': 'application/json'},
    data: {
      grant_type: 'refresh_token',
      client_id: '{yourClientId}',
      refresh_token: '${refreshToken}',
      audience: 'https://billing.example.com',
      scope: 'read:billing write:billing'
    }
  };

  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": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }",
    CURLOPT_HTTPHEADER => [
      "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 theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{
    "grant_type": "refresh_token",
    "client_id": "{yourClientId}",
    "refresh_token": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }"

  headers = { 'content-type': "application/json" }

  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/json'
  request.body = "{
    "grant_type": "refresh_token",
    "client_id": "{yourClientId}",
    "refresh_token": "${refreshToken}",
    "audience": "https://billing.example.com",
    "scope": "read:billing write:billing"
  }"

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

 Pour en savoir plus, consultez [Utiliser des jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens/use-refresh-tokens).

Si vous utilisez le SDK Swift d’Auth0, vous pouvez échanger le jeton d’actualisation à l’aide du code suivant :

```swift lines theme={null}
credentialsManager.apiCredentials(forAudience: "https://example.com/me",
                                  scope: "create:me:authentication_methods") { result in
    switch result {
    case .success(let apiCredentials):
        print("Obtained API credentials: \(apiCredentials)")
    case .failure(let error):
        print("Failed with: \(error)")
    }
}
```

Pour en savoir plus, consultez [le SDK Swift Auth0](https://github.com/auth0/Auth0.swift/blob/master/EXAMPLES.md#api-credentials-ea).

Si vous utilisez le SDK Android d’Auth0, vous pouvez échanger le jeton d’actualisation à l’aide du code suivant :

```kotlin lines theme={null}
credentialsManager.getApiCredentials(
    audience = "https://example.com/me", scope = " create:me:authentication_methods",
    callback = object : Callback<APICredentials, CredentialsManagerException> {
        override fun onSuccess(result: APICredentials) {
            print("Obtained API credentials: $result")
        }
        override fun onFailure(error: CredentialsManagerException) {
            print("Failed with: $error")
        }
    })
```

Pour en savoir plus, consultez le [SDK Android Auth0](https://github.com/auth0/Auth0.Android/blob/main/EXAMPLES.md#api-credentials-ea).

<div id="step-3-call-the-api-using-the-access-token">
  ### Étape 3 : Appeler l’API à l’aide du jeton d’accès
</div>

Utilisez le jeton d’accès pour appeler l’API sécurisée avec le [schéma d’autorisation HTTP Bearer](https://datatracker.ietf.org/doc/html/rfc6750). Pour en savoir plus, consultez [Utiliser des jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens/use-access-tokens).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous pouvez décoder le jeton d’accès sur [jwt.io](https://jwt.io) pour vérifier ce qui suit :

  * La revendication `aud` correspond à l’API demandée (par exemple : [https://billing.example.com](https://billing.example.com)).
  * La revendication `scope` contient uniquement les valeurs autorisées.
</Callout>

<div id="use-multi-resource-refresh-token-with-actions">
  ## Utiliser le jeton d’actualisation multiresource avec Actions
</div>

L’utilisation de MRRT avec [Actions](/fr-CA/docs/customize/actions) vous permet de configurer une logique décisionnelle dynamique en fonction des politiques MRRT de l’application. À cette fin, les Actions post-connexion incluent l’objet [`event.client.refresh_token.policies`](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/login-trigger/post-login-event-object), qui fournit des renseignements pertinents, notamment l’<Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (identifiant d’API) pour un Jeton d’accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=audience">audience</Tooltip> et le scope.

Vous pouvez utiliser l’objet `event.client.refresh_token.policies` pour évaluer l’audience et le scope de l’application lors de l’émission ou de l’échange d’un jeton d’actualisation, afin d’assurer un contrôle précis de l’accès à l’API et des scopes.

```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
  // retourner la liste des API autorisées dans l'application
  const allowedAPIsInTheClient = event.client.refresh_token?.policies;

  if(allowedAPIsInTheClient?.some(policy => policy?.audience?.includes('https://myapi'))){
    // logique personnalisée
  }
};
```

<div id="evaluation-logic">
  #### Logique d’évaluation
</div>

Le MRRT agit comme une extension de l’authentification initiale, et non comme un remplacement. Lors de l’échange d’un jeton d’actualisation, Auth0 évalue la demande d’échange selon la logique suivante :

* **Si le paramètre audience est omis**, Auth0 renvoie un jeton d’accès avec l’audience initiale et tous les scopes supplémentaires configurés dans la stratégie MRRT.
* **Si un nouveau paramètre audience est spécifié**, Auth0 vérifie que l’audience est incluse dans la stratégie MRRT et renvoie un jeton d’accès pour la nouvelle audience avec les scopes configurés.
* **Si le paramètre scope est omis**, Auth0 combine tous les scopes autorisés de la demande initiale et de la stratégie MRRT.
* **Si un nouveau paramètre scope est spécifié**, Auth0 valide les scopes demandés et renvoie un jeton d’accès avec les scopes inclus dans la stratégie MRRT. Les scopes invalides ou non autorisés demandés sont ignorés sans avertissement.
* **Si le paramètre audience est le même que dans la demande initiale**, Auth0 applique la stratégie MRRT et renvoie un jeton d’accès pour l’audience avec tous les scopes configurés dans MRRT et les scopes de l’authentification initiale.

Le MRRT vous permet d’étendre l’accès de l’utilisateur à de nouvelles API sans émettre de nouveaux jetons d’actualisation ni lui demander de se reconnecter.

<div id="examples">
  #### Exemples
</div>

Un utilisateur se connecte en demandant l’audience et le scope suivants :

```json lines theme={null}
{
"audience": "https://api.example.com",  
"scope": "openid profile read:messages"
}
```

La stratégie MRRT de l’application est configurée pour ajouter un scope supplémentaire :

```json lines theme={null}
{
  "audience": "https://api.example.com",
  "scope": ["write:messages"]
}
```

Un échange de jeton d’actualisation avec la même audience et sans scope produirait un jeton d’accès contenant tous les scopes configurés :

```json lines theme={null}
{
  "aud": "https://api.example.com",
  "scope": "openid profile read:messages write:messages"
}
```