> ## 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 permettre à vos utilisateurs de gérer eux-mêmes les informations de leur compte à l’aide de l’API My Account.
# My Account API
export const AuthCodeGroup = ({children, dropdown}) => {
const [processedChildren, setProcessedChildren] = useState(children);
useEffect(() => {
let unsubscribe = null;
function init() {
unsubscribe = window.autorun(() => {
const processChildren = node => {
if (typeof node === "string") {
let processedNode = node;
for (const [key, value] of window.rootStore.variableStore.values.entries()) {
const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
}
return processedNode;
} else if (Array.isArray(node)) {
return node.map(processChildren);
} else if (node && node.props && node.props.children) {
return {
...node,
props: {
...node.props,
children: processChildren(node.props.children)
}
};
}
return node;
};
setProcessedChildren(processChildren(children));
});
}
if (window.rootStore) {
init();
} else {
window.addEventListener("adu:storeReady", init);
}
return () => {
window.removeEventListener("adu:storeReady", init);
unsubscribe?.();
};
}, [children]);
return {processedChildren};
};
export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
const [displayText, setDisplayText] = useState(children);
const [copyText, setCopyText] = useState(children);
const wrapperRef = React.useRef(null);
useEffect(() => {
let unsubscribe = null;
function init() {
if (!window.autorun || !window.rootStore) {
return;
}
unsubscribe = window.autorun(() => {
let processedChildrenForDisplay = children;
let processedChildrenForCopy = children;
for (const [key, value] of window.rootStore.variableStore.values.entries()) {
const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
let displayValue = value;
if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
displayValue = value.substring(0, 3) + "*****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}
;
};
L’API My Account est offerte en accès anticipé. Pour demander l’accès, communiquez avec votre gestionnaire de compte Auth0 ou avec [l’assistance Auth0](https://support.auth0.com). Pour en savoir plus sur le cycle de lancement des produits d’Auth0, consultez [Étapes de lancement des produits](/fr-CA/docs/troubleshoot/product-lifecycle/product-release-stages).
L’API My Account d’Auth0 fournit un ensemble de points de terminaison dédiés permettant aux utilisateurs de gérer les informations de leur propre compte. Les clients peuvent utiliser ces API pour créer des expériences libre-service dans leurs applications ou ajouter progressivement des informations à un compte utilisateur.
L’API My Account fonctionne dans le contexte de l’utilisateur actuellement connecté et peut être utilisée directement dans les applications destinées aux utilisateurs finaux.
**Utiliser le domaine Auth0 ou un domaine personnalisé**
L’API My Account vous permet d’utiliser votre domaine Auth0 canonique ou votre domaine personnalisé, mais vous devez utiliser le même domaine tout au long du processus, y compris pour :
* Obtenir un jeton d’accès
* Définir la valeur `audience`
* Appeler le point de terminaison de l’API My Account
Pour en savoir plus, consultez [Domaines personnalisés](/fr-CA/docs/customize/custom-domains).
## Activer l’API My Account
Vous pouvez activer l’API My Account pour votre locataire dans le Auth0 Dashboard :
1. Accédez à **Applications > APIs**.
2. Repérez la bannière **MyAccount API**.
3. Sélectionnez **Activate**.
Par défaut, l’API My Account est créée avec les stratégies d’accès des applications à l’API suivantes :
* `require_client_grant` pour les flux utilisateur
* `deny_all` pour les flux application (machine à machine)
Pour qu’une application puisse accéder à l’API My Account au nom de l’utilisateur, vous devez créer explicitement un client grant pour cette application, ce qui vous permet de définir les scopes maximums que l’application peut demander. Vous pouvez aussi remplacer la stratégie des flux d’accès utilisateur par `allow_all`, ce qui permet à n’importe quelle application de votre locataire de demander n’importe quel scope à l’API My Account.
Auth0 ne recommande pas d’utiliser `allow_all` pour les flux d’accès utilisateur, car l’API My Account expose des informations et des opérations sensibles. Vous devriez appliquer le principe du moindre privilège à l’API My Account afin de vous assurer que les applications n’obtiennent que l’accès dont elles ont réellement besoin, ce qui réduit au minimum les risques de sécurité potentiels.
Les autorisations finales accordées à l’application sont déterminées par l’intersection des scopes autorisés par la stratégie d’accès des applications à l’API, des autorisations RBAC (Role-Based Access Control) attribuées à l’utilisateur final et du consentement donné par l’utilisateur, s’il y a lieu.
Vous ne pouvez pas mettre à jour la stratégie d’accès des applications à l’API pour l’accès client à l’API My Account, ce qui signifie que vous ne pouvez pas accéder à l’API My Account à l’aide du flux Client Credentials.
Pour en savoir plus sur la gestion des stratégies d’accès des applications à l’API et des client grants qui y sont associés, consultez [Accès des applications aux API : Client Grants](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants).
## Paramètre de la stratégie par défaut
L’Authentication Assurance pour la **API My Account** est actuellement en accès anticipé avec une seule option de stratégie. En utilisant cette fonctionnalité, vous acceptez les conditions d’essai gratuit applicables de l’[entente-cadre d’abonnement](https://www.okta.com/legal) d’Okta. Pour en savoir plus sur le cycle de mise en disponibilité des produits d’Auth0, consultez les [étapes de mise en disponibilité des produits](/fr-CA/docs/troubleshoot/product-lifecycle/product-release-stages). Pour participer au programme, communiquez avec l’[assistance Auth0](https://support.auth0.com).
La stratégie par défaut fournit une assurance d’authentification intégrée pour la API My Account en exigeant une [authentification renforcée](/fr-CA/docs/secure/multi-factor-authentication/step-up-authentication). Lorsqu’elle est activée, Auth0 veille automatiquement à ce que les utilisateurs se soient authentifiés récemment et au moyen d’un deuxième facteur.
La stratégie impose la 2FA dans une fenêtre de 15 minutes. Auth0 applique cette règle lors de la connexion et à chaque échange de jeton d’actualisation :
* Si un utilisateur a un facteur MFA inscrit, la 2FA doit être effectuée à la connexion, puis de nouveau lorsque ses jetons ont plus de 15 minutes.
* Si un utilisateur n’a aucun facteur admissible à l’inscription, Auth0 autorise l’accès initial, mais renvoie une erreur `unmet_authentication_requirements` lors des échanges de jetons d’actualisation après 15 minutes.
La stratégie par défaut n’est pas compatible avec Classic Login. Activez cette fonctionnalité si votre locataire utilise Universal Login ou un flux intégré pris en charge ([Resource Owner Password Flow](/fr-CA/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow) ou les [clés d’accès natives](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api)).
### Activer la stratégie par défaut
Pour activer la stratégie par défaut pour **API My Account** :
1. Accédez à [**Applications > APIs**](https://manage.auth0.com/#/apis), puis sélectionnez **API My Account**.
2. Sélectionnez l’onglet **Settings**.
3. Sous **Default Policy**, activez **Require 2FA**.
4. Sélectionnez **Save**.
Lorsque la stratégie par défaut est activée pour votre locataire, elle est automatiquement associée chaque fois qu’une nouvelle **API My Account** est créée.
### Hiérarchie des exigences d'authentification
La stratégie par défaut se situe entre la stratégie MFA au niveau du locataire et toute logique MFA que vous définissez dans Actions :
1. **Stratégie MFA du locataire** — la stratégie de base appliquée par défaut à l'ensemble des authentifications de votre locataire
2. **stratégie par défaut** — remplace la stratégie du locataire spécifiquement pour la API My Account
3. **Actions** — toute commande MFA dans Actions a toujours priorité sur les deux
### Comportement par défaut de la stratégie
Le comportement dépend du fait que l’utilisateur dispose ou non d’un second facteur pouvant être inscrit.
**Utilisateurs ayant un facteur MFA déjà configuré**
Pour les utilisateurs ayant déjà configuré TOTP, le courriel ou un autre facteur pris en charge :
1. À la connexion, Auth0 demande à l’utilisateur de confirmer son identité à l’aide de son facteur configuré avant d’émettre des jetons.
2. Le jeton d’actualisation consigne la méthode d’authentification et l’horodatage (AMR).
3. Lors d’un échange de jeton d’actualisation dans les 15 minutes suivant la dernière vérification, Auth0 émet un nouveau jeton d’accès sans nouvelle vérification.
4. Lors d’un échange de jeton d’actualisation après 15 minutes, Auth0 demande de nouveau à l’utilisateur de confirmer son identité avant d’émettre des jetons.
**Utilisateurs sans facteur MFA déjà configuré**
Pour les utilisateurs n’ayant ni courriel vérifié ni facteur configuré :
1. À la connexion, Auth0 autorise l’accès sans second facteur.
2. Lors d’un échange de jeton d’actualisation dans les 15 minutes, Auth0 émet un nouveau jeton d’accès sans vérification.
3. Lors d’un échange de jeton d’actualisation après 15 minutes, Auth0 renvoie une erreur `unmet_authentication_requirements`.
Lorsque `unmet_authentication_requirements` est renvoyée lors d’un échange de jeton d’actualisation, le jeton ne peut pas être actualisé. Votre application doit redémarrer l’ensemble du flux d’authentification pour obtenir de nouveaux jetons.
La même erreur est renvoyée lors d’une connexion silencieuse (`prompt=none`) lorsque l’utilisateur ne peut pas satisfaire à la stratégie après 15 minutes.
## Obtenir un jeton d’accès
Vous pouvez obtenir un jeton d’accès pour l’API My Account de la même manière que pour l’une de vos propres API.
Si vous avez besoin d’un niveau d’assurance de l’authentification supérieur à la stratégie par défaut — par exemple, pour exiger un facteur précis ou pour appliquer des exigences uniquement à certaines opérations — vous pouvez utiliser l’[authentification renforcée](/fr-CA/docs/secure/multi-factor-authentication/step-up-authentication) avec les [Actions](/fr-CA/docs/customize/actions) afin de définir une logique MFA personnalisée. Notez que les Actions remplacent toujours la stratégie par défaut.
Si vous utilisez Universal Login, consultez les articles suivants :
* [Appeler votre API à l’aide du flux Authorization Code](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow/call-your-api-using-the-authorization-code-flow)
* [Appeler votre API à l’aide du flux Authorization Code avec PKCE](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce)
Si vous utilisez l’authentification intégrée, consultez les articles suivants :
* [Appeler votre API à l’aide du flux Resource Owner Password](/fr-CA/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/call-your-api-using-resource-owner-password-flow)
* [Flux de connexion avec l’API Native Passkeys](/fr-CA/docs/authenticate/database-connections/passkeys/native-passkeys-api#login-flow)
### Audience
L’audience de l’API My Account est `https://{yourDomain}/me/`.
### Scope
L’API My Account prend en charge les scopes suivants :
| Scope | Description |
| ---------------------------------- | ---------------------------------------------------------------------------------------- |
| `create:me:authentication_methods` | Permet à l’utilisateur d’inscrire une nouvelle méthode d’authentification. |
| `read:me:authentication_methods` | Permet à l’utilisateur de consulter les méthodes d’authentification existantes. |
| `update:me:authentication_methods` | Permet à l’utilisateur de modifier les méthodes d’authentification existantes. |
| `delete:me:authentication_methods` | Permet à l’utilisateur de modifier les méthodes d’authentification existantes. |
| `read:me:factors` | Permet à l’utilisateur de consulter les facteurs d’authentification qu’il peut inscrire. |
Pour les [Connected Accounts with Token Vault](/fr-CA/docs/secure/call-apis-on-users-behalf/token-vault/connected-accounts-for-token-vault), l’API My Account prend en charge les scopes suivants :
| Scope | Description |
| ------------------------------ | ------------------------------------------------------------------------------------------ |
| `create:me:connected_accounts` | Permet à l’utilisateur de connecter un nouveau compte à son profil. |
| `read:me:connected_accounts` | Permet à l’utilisateur de consulter les comptes connectés existants associés à son profil. |
| `delete:me:connected_accounts` | Permet à l’utilisateur de supprimer un compte connecté de son profil. |
### Exemples
#### Universal Login avec le flux avec code d’autorisation
##### Étape 1 : Demander un code d’autorisation
```bash cURL theme={null}
curl --request GET \
--url 'https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F"
req, _ := http.NewRequest("GET", url, nil)
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.get("https://{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://{yourDomain}/authorize',
params: {
response_type: 'code',
client_id: '{yourClientId}',
redirect_uri: '{yourRedirectUri}',
scope: 'create:me:authentication_methods',
offline_access: '',
audience: 'https://{yourDomain}/me/'
}
};
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}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$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("")
conn.request("GET", "/{yourDomain}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
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}/authorize?response_type=code&client_id={yourClientId}&redirect_uri=%7ByourRedirectUri%7D&scope=create%3Ame%3Aauthentication_methods&offline_access=&audience=https%3A%2F%2F{yourDomain}%2Fme%2F")
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)
response = http.request(request)
puts response.read_body
```
##### Étape 2 : Échanger le code contre un jeton d’accès
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}", 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": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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/json")
.body("{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/oauth/token',
headers: {'content-type': 'application/json'},
data: {
grant_type: 'authorization_code',
client_id: '{yourClientId}',
client_secret: '{yourClientId}',
code: '{yourAuthorizationCode}',
redirect_uri: '{yourRedirectUri}',
audience: '{yourAudience}',
scope: 'create:me:authentication_methods',
offline_access: ''
}
};
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": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}",
CURLOPT_HTTPHEADER => [
"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 theme={null}
import http.client
conn = http.client.HTTPSConnection("")
payload = "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}"
headers = { 'content-type': "application/json" }
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/json'
request.body = "{"grant_type": "authorization_code","client_id": "{yourClientId}","client_secret": "{yourClientId}","code": "{yourAuthorizationCode}","redirect_uri": "{yourRedirectUri}","audience": "{yourAudience}","scope": "create:me:authentication_methods","offline_access": ""}"
response = http.request(request)
puts response.read_body
```
#### Connexion intégrée à l’aide de clés d’accès natives
##### Étape 1 : Demander le défi de connexion
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/passkey/challenge' \
--header 'content-type: application/json' \
--data '{"client_id": "{yourDomain}"}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/passkey/challenge");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{"client_id": "{yourDomain}"}", 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}/passkey/challenge"
payload := strings.NewReader("{"client_id": "{yourDomain}"}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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}/passkey/challenge")
.header("content-type", "application/json")
.body("{"client_id": "{yourDomain}"}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/passkey/challenge',
headers: {'content-type': 'application/json'},
data: {client_id: '{yourDomain}'}
};
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}/passkey/challenge",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "{"client_id": "{yourDomain}"}",
CURLOPT_HTTPHEADER => [
"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 theme={null}
import http.client
conn = http.client.HTTPSConnection("")
payload = "{"client_id": "{yourDomain}"}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/{yourDomain}/passkey/challenge", 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}/passkey/challenge")
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/json'
request.body = "{"client_id": "{yourDomain}"}"
response = http.request(request)
puts response.read_body
```
##### Étape 2 : Authentification d’un utilisateur existant
```bash cURL theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/json' \
--data '{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/oauth/token");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}", 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": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
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/json")
.body("{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'POST',
url: 'https://{yourDomain}/oauth/token',
headers: {'content-type': 'application/json'},
data: '{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}'
};
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": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}",
CURLOPT_HTTPHEADER => [
"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 theme={null}
import http.client
conn = http.client.HTTPSConnection("")
payload = "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby theme={null}
rrequire '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/json'
request.body = "{ "grant_type": "urn:okta:params:oauth:grant-type:webauthn", "client_id": "{yourClientId}", "scope": "create:me:authentication_methods offline_access", "audience": "https://{yourDomain}/me/" "auth_session": "{sessionIdFromTheFirstRequest}", "authn_response": "{authenticatorResponse}"}"
response = http.request(request)
puts response.read_body
```
## Requêtes inter-origines
Si vous comptez appeler l’API My Account directement depuis une application web exécutée dans le navigateur (comme une application monopage) sur un domaine différent de celui de votre locataire Auth0, vous serez confronté aux politiques de sécurité du navigateur appelées partage de ressources entre origines multiples (CORS). Par défaut, les navigateurs bloquent ces requêtes inter-origines.
Pour permettre à votre application d’effectuer correctement des requêtes vers l’API, vous devez ajouter le domaine de votre application (son « origine ») à la configuration de votre application :
1. Accédez à [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications). Sélectionnez l’application à afficher.
2. Dans Cross-Origin Authentication, activez l’option Allow Cross-Origin Authentication.
3. Repérez **Allowed Origins (CORS)**, puis saisissez l’URL d’origine de votre application.
4. Sélectionnez **Save**.
Pour en savoir plus, consultez [Configurer le partage de ressources entre origines multiples](/fr-CA/docs/get-started/applications/set-up-cors).
Si vous n’avez pas besoin d’utiliser CORS pour votre application, assurez-vous que l’option Allow Cross-Origin Authentication est désactivée. L’ajout de l’URL de votre application à cette liste indique à Auth0 de faire confiance aux requêtes provenant de cette origine, ce qui permet à votre application côté client d’accéder à l’API.