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

# Ajouter une fonctionnalité de connexion à 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>;
};

Vous pouvez ajouter la connexion à votre 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 [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 savoir comment appeler votre API à partir d’une application native, mobile ou monopage, consultez [Appeler votre API à l’aide du flux de code d’autorisation avec PKCE](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce).

Pour implémenter le flux de code d’autorisation avec Proof Key for Code Exchange (PKCE), vous pouvez utiliser les ressources 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 le flux; ils se chargent de la majeure partie du travail pour vous. Nos [guides de démarrage rapide pour appareils mobiles](/fr-CA/docs/quickstart/native) et [guides de démarrage rapide 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 directement notre API.

Après une connexion réussie, votre application aura accès au <Tooltip tip="ID Token : Informations d’identification destinées à l’application cliente elle-même, plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+token">jeton d’identité</Tooltip> et au <Tooltip tip="ID Token : Informations d’identification destinées à l’application cliente elle-même, plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+token">jeton d’accès</Tooltip> de l’utilisateur. Le jeton d’identité contiendra les renseignements de base du profil utilisateur, et le jeton d’accès peut servir à appeler le point de terminaison `/userinfo` d’Auth0 ou vos propres API protégées. Pour en savoir plus sur les ID tokens, consultez [ID Tokens](/fr-CA/docs/secure/tokens/id-tokens). Pour en savoir plus sur les jetons d’accès, consultez [Access Tokens](/fr-CA/docs/secure/tokens/access-tokens).

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

Enregistrez votre application dans Auth0. Pour en savoir plus, consultez [Enregistrer des applications natives](/fr-CA/docs/get-started/auth0-overview/create-applications/native-apps) ou [Enregistrer des applications Web monopages](/fr-CA/docs/get-started/auth0-overview/create-applications/single-page-web-apps).

* Sélectionnez un **Type d’application** de **Native** ou **Application monopage**, selon le type de votre application.
* Ajoutez `YOUR_CALLBACK_URL` comme **URL de rappel autorisée**. Le format de votre URL de rappel varie selon le type et la plateforme de votre application. Pour plus de détails sur le format correspondant à votre type d’application et à votre plateforme, consultez nos [guides de démarrage rapide Native/Mobile](/fr-CA/docs/quickstart/native) et [guides de démarrage rapide Application monopage](/fr-CA/docs/quickstart/spa).
* Assurez-vous que les **Types d’octroi** de votre application incluent **Code d’autorisation**. Pour en savoir plus, consultez [Mettre à jour les types d’octroi](/fr-CA/docs/get-started/applications/update-grant-types).

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

Créez un `code_verifier`, c’est-à-dire une clé aléatoire cryptographiquement sécurisée, encodée en Base64, qui sera ensuite envoyée à Auth0 pour demander des jetons.

Pour en savoir plus sur l’algorithme utilisé pour créer le `code_verifier`, consultez la section [4.1 Client Creates a Code Verifier](https://datatracker.ietf.org/doc/html/rfc7636#section-4.1) de la spécification <Tooltip tip="OAuth 2.0 : Cadre d’autorisation qui définit les protocoles et les flux d’autorisation." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=OAuth">OAuth</Tooltip> Proof Key for Code Exchange.

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

```javascript 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 pour Android
</div>

```javascript 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.encodeToString(code, Base64.URL_SAFE | Base64.NO_WRAP | Base64.NO_PADDING);
```

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

```javascript 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 code challenge
</div>

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

Pour en savoir plus sur la façon dont le `code_challenge` est généré à partir du `code_verifier`, consultez la section [4.2 Le client crée le code challenge](https://datatracker.ietf.org/doc/html/rfc7636#section-4.) de la spécification OAuth Proof Key for Code Exchange.

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

Demandez l’autorisation de l’utilisateur et redirigez-le vers votre application avec un `authorization_code`.

Une fois le `code_verifier` et le `code_challenge` créés, vous devez obtenir l’autorisation de l’utilisateur. Techniquement, c’est le début du <Tooltip tip="Flux d’autorisation : octroi d’autorisation (ou flux de travail) défini 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 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="/fr-CA/docs/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)](/fr-CA/docs/authenticate/single-sign-on) actives;
* Obtenir le consentement de l’utilisateur pour le niveau d’autorisation demandé, sauf s’il a 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 le générer.

<div id="authorization-url-example">
  ### 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}&
    state={state}`;

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

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

| 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 c’est la **seule** qu’Auth0 prend en charge, 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 code d’autorisation sera disponible dans le paramètre d’URL `code`. Vous devez indiquer cette URL comme URL de rappel 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 hash et ignore les fragments.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `scope`                 | Précise les [scopes](/fr-CA/docs/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation, ce qui détermine quelles claims (ou quels attributs utilisateur) vous voulez voir renvoyés. Ils doivent être séparés par un espace. Pour obtenir un ID Token dans la réponse, vous devez préciser au minimum le scope `openid`. Si vous souhaitez renvoyer le profil complet de l’utilisateur, vous pouvez demander `openid profile`. 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 `email`, ou des [custom claims](/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). 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/#/applications)). |
| `state`                 | (recommandé) Chaîne alphanumérique arbitraire et opaque 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 de prévenir les attaques de falsification de requête intersites (CSRF), consultez [Mitigate CSRF Attacks With State Parameters](/fr-CA/docs/secure/attack-protection/state-parameters).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `connection`            | (facultatif) Force l’utilisateur à se connecter avec une connexion précise. Par exemple, vous pouvez transmettre la valeur `github` pour envoyer directement l’utilisateur vers GitHub afin qu’il se connecte avec son compte GitHub. Lorsqu’elle n’est pas précisée, l’utilisateur voit l’écran Auth0 Lock avec toutes les connexions configurées. Vous pouvez voir la liste de vos connexions configurées dans l’onglet **Connections** de votre application.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `organization`          | (facultatif) ID de l’organisation à utiliser lors de l’authentification d’un utilisateur. Lorsqu’il n’est pas fourni, si 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’ajout de la connexion à votre application pourrait ressembler à ceci :

export const codeExample2 = `<a href="https://{yourDomain}/authorize?
  response_type=code&
  code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM&
  code_challenge_method=S256&
  client_id={yourClientId}&
  redirect_uri={yourCallbackUrl}&
  scope=openid%20profile&
  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 est inclus à la fin de l’URL :

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

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

Échangez votre `authorization_code` et votre `code_verifier` contre des jetons.

Maintenant que vous avez 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-) avec le `code_verifier`.

<div id="post-to-token-url-example">
  ### 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=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 manière cryptographiquement sûre à 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 rappel valide configurée 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 au format URL. |

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

Si tout se passe bien, vous recevrez une réponse HTTP 200 avec un payload qui contient 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>

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

Les [jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens) servent à appeler l’[endpoint /userinfo de l’Auth0 Authentication API](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](/fr-CA/docs/secure/tokens/access-tokens/validate-access-tokens).

Les [jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) servent à obtenir un nouveau jeton d’accès ou un jeton d’identité 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 l’Auth0 Dashboard.

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

<div id="use-cases">
  ## Cas d’utilisation
</div>

<div id="basic-authentication-request">
  ### Requête d’authentification de base
</div>

Cet exemple montre la requête la plus élémentaire que vous pouvez effectuer lors de l’autorisation de l’utilisateur à l’étape 1. Il affiche l’écran de connexion d’Auth0 et permet à l’utilisateur de se connecter à l’aide de n’importe laquelle de vos connexions configurées :

export const codeExample13 = `https://{yourDomain}/authorize?
    response_type=code&
    code_challenge={codeChallenge}&
    code_challenge_method=S256&
    client_id={yourClientId}&
    redirect_uri={yourCallbackUrl}&
    scope=openid`;

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

Maintenant, lorsque vous demanderez des jetons, votre ID Token contiendra les claims de base. Lorsque vous décoderez l’ID Token, il ressemblera à ceci :

```json lines theme={null}
{
  "iss": "https://auth0pnp.auth0.com/",
  "sub": "auth0|581...",
  "aud": "xvt9...",
  "exp": 1478112929,
  "iat": 1478076929
}
```

<div id="request-users-name-and-profile-picture">
  ### Demander le nom et la photo de profil de l’utilisateur
</div>

En plus de l’authentification standard de l’utilisateur, cet exemple montre comment demander des renseignements supplémentaires, comme son nom et sa photo.

Pour demander le nom et la photo de l’utilisateur, vous devez ajouter les scopes appropriés lorsque vous autorisez l’utilisateur :

export const codeExample14 = `https://{yourDomain}/authorize?
    response_type=code&
    code_challenge={codeChallenge}&
    code_challenge_method=S256&
    client_id={yourClientId}&
    redirect_uri={yourCallbackUrl}&
    scope=openid%20name%20picture&
    state={state}`;

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

Désormais, lorsque vous demanderez des jetons, votre jeton d’identité contiendra les claims `name` et `picture` demandées. Lorsque vous décoderez le jeton d’identité, il ressemblera à ceci :

```json lines theme={null}
{
  "name": "auth0user@...",
  "picture": "https://example.com/profile-pic.png",
  "iss": "https://auth0user.auth0.com/",
  "sub": "auth0|581...",
  "aud": "xvt...",
  "exp": 1478113129,
  "iat": 1478077129
}
```

<div id="request-user-log-in-with-github">
  ### Demander à l’utilisateur de se connecter avec GitHub
</div>

En plus de l’authentification habituelle des utilisateurs, cet exemple montre comment rediriger les utilisateurs directement vers un fournisseur d’identité social, comme GitHub. Pour que cet exemple fonctionne, vous devez aller à [Auth0 Dashboard > Authentification > Social](https://manage.auth0.com/#/connections/social) et configurer la connexion appropriée. Relevez le nom de la connexion dans l’onglet **Settings**.

Pour envoyer les utilisateurs directement à l’écran de connexion de GitHub, vous devez transmettre le paramètre `connection` et définir sa valeur sur le nom de la connexion (dans ce cas, `github`) au moment d’autoriser l’utilisateur :

export const codeExample15 = `https://{yourDomain}/authorize?
    response_type=code&
    code_challenge={codeChallenge}&
    code_challenge_method=S256&
    client_id={yourClientId}&
    redirect_uri={yourCallbackUrl}&
    scope=openid%20name%20picture&
    state={state}&
    connection=github`;

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

Désormais, lorsque vous demanderez des jetons, votre jeton d’identité contiendra une revendication `sub` avec l’identifiant unique de l’utilisateur renvoyé par GitHub. Lorsque vous décoderez le jeton d’identité, il ressemblera à ceci :

```json lines theme={null}
{
  "name": "John Smith",
  "picture": "https://avatars.example.com",
  "email": "jsmith@...",
  "email_verified": true,
  "iss": "https://auth0user.auth0.com/",
  "sub": "github|100...",
  "aud": "xvt...",
  "exp": 1478114742,
  "iat": 1478078742
}
```

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