> ## 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 configurer et utiliser les comptes connectés pour Token Vault.
# Comptes connectés pour Token Vault
Connected Accounts for Token Vault permet aux applications d’accéder de façon sécurisée à des API externes au nom de l’utilisateur par l’entremise de [Token Vault](/docs/fr-ca/secure/tokens/token-vault). Alors que l’authentification utilisateur standard gère la connexion de l’utilisateur par l’intermédiaire d’un fournisseur d’identité social ou d’entreprise, Connected Accounts lie un profil utilisateur à des services externes comme Google, GitHub, Slack et plus encore, ce qui facilite l’accès délégué aux API externes au nom de l’utilisateur.
Lorsqu’un utilisateur connecte son compte avec succès et autorise l’accès à un [fournisseur externe pris en charge](/docs/fr-ca/secure/tokens/token-vault#supported-external-providers), Auth0 :
* Associe le compte à l’utilisateur comme compte connecté.
* Stocke dans Token Vault les jetons d’accès et d’actualisation du fournisseur externe pour le compte connecté.
Connected Accounts for Token Vault crée et gère un profil utilisateur Auth0 unifié lié à plusieurs comptes externes, ce qui permet une autorisation fluide. Votre application récupère ensuite les informations d’identification stockées dans Token Vault pour interagir avec des API externes au nom de l’utilisateur.
## Authentification de l’utilisateur vs comptes connectés
Lorsque vous [configurez les comptes connectés](#configure-connected-accounts) pour une connexion sociale ou d’entreprise prise en charge, Auth0 utilise le flux des comptes connectés (point de terminaison `/me/v1/connected-accounts`) pour récupérer et stocker les jetons d’accès et d’actualisation dans le Token Vault, au lieu d’utiliser le flux de connexion sociale ou d’entreprise (point de terminaison `/authorize`). Une fois le flux des comptes connectés terminé avec succès, Auth0 ajoute le compte d’utilisateur au tableau `connected_accounts` du profil d’utilisateur. À l’inverse, pour le flux de connexion sociale ou d’entreprise, Auth0 ajoute le compte d’utilisateur au tableau `identities` du profil d’utilisateur.
Le tableau suivant explique les différences entre les flux d’authentification de l’utilisateur et des comptes connectés :
| | Authentification de l’utilisateur | Comptes connectés |
| -------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Flux | Flux de connexion utilisant le point de terminaison `/authorize` | Flux des comptes connectés utilisant le point de terminaison `/me/v1/connected-accounts` de la My Account API |
| Objectif | Authentifie les utilisateurs auprès d’un fournisseur d’identité social ou d’entreprise | Stocke dans Token Vault les jetons d’accès et d’actualisation du compte connecté lorsqu’un utilisateur se connecte au moyen d’un fournisseur externe pris en charge et autorise la connexion |
Vous pouvez activer l’authentification de l’utilisateur, les comptes connectés ou les deux pour les connexions sociales ou d’entreprise prises en charge. Le tableau suivant explique le comportement selon les différents paramètres de l’objectif, y compris la façon de transmettre des scopes à la connexion :
| Authentification | Comptes connectés | Comportement | Scopes |
| ---------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Activé | Désactivé | La connexion utilise le flux de connexion `/authorize` pour authentifier les utilisateurs en tant que fournisseur d’identité valide. | Utilisez le Auth0 Dashboard ou la Management API pour transmettre les scopes souhaités à votre connexion. À l’exécution, cette liste est automatiquement complétée par tout scope supplémentaire inclus dans le paramètre `connection_scope` de la requête d’autorisation. |
| Désactivé | Activé | La connexion utilise le flux des comptes connectés pour récupérer et stocker les jetons de la connexion dans le Token Vault. La connexion n’utilise pas le flux de connexion `/authorize` pour authentifier les utilisateurs et est exclue de la liste des fournisseurs d’identité valides. | Utilisez le Auth0 Dashboard ou la Management API pour transmettre les scopes souhaités à votre connexion. À l’exécution, tout scope inclus dans le paramètre `scopes` de la requête d’autorisation a préséance sur les scopes sélectionnés dans le Auth0 Dashboard, sauf `offline_access`, si la connexion l’exige et qu’il est activé dans le Auth0 Dashboard.
**Remarque :** Si la connexion l’exige, Auth0 vous invitera à activer `offline_access`, ce qui permet à l’application cliente d’obtenir un jeton d’actualisation auprès d’Auth0. Vous devez activer `offline_access` pour la connexion dans le Auth0 Dashboard. |
| Activé | Activé | La connexion utilise le flux de connexion `/authorize` pour authentifier les utilisateurs en tant que fournisseur d’identité valide. Elle utilise aussi le flux des comptes connectés pour récupérer et stocker les jetons d’accès de la connexion dans le Token Vault. | Utilisez le Auth0 Dashboard et la Management API pour transmettre les scopes souhaités à la connexion. À l’exécution, tout scope inclus dans le paramètre `scopes` a préséance sur les scopes sélectionnés dans le Auth0 Dashboard, sauf `offline_access`, si la connexion l’exige et qu’il est activé dans le Auth0 Dashboard.
**Remarque :** Si la connexion l’exige, Auth0 vous invitera à activer `offline_access`, ce qui permet à l’application cliente d’obtenir un jeton d’actualisation auprès d’Auth0. Vous devez activer `offline_access` pour la connexion dans le Auth0 Dashboard. |
## Fonctionnement
Le flux Connected Accounts utilise la [My Account API](/docs/fr-ca/manage-users/my-account-api) pour créer et gérer les comptes connectés d’un utilisateur auprès des fournisseurs externes pris en charge.
Avant que l’utilisateur puisse lancer une demande Connected Accounts depuis l’application cliente, celle-ci doit [obtenir un jeton d’accès](/docs/fr-ca/manage-users/my-account-api#get-an-access-token) avec les portées Connected Accounts pour accéder à la My Account API.
Si votre application utilise [Organizations](/docs/fr-ca/manage-users/organizations), authentifiez l’utilisateur auprès de l’organisation cible avant de lancer le flux Connected Accounts. Token Vault stocke le compte connecté dans le profil Auth0 de l’utilisateur. Chaque membre de l’organisation doit donc connecter et autoriser son propre compte externe.
Le diagramme de séquence suivant illustre le flux Connected Accounts de bout en bout :
Lorsqu’un utilisateur ouvre une session au moyen d’un fournisseur externe pris en charge par l’intermédiaire d’Auth0, il lance une demande Connected Accounts depuis l’application cliente :
1. L’application cliente effectue une requête `POST` vers le point de terminaison `/me/v1/connected-accounts/connect` de la My Account API, en transmettant les portées et d’autres paramètres à envoyer au fournisseur externe. Pour en savoir plus, consultez [Initiate Connected Accounts request](#initiate-connected-accounts-request).
2. La My Account API crée un `auth_session` unique et un `connect_uri` contenant un `ticket`, qui redirige l’utilisateur vers un navigateur Web. L’application cliente enregistre l’`auth_session` pour vérification ultérieure. Si [DPoP](/docs/fr-ca/secure/sender-constraining/demonstrating-proof-of-possession-dpop) est configuré, la My Account API valide le DPoP Proof JWT.
3. L’application cliente redirige l’utilisateur vers le `connect_uri` avec le `ticket` comme paramètre de requête, afin qu’il puisse s’authentifier et autoriser l’accès dans le navigateur. L’application cliente peut aussi transmettre un `code_challenge` ou un `code_challenge_method` dans l’URL, comme dans le [flux de code d’autorisation avec PKCE](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).
4. L’utilisateur connecte son compte et autorise les permissions de la connexion dans l’écran de consentement.
5. Une fois la connexion autorisée par l’utilisateur, le fournisseur externe redirige celui-ci vers la My Account API, qui le redirige ensuite vers l’application cliente au moyen du `redirect_uri` avec un `connect_code` à usage unique.
6. L’application cliente présente le `connect_code`, le `code_verifier` (s’il y a lieu) et l’`auth_session` d’origine à la My Account API en effectuant une requête `POST` vers le point de terminaison `/me/v1/connected-accounts/complete`. Pour en savoir plus, consultez [Complete Connected Accounts request](#complete-connected-accounts-request).
7. La My Account API valide la requête en confirmant ce qui suit :
* l’`auth_session` correspond à l’ID initialement émis pour l’utilisateur
* la requête provient du même appareil que celui ayant lancé le flux Connected Accounts
* le DPoP Proof JWT (si configuré)
* le `connect_code` à usage unique
* le `code_verifier` (si vous utilisez le flux PKCE)
8. Une fois la validation réussie, l’Auth0 Authorization Server ajoute le compte au tableau `connected_accounts` du profil utilisateur et stocke les jetons d’accès et d’actualisation du compte connecté dans le Token Vault.
9. La My Account API termine le flux en renvoyant un code d’état `200` à l’application cliente, indiquant que le compte a bien été connecté.
## Prérequis
Avant de configurer Connected Accounts, assurez-vous de :
* [Configurer Token Vault](/docs/fr-ca/secure/tokens/token-vault/configure-token-vault) pour votre application client afin d’y stocker de façon sécuritaire les jetons d’accès et d’actualisation associés à chaque compte connecté.
* [Configurer l’API My Account](#configure-my-account-api), que les utilisateurs authentifiés utilisent pour connecter et gérer leurs comptes.
* [Configurer le Multi-Resource Refresh Token (MRRT)](#configure-multi-resource-refresh-token) afin d’obtenir un jeton d’accès pour l’API My Account.
* (Facultatif) [Configurer DPoP](/docs/fr-ca/secure/sender-constraining/configure-sender-constraining) pour l’API My Account et votre application client afin de lier les jetons d’accès à l’émetteur, ce qui aide à prévenir le vol de jetons. Par défaut, l’API My Account peut accepter des jetons d’accès liés à DPoP.
### Configurer My Account API
Pour utiliser Connected Accounts, configurez My Account API dans l’Auth0 Dashboard :
1. Accédez à **Applications > APIs** et [activez My Account API](/docs/fr-ca/manage-users/my-account-api#activate-the-my-account-api).
2. Une fois l’API activée, sélectionnez **Auth0 My Account API**, puis l’onglet **Application Access**.
3. Repérez votre application cliente et sélectionnez **Edit** pour configurer ses [politiques d’accès de l’application](/docs/fr-ca/get-started/apis/api-access-policies-for-applications).
4. Sélectionnez **User Access** et, sous **Authorization**, sélectionnez **Authorized**.
5. Pour les permissions, sélectionnez **All** pour toutes les [portées de Connected Accounts](/docs/fr-ca/manage-users/my-account-api#scope) de l’application.
6. Sélectionnez **Save**. Cela crée un [client grant](/docs/fr-ca/get-started/applications/application-access-to-apis-client-grants) qui permet à votre application cliente d’accéder à My Account API avec les portées de Connected Accounts au nom de l’utilisateur.
7. Si vous utilisez [Multi-Resource Refresh Token](/docs/fr-ca/secure/tokens/refresh-tokens/multi-resource-refresh-token#multi-resource-refresh-token), accédez à l’onglet **Settings**. Sous **Access Settings**, sélectionnez **Allow Skipping User Consent**.
### Configurer le Multi-Resource Refresh Token
Configurez le Multi-Resource Refresh Token (MRRT) pour obtenir un seul jeton d’actualisation de longue durée, qui peut être échangé contre de nouveaux jetons d’accès pour My Account API et d’autres API sans obliger l’utilisateur à s’authentifier de nouveau.
Vous pouvez configurer le MRRT dans l’[Auth0 Dashboard](https://manage.auth0.com) ou au moyen de la [Management API](https://auth0.com/docs/api/management/v2).
Pour configurer le MRRT dans l’Auth0 Dashboard :
1. Accédez à **Applications > Applications** et sélectionnez votre application.
2. Sous **Multi-Resource Refresh Token**, sélectionnez **Edit Configuration**.
3. Pour activer le MRRT avec My Account API, activez la bascule **My Account API**.
Pour configurer le MRRT pour une application cliente, envoyez une requête `PATCH` au point de terminaison `/api/v2/clients/{clientId}` et ajoutez l’identifiant de My Account API ainsi que les portées Connected Accounts aux politiques du jeton d’actualisation :
```bash lines theme={null}
curl -X PATCH --location "https://${account.namespace}/api/v2/clients/{clientId}" \
-H "Authorization: Bearer " \
-H "Content-Type: application/json" \
-d '{
"is_first_party": true,
"refresh_token": {
"expiration_type": "non-expiring",
"leeway": 0,
"infinite_token_lifetime": true,
"infinite_idle_token_lifetime": true,
"token_lifetime": 31557600,
"idle_token_lifetime": 2592000,
"rotation_type": "non-rotating",
"policies": [
{
"audience": "https://'"$DOMAIN"'/me/",
"scope": [
"create:me:connected_accounts",
"read:me:connected_accounts",
"delete:me:connected_accounts"
]
}
]
}
}'
```
## Configurer les comptes connectés
Avant de configurer les comptes connectés pour une connexion, assurez-vous d’avoir autorisé la connexion pour votre application cliente.
Dans l’Auth0 Dashboard :
1. Accédez à **Authentication > Social Connections** ou **Enterprise Connections**, puis sélectionnez la connexion.
2. Sélectionnez **Applications**, puis activez la connexion pour votre application cliente.
Vous pouvez configurer les comptes connectés dans l’[Auth0 Dashboard](https://manage.auth0.com) ou avec la [Management API](https://auth0.com/docs/api/management/v2).
Pour configurer les comptes connectés dans l’Auth0 Dashboard :
1. Accédez à **Authentication > Social Connections** ou **Enterprise Connections**.
2. Sélectionnez **Create Connection** ou une connexion existante.
3. Dans **Purpose**, activez **Connected Accounts for Token Vault**. Selon le réglage **Purpose**, vous devrez peut-être activer `offline_access` dans l’Auth0 Dashboard pour permettre à l’application cliente d’obtenir un refresh token du fournisseur externe pendant le flux des comptes connectés. Pour en savoir plus, consultez [Authentification de l’utilisateur vs comptes connectés](#user-authentication-vs-connected-accounts).
4. Cliquez sur **Save**.
Pour configurer les comptes connectés avec la Management API, envoyez une requête `PATCH` à l’endpoint `/connections/{connectionId}` pour définir `connected_accounts` sur `true` :
```bash lines theme={null}
curl -L -X PATCH "https://{yourDomain}/api/v2/connections/{connectionId}" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H "Authorization: Bearer " \
-d '{"connected_accounts":{"active":true}}'
```
## Obtenir un jeton d’accès pour Connected Accounts
Avant d’amorcer une requête Connected Accounts, [obtenez un jeton d’accès](/docs/fr-ca/manage-users/my-account-api#scope) pour l’API My Account avec les portées Connected Accounts.
Les sections suivantes expliquent comment utiliser un [jeton d’actualisation multiresource (MRRT)](/docs/fr-ca/secure/tokens/refresh-tokens/multi-resource-refresh-token) pour obtenir un jeton d’accès pour l’API My Account.
### Obtenir un jeton d’actualisation
Après avoir [configuré MRRT](#configure-multi-resource-refresh-token) pour l’application cliente, lancez le flux avec code d’autorisation et échangez le code d’autorisation obtenu contre un jeton d’actualisation.
Voici une requête du flux avec code d’autorisation pour un client confidentiel qui inclut `offline_scope` afin d’obtenir un jeton d’actualisation et un code d’autorisation à usage unique pour l’identifiant de l’API My Account API `https://{yourDomain}/me/` :
```bash lines theme={null}
open "https://{yourDomain}/authorize?client_id=&response_type=code&prompt=login&scope=openid%20profile%20offline_access&redirect_uri=&state=&audience=https://my-example-api.com"
```
Échangez le code d’autorisation à usage unique contre un refresh token à l’endpoint `/token` :
```bash lines theme={null}
curl -s --request POST \
--url "https://{yourDomain}/oauth/token" \
--header 'Content-Type: application/json' \
--data-binary @- <",
"client_id": "",
"client_secret": "",
"redirect_uri": ""
}
EOF
```
### Échanger un refresh token contre un jeton d’accès à l’API My Account
Une fois que vous avez obtenu un refresh token, échangez-le contre un jeton d’accès à l’API My Account associé aux scopes de Connected Accounts en utilisant le grant type refresh token :
```bash lines theme={null}
curl -s -X POST "https://{yourDomain}/oauth/token" \
-H "Content-Type: application/x-www-form-urlencoded" \
--data-urlencode "grant_type=refresh_token" \
--data-urlencode "client_id=" \
--data-urlencode "client_secret=" \
--data-urlencode "refresh_token=" \
--data-urlencode "audience=https://{yourDomain}/me/" \
--data-urlencode "scope=openid profile offline_access create:me:connected_accounts read:me:connected_accounts delete:me:connected_accounts"
```
## Lancer une requête Connected Accounts
Pour lancer une requête Connected Accounts, envoyez une requête `POST` au point de terminaison `/me/v1/connected-accounts/connect` de la My Account API avec les paramètres suivants :
Pour une connexion sociale Google, assurez-vous de sélectionner `offline_access` dans Auth0 Dashboard lorsque vous configurez votre connexion. Cela est nécessaire pour que votre application cliente puisse récupérer un jeton d’actualisation auprès de l’Auth0 Authorization Server.
| Paramètre | Description |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connection` | Nom de la connexion. Pour une connexion sociale Google, utilisez `google-oauth2`. |
| `redirect_uri` | L’URL de rappel de votre application cliente. |
| `state` | Une chaîne unique et aléatoire associée à la requête afin de prévenir les attaques. |
| `scopes` | (Facultatif) Les scopes transmis au fournisseur externe sous forme de tableau de chaînes de caractères.
S’ils sont utilisés pour transmettre des scopes à une connexion sociale Google, incluez au minimum `openid` et `profile`. À l’exécution, tous les scopes inclus dans le paramètre `scopes` prévalent sur les scopes sélectionnés dans Auth0 Dashboard, sauf `offline_access`, s’il est requis par la connexion et activé dans Auth0 Dashboard. |
```bash lines theme={null}
curl --request POST "https://{yourDomain}/me/v1/connected-accounts/connect" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer " \
--data '{
"connection": "google-oauth2",
"redirect_uri": "",
"state": "",
"scopes": ["openid","profile"] // tout scope transmis remplace les scopes que vous avez sélectionnés dans le Auth0 Dashboard
}'
```
Si la requête réussit, la My Account API renvoie une réponse semblable à ce qui suit :
| Paramètre | Description |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `auth_session` | ID de session qui représente la session authentifiée actuelle de l’utilisateur principal. L’application cliente enregistre l’ID de session pour une vérification ultérieure. |
| `connect_uri` | URL vers laquelle l’application cliente redirige l’utilisateur et qui ouvre un navigateur Web pour gérer l’autorisation auprès du fournisseur externe. |
| `connect_params` | Paramètres supplémentaires nécessaires pour l’URI de connexion. Comprend un ticket temporaire que la My Account API utilise pour vérifier la requête. |
| `expires_in` | Délai d’expiration de la session, en secondes. |
```json theme={null}
{
"auth_session": "PKM-CYkdx2FyLb4Oob4ED91cSE7i_XJ4SVJByik0xKQxz9CgUZ5JlYr-aMPty0Xr",
"connect_uri": "https://{yourDomain}.us.auth0.com/connect",
"connect_params": {
"ticket": "9375f326-5846-4b57-ae8b-8042573f7c1f"
},
"expires_in": 300
}
```
Dans le navigateur Web, accédez au `connect_uri` avec le `ticket` comme paramètre de requête. Sur l’écran de consentement, autorisez les portées demandées, puis extrayez et enregistrez le `connect_code` dans le fragment d’URL.
```bash lines theme={null}
open https://{yourDomain}.us.auth0.com/connected-accounts/connect?ticket={tickedId}
```
## Terminer une requête Connected Accounts
Pour terminer une requête Connected Accounts, envoyez une requête `POST` au point de terminaison `/me/v1/connected-accounts/complete` avec les paramètres suivants :
| Paramètre | Description |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `auth_session` | ID de session représentant la session authentifiée en cours de l’utilisateur principal. L’application cliente conserve cet ID de session pour une vérification ultérieure. |
| `connect_code` | Code à usage unique et de courte durée reçu du processus d’autorisation du fournisseur externe. Ce code est échangé de façon sécurisée côté serveur afin de récupérer les jetons d’accès finaux de l’API externe. |
| `redirect_uri` | URL de rappel exacte de votre application vers laquelle l’utilisateur a été redirigé après avoir autorisé avec succès la connexion avec le fournisseur externe. Cette valeur doit correspondre au `redirect_uri` utilisé pour lancer le flux. |
```bash lines theme={null}
curl --location "https://{yourDomain}/me/v1/connected-accounts/complete" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer " \
--data '{
"auth_session": "",
"connect_code": "",
"redirect_uri": ""
}'
```
Si l’opération réussit, la My Account API renvoie une réponse semblable à celle-ci :
| Paramètre | Description |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id` | Identifiant unique du compte connecté. |
| `connection` | Nom de la connexion. |
| `created_at` | Horodatage indiquant quand le compte connecté a été créé et lié au profil utilisateur. |
| `scopes` | Les scopes OAuth précis (permissions) auxquels l’utilisateur a accordé l’accès à votre application lors de la connexion au fournisseur externe. Ces scopes déterminent les actions d’API externes que votre application peut effectuer. |
| `access_type` | Indique le type d’accès accordé. Une valeur courante est `offline`, ce qui signifie qu’un refresh token a bien été obtenu et stocké, permettant à votre application de conserver l’accès même lorsque l’utilisateur est hors ligne. |
```json theme={null}
{
"id": "cac_6ZqSK7Kj1R8LDZJvSb1tAn",
"connection": "google-oauth2",
"created_at": "2025-10-13T21:09:04.126Z",
"scopes": [
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/calendar.addons.execute",
"https://www.googleapis.com/auth/calendar.events",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.settings.readonly",
"https://www.googleapis.com/auth/userinfo.profile",
"openid"
],
"access_type": "offline"
}
```
## Gérer les comptes connectés
Pour gérer les comptes connectés d’un utilisateur, utilisez la collection `/me/v1/connected-accounts`.
Avant d’utiliser la collection `/connected-accounts`, [obtenez un jeton d’accès pour les comptes connectés](#get-access-token-for-connected-accounts).
### Interroger les connexions de Connected Accounts
Effectuez une requête `GET` au point de terminaison `/me/v1/connected-accounts/connections` pour obtenir la liste des connexions liées au profil utilisateur :
```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/me/v1/connected-accounts/connections" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer "
```
Si la requête réussit, My Accounts API renvoie une réponse comme celle-ci :
```json theme={null}
{
"connections": [
{
"name": "google-oauth2",
"strategy": "google-oauth2",
"scopes": [
"email",
"profile",
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/calendar.events",
"https://www.googleapis.com/auth/calendar.addons.execute",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.settings.readonly",
"openid"
]
},
{
"name": "custom",
"strategy": "oauth2",
"scopes": [
"openid"
]
}
]
}
```
### Lister les comptes connectés
Faites une requête `GET` au point de terminaison `/me/v1/connected-accounts/accounts` pour obtenir une liste des comptes connectés liés au profil utilisateur :
```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/me/v1/connected-accounts/accounts" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer "
```
Si l’opération réussit, l’API My Accounts renvoie une réponse comme celle-ci :
```json theme={null}
{
"accounts": [
{
"id": "cac_6ZqSK7Kj1R8LDZJvSb1tAn",
"connection": "google-oauth2",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/calendar.addons.execute",
"https://www.googleapis.com/auth/calendar.events",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.settings.readonly",
"https://www.googleapis.com/auth/userinfo.profile",
"openid"
],
"created_at": "2025-10-13T21:09:04.126Z"
},
{
"id": "cac_fH32E6CWN7HcWZN5w9Vieq",
"connection": "custom",
"access_type": "offline",
"scopes": [
"offline_access",
"openid",
"profile"
],
"created_at": "2025-10-13T18:06:47.216Z"
}
]
}
```
Vous pouvez aussi utiliser la Management API pour obtenir la liste des comptes connectés d’un profil utilisateur en effectuant une requête `GET` au point de terminaison `/users/{userId}/connected-accounts` :
```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/api/v2/users/{userId}/connected-accounts" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer "
```
Si l’opération réussit, la Management API renvoie une réponse comme celle-ci :
```json theme={null}
{
"connected_accounts": [
{
"id": "cac_6ZqSK7Kj1R8LDZJvSb1tAn",
"connection": "google-oauth2",
"connection_id": "con_uBbSbbSpqGqOTvRu",
"strategy": "google-oauth2",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/calendar.addons.execute",
"https://www.googleapis.com/auth/calendar.events",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.settings.readonly",
"https://www.googleapis.com/auth/userinfo.profile",
"openid"
],
"created_at": "2025-10-13T21:09:04.126Z"
}
]
}
```
### Interroger les comptes connectés pour une connexion donnée
Effectuez une requête `GET` vers le point de terminaison `/me/v1/connected-accounts/accounts` et transmettez le nom de la connexion comme paramètre de requête afin de renvoyer une liste de comptes connectés filtrés selon une connexion donnée liée à un profil d’utilisateur :
```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/me/v1/connected-accounts/accounts?connection={connectionName}" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer "
```
Si l’opération réussit, My Accounts API renvoie une réponse comme celle qui suit, filtrée pour les connexions `google-oauth2` :
```json theme={null}
{
"accounts": [
{
"id": "cac_6ZqSK7Kj1R8LDZJvSb1tAn",
"connection": "google-oauth2",
"access_type": "offline",
"scopes": [
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/calendar.addons.execute",
"https://www.googleapis.com/auth/calendar.events",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.settings.readonly",
"https://www.googleapis.com/auth/userinfo.profile",
"openid"
],
"created_at": "2025-10-13T21:09:04.126Z"
}
]
}
```
### Supprimer un compte connecté
Effectuez une requête `DELETE` au point de terminaison `/me/v1/connected-accounts/accounts/{connectedAccountId}` pour supprimer le compte connecté correspondant à un ID donné :
```bash lines theme={null}
curl -X DELETE --location "https://{yourDomain}/me/v1/connected-accounts/accounts/{connectedAccountId}" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer "
```
Lorsque vous supprimez un compte connecté, Auth0 supprime du Token Vault les jetons d’accès et d’actualisation du fournisseur externe. Cela ne révoque pas automatiquement les jetons du fournisseur externe, et le jeton d’actualisation pourrait tout de même servir à obtenir de nouveaux jetons d’accès. Vous devez révoquer manuellement les jetons du fournisseur externe s’ils ont été partagés ou copiés ailleurs.
Si l’opération réussit, l’API My Accounts renvoie une réponse semblable à la suivante :
```
HTTP/1.1 204 No Content
```