> ## 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 du mobile pour le scénario d’architecture Mobile + API # Configuration de l’API et du mobile (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) + "*****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
{displayText}
; }; Dans cette section, nous verrons comment implémenter une API pour notre scénario. Par souci de simplicité, nous limiterons notre mise en œuvre à l’authentification et à l’autorisation. Comme vous le verrez dans les exemples, l’entrée de feuille de temps fournie en entrée sera codée en dur, et l’API n’enregistrera pas cette entrée. Elle se contentera plutôt de renvoyer une partie des informations.
## Définir les API points de terminaison
Nous devons d’abord définir les points de terminaison de notre API. Un **API point de terminaison** est une URL unique qui représente un objet. Pour interagir avec cet objet, votre application doit pointer vers 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 à l’aide de différentes méthodes HTTP; par exemple, `POST /orders` pourrait créer une nouvelle commande, ou `GET /orders` pourrait récupérer l’ensemble de données d’une ou de plusieurs commandes. Pour cette mise en œuvre, nous ne définirons que deux points de terminaison : un pour récupérer la liste de tous les timesheets d’un Employee, et un autre qui permettra à un Employee de créer une nouvelle timesheet entry. Une requête `HTTP GET` vers le point de terminaison `/timesheets` permettra à un utilisateur de récupérer ses timesheets, et une requête `HTTP POST` vers le point de terminaison `/timesheets` permettra à un utilisateur d’ajouter une nouvelle timesheet. Consultez la mise en œuvre dans [Node.js](/docs/fr-ca/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 porteur dans l’en-tête, la première chose à faire est de valider le jeton. Ce processus 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` à l’intention de l’application appelante. Les validations que l’API doit effectuer sont les suivantes : * Vérifier que le JWT est bien formé * Vérifier la signature * Valider les claims standard [JWT.io](https://jwt.io/) fournit une liste de bibliothèques qui peuvent faire l’essentiel du travail pour vous : analyser le JWT, vérifier la signature et les claims. Le processus de validation comprend aussi la vérification des permissions du client (scopes), mais nous y reviendrons 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](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens). Consultez la mise en œuvre dans [Node.js](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#2-secure-the-api-endpoints)
### Vérifier les permissions du client
À ce stade, nous avons vérifié que le JWT est valide. La dernière étape consiste à vérifier que le client dispose des permissions requises pour accéder aux ressources protégées. Pour ce faire, l’API doit vérifier les [scopes](/docs/fr-ca/get-started/apis/scopes) du JWT décodé. Ce claim fait partie du payload, et il s’agit d’une liste de chaînes séparées par des espaces. Voir la mise en œuvre dans [Node.js](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#3-check-the-client-permissions)
### Déterminer l’identité de l’utilisateur
Pour les deux endpoints (récupération de la liste des feuilles de temps et ajout d’une nouvelle feuille de temps), nous devrons déterminer l’identité de l’utilisateur. Pour récupérer la liste des feuilles de temps, cela permet de nous assurer que nous renvoyons uniquement les feuilles de temps qui appartiennent à l’utilisateur qui fait la requête; et pour ajouter une nouvelle feuille de temps, cela permet de nous assurer que la feuille de temps est associée à l’utilisateur qui fait la requête. L’une des claims standard d’un JWT est la claim `sub`, qui identifie le principal auquel la claim s’applique. Dans le cas du flux Implicit Grant, cette claim contiendra l’identité de l’utilisateur, c’est-à-dire l’identifiant unique de l’utilisateur Auth0. Vous pouvez vous en servir pour associer à un utilisateur particulier toute information stockée dans des systèmes externes. Vous pouvez également utiliser une custom claim pour ajouter un autre attribut de l’utilisateur — comme son adresse courriel — au jeton d’accès et vous en servir pour identifier l’utilisateur de façon unique. Consultez la mise en œuvre dans [Node.js](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs#4-determine-the-user-identity)
## Mettre en œuvre l’application mobile
Dans cette section, nous verrons comment mettre en œuvre une application mobile pour notre scénario. [Voir la mise en œuvre sur Android.](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#1-set-up-the-application)
### Autoriser l’utilisateur
Pour autoriser l’utilisateur, nous mettrons en œuvre le [flux de code d’autorisation avec clé de preuve pour l’échange de code (PKCE)](/docs/fr-ca/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 Auth0 Client Id. Vous pouvez la trouver dans les Settings de votre Application dans le [Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **audience** | La valeur de votre API Identifier. Vous pouvez la trouver dans les Settings de votre API dans le [Auth0 Dashboard](https://manage.auth0.com/#/apis). | | **scope** | Les [scopes](/docs/fr-ca/get-started/apis/scopes) qui déterminent les claims 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 application mobile d’exemple, nous utilisons les scopes suivants : `create:timesheets read:timesheets openid profile email offline_access`. Ces scopes permettent à l’application mobile d’effectuer une requête à l’API, d’obtenir un [Refresh Token](/docs/fr-ca/glossary?term=Refresh+Token) et de renvoyer les claims `name`, `picture` et `email` de l’utilisateur dans l’ID Token. | | **response\_type** | Indique le Authentication Flow à 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](/docs/fr-ca/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 en charge uniquement `S256`. | | **redirect\_uri** | L’URL vers laquelle Auth0 redirigera le navigateur une fois que l’utilisateur aura accordé l’autorisation. L’Authorization Code sera disponible dans le paramètre d’URL `code`. Cette URL doit être indiquée comme callback URL valide dans les [Settings de votre Application](https://manage.auth0.com/#/applications). | [Voir la mise en œuvre dans Android.](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#2-authorize-the-user)
### Obtenir les identifiants
Après avoir envoyé une requête à l’URL d’autorisation avec succès, vous devriez recevoir la réponse suivante : export const codeExample2 = `HTTP/1.1 302 Found Location: https://{yourDomain}/callback?code=AUTHORIZATION_CODE`; Ensuite, vous pouvez échanger l’`authorization_code` de la réponse contre un jeton d’accès qui peut être utilisé pour faire des requêtes à votre API. Effectuez une requête `POST` vers 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_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_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 sur `authorization_code`. | | **client\_id** | La valeur de votre Auth0 Client Id. Vous pouvez l’obtenir dans les Settings de votre Application, dans l’[Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **code\_verifier** | Clé aléatoire sécurisée sur le plan cryptographique qui a servi à 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 de la requête authorize précédente. | | **redirect\_uri** | L’URL doit correspondre au `redirect_uri` transmis dans la section précédente à `/authorize`. | La réponse de l’URL de 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, précisé par l’`audience`. * **refresh\_token**: un [Refresh Token](/docs/fr-ca/secure/tokens/refresh-tokens) ne sera présent que si vous avez inclus le scope `offline_access` ET activé **Allow Offline Access** pour votre API dans le Dashboard. * **id\_token**: un ID Token JWT contenant des renseignements du profil utilisateur. * **token\_type**: une chaîne indiquant le type de jeton; il s’agira toujours d’un jeton Bearer. * **expires\_in**: le nombre de secondes avant l’expiration du jeton d’accès. Vous devrez stocker les identifiants ci-dessus dans le stockage local afin de les utiliser pour appeler votre API et récupérer le profil utilisateur. [Voir la mise en œuvre sur Android](/docs/fr-ca/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](/docs/fr-ca/secure/tokens/id-tokens) à l’aide de l’une des [bibliothèques JWT](https://jwt.io/#libraries-io). Pour ce faire, il faut [vérifier la signature](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens#verify-the-signature) et [vérifier les claims](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens#verify-the-claims) du token. Après avoir validé l’ID Token, vous pouvez accéder à son payload, qui contient les renseignements de 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..." } ``` [Consultez la mise en œuvre sur Android.](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#3-get-the-user-profile)
### Afficher des éléments de l’interface utilisateur de façon conditionnelle 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 devrez examiner le `scope` qui lui a été accordé au moment de son authentification. Il s’agira d’une chaîne contenant tous les scopes; vous devrez donc l’examiner pour vérifier si elle contient le `scope` requis et décider, en conséquence, s’il faut afficher un élément particulier de l’interface utilisateur. [Voir la mise en œuvre sur Android](/docs/fr-ca/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 qui y sont envoyées. Pour ce faire, envoyez le jeton d’accès dans un en-tête `Authorization` en utilisant le schéma `Bearer`. [Voir la mise en œuvre sur Android.](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#5-call-the-api)
### Actualiser le jeton
Les Refresh Tokens 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 Refresh Tokens sont compromis ou si vous n’en avez plus besoin, vous pouvez les révoquer à l’aide de l’[Authentication API](https://auth0.com/docs/api/authentication#revoke-refresh-token). Pour actualiser votre jeton d’accès, envoyez une requête `POST` au point de terminaison `/oauth/token` à l’aide du Refresh Token obtenu dans votre résultat d’autorisation. Un [Refresh Token](/docs/fr-ca/secure/tokens/refresh-tokens) ne sera 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 le 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_PEER 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** | Ce paramètre doit être défini à `refresh_token`. | | **client\_id** | La valeur de votre Auth0 Client Id. Vous pouvez l’obtenir dans les Settings de votre Application dans l’[Auth0 Dashboard](https://manage.auth0.com/#/applications). | | **refresh\_token** | le Refresh Token à utiliser, provenant du résultat d’authentification précédent. | La réponse comprendra 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 } ``` [Voir la mise en œuvre sur Android.](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/mobile-implementation-android#store-the-credentials)