> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Découvrez comment appeler votre API depuis un appareil aux capacités d’entrée limitées au moyen du flux d’autorisation d’appareil.

# Appeler 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) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce tutoriel vous aidera à appeler votre propre API depuis un appareil aux capacités de saisie limitées à 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](/fr-CA/docs/get-started/authentication-and-authorization-flow/device-authorization-flow).
</Callout>

Auth0 permet à votre application de mettre en œuvre facilement le flux d’<Tooltip tip="Flux d’autorisation : octroi d’autorisation (ou workflow) défini dans le cadre OAuth 2.0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Authorization+flow">autorisation</Tooltip> d’appareil au moyen de :

* [Authentication API](https://auth0.com/docs/api/authentication) : poursuivez votre lecture pour découvrir comment 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) pour vous assurer que le flux d’autorisation de l’appareil convient à votre implémentation.
* [Enregistrez l’application dans Auth0](/fr-CA/docs/get-started/auth0-overview/create-applications/native-apps).

  * Sélectionnez **Native** comme **Application Type**.
  * Au besoin, définissez **Allowed Web Origins**. 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 particulier dont l’architecture est soumise à CORS (p. ex., HTML5 + JS). La plupart des applications n’utiliseront pas ce paramètre.
  * Assurez-vous que l’option **OIDC Conformant** est activée. Ce paramètre se trouve dans l’[Auth0 Dashboard](https://manage.auth0.com/#), sous **Applications > Application > Advanced Settings > OAuth**.
  * Assurez-vous que les **Grant Types** de l’application incluent **Device Code**. Pour savoir comment faire, consultez [Update Grant Types](/fr-CA/docs/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 **Refresh Token**. Pour savoir comment faire, consultez [Update Grant Types](/fr-CA/docs/get-started/applications/update-grant-types). Pour en savoir plus sur les jetons d’actualisation, consultez [Refresh Tokens](/fr-CA/docs/secure/tokens/refresh-tokens).
* Configurez et activez au moins une connexion pour l’application : [connexions de base de données](/fr-CA/docs/get-started/applications/set-up-database-connections), [connexions sociales](/fr-CA/docs/authenticate/identity-providers/social-identity-providers)
* [Enregistrez votre API dans Auth0](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/part-2#create-the-api)

  * 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**. Pour en savoir plus sur les jetons d’actualisation, consultez [Refresh Tokens](/fr-CA/docs/secure/tokens/refresh-tokens).
* [Configurez les paramètres du code utilisateur de l’appareil](/fr-CA/docs/get-started/tenant-settings/configure-device-user-code-settings) afin de définir le jeu de caractères, le format et la longueur de votre code utilisateur généré aléatoirement.

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

1. [Demander un code d’appareil](#request-device-code) (flux d’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 d’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 d’appareil) : Interrogez le point de terminaison de jeton pour demander un jeton.
4. [Autoriser l’utilisateur](#authorize-user) (flux de navigateur) : L’utilisateur autorise l’appareil afin que celui-ci puisse recevoir des jetons.
5. [Recevoir des jetons](#receive-tokens) (flux d’appareil) : Une fois que l’utilisateur a autorisé l’appareil, recevez les jetons.
6. [Appeler l’API](#call-your-api) (flux d’appareil) : Utilisez le Jeton d’accès récupéré pour appeler votre API.
7. [Actualiser les jetons](#refresh-tokens) (flux d’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 lancé l’application sur son appareil et veut autoriser celui-ci, vous devez obtenir un code d’appareil. Lorsque l’utilisateur ouvre sa session sur son appareil doté d’un navigateur, ce code est associé à cette session.

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

<div id="example-post-to-device-code-url">
  #### Exemple de requête POST vers 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_NONE

  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 appeler une API personnalisée, vous :

* devez inclure un paramètre <Tooltip tip="Audience : identificateur unique du destinataire 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>
* 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 un Jeton d’accès uniquement pour récupérer des renseignements sur l’utilisateur authentifié, aucun paramètre audience n’est nécessaire.
</Callout>

| Nom du paramètre | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `client_id`      | L’ID client de votre application. Vous pouvez trouver cette valeur dans vos [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `scope`          | Les [scopes](/fr-CA/docs/get-started/apis/scopes) pour lesquels vous voulez 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 [revendications personnalisées](/fr-CA/docs/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format avec espace de noms](/fr-CA/docs/secure/tokens/json-web-tokens/create-custom-claims), ou n’importe quels [scopes pris en charge par l’API cible](/fr-CA/docs/get-started/apis/scopes/api-scopes) (p. 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 renseignements 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 [paramètres de l’API](https://manage.auth0.com/#/apis)). Notez que cette valeur doit être encodée dans l’URL. |
| `audience`       | L’identificateur 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 les prérequis de ce tutoriel. Notez que cette valeur doit être encodée dans l’URL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant les valeurs `device_code`, `user_code`, `verification_uri`, `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` dans le navigateur de son appareil, ce code est associé à sa session.
* `user_code` contient le code à saisir à l’adresse `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](/fr-CA/docs/get-started/tenant-settings/configure-device-user-code-settings) dans Paramètres du locataire.

  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 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’adresse `verification_uri` sur son ordinateur portable ou son téléphone intelligent et 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="Demande d’activation de l’appareil Auth0 Flows, 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é à l’utilisateur et ne doit pas être affiché pendant l’interaction afin d’éviter toute confusion.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous créez une 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 à scruter l’URL du 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="/fr-CA/docs/glossary?term=Access+Token">Jeton d’accès</Tooltip>. À l’aide de l’intervalle de scrutation (`interval`) extrait à l’étape précédente, vous devrez envoyer une requête `POST` à l’[URL du jeton](https://auth0.com/docs/api/authentication#device-auth) avec le `device_code`.

Pour éviter les erreurs dues à la latence réseau, commencez à compter chaque intervalle après avoir reçu la réponse à la requête de scrutation précédente.

<div id="example-request-token-post-to-token-url">
  #### Exemple de requête POST pour obtenir un jeton à 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_NONE

  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 requête de jeton
</div>

| Nom du paramètre | Description                                                                                                                                                                                                                                                           |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez cette valeur à "urn:ietf:params:oauth:grant-type:device\_code". Il s’agit d’un type d’octroi 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 URL. |
| `device_code`    | Le `device_code` récupéré à l’étape précédente de ce tutoriel.                                                                                                                                                                                                        |
| `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).                                                                                               |

<div id="token-responses">
  #### Réponses liées au jeton
</div>

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

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

Vous verrez cette erreur en attendant que l’utilisateur passe à l’action. Continuez la scrutation à l’aide de l’intervalle suggéré récupéré à 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 la scrutation trop rapidement. 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 scrutation.

```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 relancer le flux.

<Warning>
  L’erreur `expired_token` n’est renvoyée qu’une seule fois ; par la suite, `invalid_grant` est renvoyée. Votre appareil **doit** arrêter la scrutation.
</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 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 accessibles à un utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=authorization+server">serveur d’autorisation</Tooltip> a rejeté la transaction
* une Rule configurée a refusé l’accès (Pour en savoir plus, consultez [Auth0 Rules](/fr-CA/docs/customize/rules).)

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

L’utilisateur balayera soit le code QR, soit ouvrira la page d’activation et saisira le code d’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 d’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 d’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 :

* L’authentification de l’utilisateur;
* La 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="/fr-CA/docs/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> pour gérer l’authentification;
* La vérification de sessions d’<Tooltip tip="authentification unique (SSO) : service qui, après qu’un utilisateur se connecte à une application, le connecte automatiquement à d’autres applications." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=SSO">SSO</Tooltip> actives;
* L’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 pour l’autorisation de l’appareil d’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 obtenu, 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 - Autorisation de l’appareil - 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 les jetons
</div>

Pendant que l’utilisateur s’authentifie et autorise l’appareil, l’application sur l’appareil a continué d’interroger l’URL du jeton pour demander un jeton d’accès.

Une fois que l’utilisateur a autorisé l’appareil avec succès, vous recevrez une réponse `HTTP 200` avec un payload contenant `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 les ID Tokens](/fr-CA/docs/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens/validate-access-tokens).
</Warning>

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

<Tooltip tip="ID Token : information d’identification destinée à l’application cliente elle-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+Tokens">ID Tokens</Tooltip> contiennent des informations sur l’utilisateur qu’il faut décoder et extraire. (Pour en savoir plus sur les ID Tokens, consultez [ID Tokens](/fr-CA/docs/secure/tokens/id-tokens).) Le `id_token` ne sera présent dans la réponse que si vous avez inclus le scope `openid`.

<Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau jeton d’accès sans obliger les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Refresh+Tokens">Jetons d’actualisation</Tooltip> servent à obtenir un nouveau jeton d’accès ou un ID Token après l’expiration du précédent. (Pour en savoir plus sur les jetons d’actualisation, consultez [Jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens).) Le `refresh_token` ne sera présent dans la réponse que si vous avez inclus le scope `offline_access` et activé **Allow Offline Access** pour votre API dans l’Auth0 Dashboard.

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

<div id="call-your-api">
  ### Appelez votre API
</div>

Pour appeler votre API, l’application doit transmettre le Jeton d’accès obtenu sous forme de Bearer Token dans l’en-tête Authorization de la 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_NONE

  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 le scope `offline_access` lorsque vous avez lancé la demande d’authentification au moyen du [point de terminaison authorize](https://auth0.com/docs/api/authentication/reference#authorize-application)

Vous pouvez utiliser le Jeton d’actualisation 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. Il est déconseillé d’appeler le point de terminaison pour obtenir un nouveau Jeton d’accès chaque fois que vous appelez une API, et Auth0 applique des limites de débit qui réduiront le nombre de requêtes vers le point de terminaison pouvant être exécutées avec le même jeton depuis la même adresse IP.

Pour actualiser votre jeton, effectuez une requête `POST` vers le 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 avec un jeton d’actualisation à 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 '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_NONE

  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`      | 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_secret`  | Le Secret client 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 transmis, 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 au format 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 un payload contenant un nouvel `access_token`, un `id_token` (facultatif), la durée de validité du jeton en secondes (`expires_in`), les valeurs de `scope` accordées et le `token_type` :

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

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

<div id="sample-use-cases">
  ## Exemples 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, consultez [Auth0 Rules](/fr-CA/docs/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 d’implémentation
</div>

* [Bac à sable du flux d’autorisation d’appareil](https://auth0.github.io/device-flow-playground/)
* [AppleTV (Swift)](https://github.com/pushpabrol/auth0-device-flow-appletv): 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 d’implémentation d’une CLI qui utilise le flux d’autorisation d’appareil au lieu du 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>

Les journaux du locataire sont générés pour chaque interaction et peuvent servir au dépannage. Pour en savoir plus, consultez [Logs](/fr-CA/docs/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 d’appareil contre jeton d’accès |
| `sede`  | Échange réussi                                       | Code d’appareil contre 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 du serveur (SNI) lorsque des [Domaines personnalisés](/fr-CA/docs/customize/custom-domains) sont utilisés
* Avoir un [type d’application Auth0](/fr-CA/docs/get-started/applications) défini sur **Native**
* Avoir la [méthode d’authentification du point de terminaison de jeton](/fr-CA/docs/get-started/applications/application-settings) définie sur **None**
* Être [conformes à OIDC](/fr-CA/docs/get-started/applications/application-settings)
* Ne pas être créés au moyen de l’[Enregistrement dynamique des applications](/fr-CA/docs/get-started/applications/dynamic-client-registration)

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

* Les [connexions sociales](/fr-CA/docs/authenticate/identity-providers/social-identity-providers) utilisant des [clés de développeur Auth0](/fr-CA/docs/authenticate/identity-providers/social-identity-providers/devkeys), à moins que vous n’utilisiez l’[expérience Universal Login](/fr-CA/docs/authenticate/login/auth0-universal-login/universal-login-vs-classic-login/universal-experience)
* L’accès 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](/fr-CA/docs/manage-users/user-accounts/user-account-linking)

Nous prenons en charge l’intégralité du brouillon 15, sauf pour les <Tooltip tip="Application confidentielle : une application qui peut conserver des identifiants en toute sécurité à l’aide d’un serveur backend fiable. Par exemple, une application Web avec un backend sécurisé et une application machine à machine (M2M)." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=confidential+Clients">applications confidentielles</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](/fr-CA/docs/authenticate/protocols/oauth)
* [Protocole OpenID Connect](/fr-CA/docs/authenticate/protocols/openid-connect-protocol)
* [Jetons](/fr-CA/docs/secure/tokens)
* [Logs](/fr-CA/docs/deploy-monitor/logs)