> ## 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 à partir d’une application native, mobile ou d’une application monopage à l’aide du flux de code d’autorisation avec PKCE.

# Appeler votre API à l’aide du flux de code d’autorisation avec PKCE

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 explique comment appeler votre propre API à partir d’une application native, mobile ou monopage à l’aide du flux de code d’autorisation avec PKCE. Pour savoir comment fonctionne ce flux et pourquoi vous devriez l’utiliser, consultez [Flux de code d’autorisation avec Proof Key for Code Exchange (PKCE)](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce). Pour apprendre à ajouter la connexion à votre application native, mobile ou monopage, consultez [Ajouter la connexion à l’aide du flux de code d’autorisation avec PKCE](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/add-login-using-the-authorization-code-flow-with-pkce).
</Callout>

Auth0 facilite l’implémentation du flux de code d’autorisation avec Proof Key for Code Exchange (PKCE) dans votre application à l’aide des options suivantes :

* [SDK mobiles Auth0](/fr-CA/docs/libraries) et [SDK Auth0 pour application monopage](/fr-CA/docs/libraries/auth0-single-page-app-sdk) : la façon la plus simple d’implémenter ce flux; ces SDK prennent en charge la plus grande partie du travail. Nos [Quickstarts mobiles](/fr-CA/docs/quickstart/native) et [Quickstarts pour applications monopages](/fr-CA/docs/quickstart/spa) vous guideront tout au long du processus.
* [Authentication API](https://auth0.com/docs/api/authentication) : si vous préférez créer votre propre solution, poursuivez votre lecture pour apprendre à appeler notre API directement.

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

**Avant de commencer ce tutoriel :**

* [Enregistrez l’application dans Auth0](/fr-CA/docs/get-started/auth0-overview/create-applications/native-apps).

  * Sélectionnez **Application Type** : **Native** ou **application monopage**, selon le type de votre application.
  * Ajoutez `{yourCallbackUrl}` comme **Allowed Callback URL**. Le format de l’URL de rappel varie selon le type de votre application et votre plateforme. Pour en savoir plus sur le format propre à votre type d’application et à votre plateforme, consultez nos [Quickstarts Native/Mobile](/fr-CA/docs/quickstart/native) et [Quickstarts application monopage](/fr-CA/docs/quickstart/spa).
  * Assurez-vous que **Grant Types** inclut **Authorization 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 **Grant Types** inclut **Jeton d’actualisation**. Pour savoir comment faire, consultez [Update Grant Types](/fr-CA/docs/get-started/applications/update-grant-types). Pour en savoir plus sur les **Jetons d’actualisation**, consultez [Refresh Tokens](/fr-CA/docs/secure/tokens/refresh-tokens).
* [Enregistrez votre API 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** afin de pouvoir obtenir de nouveaux jetons lorsque les précédents expirent, activez **Allow Offline Access**.

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

1. [Créer le vérificateur de code](#create-code-verifier):
   Générez un `code_verifier` qui sera envoyé à Auth0 pour demander des jetons.
2. [Créer le défi de code](#create-code-challenge):
   Générez un `code_challenge` à partir du `code_verifier`, qui sera envoyé à Auth0 pour demander un `authorization_code`.
3. [Autoriser l’utilisateur](#authorize-user):
   Demandez l’autorisation de l’utilisateur, puis redirigez-le vers votre application avec un `authorization_code`.
4. [Demander des jetons](#request-tokens):
   Échangez votre `authorization_code` et votre `code_verifier` contre des jetons.
5. [Appeler l’API](#call-api):
   Utilisez le Jeton d’accès récupéré pour appeler votre API.
6. [Actualiser les jetons](#refresh-tokens):
   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).

<div id="create-code-verifier">
  ### Créer un vérificateur de code
</div>

Créez un `code_verifier`, c’est-à-dire une clé générée aléatoirement de manière cryptographiquement sûre et encodée en Base64, qui sera ensuite envoyée à Auth0 pour demander des jetons.

<div id="javascript-sample">
  #### Exemple JavaScript
</div>

```javascript lines theme={null}
// Dépendance : module crypto de Node.js
// https://nodejs.org/api/crypto.html#crypto_crypto
function base64URLEncode(str) {
    return str.toString('base64')
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
}
var verifier = base64URLEncode(crypto.randomBytes(32));
```

<div id="java-sample">
  #### Exemple en Java
</div>

```java lines theme={null}
// Dépendance : Apache Commons Codec
// https://commons.apache.org/proper/commons-codec/
// Importer la classe Base64.
// import org.apache.commons.codec.binary.Base64;
SecureRandom sr = new SecureRandom();
byte[] code = new byte[32];
sr.nextBytes(code);
String verifier = Base64.getUrlEncoder().withoutPadding().encodeToString(code);
```

<div id="android-sample">
  #### Exemple Android
</div>

```kotlin lines theme={null}
// See https://developer.android.com/reference/android/util/Base64
// Importer la classe Base64
// import android.util.Base64;
SecureRandom sr = new SecureRandom();
byte[] code = new byte[32];
sr.nextBytes(code);
String verifier = Base64.encodeToString(code, Base64.URL_SAFE | Base64.NO_WRAP | Base64.NO_PADDING);
```

<div id="swift-5-sample">
  #### Exemple en Swift 5
</div>

```swift lines theme={null}
var buffer = [UInt8](repeating: 0, count: 32)
_ = SecRandomCopyBytes(kSecRandomDefault, buffer.count, &buffer)
let verifier = Data(buffer).base64EncodedString()
    .replacingOccurrences(of: "+", with: "-")
    .replacingOccurrences(of: "/", with: "_")
    .replacingOccurrences(of: "=", with: "")
```

<div id="objective-c-sample">
  #### Exemple en Objective-C
</div>

```objc lines theme={null}
NSMutableData *data = [NSMutableData dataWithLength:32];
int result __attribute__((unused)) = SecRandomCopyBytes(kSecRandomDefault, 32, data.mutableBytes);
NSString *verifier = [[[[data base64EncodedStringWithOptions:0]
                        stringByReplacingOccurrencesOfString:@"+" withString:@"-"]
                        stringByReplacingOccurrencesOfString:@"/" withString:@"_"]
                        stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"="]];
```

<div id="create-code-challenge">
  ### Créer le défi de code
</div>

Générez un `code_challenge` à partir du `code_verifier`, qui sera envoyé à Auth0 afin de demander un `authorization_code`.

<div id="javascript-sample">
  #### Exemple JavaScript
</div>

```javascript lines theme={null}
// Dépendance : module crypto de Node.js
// https://nodejs.org/api/crypto.html#crypto_crypto
function sha256(buffer) {
    return crypto.createHash('sha256').update(buffer).digest();
}
var challenge = base64URLEncode(sha256(verifier));
```

<div id="java-sample">
  #### Exemple en Java
</div>

```java lines theme={null}
// Dépendance : Apache Commons Codec
// https://commons.apache.org/proper/commons-codec/
// Importer la classe Base64.
// import org.apache.commons.codec.binary.Base64;
byte[] bytes = verifier.getBytes("US-ASCII");
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(bytes, 0, bytes.length);
byte[] digest = md.digest();
String challenge = Base64.encodeBase64URLSafeString(digest);
```

<div id="swift-5-sample">
  #### Exemple en Swift 5
</div>

```swift lines theme={null}
import CommonCrypto

// ...

guard let data = verifier.data(using: .utf8) else { return nil }
var buffer = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
_ = data.withUnsafeBytes {
    CC_SHA256($0.baseAddress, CC_LONG(data.count), &buffer)
}
let hash = Data(buffer)
let challenge = hash.base64EncodedString()
    .replacingOccurrences(of: "+", with: "-")
    .replacingOccurrences(of: "/", with: "_")
    .replacingOccurrences(of: "=", with: "")
```

<div id="objective-c-sample">
  #### Exemple en Objective-C
</div>

```objc lines theme={null}
// Dépendance : bibliothèque Apple Common Crypto
// http://opensource.apple.com//source/CommonCrypto
u_int8_t buffer[CC_SHA256_DIGEST_LENGTH * sizeof(u_int8_t)];
memset(buffer, 0x0, CC_SHA256_DIGEST_LENGTH);
NSData *data = [verifier dataUsingEncoding:NSUTF8StringEncoding];
CC_SHA256([data bytes], (CC_LONG)[data length], buffer);
NSData *hash = [NSData dataWithBytes:buffer length:CC_SHA256_DIGEST_LENGTH];
NSString *challenge = [[[[hash base64EncodedStringWithOptions:0]
                         stringByReplacingOccurrencesOfString:@"+" withString:@"-"]
                         stringByReplacingOccurrencesOfString:@"/" withString:@"_"]
                         stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"="]];
```

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

Une fois que vous avez créé le `code_verifier` et le `code_challenge`, vous devez obtenir l’autorisation de l’utilisateur. Il s’agit techniquement du début du <Tooltip tip="Flux d’autorisation : autorisation (ou séquence d’étapes) définie dans le cadre OAuth 2.0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=authorization+flow">flux d’autorisation</Tooltip>, et cette étape peut inclure un ou plusieurs des processus suivants :

* Authentifier l’utilisateur;
* Rediriger 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 prendre en charge l’authentification;
* Vérifier la présence de sessions [d’authentification unique (SSO)](/fr-CA/docs/authenticate/single-sign-on) actives;
* Obtenir le consentement de l’utilisateur pour le niveau d’accès demandé, à moins que ce consentement n’ait déjà été accordé.

Pour autoriser l’utilisateur, votre application doit le rediriger vers l’[URL d’autorisation](https://auth0.com/docs/api/authentication#authorization-code-grant-pkce-), en incluant le `code_challenge` généré à l’étape précédente ainsi que la méthode utilisée pour générer le `code_challenge`.

<div id="example-authorization-url">
  #### Exemple d’URL d’autorisation
</div>

export const codeExample1 = `https://{yourDomain}/authorize?
    response_type=code&
    code_challenge={codeChallenge}&
    code_challenge_method=S256&
    client_id={yourClientId}&
    redirect_uri={yourCallbackUrl}&
    scope=SCOPE&
    audience={apiAudience}&
    state={state}`;

<AuthCodeBlock children={codeExample1} language="http" />

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

Notez que, pour autoriser un utilisateur lors de l’appel à une API personnalisée, vous :

* devez inclure un paramètre <Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Appelée aud dans un jeton, sa valeur contient l’ID soit d’une application (ID client) pour un ID Token, soit 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

| Parameter Name          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `response_type`         | Indique le type d’identifiant qu’Auth0 renverra (`code` ou `token`). Pour ce flux, la valeur doit être `code`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `code_challenge`        | Défi généré à partir du `code_verifier`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `code_challenge_method` | Méthode utilisée pour générer le défi (par ex., S256). La spécification PKCE définit deux méthodes, `S256` et `plain` ; la première est utilisée dans cet exemple et est la **seule** prise en charge par Auth0, puisque la seconde est déconseillée.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `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).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `redirect_uri`          | L’URL vers laquelle Auth0 redirigera le navigateur une fois que l’utilisateur aura accordé l’autorisation. Le code d’autorisation sera disponible dans le paramètre d’URL `code`. Vous devez spécifier cette URL comme URL de callback valide dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).<br /><br />**Avertissement :** Conformément à la [spécification OAuth 2.0](https://tools.ietf.org/html/rfc6749#section-3.1.2), Auth0 supprime tout ce qui suit le dièse et ne prend *pas* en charge les fragments.                                                                                                                                                                                                                                                                                                                                                     |
| `scope`                 | Les [scopes](/fr-CA/docs/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 OpenID Connect (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 tout scope pris en charge par l’API cible (par ex., `read:contacts`). Incluez `offline_access` pour obtenir un [Jeton d’actualisation](/fr-CA/docs/glossary?term=Refresh+Token) (assurez-vous que le champ **Allow Offline Access** est activé dans les [paramètres de l’application](https://manage.auth0.com/#/apis)). |
| `audience`              | L’identifiant unique de l’API à laquelle votre application mobile 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `state`                 | (recommandé) Chaîne alphanumérique opaque et arbitraire que votre application ajoute à la requête initiale et qu’Auth0 inclut lors de la redirection vers votre application. Pour savoir comment utiliser cette valeur afin d’empêcher les attaques de falsification de requêtes intersites (CSRF), consultez [Mitigate CSRF Attacks With State Parameters](/fr-CA/docs/secure/attack-protection/state-parameters).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `organization`          | (facultatif) ID de l’organisation à utiliser lors de l’authentification d’un utilisateur. Si ce paramètre n’est pas fourni et que votre application est configurée pour **Display Organization Prompt**, l’utilisateur pourra saisir le nom de l’organisation au moment de l’authentification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `invitation`            | (facultatif) ID du ticket d’invitation de l’organisation. Lorsque vous [invitez un membre à une organisation](/fr-CA/docs/manage-users/organizations/configure-organizations/invite-members), votre application doit gérer l’acceptation de l’invitation en transmettant les paires clé-valeur `invitation` et `organization` lorsque l’utilisateur accepte l’invitation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

Par exemple, votre extrait HTML pour votre URL d’autorisation lors de l’appel à une API pourrait ressembler à ceci :

export const codeExample2 = `<a href="https://{yourDomain}/authorize?
  response_type=code&
  client_id={yourClientId}&
  code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&
  code_challenge_method=S256&
  redirect_uri={yourCallbackUrl}&
  scope=appointments%20contacts&
  audience=appointments:api&
  state=xyzABC123">
  Se connecter
</a>`;

<AuthCodeBlock children={codeExample2} language="html" />

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

Si tout se passe bien, vous recevrez une réponse `HTTP 302`. Le code d’autorisation se trouve à la fin de l’URL :

```http lines theme={null}
HTTP/1.1 302 Found
Location: {yourCallbackUrl}?code={authorizationCode}&state=xyzABC123
```

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

Maintenant que vous disposez d’un code d’autorisation, vous devez l’échanger contre des jetons. À l’aide du code d’autorisation extrait (`code`) à l’étape précédente, vous devrez envoyer une requête `POST` à l’[URL du jeton](https://auth0.com/docs/api/authentication#authorization-code-pkce-) en y joignant le `code_verifier`.

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

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oauth/token' \
    --header 'content-type: application/x-www-form-urlencoded' \
    --data grant_type=authorization_code \
    --data 'client_id={yourClientId}' \
    --data 'code_verifier={yourGeneratedCodeVerifier}' \
    --data 'code={yourAuthorizationCode}' \
    --data 'redirect_uri={https://yourApp/callback}'
  ```

  ```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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}", 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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}")

  	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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}")
    .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: 'authorization_code',
      client_id: '{yourClientId}',
      code_verifier: '{yourGeneratedCodeVerifier}',
      code: '{yourAuthorizationCode}',
      redirect_uri: '{https://yourApp/callback}'
    })
  };

  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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}",
    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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}"

  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=authorization_code&client_id={yourClientId}&code_verifier=%7ByourGeneratedCodeVerifier%7D&code=%7ByourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}"

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

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

| Nom du paramètre | Description                                                                                                                                                                                                                               |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez cette valeur sur « authorization\_code ».                                                                                                                                                                                      |
| `code_verifier`  | La clé aléatoire générée de façon cryptographiquement sécurisée à la première étape de ce tutoriel.                                                                                                                                       |
| `code`           | Le `authorization_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).                                                                   |
| `redirect_uri`   | L’URL de callback valide définie dans les paramètres de votre application. Elle doit correspondre exactement au `redirect_uri` envoyé à l’URL d’autorisation à l’étape précédente de ce tutoriel. Notez qu’elle doit être encodée en URL. |

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

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

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

[ID tokens](/fr-CA/docs/secure/tokens/id-tokens) contiennent des informations sur l’utilisateur qui doivent être décodées et extraites.

[Jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens) servent à appeler le [point de terminaison /userinfo de l’Authentication API d’Auth0](https://auth0.com/docs/api/authentication#get-user-info) ou une autre API. Si vous appelez votre propre API, la première chose à faire sera de [vérifier le jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens/validate-access-tokens).

[Jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) servent à obtenir un nouveau <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+token">jeton d’accès</Tooltip> ou un nouvel <Tooltip tip="ID Token : justificatif OpenID Connect, généralement sous la forme d’un JWT, utilisé pour transmettre l’identité de l’utilisateur au client." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+token">ID token</Tooltip> après l’expiration du précédent. Le `refresh_token` n’est 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écuritaire, puisqu’ils permettent à un utilisateur de rester authentifié essentiellement indéfiniment.
</Warning>

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

Pour appeler votre API depuis une application native ou mobile, l’application doit transmettre le Jeton d’accès récupéré comme jeton Bearer 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 {accessToken}' \
    --header 'content-type: application/json'
  ```

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

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

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

  func main() {

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

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

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

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

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

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

  }
  ```

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

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

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

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

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

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

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

  curl_close($curl);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vous pouvez utiliser le <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau jeton d’accès sans obliger les utilisateurs à se reconnecter." cta="Consulter le glossaire" href="/fr-CA/docs/glossary?term=Refresh+Token">Jeton d’actualisation</Tooltip> pour obtenir un nouveau jeton d’accès. En général, un utilisateur n’a besoin d’un nouveau jeton d’accès qu’après l’expiration du précédent ou lorsqu’il accède à une nouvelle ressource pour la première fois. Il est déconseillé d’appeler le point de terminaison pour obtenir un nouveau jeton d’accès chaque fois que vous appelez une API, et Auth0 applique des limites de débit qui limiteront le nombre de requêtes au point de terminaison pouvant être exécutées avec le même jeton depuis la même adresse IP.

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

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

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

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/token");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/x-www-form-urlencoded");
  request.AddParameter("application/x-www-form-urlencoded", "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{yourDomain}/oauth/token"

  	payload := strings.NewReader("grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")

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

  	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {'content-type': 'application/x-www-form-urlencoded'},
    data: new URLSearchParams({
      grant_type: 'refresh_token',
      client_id: '{yourClientId}',
      refresh_token: '{yourRefreshToken}'
    })
  };

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

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

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/oauth/token",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D",
    CURLOPT_HTTPHEADER => [
      "content-type: application/x-www-form-urlencoded"
    ],
  ]);

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

  curl_close($curl);

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

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

  conn = http.client.HTTPSConnection("")

  payload = "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"

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

  conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)

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

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

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

  url = URI("https://{yourDomain}/oauth/token")

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

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

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

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

| Nom du paramètre | Description                                                                                                                                                                                                                                  |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez-le sur `refresh_token`.                                                                                                                                                                                                           |
| `client_id`      | L’ID client de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                      |
| `refresh_token`  | Le jeton d’actualisation à utiliser.                                                                                                                                                                                                         |
| `scope`          | (facultatif) Liste des scopes demandés, délimitée par des espaces. S’il n’est pas envoyé, les scopes d’origine sont utilisés; sinon, vous pouvez demander un ensemble réduit de scopes. Notez que cette valeur doit être encodée dans l’URL. |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant un nouvel `access_token`, sa durée de vie en secondes (`expires_in`), les valeurs de `scope` accordées et `token_type`. Si le scope du jeton initial comprenait `openid`, la réponse inclura également un nouvel `id_token` :

```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, consultez [Valider les ID tokens](/fr-CA/docs/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens/validate-access-tokens).
</Warning>

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

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

Vous pouvez utiliser Actions pour modifier les scopes renvoyés par les jetons d’accès et/ou ajouter des revendications aux jetons d’accès et aux ID Tokens. (Pour en savoir plus sur Actions, consultez [Auth0 Actions](/fr-CA/docs/customize/actions). ) Pour ce faire, ajoutez l’Action suivante, qui s’exécutera après l’authentification de l’utilisateur :

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

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

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

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

<div id="view-sample-application-mobile-app-api">
  #### Consulter l’application exemple : application mobile + API
</div>

Pour un exemple d’implémentation, consultez le scénario d’architecture [Mobile + API](/fr-CA/docs/get-started/architecture-scenarios/mobile-api). Cette série de tutoriels s’accompagne d’un [exemple de code accessible sur GitHub](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets).

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