> ## 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 une application Native, mobile ou monopage à l’aide du flux de code d’autorisation avec la clé de preuve pour l’échange de code (PKCE).

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce tutoriel vous aide à 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 ce flux fonctionne et pourquoi vous devriez l’utiliser, consultez [Authorization Code Flow with Proof Key for Code Exchange (PKCE)](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce). Pour apprendre à ajouter la connexion à votre application native, mobile ou monopage, consultez [Add Login Using Authorization Code Flow with PKCE](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/add-login-using-the-authorization-code-flow-with-pkce).
</Callout>

Auth0 permet à votre application de mettre facilement en œuvre le flux de code d’autorisation avec clé de preuve pour l’échange de code (PKCE) à l’aide de :

* [Auth0 Mobile SDKs](/docs/fr-ca/libraries) et [Auth0 Single-Page App SDK](/docs/fr-ca/libraries/auth0-single-page-app-sdk) : la façon la plus simple de mettre en œuvre ce flux; ces outils feront l’essentiel du travail pour vous. Nos [Mobile Quickstarts](/docs/fr-ca/quickstart/native) et [Single-Page App Quickstarts](/docs/fr-ca/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 directement notre API.

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

**Avant de commencer ce tutoriel :**

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

  * Sélectionnez un **type d’application** **Native** ou **Single-Page App**, selon le type de votre application.
  * Ajoutez une **URL de rappel autorisée** : `{yourCallbackUrl}`. Le format de votre URL de rappel varie selon le type de votre application et votre plateforme. Pour en savoir plus sur le format correspondant à votre type d’application et à votre plateforme, consultez nos [Quickstarts Native/Mobile](/docs/fr-ca/quickstart/native) et [Quickstarts Single-Page App](/docs/fr-ca/quickstart/spa).
  * Assurez-vous que les **types d’octroi** de l’application comprennent **Code d’autorisation**. Pour savoir comment faire, consultez [Mettre à jour les type d’octroi](/docs/fr-ca/get-started/applications/update-grant-types).
  * Si vous voulez que votre application puisse utiliser des jetons d’actualisation, assurez-vous que les **types d’octroi** de l’application comprennent **Jeton d’actualisation**. Pour savoir comment faire, consultez [Mettre à jour les type d’octroi](/docs/fr-ca/get-started/applications/update-grant-types). Pour en savoir plus sur les jetons d’actualisation, consultez [Jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).
* [Enregistrez votre API dans Auth0](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/part-2#create-the-api)

  * Si vous voulez que votre API reçoive des jetons d’actualisation afin de pouvoir obtenir de nouveaux jetons lorsque les précédents expirent, activez **Allow Offline Access**.

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

1. [Créer le code verifier](#create-code-verifier):
   Générez un `code_verifier` qui sera envoyé à Auth0 pour demander des jetons.
2. [Créer le code challenge](#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 actuels expirent.

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

<div id="create-code-verifier">
  ### Créer le code\_verifier
</div>

Créez un `code_verifier`, soit une clé encodée en Base64 générée de façon cryptographiquement aléatoire, qui sera ensuite envoyée à Auth0 pour demander des jetons.

<div id="javascript-sample">
  #### Exemple en 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/
// Importez 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 pour 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 un code challenge
</div>

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

<div id="javascript-sample">
  #### Exemple en 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/
// Importation de 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. Techniquement, c’est le début du <Tooltip tip="Flux d’autorisation : grant d’autorisation (ou workflow) spécifié dans le framework OAuth 2.0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=authorization+flow">flux d’autorisation</Tooltip>, et cette étape peut comprendre 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="/docs/fr-ca/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> pour prendre en charge l’authentification;
* Vérifier s’il existe des sessions [d’authentification unique (SSO)](/docs/fr-ca/authenticate/single-sign-on) actives;
* Obtenir le consentement de l’utilisateur pour le niveau de permission 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 d’une requête vers une API personnalisée, vous :

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

| Parameter Name          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `response_type`         | Indique le type d’identifiant qu’Auth0 renverra (`code` ou `token`). Pour ce flow, la valeur doit être `code`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `code_challenge`        | Challenge généré à partir du `code_verifier`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `code_challenge_method` | Méthode utilisée pour générer le challenge (p. ex., S256). La spécification PKCE définit deux méthodes, `S256` et `plain`; la première est utilisée dans cet exemple et c’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 vos [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `redirect_uri`          | L’URL vers laquelle Auth0 redirigera le navigateur une fois l’autorisation accordée par l’utilisateur. Le Authorization Code sera disponible dans le paramètre d’URL `code`. Vous devez indiquer cette URL comme callback URL valide dans vos [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 tient *pas* compte des fragments.                                                                                                                                                                                                                                                                                                                               |
| `scope`                 | Les [scopes](/docs/fr-ca/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation. Ils doivent être séparés par un espace. Vous pouvez demander n’importe lequel des [scopes OpenID Connect (OIDC) standard](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` et `email`, des [custom claims](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format namespaced](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims), ou tout scope pris en charge par l’API cible (p. ex., `read:contacts`). Incluez `offline_access` pour obtenir un [Refresh Token](/docs/fr-ca/glossary?term=Refresh+Token) (assurez-vous que le champ **Allow Offline Access** est activé dans les [paramètres de l’application](https://manage.auth0.com/#/apis)). |
| `audience`              | L’identifiant unique de l’API à laquelle votre application mobile souhaite 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 request initiale et qu’Auth0 inclut lors de la redirection vers votre application. Pour savoir comment utiliser cette valeur afin de prévenir les attaques de falsification de requête intersites (CSRF), consultez [Mitigate CSRF Attacks With State Parameters](/docs/fr-ca/secure/attack-protection/state-parameters).                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `organization`          | (facultatif) ID de l’organisation à utiliser lors de l’authentification d’un utilisateur. Si aucune valeur n’est fournie et que votre application est configurée pour **Display Organization Prompt**, l’utilisateur pourra saisir le nom de l’organisation lors de l’authentification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `invitation`            | (facultatif) Ticket ID de l’invitation à l’organisation. Lorsque vous [invitez un membre à une Organization](/docs/fr-ca/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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

À titre d’exemple, l’extrait HTML de votre authorization URL lors d’une requête à 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 figure à 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 avez un Authorization Code, vous devez l’échanger contre des jetons. À l’aide de l’Authorization Code (`code`) extrait à l’étape précédente, vous devrez envoyer une requête `POST` au [URL du jeton](https://auth0.com/docs/api/authentication#authorization-code-pkce-) en y joignant le `code_verifier`.

#### Exemple de requête POST au 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_PEER

  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é générée aléatoirement de façon cryptographiquement sûre à la première étape de ce tutoriel.                                                                                                                                              |
| `code`           | Le `authorization_code` obtenu à l’étape précédente de ce tutoriel.                                                                                                                                                                             |
| `client_id`      | L’ID client de votre application. Vous trouverez cette valeur dans vos [Paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).                                                                         |
| `redirect_uri`   | L’URL de rappel valide définie dans les paramètres de votre application. Elle doit correspondre exactement au `redirect_uri` transmis à l’URL d’autorisation à l’étape précédente de ce tutoriel. Notez qu’elle doit être encodée dans une 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 le jeton d’identité](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
</Warning>

Les [jetons d’identité](/docs/fr-ca/secure/tokens/id-tokens) contiennent des renseignements sur l’utilisateur qui doivent être décodés puis extraits.

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

Les [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) servent à obtenir un nouveau <Tooltip tip="Jeton d’accès : information d’identification d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+token">jeton d’accès</Tooltip> ou <Tooltip tip="Jeton d’accès : information d’identification d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+token">jeton d’identité</Tooltip> après l’expiration du précédent. 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 le 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-api">
  ### Appeler l’API
</div>

Pour appeler votre API depuis une application native/mobile, l’application doit transmettre le jeton d’accès obtenu 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_PEER

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

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

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

Vous avez déjà reçu un [jeton d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) si vous 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 requête d’authentification par le [point de terminaison `authorize`](https://auth0.com/docs/api/authentication/reference#authorize-application).

Vous pouvez utiliser le <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau jeton d’accès sans obliger les utilisateurs à se connecter de nouveau." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Refresh+Token">Refresh Token</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 n’est pas recommandé d’appeler le point de terminaison pour obtenir un nouveau jeton d’accès chaque fois que vous faites une requête à une API, et Auth0 applique des limites de débit qui restreignent le nombre de requêtes au point de terminaison pouvant être exécutées avec le même jeton à partir de la même adresse IP.

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

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

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

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

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

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

  func main() {

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

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

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

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

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

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

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

  }
  ```

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

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

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

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

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

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

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

  curl_close($curl);

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

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

  conn = http.client.HTTPSConnection("")

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

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

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

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

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

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

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

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

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

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

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

| Nom du paramètre | Description                                                                                                                                                                                                                                                       |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type`     | Définissez cette valeur sur `refresh_token`.                                                                                                                                                                                                                      |
| `client_id`      | 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) Une liste des portées demandées, séparées par des espaces. Si ce paramètre n’est pas envoyé, les portées d’origine seront utilisées; sinon, vous pouvez demander un ensemble réduit de portées. Notez que cette valeur doit être encodée pour l’URL. |

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

Si tout se passe bien, vous recevrez une réponse `HTTP 200` dont la charge utile contient un nouvel `access_token`, sa durée de validité en secondes (`expires_in`), les valeurs de `scope` accordées, ainsi que `token_type`. Si la portée du token 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 les valider, consultez [Valider le jeton d’identité](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
</Warning>

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

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

Vous pouvez utiliser les Actions pour modifier les scopes renvoyés dans les Access Tokens et/ou ajouter des claims aux Access Tokens et aux ID Tokens. (Pour en savoir plus sur les Actions, consultez [Auth0 Actions](/docs/fr-ca/customize/actions). ) Pour ce faire, ajoutez l’Action suivante, qui s’exécutera une fois l’utilisateur authentifié :

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

  // Modifier la portée 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 claims structurés, comme le définit la [spécification OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Cela signifie que les custom claims ajoutées aux ID tokens ou aux jetons d’accès doivent [respecter les directives et les restrictions](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims) afin d’éviter d’éventuelles collisions.
</Warning>

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

Pour un exemple de mise en œuvre, consultez le scénario d’architecture [Mobile + API](/docs/fr-ca/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](/docs/fr-ca/authenticate/protocols/oauth)
* [Protocole OpenID Connect](/docs/fr-ca/authenticate/protocols/openid-connect-protocol)
* [Jetons](/docs/fr-ca/secure/tokens)