> ## 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 traditionnelles à 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) + "*****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}
;
};
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 souhaitez comprendre le fonctionnement de ce flux et pourquoi vous devriez l’utiliser, consultez [flux de code d’autorisation](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow). Si vous souhaitez apprendre à ajouter une fonctionnalité de connexion à votre application web traditionnelle, consultez [Add Login Using the flux de code d’autorisation](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow/add-login-auth-code-flow).
Auth0 permet à votre application d’implémenter facilement le flux de code d’autorisation à l’aide de :
* [Quickstarts pour les applications web traditionnelles](/docs/fr-ca/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 dans Auth0](/docs/fr-ca/get-started/auth0-overview/create-applications/regular-web-apps).
* Sélectionnez le **Type d’application** **Regular Web Apps**.
* Ajoutez l’**URL de rappel autorisée** `{https://yourApp/callback}`.
* Assurez-vous que les **Types d’octroi** de votre application incluent le **Code d’autorisation**. Pour savoir comment faire, consultez [Mettre à jour les types d’octroi](/docs/fr-ca/get-started/applications/update-grant-types).
* Si vous voulez que votre application puisse utiliser des [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens), assurez-vous que les **Types d’octroi** de l’application incluent le **jeton d’actualisation**. Pour savoir comment faire, consultez [Mettre à jour les types d’octroi](/docs/fr-ca/get-started/applications/update-grant-types). Pour en savoir plus sur les jetons d’actualisation, consultez [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).
* [Enregistrez votre API dans Auth0](/docs/fr-ca/get-started/auth0-overview/set-up-apis)
* Si vous voulez que votre API reçoive des jetons d’actualisation pour pouvoir obtenir de nouveaux jetons lorsque les précédents expirent, activez **Allow Offline Access**.
## É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 la présence de sessions actives d’authentification unique (SSO)
* Obtenir le consentement de l’utilisateur pour le niveau de permission demandé, sauf si ce consentement a déjà été accordé.
Pour autoriser l’utilisateur, votre application doit rediriger l’utilisateur 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 d’identifiant qu’Auth0 renverra (`code` ou `token`). Pour ce flux, la valeur doit être `code`. |
| `client_id` | Le Client ID 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 vers laquelle Auth0 redirigera le navigateur une fois que l’autorisation aura été 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).
**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 prend *pas* en charge les fragments. |
| `scope` | Précise les [scopes](/docs/fr-ca/get-started/apis/scopes) pour lesquels vous souhaitez demander une autorisation, lesquels déterminent quelles claims (ou quels attributs utilisateur) vous souhaitez voir renvoyés. Ceux-ci doivent être séparés par une espace. Vous pouvez demander n’importe lequel des [scopes OpenID Connect (OIDC) standard](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` ou `email`, des [claims personnalisées](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format avec espace de noms](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims), ou tout scope pris en charge par l’API cible (p. ex. `read:contacts`). Incluez `offline_access` pour obtenir un [Refresh Token](/docs/fr-ca/glossary?term=Refresh+Token) (assurez-vous que le champ **Allow Offline Access** est activé dans les [Paramètres de l’application](https://manage.auth0.com/#/applications)). |
| `audience` | L’identifiant unique de l’API à laquelle votre application web veut accéder. Utilisez la valeur **Identifier** dans l’onglet [Paramètres](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 voir comment utiliser cette valeur afin de prévenir les attaques de falsification de requêtes intersites (CSRF), consultez [Mitiger les attaques CSRF avec les paramètres d’état](/docs/fr-ca/secure/attack-protection/state-parameters). |
| `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 à l’organisation. Lorsque vous [invitez un membre dans une organisation](/docs/fr-ca/manage-users/organizations/configure-organizations/invite-members), votre application doit gérer l’acceptation de l’invitation en transmettant les paires clé-valeur `invitation` et `organization` lorsque l’utilisateur accepte l’invitation. |
Par exemple, l’extrait HTML de votre URL d’autorisation pourrait ressembler à ceci lorsque vous ajoutez la connexion à votre application :
#### 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 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 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_PEER
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` | Réglez ce paramètre à `authorization_code`. |
| `code` | Le `authorization_code` récupéré à l’étape précédente de ce tutoriel. |
| `client_id` | Le Client ID de votre application. Vous trouverez 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](/docs/fr-ca/secure/application-credentials). |
| `redirect_uri` | L’URL de rappel valide définie dans les paramètres de votre application. Elle doit correspondre exactement au `redirect_uri` transmis à l’URL d’autorisation à l’étape précédente de ce tutoriel. Notez qu’elle doit être encodée pour une URL. |
#### Réponse
Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec une charge utile 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, consultez [Valider les jetons d’identité](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
[Les jetons d'ID](/docs/fr-ca/secure/tokens/id-tokens) contiennent des informations sur l'utilisateur qui doivent être décodées et extraites.
Les [jetons d'accès](/docs/fr-ca/secure/tokens/access-tokens) sont utilisés pour appeler le [point de terminaison /userinfo de l'API d'authentification Auth0](https://auth0.com/docs/api/authentication#get-user-info) ou une autre API. Si vous appelez votre propre API, la première chose que votre API devra faire est de [vérifier le jeton d'accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
[Les jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) servent à obtenir un nouveau jeton d’accès ou un jeton d’ID après l’expiration du précédent. Le `refresh_token` ne sera présent dans la réponse que si vous avez inclus la portée `offline_access` et activé **Allow Offline Access** pour votre API dans le tableau de bord.
Les jetons d’actualisation doivent être stockés de façon sécurisée, puisqu’ils permettent à un utilisateur de rester authentifié pratiquement indéfiniment.
Pour appeler votre API à partir d’une application Web traditionnelle, l’application doit transmettre le jeton d’accès récupéré comme jeton Bearer dans l’en-tête Authorization de votre requête HTTP.
```bash cURL lines theme={null}
curl --request GET \
--url https://myapi.com/api \
--header 'authorization: Bearer {accessToken}' \
--header 'content-type: application/json'
```
```csharp C# lines theme={null}
var client = new RestClient("https://myapi.com/api");
var request = new RestRequest(Method.GET);
request.AddHeader("content-type", "application/json");
request.AddHeader("authorization", "Bearer {accessToken}");
IRestResponse response = client.Execute(request);
```
```go Go lines expandable theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://myapi.com/api"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("content-type", "application/json")
req.Header.Add("authorization", "Bearer {accessToken}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines theme={null}
HttpResponse response = Unirest.get("https://myapi.com/api")
.header("content-type", "application/json")
.header("authorization", "Bearer {accessToken}")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://myapi.com/api',
headers: {'content-type': 'application/json', authorization: 'Bearer {accessToken}'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```php PHP lines expandable theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://myapi.com/api",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: Bearer {accessToken}",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPSConnection("myapi.com")
headers = {
'content-type': "application/json",
'authorization': "Bearer {accessToken}"
}
conn.request("GET", "/api", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://myapi.com/api")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_PEER
request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request["authorization"] = 'Bearer {accessToken}'
response = http.request(request)
puts response.read_body
```
Vous avez déjà reçu un [jeton d'actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) si vous avez suivi ce tutoriel et complété ce qui suit :
* configuré votre API pour permettre l’accès hors ligne
* inclus la portée `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 Refresh Token pour obtenir un nouveau jeton d'accès. En général, un utilisateur n'aura besoin d'un nouveau jeton d'accès qu'après l'expiration du précédent ou lors de l'accès à une nouvelle ressource pour la première fois. Il est déconseillé d'envoyer une requête à l'endpoint pour obtenir un nouveau jeton d'accès chaque fois que vous effectuez une requête vers une API. Auth0 applique des limites de débit qui restreignent le nombre de requêtes vers l'endpoint pouvant être exécutées avec le même jeton depuis la même adresse IP.
Pour actualiser votre jeton, effectuez une requête `POST` vers le point de terminaison `/oauth/token` de l’API d’authentification, en utilisant `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_PEER
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "grant_type=refresh_token&client_id={yourClientId}&refresh_token=%7ByourRefreshToken%7D"
response = http.request(request)
puts response.read_body
```
###### Paramètres
| Nom du paramètre | Description |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grant_type` | Réglez cette valeur sur `refresh_token`. |
| `client_id` | Le Client ID de votre application. Vous trouverez cette valeur dans [Application Settings](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `refresh_token` | Le jeton d’actualisation à utiliser. |
| `scope` | (facultatif) Une liste des portées demandées, séparées par des espaces. Si ce paramètre n’est pas envoyé, les portées d’origine seront utilisées ; sinon, vous pouvez demander un sous-ensemble de portées. Notez que ce paramètre doit être encodé dans l’URL. |
###### Réponse
Si tout se passe bien, vous recevrez une réponse `HTTP 200` avec une charge utile contenant un nouvel `access_token`, sa durée de vie en secondes (`expires_in`), les valeurs de `scope` accordées et le `token_type`. Si le scope du jeton initial incluait `openid`, la réponse comprendra é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, consultez [Valider les jetons d’identité](/docs/fr-ca/secure/tokens/id-tokens/validate-id-tokens) et [Valider les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/validate-access-tokens).
### Exemples de scénarios d’utilisation
#### Personnaliser les jetons
Vous pouvez utiliser Auth0 Actions pour modifier les scopes d’un jeton d’accès et/ou ajouter des claims personnalisées aux jetons d’accès et aux jetons d’identification. Pour en savoir plus sur Auth0 Actions, consultez [Comprendre le fonctionnement d’Auth0 Actions.](/docs/fr-ca/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 la portée du jeton d'accès
api.accessToken.addScope('foo');
api.accessToken.addScope('bar');
};
```
Auth0 renvoie les informations du profil dans un format de claim structuré, tel que défini par la [spécification OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims). Cela signifie que les claims personnalisés ajoutés aux ID tokens ou aux jetons d’accès doivent [respecter les directives et les restrictions](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims) afin d’éviter d’éventuels conflits.
## En savoir plus
* [Cadre d’autorisation OAuth 2.0](/docs/fr-ca/authenticate/protocols/oauth)
* [Protocole OpenID Connect](/docs/fr-ca/authenticate/protocols/openid-connect-protocol)
* [Jetons](/docs/fr-ca/secure/tokens)