> ## 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 faire une requête à votre API à partir d’un appareil à capacité de saisie limitée au moyen du flux d’autorisation d’appareil.

# Faire une requête à votre API au moyen du flux d’autorisation d’appareil

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 à partir d’un appareil à saisie limitée à l’aide du flux d’autorisation d’appareil. Si vous voulez comprendre comment ce flux fonctionne et pourquoi vous devriez l’utiliser, consultez [flux d’autorisation d’appareil](/docs/fr-ca/get-started/authentication-and-authorization-flow/device-authorization-flow).
</Callout>

Auth0 permet à votre application d’implémenter facilement le Device <Tooltip tip="Flux d’autorisation : grant d’autorisation (ou workflow) spécifié dans le framework OAuth 2.0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Authorization+flow">Authorization flow</Tooltip> à l’aide de ce qui suit :

* [Authentication API](https://auth0.com/docs/api/authentication) : poursuivez votre lecture pour apprendre à appeler notre API directement. Pour une expérience interactive, consultez [Device Flow Playground](https://auth0.github.io/device-flow-playground/).

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

Avant de commencer ce tutoriel :

* Vérifiez les limites (ci-dessous) afin de vous assurer que le Device Authorization Flow convient à votre mise en œuvre.
* [Enregistrez l’application auprès d’Auth0](/docs/fr-ca/get-started/auth0-overview/create-applications/native-apps).

  * Sélectionnez **Native** comme **Type d’application**.
  * Au besoin, définissez les **Origines Web autorisées**. Vous pouvez l’utiliser pour autoriser localhost comme origine en développement local, ou pour définir une origine autorisée pour un logiciel de téléviseur précis dont l’architecture est soumise à CORS (p. ex., HTML5 + JS). La plupart des applications n’utiliseront pas ce paramètre.
  * Assurez-vous que la bascule **OIDC Conformant** est activée. Ce paramètre se trouve dans le [Dashboard](https://manage.auth0.com/#), sous **Applications > Application > Advanced Settings > OAuth**.
  * Assurez-vous que les **Types d’octroi** de l’application comprennent **Device Code**. 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 ses **Types d’octroi** comprennent **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).
* Configurez et activez au moins une connection pour l’application : [Database connections](/docs/fr-ca/get-started/applications/set-up-database-connections), [Social connections](/docs/fr-ca/authenticate/identity-providers/social-identity-providers)
* [Enregistrez votre API auprès d’Auth0](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/part-2#create-the-api)

  * Si vous voulez que votre API reçoive des **jetons d’actualisation** afin de pouvoir obtenir de nouveaux jetons lorsque les précédents expirent, activez **Allow Offline Access**. Pour en savoir plus sur les **jetons d’actualisation**, consultez [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).
* [Configurez les paramètres du user code de l’appareil](/docs/fr-ca/get-started/tenant-settings/configure-device-user-code-settings) pour définir le jeu de caractères, le format et la longueur de votre user code généré aléatoirement.

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

1. [Demander un code d’appareil](#request-device-code) (flux de l’appareil) : Demandez un code d’appareil que l’utilisateur pourra utiliser pour autoriser l’appareil.
2. [Demander l’activation de l’appareil](#request-device-activation) (flux de l’appareil) : Demandez à l’utilisateur d’autoriser l’appareil à l’aide de son ordinateur portable ou de son téléphone intelligent.
3. [Demander des jetons](#request-tokens) (flux de l’appareil) : Interrogez le point de terminaison des jetons pour demander un jeton.
4. [Autoriser l’utilisateur](#authorize-user) (flux du navigateur) : L’utilisateur autorise l’appareil afin que celui-ci puisse recevoir des jetons.
5. [Recevoir des jetons](#receive-tokens) (flux de l’appareil) : Une fois que l’utilisateur a autorisé l’appareil avec succès, recevez les jetons.
6. [Appeler l’API](#call-your-api) (flux de l’appareil) : Utilisez le jeton d’accès récupéré pour appeler votre API.
7. [Actualiser les jetons](#refresh-tokens) (flux de l’appareil) : Utilisez un jeton d’actualisation pour demander de nouveaux jetons lorsque les jetons existants expirent.

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

Facultatif : [Dépannage](#troubleshoot).

<div id="request-device-code">
  ### Demander un code d’appareil
</div>

Une fois que l’utilisateur a démarré son application de l’appareil et souhaite autoriser l’appareil, vous devrez obtenir un code d’appareil. Lorsque l’utilisateur ouvre sa session sur son appareil avec navigateur, ce code sera associé à cette session.

Pour obtenir le code d’appareil, votre application doit faire une requête à l’[URL du code d’appareil](https://auth0.com/docs/api/authentication#get-device-code), en incluant le <Tooltip tip="Client ID : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Client+ID">Client ID</Tooltip>.

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

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

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/device/code");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/x-www-form-urlencoded");
  request.AddParameter("application/x-www-form-urlencoded", "client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%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/device/code"

  	payload := strings.NewReader("client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%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/device/code")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%7D")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/device/code',
    headers: {'content-type': 'application/x-www-form-urlencoded'},
    data: {client_id: '{yourClientId}', scope: '{scope}', audience: '{audience}'}
  };

  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/device/code",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%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 = "client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%7D"

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

  conn.request("POST", "/{yourDomain}/oauth/device/code", 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/device/code")

  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 = "client_id={yourClientId}&scope=%7Bscope%7D&audience=%7Baudience%7D"

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

<div id="device-code-parameters">
  ##### Paramètres du code d’appareil
</div>

Notez que lorsque vous demandez un code d’appareil pour effectuer une requête à une API personnalisée, vous :

* devez inclure un paramètre <Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID soit d’une application (Client ID) pour un ID Token, soit d’une API (API Identifier) pour un jeton d’accès." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip>
* pouvez inclure des scopes supplémentaires pris en charge par l’API cible

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si votre application veut seulement un jeton d’accès pour récupérer des informations sur l’utilisateur authentifié, aucun paramètre audience n’est requis.
</Callout>

| Nom du paramètre | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `scope`          | Les [scopes](/docs/fr-ca/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation. Ils doivent être séparés par un espace. Vous pouvez demander n’importe lequel des [scopes OIDC standard](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` et `email`, des [custom claims](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format namespaced](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims), ou tout [scope pris en charge par l’API cible](/docs/fr-ca/get-started/apis/scopes/api-scopes) (par ex. : `read:contacts`). Incluez `openid` pour obtenir un ID Token ou pour pouvoir utiliser le [point de terminaison /userinfo](https://auth0.com/docs/api/authentication#user-profile) afin de récupérer les informations de profil de l’utilisateur. Incluez `offline_access` pour obtenir un jeton d’actualisation (assurez-vous que le champ **Allow Offline Access** est activé dans les [API Settings](https://manage.auth0.com/#/apis)). Notez que cette valeur doit être encodée dans l’URL. |
| `audience`       | L’identifiant unique de l’API à laquelle votre application veut accéder. Utilisez la valeur **Identifier** dans l’onglet [Settings](https://manage.auth0.com/#/apis) de l’API que vous avez créée dans le cadre des prérequis de ce tutoriel. Notez que cette valeur doit être encodée dans l’URL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |

<div id="device-code-response">
  #### Réponse de code d’appareil
</div>

Si tout se passe bien, vous recevrez une réponse `HTTP 200` dont la charge utile contient `device_code`, `user_code`, `verification_uri` ainsi que les valeurs `expires_in`, `interval` et `verification_uri_complete` :

```json lines theme={null}
{
  "device_code": "Ag_EE...ko1p",
  "user_code": "QTZL-MCBW",
  "verification_uri": "https://accounts.acmetest.org/activate",
  "verification_uri_complete": "https://accounts.acmetest.org/activate?user_code=QTZL-MCBW",
  "expires_in": 900,
  "interval": 5
}
```

* `device_code` est le code unique de l’appareil. Lorsque l’utilisateur accède à `verification_uri` depuis son navigateur sur l’appareil, ce code est associé à sa session.
* `user_code` contient le code qui doit être saisi à `verification_uri` pour autoriser l’appareil.
* `verification_uri` contient l’URL que l’utilisateur doit ouvrir pour autoriser l’appareil.
* `verification_uri_complete` contient l’URL complète que l’utilisateur doit ouvrir pour autoriser l’appareil. Cela permet à votre application d’inclure le `user_code` dans l’URL, si vous le souhaitez.
* `expires_in` indique la durée de validité (en secondes) du `device_code` et du `user_code`.
* `interval` indique l’intervalle (en secondes) auquel l’application doit interroger l’URL du jeton pour demander un jeton.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous pouvez [configurer le jeu de caractères, le format et la longueur de votre code utilisateur généré aléatoirement](/docs/fr-ca/get-started/tenant-settings/configure-device-user-code-settings) dans les paramètres de votre tenant.

  Pour prévenir les attaques par force brute, nous appliquons les limites suivantes à `user_code` :

  **Longueur minimale** :

  * Lettres BASE20 : 8 caractères
  * Chiffres : 9 caractères

  **Longueur maximale** :

  * 20 caractères (y compris les traits d’union et les espaces, qui peuvent être ajoutés comme séparateurs pour en faciliter la lecture)

  **Durée d’expiration** :

  * 15 minutes
</Callout>

<div id="request-device-activation">
  ### Demander l’activation de l’appareil
</div>

Une fois que vous avez reçu un `device_code` et un `user_code`, vous devez demander à l’utilisateur de se rendre à l’`verification_uri` sur son ordinateur portable ou son téléphone, puis d’entrer le `user_code` :

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2WzaeNXIYCVduRuzyRd0Sb/cdb4d59b657166d0a9a555a662b9ed63/request-device-activation.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=c452a5b19705d03633ccbfa1247e1fc6" alt="Auth0 Flows Device Authorization Request, exemple de page montrant deux méthodes d’activation, user_code et code QR" width="1986" height="1432" data-path="docs/images/cdy7uua7fh8z/2WzaeNXIYCVduRuzyRd0Sb/cdb4d59b657166d0a9a555a662b9ed63/request-device-activation.png" />
</Frame>

Le `device_code` n’est pas destiné directement à l’utilisateur et ne devrait pas être affiché pendant l’interaction afin d’éviter toute confusion.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous créez un CLI, vous pouvez ignorer cette étape et ouvrir immédiatement le navigateur avec `verification_uri_complete`.
</Callout>

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

Pendant que vous attendez que l’utilisateur active l’appareil, commencez à interroger périodiquement l’URL de jeton pour demander un <Tooltip tip="Jeton d’accès : information d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip>. En utilisant l’intervalle de polling extrait (`interval`) à l’étape précédente, vous devrez envoyer une requête `POST` à l’[URL de jeton](https://auth0.com/docs/api/authentication#device-auth) avec le `device_code`.

Pour éviter les erreurs dues à la latence du réseau, vous devriez commencer à compter chaque intervalle après avoir reçu la réponse à la dernière requête de polling.

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

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

  ```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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}", 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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}")

  	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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}")
    .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: 'urn:ietf:params:oauth:grant-type:device_code',
      device_code: '{yourDeviceCode}',
      client_id: '{yourClientId}'
    })
  };

  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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}",
    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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}"

  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=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code&device_code=%7ByourDeviceCode%7D&client_id={yourClientId}"

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

<div id="token-request-parameters">
  ##### Paramètres de la demande de jeton
</div>

| Nom du paramètre | Description                                                                                                                                                                                                                                                                            |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez cette valeur sur « urn:ietf:params:oauth:grant-type:device\_code ». Il s’agit d’un type d’autorisation d’extension (tel que défini à la section 4.5 de la [RFC6749](https://tools.ietf.org/html/rfc6749#section-4.5)). Notez que cette valeur doit être encodée dans l’URL. |
| `device_code`    | Le `device_code` récupéré à l’étape précédente de ce tutoriel.                                                                                                                                                                                                                         |
| `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).                                                                                                               |

<div id="token-responses">
  #### Réponses de jeton
</div>

Pendant que vous attendez que l’utilisateur autorise l’appareil, il se peut que vous receviez quelques réponses `HTTP 4xx` différentes :

<div id="authorization-pending">
  ##### Autorisation en attente
</div>

Vous verrez cette erreur en attendant que l’utilisateur passe à l’action. Continuez à interroger le point de terminaison selon l’intervalle suggéré obtenu à l’étape précédente de ce tutoriel.

```json lines theme={null}
HTTP/1.1 403 Forbidden
{
  "error": "authorization_pending",
  "error_description": "..."
}
```

<div id="slow-down">
  ##### Ralentissez
</div>

Vous effectuez des vérifications trop fréquemment. Ralentissez et utilisez l’intervalle suggéré obtenu à l’étape précédente de ce tutoriel. Pour éviter de recevoir cette erreur en raison de la latence du réseau, vous devriez commencer à compter chaque intervalle après avoir reçu la réponse à la dernière requête de vérification.

```json lines theme={null}
HTTP/1.1 429 Too Many Requests
{
  "error": "slow_down",
  "error_description": "..."
}
```

<div id="expired-token">
  ##### Jeton expiré
</div>

L’utilisateur n’a pas autorisé l’appareil assez rapidement, donc le `device_code` a expiré. Votre application doit informer l’utilisateur que le flux a expiré et lui demander de le relancer.

<Warning>
  L’erreur `expired_token` ne sera renvoyée qu’une seule fois; par la suite, `invalid_grant` sera renvoyée. Votre appareil **doit** cesser d’interroger le point de terminaison.
</Warning>

```json lines theme={null}
HTTP/1.1 403 Bad Request
{ 
  "error": "expired_token",
  "error_description": "..."
}
```

<div id="access-denied">
  ##### Accès refusé
</div>

Enfin, si l’accès vous est refusé, vous recevrez :

```json lines theme={null}
HTTP/1.1 403 Forbidden
{
  "error": "access_denied",
  "error_description": "..."
}
```

Cela peut se produire pour diverses raisons, notamment :

* l’utilisateur a refusé d’autoriser l’appareil
* le <Tooltip tip="Serveur d’autorisation : serveur centralisé qui contribue à définir les limites de l’accès d’un utilisateur. Par exemple, votre serveur d’autorisation peut contrôler les données, les tâches et les fonctionnalités offertes à un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=authorization+server">serveur d’autorisation</Tooltip> a refusé la transaction
* une règle configurée a refusé l’accès (Pour en savoir plus, consultez [Auth0 Rules](/docs/fr-ca/customize/rules).)

<div id="authorize-user">
  ### Autoriser l’utilisateur
</div>

L’utilisateur balaiera le code QR ou ouvrira la page d’activation et saisira le code utilisateur :

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7KRZGb2QcksaEVewXK5bc2/b688b813428f0750ea76b7bcac418bba/enter-user-code__1_.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=e814986a9a1eec7cadb6fea50c646497" alt="Invite d’autorisation de l’appareil dans Auth0 Flows demandant à l’utilisateur de saisir le code affiché sur son appareil" width="390" height="532" data-path="docs/images/cdy7uua7fh8z/7KRZGb2QcksaEVewXK5bc2/b688b813428f0750ea76b7bcac418bba/enter-user-code__1_.png" />
</Frame>

Une page de confirmation s’affichera pour demander à l’utilisateur de confirmer qu’il s’agit du bon appareil :

<Frame>
  <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/4udH69PJSo20QyK8cwhhtc/193488ee0f689f0724345a40dcdb6478/confirm-device__1_.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=771499858a79702e1084c6551dab7c3e" alt="Exemple d’invite de confirmation d’autorisation de l’appareil dans Auth0 Flows demandant à l’utilisateur de confirmer le code" width="394" height="532" data-path="docs/images/cdy7uua7fh8z/4udH69PJSo20QyK8cwhhtc/193488ee0f689f0724345a40dcdb6478/confirm-device__1_.png" />
</Frame>

L’utilisateur terminera la transaction en se connectant. Cette étape peut inclure un ou plusieurs des processus suivants :

* Authentification de l’utilisateur ;
* Redirection de l’utilisateur vers un <Tooltip tip="Fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> pour effectuer l’authentification ;
* Vérification des sessions <Tooltip tip="Single Sign-On (SSO) : service qui, après qu’un utilisateur se connecte à une application, connecte automatiquement cet utilisateur aux autres applications." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SSO">SSO</Tooltip> actives ;
* Obtention du consentement de l’utilisateur pour l’appareil, sauf si ce consentement a déjà été accordé.

<Frame>
  <img src="https://mintcdn.com/translations/pvjQqAy3EB2TK6NP/docs/images/cdy7uua7fh8z/4UbIdGQMucMhoaXxvFLcki/8c1616d7f28bbd37c253a0145a93a17d/user-auth__1_.png?fit=max&auto=format&n=pvjQqAy3EB2TK6NP&q=85&s=8338c652e72d813a0dcc386af5a97b21" alt="Invite d’autorisation de l’utilisateur dans Auth0 Flows demandant à l’utilisateur de se connecter avec son courriel et son mot de passe, ou avec Google ou un autre fournisseur d’identité" width="317" height="584" data-path="docs/images/cdy7uua7fh8z/4UbIdGQMucMhoaXxvFLcki/8c1616d7f28bbd37c253a0145a93a17d/user-auth__1_.png" />
</Frame>

Une fois l’authentification réussie et le consentement accordé, l’invite de confirmation s’affichera :

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7ze8nZU4b0q3YOzLQSJ6nJ/48ef5170035a200cebb821c581cec9bb/user-confirmation__1_.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=08d4f09c478a98f6d5b745e7e6b3e1a6" alt="Flows - Device Authorization - Notification de félicitations pour l’utilisateur" width="392" height="536" data-path="docs/images/cdy7uua7fh8z/7ze8nZU4b0q3YOzLQSJ6nJ/48ef5170035a200cebb821c581cec9bb/user-confirmation__1_.png" />
</Frame>

À ce stade, l’utilisateur s’est authentifié et l’appareil a été autorisé.

<div id="receive-tokens">
  ### Recevoir des jetons
</div>

Pendant que l’utilisateur s’authentifie et autorise l’appareil, l’application de l’appareil continue d’interroger l’URL du jeton pour demander un jeton d’accès.

Une fois que l’utilisateur a bien autorisé l’appareil, vous recevrez une réponse `HTTP 200` avec une charge utile contenant les valeurs `access_token`, `refresh_token` (facultatif), `id_token` (facultatif), `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":86400
}
```

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

Les jetons d’accès servent à appeler le [point de terminaison `/userinfo`](https://auth0.com/docs/api/authentication#get-user-info) de l’API d’authentification Auth0 ou une autre API. (Pour en savoir plus sur les jetons d’accès, consultez [Jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens).) Vous ne pourrez utiliser le jeton d’accès pour appeler `/userinfo` que si vous avez inclus la portée `openid`. Si vous appelez votre propre API, la première chose qu’elle devra faire sera de [vérifier le jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).

<Tooltip tip="Jeton d’identité : jeton destiné au client lui-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+Tokens">Jetons d’identité</Tooltip> contiennent des renseignements sur l’utilisateur qui doivent être décodés et extraits. (Pour en savoir plus sur les jetons d’identité, consultez [Jetons d’identité](/docs/fr-ca/secure/tokens/id-tokens).) Le `id_token` ne sera présent dans la réponse que si vous avez inclus la portée `openid`.

<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+Tokens">Jetons d’actualisation</Tooltip> servent à obtenir un nouveau jeton d’accès ou un nouveau jeton d’identité après l’expiration du précédent. (Pour en savoir plus sur les jetons d’actualisation, consultez [Jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).) Le `refresh_token` ne sera présent dans la réponse que si vous avez inclus la portée `offline_access` et activé **Autoriser l’accès hors ligne** pour votre API dans le Dashboard.

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

<div id="call-your-api">
  ### Effectuer une requête à votre API
</div>

Pour effectuer une requête à votre API, l’application doit transmettre le jeton d’accès 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 ACCESS_TOKEN' \
    --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 ACCESS_TOKEN");
  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 ACCESS_TOKEN")

  	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 ACCESS_TOKEN")
    .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 ACCESS_TOKEN'}
  };

  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 ACCESS_TOKEN",
      "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 ACCESS_TOKEN"
      }

  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 ACCESS_TOKEN'

  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 si vous avez suivi ce tutoriel et effectué les étapes suivantes :

* configuré votre API pour autoriser l’accès hors ligne
* inclus la portée `offline_access` lorsque vous avez lancé la requête d’authentification par l’intermédiaire du [point de terminaison authorize](https://auth0.com/docs/api/authentication/reference#authorize-application)

Vous pouvez utiliser le jeton d’actualisation pour obtenir un nouveau jeton d’accès. En général, un utilisateur n’aura besoin d’un nouveau jeton d’accès qu’après l’expiration du précédent ou lorsqu’il devra accéder à une nouvelle ressource pour la première fois. C’est une mauvaise 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 débit qui restreindront 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-refresh-token-post-to-token-url">
  #### Exemple de requête POST de jeton d’actualisation à l’URL de 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 'client_secret={yourClientSecret}' \
    --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}&client_secret={yourClientSecret}&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}&client_secret={yourClientSecret}&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}&client_secret={yourClientSecret}&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}',
      client_secret: '{yourClientSecret}',
      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}&client_secret={yourClientSecret}&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}&client_secret={yourClientSecret}&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}&client_secret={yourClientSecret}&refresh_token=%7ByourRefreshToken%7D"

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

<div id="refresh-token-request-parameters">
  ##### Paramètres de la requête de jeton d’actualisation
</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).                                                                        |
| `client_secret`  | Le Client Secret de votre application. Vous trouverez cette valeur dans les [Paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientSecret}/settings).                                                                |
| `refresh_token`  | Le jeton d’actualisation à utiliser.                                                                                                                                                                                                            |
| `scope`          | (Facultatif) Une liste de scopes demandés, séparés par des espaces. S’il n’est pas envoyé, 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="refresh-token-response">
  #### Réponse du jeton d’actualisation
</div>

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec une charge utile qui contient un nouvel `access_token`, un `id_token` (facultatif), la durée de validité du jeton 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",
  "id_token": "eyJ...0NE",
  "token_type": "Bearer"
}
```

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

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

<div id="detect-device-authorization-flow-use">
  ### Détecter l’utilisation du flux d’autorisation d’appareil
</div>

Vous pouvez utiliser Rules pour détecter si la transaction en cours utilise le flux d’autorisation d’appareil. (Pour en savoir plus sur Rules, consultez [Auth0 Rules](/docs/fr-ca/customize/rules).) Pour ce faire, vérifiez la propriété `protocol` de l’objet `context` :

```javascript lines theme={null}
function (user, context, callback) {
   if (context.protocol === 'oauth2-device-code') {
      ...
   }
 
   callback(null, user, context);
}
```

<div id="sample-implementations">
  ### Exemples de mises en œuvre
</div>

* [Device Authorization Playground](https://auth0.github.io/device-flow-playground/)
* [AppleTV (Swift)](https://github.com/pushpabrol/auth0-device-flow-appletv): Une application simple qui montre comment utiliser Auth0 avec le flux d’autorisation d’appareil sur une Apple TV.
* [CLI (Node.js)](https://gist.github.com/panva/ebaacfe433a8677bdbf458f6e1132045): Exemple de mise en œuvre d’un CLI qui utilise le flux d’autorisation d’appareil plutôt que le flux de code d’autorisation. La principale différence, c’est que votre CLI n’a pas besoin d’héberger un serveur Web ni d’écouter sur un port.

<div id="troubleshoot">
  ## Dépannage
</div>

Des logs du tenant sont créés pour chaque interaction et peuvent servir au dépannage. Pour en savoir plus, consultez [Logs](/docs/fr-ca/deploy-monitor/logs).

<div id="error-codes">
  ### Codes d’erreur
</div>

| Code    | Nom                                                  | Description                           |
| ------- | ---------------------------------------------------- | ------------------------------------- |
| `fdeaz` | Échec de la demande d’autorisation de l’appareil     |                                       |
| `fdeac` | Échec de l’activation de l’appareil                  |                                       |
| `fdecc` | L’utilisateur a annulé la confirmation de l’appareil |                                       |
| `fede`  | Échec de l’échange                                   | code de l’appareil pour jeton d’accès |
| `sede`  | réussite de l’échange                                | code de l’appareil pour jeton d’accès |

<div id="limitations">
  ### Limitations
</div>

Pour utiliser le flux d’autorisation d’appareil, les appareils doivent :

* Prendre en charge l’indication du nom de serveur (SNI) lorsque des [domaines personnalisés](/docs/fr-ca/customize/custom-domains) sont utilisés
* Avoir un [type d’application Auth0](/docs/fr-ca/get-started/applications) **Native**
* Avoir la [méthode d’authentification du Token Endpoint](/docs/fr-ca/get-started/applications/application-settings) réglée sur **None**
* Être [conformes à OIDC](/docs/fr-ca/get-started/applications/application-settings)
* Ne pas avoir été créés au moyen de l’[enregistrement dynamique des clients](/docs/fr-ca/get-started/applications/dynamic-client-registration)

De plus, le flux d’autorisation d’appareil ne permet pas :

* Les [connexions sociales](/docs/fr-ca/authenticate/identity-providers/social-identity-providers) utilisant des [clés de développeur Auth0](/docs/fr-ca/authenticate/identity-providers/social-identity-providers/devkeys), sauf si vous utilisez l’[expérience Universal Login](/docs/fr-ca/authenticate/login/auth0-universal-login/universal-login-vs-classic-login/universal-experience)
* D’accéder aux paramètres de chaîne de requête à partir de la page de connexion hébergée, de Rules ou d’Actions
* La [liaison de comptes d’utilisateur](/docs/fr-ca/manage-users/user-accounts/user-account-linking)

Nous prenons entièrement en charge le Draft 15, sauf pour les <Tooltip tip="Client confidentiel : client (application) qui peut conserver des informations d’authentification en toute sécurité à l’aide d’un backend fiable. Par exemple, une application web avec un backend sécurisé et une application machine à machine (M2M)." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=confidential+Clients">clients confidentiels</Tooltip>. Pour en savoir plus, consultez [OAuth 2.0 Device Authorization Grant Draft 15 sur ietf.org](https://tools.ietf.org/html/draft-ietf-oauth-device-flow-15).

<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)
* [Journaux](/docs/fr-ca/deploy-monitor/logs)