> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Découvrez comment appeler votre propre API depuis des applications Web régulières à l’aide du flux de code d’autorisation.
# Appeler votre API à l’aide du flux de code d’autorisation
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}
;
};
export const codeExample1 = `https://{yourDomain}/authorize?
response_type=code&
client_id={yourClientId}&
redirect_uri={https://yourApp/callback}&
scope={scope}&
audience={apiAudience}&
state={state}`;
export const codeExample2 = `
Se connecter
`;
Ce tutoriel vous aidera à appeler votre propre API à l’aide du flux de code d’autorisation. Si vous voulez comprendre comment ce flux fonctionne et pourquoi vous devriez l’utiliser, consultez [Flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow). Si vous voulez apprendre à ajouter la connexion à votre application Web régulière, consultez [Ajouter la connexion à l’aide du flux de code d’autorisation](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/add-login-auth-code-flow).
Auth0 permet à votre application d’implémenter facilement le flux Authorization Code au moyen des options suivantes :
* [Guides de démarrage rapide pour les applications Web régulières](/fr-CA/docs/quickstart/webapp) : la façon la plus simple d’implémenter ce flux.
* [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.
## Prérequis
**Avant de commencer ce tutoriel :**
* [Enregistrez votre application auprès d’Auth0](/fr-CA/docs/get-started/auth0-overview/create-applications/regular-web-apps).
* Sélectionnez le **type d’application** **Applications Web régulières**.
* Ajoutez l’**URL de callback autorisée** `{https://yourApp/callback}`.
* Assurez-vous que les **types d’octroi** de votre application incluent **Authorization Code**. Pour savoir comment faire, consultez [Mettre à jour les types d’octroi](/fr-CA/docs/get-started/applications/update-grant-types).
* Si vous voulez que votre application puisse utiliser des [jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens), assurez-vous que les **types d’octroi** de l’application incluent **refresh token**. Pour savoir comment faire, consultez [Mettre à jour les types d’octroi](/fr-CA/docs/get-started/applications/update-grant-types). Pour en savoir plus sur les jetons d’actualisation, consultez [les jetons d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens).
* [Enregistrez votre API auprès d’Auth0](/fr-CA/docs/get-started/auth0-overview/set-up-apis)
* Si vous voulez que votre API reçoive des jetons d’actualisation afin d’obtenir de nouveaux jetons lorsque les précédents expirent, activez **Autoriser l’accès hors ligne**.
## Étapes
Cette étape peut inclure un ou plusieurs des processus suivants :
* Authentifier l’utilisateur
* Rediriger l’utilisateur vers un fournisseur d’identité pour gérer l’authentification
* Vérifier s’il existe des sessions d’authentification unique (SSO) actives
* Obtenir le consentement de l’utilisateur pour le niveau d’autorisation demandé, à moins qu’il n’ait déjà été accordé.
Pour autoriser l’utilisateur, votre application doit l’envoyer vers l’[URL d’autorisation](https://auth0.com/docs/api/authentication#authorization-code-grant).
#### Exemple d’URL d’autorisation
##### Paramètres
Notez que, pour autoriser un utilisateur lors de l’appel d’une API personnalisée, vous :
* devez inclure un paramètre audience
* pouvez inclure des scopes supplémentaires pris en charge par l’API cible
| Nom du paramètre | Description |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `response_type` | Indique le type de justificatif qu’Auth0 retournera (`code` ou `token`). Pour ce flux, la valeur doit être `code`. |
| `client_id` | L’ID client de votre application. Vous pouvez trouver cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `redirect_uri` | L’URL vers laquelle Auth0 redirigera le navigateur une fois l’autorisation accordée par l’utilisateur. Le code d’autorisation sera disponible dans le paramètre d’URL `code`. Vous devez spécifier cette URL comme URL de rappel valide dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings).
**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 ne tient *pas* compte des fragments. |
| `scope` | Précise les [scopes](/fr-CA/docs/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation, et qui déterminent les claims (ou attributs utilisateur) que vous souhaitez obtenir en retour. Ils doivent être séparés par un espace. Vous pouvez demander n’importe lequel des [scopes standards d’OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` ou `email`, des [claims personnalisées](/fr-CA/docs/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format avec espace de noms](/fr-CA/docs/secure/tokens/json-web-tokens/create-custom-claims), ou tout scope pris en charge par l’API cible (par exemple, `read:contacts`). Incluez `offline_access` pour obtenir un [Jeton d’actualisation](/fr-CA/docs/glossary?term=Refresh+Token) (assurez-vous que le champ **Allow Offline Access** est activé dans les [paramètres de l’application](https://manage.auth0.com/#/applications)). |
| `audience` | L’identifiant unique de l’API à laquelle votre application Web veut accéder. Utilisez la valeur **Identifiant** dans l’onglet [Settings](https://manage.auth0.com/#/apis) de l’API que vous avez créée dans le cadre des prérequis de ce tutoriel. |
| `state` | (recommandé) Une chaîne alphanumérique arbitraire 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 intersite (CSRF), consultez [Atténuer les attaques CSRF avec les paramètres state](/fr-CA/docs/secure/attack-protection/state-parameters). |
| `organization` | (facultatif) ID de l’organisation à utiliser lors de l’authentification d’un utilisateur. S’il n’est pas fourni et que votre application est configurée pour **Display Organization Prompt**, l’utilisateur pourra saisir le nom de l’organisation au moment de s’authentifier. |
| `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, l’extrait HTML de votre URL d’autorisation pour ajouter la connexion à votre application pourrait ressembler à ceci :
#### Réponse
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: {https://yourApp/callback}?code={authorizationCode}&state=xyzABC123
```
Maintenant que vous disposez d'un Authorization Code, vous devez l'échanger contre des jetons. À l'aide de l'Authorization Code (`code`) extrait à l'étape précédente, vous devrez effectuer un `POST` vers l'[URL du jeton](https://auth0.com/docs/api/authentication#authorization-code).
#### Exemple de POST vers l'URL du jeton
```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 'client_secret={yourClientSecret}' \
--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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%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}',
client_secret: '{yourClientSecret}',
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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%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}&client_secret=%7ByourClientSecret%7D&code=yourAuthorizationCode%7D&redirect_uri={https://yourApp/callback}"
response = http.request(request)
puts response.read_body
```
##### Paramètres
| Nom du paramètre | Description |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `grant_type` | Définissez-la à `authorization_code`. |
| `code` | Le `authorization_code` obtenu à l’étape précédente de ce tutoriel. |
| `client_id` | L’ID client de votre application. Vous pouvez trouver cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `client_secret` | Le Secret client de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). Pour en savoir plus sur les méthodes d’authentification d’application disponibles, consultez [Identifiants de l’application](/fr-CA/docs/secure/application-credentials). |
| `redirect_uri` | L’URL de callback valide définie dans les paramètres de l’application. Elle doit correspondre exactement au `redirect_uri` envoyé à l’URL d’autorisation à l’étape précédente de ce tutoriel. Notez qu’elle doit être URL-encodée. |
#### Réponse
Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant les valeurs `access_token`, `refresh_token`, `id_token` et `token_type` :
```json lines theme={null}
{
"access_token": "eyJz93a...k4laUWw",
"refresh_token": "GEbRxBN...edjnXbL",
"id_token": "eyJ0XAi...4faeEoQ",
"token_type": "Bearer"
}
```
Validez vos jetons avant de les enregistrer. Pour savoir comment procéder, 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).
[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 le [point de terminaison /userinfo de l'Authentication API Auth0](https://auth0.com/docs/api/authentication#get-user-info) ou une autre API. Si vous appelez votre propre API, la première chose que votre API devra faire est 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) permettent d'obtenir un nouveau jeton d'accès ou 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 le Auth0 Dashboard.
Les jetons d’actualisation doivent être stockés de manière sécuritaire, puisqu’ils permettent à un utilisateur de demeurer authentifié pratiquement indéfiniment.
Pour appeler votre API à partir d’une Application Web régulière, l’application doit transmettre le jeton d’accès récupéré dans l’en-tête Authorization de votre requête HTTP, sous forme de Bearer Token.
```bash cURL lines theme={null}
curl --request GET \
--url https://myapi.com/api \
--header 'authorization: Bearer {accessToken}' \
--header 'content-type: application/json'
```
```csharp C# lines theme={null}
var client = new RestClient("https://myapi.com/api");
var request = new RestRequest(Method.GET);
request.AddHeader("content-type", "application/json");
request.AddHeader("authorization", "Bearer {accessToken}");
IRestResponse response = client.Execute(request);
```
```go Go lines expandable theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://myapi.com/api"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("content-type", "application/json")
req.Header.Add("authorization", "Bearer {accessToken}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines theme={null}
HttpResponse response = Unirest.get("https://myapi.com/api")
.header("content-type", "application/json")
.header("authorization", "Bearer {accessToken}")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://myapi.com/api',
headers: {'content-type': 'application/json', authorization: 'Bearer {accessToken}'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```php PHP lines expandable theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://myapi.com/api",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: Bearer {accessToken}",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPSConnection("myapi.com")
headers = {
'content-type': "application/json",
'authorization': "Bearer {accessToken}"
}
conn.request("GET", "/api", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://myapi.com/api")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request["authorization"] = 'Bearer {accessToken}'
response = http.request(request)
puts response.read_body
```
Vous avez déjà reçu un [jeton d'actualisation](/fr-CA/docs/secure/tokens/refresh-tokens) si vous avez suivi ce tutoriel et complété les étapes suivantes :
* configuré votre API pour permettre l’accès hors ligne
* inclus le scope `offline_access` lorsque vous avez lancé la requête d’authentification au moyen du [point de terminaison authorize](https://auth0.com/docs/api/authentication/reference#authorize-application).
Vous pouvez utiliser le Jeton d'actualisation pour obtenir un nouveau jeton d'accès. En général, un utilisateur n'a besoin d'un nouveau jeton d'accès qu'après l'expiration du précédent ou lors du premier accès à une nouvelle ressource. Il est déconseillé d'appeler l'endpoint pour obtenir un nouveau jeton d'accès à chaque appel d'API ; Auth0 applique des limites de débit qui restreignent le nombre de requêtes pouvant être exécutées vers l'endpoint avec le même jeton depuis la même adresse IP.
Pour actualiser votre token, effectuez une requête `POST` au point de terminaison `/oauth/token` de l'Authentication API, avec `grant_type=refresh_token`.
##### Exemple de POST vers l'URL du jeton
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/x-www-form-urlencoded' \
--data grant_type=refresh_token \
--data 'client_id={yourClientId}' \
--data 'refresh_token={yourRefreshToken}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/oauth/token"
payload := strings.NewReader("grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/x-www-form-urlencoded")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java theme={null}
HttpResponse response = Unirest.post("https://{yourDomain}/oauth/token")
.header("content-type", "application/x-www-form-urlencoded")
.body("grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/oauth/token',
headers: {'content-type': 'application/x-www-form-urlencoded'},
data: new URLSearchParams({
grant_type: 'refresh_token',
client_id: '{yourClientId}',
refresh_token: '{yourRefreshToken}'
})
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```php PHP theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://{yourDomain}/oauth/token",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D",
CURLOPT_HTTPHEADER => [
"content-type: application/x-www-form-urlencoded"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python theme={null}
import http.client
conn = http.client.HTTPSConnection("")
payload = "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"
headers = { 'content-type': "application/x-www-form-urlencoded" }
conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://{yourDomain}/oauth/token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"
response = http.request(request)
puts response.read_body
```
###### Paramètres
| Nom du paramètre | Description |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type` | Réglez cette valeur sur `refresh_token`. |
| `client_id` | L’ID client de votre application. Vous trouverez cette valeur dans les [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `refresh_token` | Le jeton d’actualisation à utiliser. |
| `scope` | (facultatif) Une liste de scopes demandés séparés par des espaces. S’il n’est pas envoyé, les scopes d’origine seront utilisés; sinon, vous pouvez demander un ensemble réduit de scopes. Notez que cette valeur doit être encodée dans l’URL. |
###### Réponse
Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec un payload contenant un nouvel `access_token`, sa durée de vie en secondes (`expires_in`), les valeurs de `scope` octroyées et le `token_type`. Si le scope du jeton initial incluait `openid`, la réponse inclura également un nouvel `id_token` :
```json lines theme={null}
{
"access_token": "eyJ...MoQ",
"expires_in": 86400,
"scope": "openid offline_access",
"id_token": "eyJ...0NE",
"token_type": "Bearer"
}
```
Validez vos jetons avant de les enregistrer. Pour savoir comment procéder, 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).
### Exemples de cas d’utilisation
#### Personnaliser les jetons
Vous pouvez utiliser les Actions Auth0 pour modifier les scopes d’un jeton d’accès et/ou ajouter des revendications personnalisées aux jetons d’accès et aux ID tokens. Pour en savoir plus sur les Actions, consultez [Comprendre le fonctionnement des Actions Auth0.](/fr-CA/docs/customize/actions/actions-overview)
Pour ce faire, ajoutez l’Action Post-Login suivante, qui s’exécutera une fois l’utilisateur authentifié :
```js lines theme={null}
exports.onExecutePostLogin = async (event, api) => {
// Ajouter des revendications personnalisées au jeton d'accès et au jeton d'identité
api.accessToken.setCustomClaim('https://foo/bar', 'value');
api.idToken.setCustomClaim('https://fiz/baz', 'some other value');
// Modifier le scope du jeton d'accès
api.accessToken.addScope('foo');
api.accessToken.addScope('bar');
};
```
Auth0 renvoie les informations de profil sous forme de revendications structurées, comme le définit la [spécification OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Cela signifie que les revendications personnalisées ajoutées aux ID tokens ou aux jetons d’accès doivent [respecter les directives et restrictions](/fr-CA/docs/secure/tokens/json-web-tokens/create-custom-claims) afin d’éviter d’éventuelles collisions.
## En savoir plus
* [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)