> ## 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. > Configuration de l’API et des applications mobiles pour le scénario d’architecture Applications mobiles + API # Configuration de l’API et des applications mobiles (Applications mobiles + API) 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 {processedChildren}; }; 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
{displayText}
; }; Dans cette section, nous verrons comment implémenter une API pour notre cas d’utilisation. Par souci de simplicité, notre implémentation portera uniquement sur l’authentification et l’autorisation. Comme vous le verrez dans les exemples, l’entrée de feuille de temps sera codée en dur, et l’API ne la conservera pas. Elle renverra simplement une partie des informations.
## Définir les points de terminaison de l’API
Nous devons d’abord définir les points de terminaison de notre API. Un **point de terminaison d’API** est une URL unique qui représente un objet. Pour interagir avec cet objet, votre application doit utiliser son URL. Par exemple, si vous aviez une API capable de renvoyer soit des commandes, soit des clients, vous pourriez configurer deux points de terminaison : `/orders` et `/customers`. Votre application interagirait avec ces points de terminaison au moyen de différentes méthodes HTTP ; par exemple, `POST /orders` pourrait créer une nouvelle commande, tandis que `GET /orders` pourrait récupérer les données d’une ou de plusieurs commandes. Pour cette implémentation, nous ne définirons que deux points de terminaison : l’un pour récupérer la liste de toutes les feuilles de temps d’un employé, et l’autre pour permettre à un employé de créer une nouvelle entrée de feuille de temps. Une requête `HTTP GET` vers le point de terminaison `/timesheets` permettra à un utilisateur de récupérer ses feuilles de temps, et une requête `HTTP POST` vers le point de terminaison `/timesheets` permettra à un utilisateur d’ajouter une nouvelle feuille de temps. Consultez l’implémentation dans [Node.js](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#1-define-the-api-endpoints)
### Sécuriser les points de terminaison
Lorsqu’une API reçoit une requête avec un jeton d’accès de type Bearer dans l’en-tête, la première chose à faire est de valider le jeton. Cela comprend une série d’étapes, et si l’une d’elles échoue, la requête doit être rejetée avec le message d’erreur `Missing or invalid token` renvoyé à l’application appelante. Les validations que l’API doit effectuer sont : * Vérifier que le JWT est bien formé * Vérifier la signature * Valider les revendications standard [JWT.io](https://jwt.io/) fournit une liste de bibliothèques pouvant effectuer l’essentiel du travail pour vous : analyser le JWT, vérifier la signature et les revendications. Le processus de validation comprend aussi la vérification des autorisations de l’application (scopes), mais nous traiterons cet aspect séparément dans le paragraphe suivant de ce document. Pour en savoir plus sur la validation des jetons d’accès, consultez [Valider les jetons d’accès](/fr-CA/docs/secure/tokens/access-tokens/validate-access-tokens). Consultez l’implémentation dans [Node.js](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#2-secure-the-api-endpoints)
### Vérifier les autorisations de l’application
À ce stade, nous avons vérifié que le JWT est valide. La dernière étape consiste à vérifier que l’application possède les autorisations requises pour accéder aux ressources protégées. Pour ce faire, l’API doit vérifier les [scopes](/fr-CA/docs/get-started/apis/scopes) du JWT décodé. Cette revendication fait partie de la charge utile et consiste en une liste de chaînes séparées par des espaces. Consultez l’implémentation dans [Node.js](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#3-check-the-client-permissions)
### Déterminer l’identité de l’utilisateur
Pour les deux points de terminaison (récupération de la liste des feuilles de temps et ajout d’une nouvelle feuille de temps), nous devons déterminer l’identité de l’utilisateur. Pour récupérer la liste des feuilles de temps, cela permet de s’assurer que nous renvoyons uniquement les feuilles de temps appartenant à l’utilisateur qui fait la requête. Pour ajouter une nouvelle feuille de temps, cela permet de s’assurer que la feuille de temps est associée à l’utilisateur qui fait la requête. L’une des revendications standard d’un JWT est la revendication `sub`, qui identifie le principal visé par la revendication. Dans le cas du flux Implicit Grant, cette revendication contient l’identité de l’utilisateur, c’est-à-dire l’identifiant unique de l’utilisateur Auth0. Vous pouvez l’utiliser pour associer à un utilisateur précis toute information stockée dans des systèmes externes. Vous pouvez aussi utiliser une revendication personnalisée pour ajouter un autre attribut de l’utilisateur, comme son adresse de courriel, au Jeton d’accès et vous en servir pour identifier l’utilisateur de façon unique. Consultez l’implémentation dans [Node.js](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#4-determine-the-user-identity)
## Implémenter l’application mobile
Dans cette section, nous verrons comment mettre en œuvre une application mobile dans notre scénario. [Voir l’implémentation sous Android.](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#1-set-up-the-application)
### Autoriser l’utilisateur
Pour autoriser l’utilisateur, nous allons implémenter le [Authorization Code Flow with Proof Key for Code Exchange (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). L’application mobile doit d’abord rediriger l’utilisateur vers l’[URL d’autorisation](https://auth0.com/docs/api/authentication#authorization-code-grant-pkce-) avec le `code_challenge` et la méthode utilisée pour le générer : export const codeExample1 = `https://{yourDomain}/authorize? audience=API_AUDIENCE& scope=SCOPE& response_type=code& client_id={yourClientId}& code_challenge=CODE_CHALLENGE& code_challenge_method=S256& redirect_uri=https://YOUR_APP/callback`; La requête `GET` vers l’URL d’autorisation doit inclure les valeurs suivantes : | Parameter | Description | | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **client\_id** | La valeur de votre ID client Auth0. Vous pouvez la trouver dans les paramètres de votre application dans l’[Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **audience** | La valeur de l’identifiant de votre API. Vous pouvez la trouver dans les paramètres de votre API dans l’[Auth0 Dashboard](https://manage.auth0.com/#/apis). | | **scope** | Les [scopes](/fr-CA/docs/get-started/apis/scopes) qui déterminent les revendications renvoyées dans l’ID Token et le jeton d’accès. Par exemple, le scope `openid` renverra un ID Token dans la réponse. Dans notre exemple d’application mobile, nous utilisons les scopes suivants : `create:timesheets read:timesheets openid profile email offline_access`. Ces scopes permettent à l’application mobile d’appeler l’API, d’obtenir un [Jeton d’actualisation](/fr-CA/docs/glossary?term=Refresh+Token) et de renvoyer les revendications `name`, `picture` et `email` de l’utilisateur dans l’ID Token. | | **response\_type** | Indique le flux d’authentification à utiliser. Pour une application mobile utilisant PKCE, cette valeur doit être définie sur `code`. | | **code\_challenge** | Le code challenge généré à partir du code verifier. Vous trouverez des instructions pour générer un code challenge [ici](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce#authorize-the-user%23create-a-code-verifier). | | **code\_challenge\_method** | Méthode utilisée pour générer le challenge. Auth0 prend uniquement en charge `S256`. | | **redirect\_uri** | L’URL vers laquelle Auth0 redirigera le navigateur une fois que l’utilisateur aura accordé l’autorisation. Le code d’autorisation sera disponible dans le paramètre d’URL `code`. Cette URL doit être indiquée comme URL de rappel valide dans les paramètres de votre [application](https://manage.auth0.com/#/applications). | [Voir l’implémentation sur Android.](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#2-authorize-the-user)
### Obtenez les identifiants
Après une requête réussie à l’URL d’autorisation, vous devriez recevoir la réponse suivante : export const codeExample2 = `HTTP/1.1 302 Found Location: https://{yourDomain}/callback?code=AUTHORIZATION_CODE`; Vous pouvez ensuite échanger l’`authorization_code` de la réponse contre un jeton d’accès que vous pourrez utiliser pour appeler votre API. Effectuez une requête `POST` à l’[URL du jeton](https://auth0.com/docs/api/authentication#authorization-code-pkce-) en incluant les données suivantes : ```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_verified=YOUR_GENERATED_CODE_VERIFIER \ --data code=YOUR_AUTHORIZATION_CODE \ --data 'redirect_uri=https://{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{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_verified: 'YOUR_GENERATED_CODE_VERIFIER', code: 'YOUR_AUTHORIZATION_CODE', redirect_uri: 'https://{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{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_verified=YOUR_GENERATED_CODE_VERIFIER&code=YOUR_AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2F{https://yourApp/callback}" response = http.request(request) puts response.read_body ``` | Paramètre | Description | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **grant\_type** | Cette valeur doit être définie à `authorization_code`. | | **client\_id** | La valeur de l’ID client Auth0 de votre application. Vous pouvez la récupérer dans les paramètres de votre application dans le [Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **code\_verifier** | Clé aléatoire générée de façon cryptographiquement sécurisée et utilisée pour générer le `code_challenge` transmis à l’[URL d’autorisation](https://auth0.com/docs/api/authentication#authorization-code-grant-pkce-) (`/authorize`). | | **code** | Le `authorization_code` reçu lors de l’appel précédent à `/authorize`. | | **redirect\_uri** | L’URL doit correspondre au `redirect_uri` transmis dans la section précédente à `/authorize`. | La réponse renvoyée par l’URL du jeton contiendra : ```json lines theme={null} { "access_token": "eyJz93a...k4laUWw", "refresh_token": "GEbRxBN...edjnXbL", "id_token": "eyJ0XAi...4faeEoQ", "token_type": "Bearer", "expires_in":86400 } ``` * **access\_token** : un Jeton d’accès pour l’API, défini par `audience`. * **refresh\_token** : un [Jeton d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) n’est présent que si vous avez inclus le scope `offline_access` ET activé **Allow Offline Access** pour votre API dans l’Auth0 Dashboard. * **id\_token** : un ID Token JWT contenant les renseignements de profil de l’utilisateur. * **token\_type** : une chaîne indiquant le type de jeton; il s’agit toujours d’un jeton Bearer. * **expires\_in** : le nombre de secondes avant l’expiration du Jeton d’accès. Vous devrez stocker les informations d’identification ci-dessus dans le stockage local afin de les utiliser pour appeler votre API et récupérer le profil de l’utilisateur. [Voir l’implémentation sur Android](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#store-credentials).
### Récupérer le profil de l’utilisateur
Pour récupérer le [profil de l’utilisateur](https://auth0.com/docs/api/authentication?http#user-profile), votre application mobile peut décoder le [ID Token](/fr-CA/docs/secure/tokens/id-tokens) à l’aide de l’une des [bibliothèques JWT](https://jwt.io/#libraries-io). Pour ce faire, vous devez [vérifier la signature](/fr-CA/docs/secure/tokens/id-tokens/validate-id-tokens#verify-the-signature) et [vérifier les revendications](/fr-CA/docs/secure/tokens/id-tokens/validate-id-tokens#verify-the-claims) du jeton. Après avoir validé l’ID Token, vous pouvez accéder à son payload, qui contient les renseignements sur l’utilisateur : ```json lines theme={null} { "email_verified": false, "email": "test.account@userinfo.com", "clientID": "q2hnj2iu...", "updated_at": "2016-12-05T15:15:40.545Z", "name": "test.account@userinfo.com", "picture": "https://s.gravatar.com/avatar/dummy.png", "user_id": "auth0|58454...", "nickname": "test.account", "created_at": "2016-12-05T11:16:59.640Z", "sub": "auth0|58454..." } ``` [Voir l’implémentation pour Android.](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#3-get-the-user-profile)
### Afficher conditionnellement des éléments de l’interface utilisateur selon le scope
Selon le `scope` de l’utilisateur, vous pourriez vouloir afficher ou masquer certains éléments de l’interface utilisateur. Pour déterminer le scope accordé à un utilisateur, vous devez examiner le `scope` qui lui a été octroyé au moment de l’authentification. Il s’agit d’une chaîne contenant tous les scopes; vous devez donc vérifier si elle contient le `scope` requis afin de décider s’il faut afficher un élément particulier de l’interface utilisateur. [Voir l’implémentation sur Android](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#4-display-ui-elements-conditionally-based-on-scope)
### Appeler l’API
Pour accéder aux ressources sécurisées de votre API, le Jeton d’accès de l’utilisateur authentifié doit être inclus dans les requêtes envoyées à l’API. Pour ce faire, envoyez le Jeton d’accès dans un en-tête `Authorization` à l’aide du schéma `Bearer`. [Voir l’implémentation sur Android.](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#5-call-the-api)
### Renouveler le jeton
Les jetons d’actualisation doivent être stockés de manière sécurisée par une application, puisqu’ils n’expirent pas et permettent à un utilisateur de rester authentifié pratiquement indéfiniment. Si des jetons d’actualisation sont compromis ou que vous n’en avez plus besoin, vous pouvez les révoquer au moyen de l’[Authentication API](https://auth0.com/docs/api/authentication#revoke-refresh-token). Pour actualiser votre Jeton d’accès, effectuez une requête `POST` au point de terminaison `/oauth/token` en utilisant le Jeton d’actualisation obtenu dans votre résultat d’autorisation. Un [Jeton d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) n’est présent que si vous avez inclus le scope `offline_access` dans la requête d’autorisation précédente et activé **Allow Offline Access** pour votre API dans l’Auth0 Dashboard. Votre requête doit inclure : ```bash cURL theme={null} curl --request POST \ --url 'https://{yourDomain}/oauth/token' \ --header 'content-type: application/x-www-form-urlencoded' ``` ```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"); IRestResponse response = client.Execute(request); ``` ```go Go theme={null} package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://{yourDomain}/oauth/token" req, _ := http.NewRequest("POST", url, nil) 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") .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'} }; 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_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("") headers = { 'content-type': "application/x-www-form-urlencoded" } conn.request("POST", "/{yourDomain}/oauth/token", headers=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' response = http.request(request) puts response.read_body ``` | Paramètre | Description | | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **grant\_type** | Doit être défini sur `refresh_token`. | | **client\_id** | La valeur de votre ID client Auth0. Vous pouvez l’obtenir dans les paramètres de votre application dans l’[Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **refresh\_token** | Le Jeton d’actualisation à utiliser, obtenu à partir du résultat d’authentification précédent. | La réponse inclura le nouveau Jeton d’accès : ```json lines theme={null} { "access_token": "eyJz93a...k4laUWw", "refresh_token": "GEbRxBN...edjnXbL", "id_token": "eyJ0XAi...4faeEoQ", "token_type": "Bearer", "expires_in":86400 } ``` [Consultez l’implémentation sur Android.](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#store-the-credentials)