> ## 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 exécuter le Hybrid Flow afin que votre application puisse utiliser un jeton d’identité pour accéder aux renseignements sur l’utilisateur, tout en obtenant un code d’autorisation pouvant être échangé contre un jeton d’accès.
# Appelez votre API à l’aide du Hybrid Flow
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}
;
};
Ce tutoriel vous aidera à appeler votre propre API à l’aide du Hybrid Flow. Si vous souhaitez comprendre le fonctionnement de ce flux et pourquoi vous devriez l’utiliser, consultez [Hybrid Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/hybrid-flow).
Auth0 facilite la mise en œuvre du flux de code d’autorisation dans votre application à l’aide de :
* [API d’authentification](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** approprié.
* Ajoutez `{https://yourApp/callback}` comme **URL de rappel autorisée**.
* Assurez-vous que les **types d’octroi** de votre Application incluent **Implicit** et **Authorization Code**. 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, assurez-vous que les **types d’octroi** de l’Application incluent **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 afin d’obtenir de nouveaux jetons lorsque les précédents expirent, activez **autoriser l’accès hors ligne**.
## Étapes
1. [Autoriser l’utilisateur](#authorize-user):
Demandez l’autorisation de l’utilisateur, puis redirigez-le vers votre application avec un code d’autorisation.
2. [Demander des jetons](#request-tokens):
Échangez votre code d’autorisation contre des jetons.
3. [Appeler l’API](#call-api):
Utilisez le jeton d’accès obtenu pour appeler votre API.
4. [Actualiser les jetons](#refresh-tokens):
Utilisez un jeton d’actualisation pour demander de nouveaux jetons lorsque les jetons actuels expirent.
Facultatif : [Voir des exemples de cas d’utilisation](#sample-use-cases)
### Autoriser l’utilisateur
Cette étape peut comprendre un ou plusieurs des processus suivants :
* Authentifier l’utilisateur
* Rediriger l’utilisateur vers un Identity Provider pour prendre en charge 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é, 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
export const codeExample1 = `https://{yourDomain}/authorize?
response_type=YOUR_RESPONSE_TYPE&
response_mode=form_post&
client_id={yourClientId}&
redirect_uri={https://yourApp/callback}&
scope=SCOPE&
audience=API_AUDIENCE&
state=STATE&
nonce=NONCE`;
##### Paramètres
Notez que pour autoriser un utilisateur lors d’une requête à une API personnalisée, vous :
* devez inclure un paramètre audience
* pouvez inclure des portées supplémentaires pris en charge par l’API cible
| Nom du paramètre | Description |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `response_type` | Indique le type d’informations d’authentification qu’Auth0 renverra (code ou token). Pour ce flux, la valeur doit inclure `code`, mais peut aussi inclure `id_token`, `token` ou `id_token token`. Plus précisément, `id_token` renvoie un ID Token, et `token` renvoie un jeton d’accès. |
| `response_mode` | Précise la façon dont les paramètres de réponse doivent être renvoyés. Pour des raisons de sécurité, la valeur devrait être `form_post`. Dans ce mode, les paramètres de réponse seront encodés comme des valeurs de formulaire HTML transmises au moyen de la méthode HTTP POST et encodées dans le corps à l’aide du format `application/x-www-form-urlencoded`. |
| `client_id` | Le ID client de votre application. Vous trouverez cette valeur dans vos [paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `redirect_uri` | L’URL vers laquelle Auth0 redirigera le navigateur après que l’utilisateur aura accordé l’autorisation. 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 tient *pas* compte des fragments. |
| `scope` | Précise les [portées](/docs/fr-ca/get-started/apis/scopes) pour lesquelles vous souhaitez demander une autorisation, ce qui détermine quelles claims (ou quels attributs utilisateur) vous voulez voir renvoyés. Ils doivent être séparés par un espace. Vous pouvez demander n’importe lequel des [portées OpenID Connect (OIDC) standard](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) concernant les utilisateurs, comme `profile` ou `email`, des [custom claims](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-claims#custom-claims) conformes à un [format namespaced](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims), ou tout portée pris en charge par l’API cible (p. ex., `read:contacts`). Incluez `offline_access` pour obtenir un [jeton d’actualisation](/docs/fr-ca/glossary?term=Refresh+Token) (assurez-vous que le champ **autoriser l’accès hors ligne** est activé dans les [paramètres de l’application](https://manage.auth0.com/#/applications)). |
| `audience` | L’identifiant unique de l’API à laquelle votre application souhaite accéder. Utilisez la valeur **Identifier** 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 opaque et arbitraire 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êtes intersites (CSRF), consultez [Mitigate CSRF Attacks With State Parameters](/docs/fr-ca/secure/attack-protection/state-parameters). |
| `nonce` | Une chaîne aléatoire cryptographiquement sûre que votre application ajoute à la requête initiale et qu’Auth0 inclut dans l’ID Token, [utilisée pour prévenir les attaques par rejeu de jetons](/docs/fr-ca/get-started/authentication-and-authorization-flow/implicit-flow-with-form-post/mitigate-replay-attacks-when-using-the-implicit-flow). |
| `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 lors de l’authentification. |
| `invitation` | (facultatif) ID du ticket d’invitation de l’organisation. Lors de l’[invitation d’un membre à une Organization](/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. |
À titre d’exemple, votre extrait HTML pour votre URL d’autorisation lors de l’ajout de la fonctionnalité de connexion à votre application pourrait ressembler à ceci :
export const codeExample2 = `
Sign In
`;
#### Réponse
Si tout se passe bien, vous recevrez une réponse `HTTP 302`. Les identifiants demandés sont encodés dans le corps :
```json lines theme={null}
HTTP/1.1 302 Found
Content-Type: application/x-www-form-urlencoded
code=AUTHORIZATION_CODE&
access_token=ey...MhPw
&expires_in=7200
&token_type=Bearer
id_token=eyJ...acA&
state=xyzABC123
```
Notez que les valeurs renvoyées dépendent du `response_type` que vous avez demandé.
| Type de réponse | Composants |
| ---------------- | ------------------------------------------------------------------------------- |
| `code ` | code d’autorisation |
| `id_token ` | jeton d’identité |
| `token ` | jeton d’accès (plus les valeurs `expires_in` et `token_type`) |
| `id_token token` | jeton d’identité, jeton d’accès (plus les valeurs `expires_in` et `token_type`) |
Auth0 renverra également toute valeur `state` que vous avez incluse dans votre requête vers l’URL d’autorisation.
Le jeton d’accès que vous recevez dans cette transaction n’est que le premier jeton d’accès que vous recevrez. Nous ne recommandons pas de l’utiliser pour appeler des API.
Validez vos jetons avant de les enregistrer. Pour savoir comment faire, consultez [Valider le jeton 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).
Lorsque vous décodez et analysez votre jeton d’identité, vous remarquerez une revendication supplémentaire, `c_hash`, qui contient un hachage du `code`. Cette revendication est obligatoire lorsqu’un jeton d’identité est émis en même temps qu’un `code`, et vous devez la valider :
1. À l’aide de l’algorithme de hachage indiqué dans la revendication `alg` de l’en-tête du jeton d’identité, calculez le hachage des octets de la représentation ASCII du `code`.
2. Encodez en Base64url la moitié gauche du hachage.
3. Vérifiez que le résultat correspond à la valeur `c_hash`.
### Demander des jetons
Maintenant que vous avez un code d’autorisation, vous devez l’échanger contre des jetons. À l’aide du code d’autorisation (`code`) extrait à l’étape précédente, vous devrez envoyer une requête `POST` à l’[URL de jeton](https://auth0.com/docs/api/authentication#authorization-code).
Le jeton d’accès que vous recevez à cette étape est celui que vous devez utiliser pour effectuer des requêtes à votre API. Assurez-vous de le garder distinct du jeton d’accès que vous avez reçu à l’étape précédente de ce tutoriel.
#### Exemple de requête 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` | Définissez cette valeur sur `authorization_code`. |
| `code` | Le `authorization_code` récupéré à l’étape précédente de ce tutoriel. |
| `client_id` | L’ID client de votre application. Vous trouverez cette valeur dans les [Paramètres de l’application](https://manage.auth0.com/#/Applications/\{yourClientId}/settings). |
| `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 que cette valeur doit être encodée dans une URL. |
#### 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 faire, 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’identité](/docs/fr-ca/secure/tokens/id-tokens) contiennent des renseignements sur l’utilisateur qui doivent être décodés et extraits.
[Les jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens) servent à effectuer une requête au [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 effectuez une requête à 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 nouveau 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 la portée `offline_access` et activé **Autoriser l’accès hors ligne** pour votre API dans le Dashboard.
Les jetons d’actualisation doivent être stockés de manière sécuritaire, puisqu’ils permettent à un utilisateur de rester authentifié pratiquement indéfiniment.
### Appeler l’API
Pour appeler votre API à partir d’une application Web classique (ou dans des cas semblables où les identifiants de l’application peuvent être stockés en toute sécurité), l’application doit transmettre le jeton d’accès récupéré en tant que 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
```
### Jetons d’actualisation
Vous avez déjà reçu un [jeton d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) si vous avez suivi ce tutoriel et effectué les étapes suivantes :
* configuré votre API pour autoriser l’accès hors ligne
* inclus la portée `offline_access` lorsque vous avez lancé la requête d’authentification par l’intermédiaire 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 le point de terminaison pour obtenir un nouveau jeton d’accès chaque fois que vous faites une requête à une API, et Auth0 applique des limites de débit qui restreignent le nombre de requêtes au point de terminaison pouvant être exécutées avec le même jeton à partir de la même adresse IP.
Pour actualiser votre jeton, faites une requête `POST` au point de terminaison `/oauth/token` dans l’API d’authentification, en utilisant `grant_type=refresh_token`.
#### Exemple de requête POST à 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` | Définissez ce paramètre sur `refresh_token`. |
| `client_id` | Le 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) Liste des portées demandées, séparées par des espaces. Si elle n’est pas envoyée, les portées d’origine seront utilisées; sinon, vous pouvez demander un sous-ensemble réduit de portées. 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 une charge utile contenant un nouvel `access_token`, sa durée de validité en secondes (`expires_in`), les valeurs `scope` accordées et `token_type`. Si la portée du jeton initial comprenait `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 faire, consultez [valider le jeton 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).
### Quelques cas d’utilisation
#### Personnaliser les jetons
Vous pouvez utiliser des Rules pour modifier les `portées` renvoyés dans les jetons d’accès et/ou ajouter des claims aux jetons d’accès et aux jetons d’ID. (Pour en savoir plus sur les Rules, consultez [Auth0 Rules](/docs/fr-ca/customize/rules).) Pour ce faire, ajoutez la Rule suivante, qui s’exécutera après l’authentification de l’utilisateur :
```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');
};
```
Les portées seront disponibles dans le jeton une fois que toutes les règles auront été exécutées.
Auth0 renvoie les informations de profil dans un format structuré de claims, 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 de possibles collisions.
## Pour 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)