Obtenir des jetons d’accès

Pour accéder à votre API, vous devez demander un jeton d’accès lors de l’authentification d’un utilisateur.

Pour demander un jeton d’accès, effectuez une requête POST au jeton URL.

Exemple de requête POST au jeton URL




  


  
  
curl --request POST \
  --url 'https://{yourDomain}/oauth/token' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data grant_type=client_credentials \
  --data client_id=YOUR_CLIENT_ID \
  --data client_secret=YOUR_CLIENT_SECRET \
  --data audience=YOUR_API_IDENTIFIER
Was this helpful?
/
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=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Was this helpful?
/
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://{yourDomain}/oauth/token"

	payload := strings.NewReader("grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER")

	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))

}
Was this helpful?
/
HttpResponse<String> response = Unirest.post("https://{yourDomain}/oauth/token")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER")
  .asString();
Was this helpful?
/
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: 'client_credentials',
    client_id: 'YOUR_CLIENT_ID',
    client_secret: 'YOUR_CLIENT_SECRET',
    audience: 'YOUR_API_IDENTIFIER'
  })
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
Was this helpful?
/
#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"grant_type=client_credentials" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&client_id=YOUR_CLIENT_ID" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&client_secret=YOUR_CLIENT_SECRET" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&audience=YOUR_API_IDENTIFIER" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/oauth/token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
Was this helpful?
/
$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=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER",
  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;
}
Was this helpful?
/
import http.client

conn = http.client.HTTPSConnection("")

payload = "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER"

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"))
Was this helpful?
/
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=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&audience=YOUR_API_IDENTIFIER"

response = http.request(request)
puts response.read_body
Was this helpful?
/
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "grant_type=client_credentials".data(using: String.Encoding.utf8)!)
postData.append("&client_id=YOUR_CLIENT_ID".data(using: String.Encoding.utf8)!)
postData.append("&client_secret=YOUR_CLIENT_SECRET".data(using: String.Encoding.utf8)!)
postData.append("&audience=YOUR_API_IDENTIFIER".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/oauth/token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
Was this helpful?
/



Paramètres



Nom du paramètre
Description






grant_type
Définissez sur « client_credentials ».




client_id
L’ID client de votre application. Vous pouvez trouver cette valeur dans l’onglet des paramètres de l’application.




client_secret
Le secret client de votre application. Vous pouvez trouver cette valeur dans l’onglet des paramètres de l’application.  Pour en savoir plus sur les méthodes d’authentification des applications disponibles, veuillez consulter Informations d’identification de l’application .




audience
L’audience du jeton, qui est votre API. Vous pouvez le trouver dans le champ Identifier de votre onglet Paramètres de l’API.




organization
Facultatif. Le nom de l’organisation ou l’identifiant auquel vous souhaitez que la demande soit associée. Pour en savoir plus, lisez Accès de communication entre machines pour les Organizations.




Response (Réponse)
Vous recevrez une réponse HTTP 200 avec une charge utile contenant les valeurs access_token, token_type et expires_in :
{
  "access_token":"eyJz93a...k4laUWw",
  "token_type":"Bearer",
  "expires_in":86400
}
Was this helpful?
/


Contrôler l'audiance du jeton d’accès
Lorsqu’un utilisateur s’authentifie, vous demandez un jeton d’accès et incluez l'audience cible et la permission de l’accès dans votre demande. L’application utilise le point de terminaison /authorize pour demander l’accès. Cet accès est à la fois demandé par l’application et accordé par l’utilisateur lors de l’authentification.
Vous pouvez configurer votre locataire pour qu’il inclue toujours une audience par défaut.



Utilisation des jetons
Format
Public demandé
Permission demandée






Point de terminaison /userinfo
Opaque
Opaque
nom du locataire ({yourDomain}), aucune valeur pour le paramètre audience, aucun paramètre audience transmis




Auth0 Management API
JWT
Identifiant de l’Auth0 Management API v2 (https://{tenant}.auth0.com/api/v2/)





Dans une seule instance particulière, les jetons d’accès peuvent avoir plusieurs audiences cibles. Cela nécessite que l’algorithme de signature de votre API personnalisée soit défini sur RS256. Pour en savoir plus, consultez Meilleures pratiques en matière de jetons.
Audiences multiples
Si vous spécifiez une audience pour l’identifiant de votre API personnalisé et une permission openid, la demande aud du jeton d’accès résultant sera un tableau plutôt qu’une chaîne, et le jeton d’accès sera valide à la fois pour votre API personnalisée et pour le point de terminaison/userinfo. Vos jetons d’accès ne peuvent avoir deux audiences ou plus que si vous utilisez une seule API personnalisée ainsi que le point de terminaison /userinfo lié à Auth0.
Domaines personnalisés et Management API Auth0
Auth0 émet des jetons avec une demande de l’émetteur (iss) du domaine que vous avez utilisé lors de la demande du jeton. Les utilisateurs de domaines personnalisés peuvent utiliser leur domaine personnalisé ou leur domaine Auth0.
Par exemple, supposons que vous ayez un domaine personnalisé, https://login.northwind.com. Si vous demandez un jeton d’accès à partir de https://login.northwind.com/authorize, la demande iss de votre jeton sera https://login.northwind.com/. Cependant, si vous demandez un jeton d’accès à partir de https://northwind.auth0.com/authorize, la demande iss de votre jeton sera https://northwind.auth0.com/.
Si vous demandez un jeton d’accès à partir de votre domaine personnalisé avec l'audience cible de Management API Auth0, vous devez appeler Management API Auth0 à partir de votre domaine personnalisé. Sinon, votre jeton d’accès est considéré comme invalide.
Renouveler des jetons d’accès
Par défaut, un jeton d’accès pour une API personnalisée est valide pendant 86 400 secondes (24 heures). Vous pouvez raccourcir la période de validité avant l’expiration du jeton.
Il est possible de renouveler un jeton d’accès qui a expiré. Pour ce faire, réauthentifiez l’utilisateur à l’aide d’Auth0 ou utilisez un jeton d’actualisation.
En savoir plus