> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.generaltranslation.app/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

Les Comptes connectés pour Token Vault permettent aux applications d’accéder en toute sécurité à des API externes au nom de l’utilisateur par l’intermédiaire de [Token Vault](/docs/fr-CA/secure/tokens/token-vault). Alors que l’authentification standard gère la connexion de l’utilisateur au moyen d’un fournisseur d'identité social ou d’entreprise, les Comptes connectés lient un profil utilisateur à des services externes comme Google, GitHub, Slack et bien plus encore, ce qui facilite l’accès délégué aux API externes au nom de l’utilisateur.

Une fois qu’un utilisateur a connecté son compte et autorisé 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 en tant que compte connecté.
* Stocke les jetons d’accès et d’actualisation du fournisseur externe pour le compte connecté dans Token Vault.

Les Comptes connectés pour Token Vault créent et gèrent un profil utilisateur Auth0 unifié lié à plusieurs comptes externes, ce qui permet une autorisation fluide. Votre application récupère ensuite les identifiants stockés dans Token Vault pour interagir avec les API externes au nom de l’utilisateur.

<div id="user-authentication-vs-connected-accounts">
  ## Authentification de l’utilisateur vs Comptes connectés
</div>

Lorsque vous [configurez des Comptes connectés](#configure-connected-accounts) pour une connexion sociale ou d’entreprise prise en charge, Auth0 utilise le flux 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 Comptes connectés terminé avec succès, Auth0 ajoute le compte de l’utilisateur au tableau `connected_accounts` dans le profil de l’utilisateur. En revanche, pour le flux de connexion sociale ou d’entreprise, Auth0 ajoute le compte de l’utilisateur au tableau `identities` dans le profil de l’utilisateur.

Le tableau suivant explique les différences entre les flux d’authentification de l’utilisateur et de Comptes connectés :

<table class="table">
  <thead>
    <tr>
      <th />

      <th><strong>Authentification de l’utilisateur</strong></th>
      <th><strong>Comptes connectés</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>Flux</td>
      <td>Flux de connexion utilisant le point de terminaison `/authorize`</td>
      <td>Flux Comptes connectés utilisant le point de terminaison `/me/v1/connected-accounts` de l’API My Account</td>
    </tr>

    <tr>
      <td>Objectif</td>
      <td>Authentifier les utilisateurs auprès d’un fournisseur d’identité social ou d’entreprise</td>
      <td>Stocker les jetons d’accès et d’actualisation pour le compte connecté dans le Token Vault lorsqu’un utilisateur se connecte via un fournisseur externe pris en charge, établit la connexion et l’autorise</td>
    </tr>
  </tbody>
</table>

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 pour les différents paramètres d’Objectif, y compris comment transmettre des scopes à la connexion :

<table class="table">
  <thead>
    <tr>
      <th><strong>Authentification</strong></th>
      <th><strong>Comptes connectés</strong></th>
      <th><strong>Comportement</strong></th>
      <th><strong>Scopes</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>Activée</td>
      <td>Désactivée</td>
      <td>La connexion utilise le flux de connexion `/authorize` pour authentifier les utilisateurs en tant que fournisseur d’identité valide.</td>
      <td>Utilisez Auth0 Dashboard ou Management API pour transmettre les scopes souhaités pour votre connexion. À l’exécution, cette liste est automatiquement complétée avec tous les scopes supplémentaires inclus dans le paramètre `connection_scope` de la requête d’autorisation.</td>
    </tr>

    <tr>
      <td>Désactivée</td>
      <td>Activée</td>
      <td>La connexion utilise le flux 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.</td>
      <td>Utilisez Auth0 Dashboard ou Management API pour transmettre les scopes souhaités à votre connexion. À l’exécution, tous les scopes inclus dans le paramètre `scopes` de la requête d’autorisation ont préséance sur les scopes sélectionnés dans Auth0 Dashboard, à l’exception de `offline_access`, si requis par la connexion et activé dans Auth0 Dashboard.<br /><br /><strong>Remarque :</strong> Si requis par la connexion, Auth0 vous invitera à activer `offline_access`, ce qui permet à l’application cliente de récupérer un jeton d’actualisation auprès d’Auth0. Vous devez activer `offline_access` pour la connexion dans Auth0 Dashboard.</td>
    </tr>

    <tr>
      <td>Activée</td>
      <td>Activée</td>
      <td>La connexion utilise le flux de connexion `/authorize` pour authentifier les utilisateurs en tant que fournisseur d’identité valide. Elle utilise également le flux Comptes connectés pour récupérer et stocker les jetons d’accès pour la connexion dans le Token Vault.</td>
      <td>Utilisez Auth0 Dashboard et Management API pour transmettre les scopes souhaités à la connexion. À l’exécution, tous les scopes inclus dans le paramètre `scopes` ont préséance sur les scopes sélectionnés dans Auth0 Dashboard, à l’exception de `offline_access`, si requis par la connexion et activé dans Auth0 Dashboard.<br /><br /><strong>Remarque :</strong> Si requis par la connexion, Auth0 vous invitera à activer `offline_access`, ce qui permet à l’application cliente de récupérer un jeton d’actualisation auprès d’Auth0. Vous devez activer `offline_access` pour la connexion dans Auth0 Dashboard.</td>
    </tr>
  </tbody>
</table>

<div id="how-it-works">
  ## Fonctionnement
</div>

Le flux Comptes connectés utilise l’[API My Account](/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 initier une demande de Comptes connectés à partir de 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 scopes Comptes connectés pour accéder à l’API My Account.

Le diagramme de séquence suivant illustre le flux Comptes connectés de bout en bout :

<Frame>
  <img src="https://mintcdn.com/generaltranslationinc/78hG6sVmUVcUqk59/docs/images/token-vault/connected_accounts_flow_diagram.png?fit=max&auto=format&n=78hG6sVmUVcUqk59&q=85&s=0ec4f2dd2b281f40129f50de7a9f1998" alt="" width="2970" height="1458" data-path="docs/images/token-vault/connected_accounts_flow_diagram.png" />
</Frame>

Lorsqu’un utilisateur ouvre une session au moyen d’un fournisseur externe pris en charge via Auth0, il initie une demande de Comptes connectés à partir de l’application cliente :

1. L’application cliente envoie une requête `POST` vers le point de terminaison `/me/v1/connected-accounts` de l’API My Account, en passant les scopes et d’autres paramètres à transmettre au fournisseur externe. Pour en savoir plus, consultez [Initier une demande de Comptes connectés](#initiate-connected-accounts-request).
2. L’API My Account crée un `auth_session` et un `connect_uri` uniques contenant un `ticket` qui redirige l’utilisateur vers un navigateur Web. L’application cliente enregistre le `auth_session` pour une vérification ultérieure. Si [DPoP](/docs/fr-CA/secure/sender-constraining/demonstrating-proof-of-possession-dpop) est configuré, l’API My Account valide le JWT de preuve DPoP.
3. L’application cliente redirige l’utilisateur vers le `connect_uri` avec le `ticket` comme paramètre de requête pour l’authentification et l’autorisation de l’utilisateur dans le navigateur. L’application cliente peut aussi transmettre un `code_challenge` ou un `code_challenge_method` dans l’URL, comme dans le [flux Authorization Code avec PKCE](/docs/fr-CA/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).
4. L’utilisateur établit la connexion et accorde les autorisations pour la connexion dans l’écran de consentement.
5. Une fois que l’utilisateur a autorisé la connexion avec succès, le fournisseur externe redirige l’utilisateur vers l’API My Account, qui le redirige ensuite vers l’application cliente en utilisant le `redirect_uri` avec un `connect_code` à usage unique.
6. L’application cliente présente le `connect_code`, le `code_verifier` (le cas échéant) et le `auth_session` original à l’API My Account en effectuant une requête `POST` vers le point de terminaison `/me/v1/connected-accounts/complete`. Pour en savoir plus, consultez [Compléter une demande de Comptes connectés](#complete-connected-accounts-request).
7. L’API My Account valide la requête en confirmant :
   * que le `auth_session` correspond à l’id initialement émis pour l’utilisateur;
   * que la requête provient du même appareil que celui qui a lancé le flux Comptes connectés;
   * le JWT de preuve DPoP (s’il est configuré);
   * le `connect_code` à usage unique;
   * le `code_verifier` (si vous utilisez le flux PKCE).
8. Après validation réussie, le Serveur d’autorisation Auth0 ajoute le compte au tableau `connected_accounts` dans le profil de l’utilisateur et stocke les jetons d’accès et d’actualisation du compte connecté dans le Token Vault.
9. L’API My Account termine le flux en renvoyant un code d’état `200` à l’application cliente, indiquant que le compte a été connecté avec succès.

<div id="prerequisites">
  ## Conditions préalables
</div>

Avant de configurer les comptes connectés, assurez-vous de :

* [Configurer Token Vault](/docs/fr-CA/secure/tokens/token-vault/configure-token-vault) pour votre application cliente afin de stocker en toute sécurité les jetons d’accès et d’actualisation associés à chaque compte connecté dans Token Vault.
* [Configurer l’API My Account](#configure-my-account-api), qui est utilisée par les utilisateurs authentifiés pour connecter et gérer leurs comptes.
* [Configurer le Multi-Resource Refresh Token (MRRT)](#configure-multi-resource-refresh-token) pour 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 cliente afin d’appliquer une contrainte liée à l’émetteur sur les jetons d’accès, ce qui permet de prévenir le vol de jetons. Par défaut, l’API My Account peut accepter des jetons d’accès liés à DPoP.

<div id="configure-my-account-api">
  ### Configurer l’API My Account
</div>

Pour utiliser Connected Accounts, configurez l’API My Account dans l’Auth0 Dashboard :

1. Accédez à **Applications > APIs** et [activez l’API My Account](/docs/fr-CA/manage-users/my-account-api#activate-the-my-account-api).
2. Une fois activée, sélectionnez **Auth0 My Account API**, puis l’onglet **Applications**.
3. Activez votre application cliente pour l’autoriser à accéder à l’API My Account.
4. Dans le menu déroulant, sélectionnez les [scopes Connected Accounts](/docs/fr-CA/manage-users/my-account-api#scope) pour l’application.
5. Sélectionnez **Update**. 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 à l’API My Account avec les scopes Connected Accounts au nom de l’utilisateur.
6. 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**.

<div id="configure-multi-resource-refresh-token">
  ### Configurer le Jeton d’actualisation multi‑ressource
</div>

Configurez le Jeton d’actualisation multi‑ressource (MRRT) pour obtenir un seul jeton d’actualisation de longue durée qui peut être échangé contre de nouveaux jetons d’accès de l’API My Account et d’autres API sans exiger une nouvelle authentification de l’utilisateur.

Vous pouvez configurer MRRT avec l’[Auth0 Dashboard](https://manage.auth0.com) ou la [Management API](https://auth0.com/docs/api/management/v2).

<Tabs>
  <Tab title="Auth0 Dashboard">
    Pour configurer MRRT avec 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 MRRT avec l’API My Account, activez **My Account API**.
  </Tab>

  <Tab title="Management API">
    Pour configurer MRRT pour une application client, effectuez une requête `PATCH` vers le point de terminaison `/api/v2/clients/{clientId}` et ajoutez l’identificateur de l’API My Account et les scopes de Connected Accounts aux stratégies de jeton d’actualisation :

    ```bash lines theme={null}
    curl -X PATCH --location "https://${account.namespace}/api/v2/clients/{clientId}" \
        -H "Authorization: Bearer <YOUR_MANAGEMENT_API_TOKEN>" \
        -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"
                    ]
                  }
                ]
              }
            }'
    ```
  </Tab>
</Tabs>

<div id="configure-connected-accounts">
  ## Configurer les comptes connectés
</div>

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** et sélectionnez la connexion.
2. Sélectionnez **Applications**, puis activez la connexion pour votre application cliente.

Vous pouvez configurer les comptes connectés avec l’[Auth0 Dashboard](https://manage.auth0.com) ou la [Management API](https://auth0.com/docs/api/management/v2).

<Tabs>
  <Tab title="Auth0 Dashboard">
    Pour configurer les comptes connectés avec l’Auth0 Dashboard :

    1. Accédez à **Authentication > Social Connections** ou **Enterprise Connections**.
    2. Sélectionnez **Create Connection** ou sélectionnez une connexion existante.
    3. Dans **Purpose**, activez **Use for Connected Accounts for Token Vault**. Selon votre paramètre **Purpose**, vous pourriez devoir activer `offline_access` dans l’Auth0 Dashboard afin de permettre à l’application cliente d’obtenir un jeton d’actualisation du fournisseur externe pendant le flux de 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**.
  </Tab>

  <Tab title="Management API">
    Pour configurer les comptes connectés avec la Management API, faites une requête `PATCH` vers le point de terminaison `/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 <YOUR_MANAGEMENT_API_TOKEN>" \
    -d '{"connected_accounts":{"active":true}}'
    ```
  </Tab>
</Tabs>

<div id="get-access-token-for-connected-accounts">
  ## Obtenir un jeton d’accès pour Connected Accounts
</div>

Avant d’effectuer 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 scopes de Connected Accounts.

Les sections suivantes expliquent comment utiliser le [Jeton d’actualisation multi-ressource (MRRT)](/docs/fr-CA/secure/tokens/refresh-tokens/multi-resource-refresh-token) pour obtenir un jeton d’accès pour l’API My Account.

<div id="fetch-a-refresh-token">
  ### Récupérer un jeton d’actualisation
</div>

Après avoir [configuré MRRT](#configure-multi-resource-refresh-token) pour l’application cliente, lancez le flux de code d’autorisation et échangez le code d’autorisation qui en résulte contre un jeton d’actualisation.

La requête suivante illustre un flux de code d’autorisation pour un client confidentiel qui inclut le paramètre `offline_scope` afin de renvoyer un jeton d’actualisation et un code d’autorisation à usage unique pour l’identifiant d’API My Account `https://{yourDomain}/me/` :

```bash lines theme={null}
open "https://{yourDomain}/authorize?client_id=<CLIENT_ID>&response_type=code&prompt=login&scope=openid%20profile%20offline_access&redirect_uri=<REDIRECT_URI>&state=<STATE>&audience=https://my-example-api.com"
```

Échangez le code d’autorisation à usage unique contre un jeton d’actualisation au point de terminaison `/token` :

```bash lines theme={null}
curl -s --request POST \
  --url "https://{yourDomain}/oauth/token" \
  --header 'Content-Type: application/json' \
  --data-binary @- <<EOF | jq -r '.refresh_token'
{
  "grant_type": "authorization_code",
  "code": "<CONNECT_CODE>",
  "scope": "openid profile offline_access",
  "client_id": "<CLIENT_ID>",
  "client_secret": "<CLIENT_SECRET>",
  "audience": "https://{yourDomain}/me/",
  "redirect_uri": "<REDIRECT_URI>"
}
EOF
```

<div id="exchange-refresh-token-for-my-account-api-access-token">
  ### Échanger un jeton d’actualisation contre un jeton d’accès à l’API My Account
</div>

Une fois que vous avez obtenu un jeton d’actualisation, échangez‑le contre un jeton d’accès à l’API My Account avec les scopes Connected Accounts en utilisant le type de grant `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=<CLIENT_ID>" \
  --data-urlencode "client_secret=<CLIENT_SECRET>" \
  --data-urlencode "refresh_token=<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"
```

<div id="initiate-connected-accounts-request">
  ## Lancer une requête Connected Accounts
</div>

Pour lancer une requête Connected Accounts, faites une requête `POST` vers le point de terminaison `/me/v1/connected-accounts/connect` de l’API My Account avec les paramètres suivants :

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour une connexion sociale Google, assurez-vous de sélectionner `offline_access` dans Auth0 Dashboard lorsque vous configurez votre connexion. Ceci est requis pour que votre application client puisse récupérer un Jeton d’actualisation auprès du Serveur d’autorisation Auth0.
</Callout>

<table class="table">
  <thead>
    <tr>
      <th><strong>Paramètre</strong></th>
      <th><strong>Description</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><code>connection</code></td>
      <td>Nom de la connexion. Pour une connexion sociale Google, définissez-la sur <code>google-oauth2</code>.</td>
    </tr>

    <tr>
      <td><code>redirect\_uri</code></td>
      <td>L’URL de rappel (callback) de votre application client.</td>
    </tr>

    <tr>
      <td><code>state</code></td>
      <td>Une chaîne unique et aléatoire associée à la requête pour prévenir les attaques.</td>
    </tr>

    <tr>
      <td><code>scopes</code></td>
      <td>(Facultatif) Les scopes transmis au fournisseur externe sous forme de tableau de chaînes.<br /><br />S’il est utilisé pour transmettre des scopes pour une connexion sociale Google, incluez au minimum `openid` et `profile`. Au moment de l’exécution, tous les scopes inclus dans le paramètre `scopes` ont préséance sur les scopes sélectionnés dans Auth0 Dashboard, à l’exception de `offline_access`, s’il est requis par la connexion et activé dans Auth0 Dashboard.</td>
    </tr>
  </tbody>
</table>

```bash lines theme={null}
curl --request POST "https://{yourDomain}/me/v1/connected-accounts/connect" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer <MY_ACCOUNT_API_TOKEN>" \
--data '{
    "connection": "google-oauth2",
    "redirect_uri": "<REDIRECT_URI>",
    "state": "<STATE>",
    "scopes": ["openid","profile"] // toutes les portées transmises remplacent les portées sélectionnées dans le Auth0 Dashboard
}'
```

Si l’opération réussit, l’API My Account renvoie une réponse semblable à la suivante :

<table class="table">
  <thead>
    <tr>
      <th><strong>Paramètre</strong></th>
      <th><strong>Description</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><code>auth\_session</code></td>
      <td>ID de session qui représente la session actuelle authentifiée de l’utilisateur principal. L’application cliente enregistre l’ID de session pour une vérification ultérieure.</td>
    </tr>

    <tr>
      <td><code>connect\_uri</code></td>
      <td>URL vers laquelle l’application cliente redirige l’utilisateur, ce qui ouvre un navigateur web pour gérer l’autorisation avec le fournisseur externe.</td>
    </tr>

    <tr>
      <td><code>connect\_params</code></td>
      <td>Paramètres supplémentaires requis pour l’URI de connexion. Comprend un ticket temporaire que l’API My Account utilise pour vérifier la requête.</td>
    </tr>

    <tr>
      <td><code>expires\_in</code></td>
      <td>Temps d’expiration de la session, en secondes.</td>
    </tr>
  </tbody>
</table>

```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 à `connect_uri` avec le `ticket` en tant que paramètre de requête. Autorisez la liste de scopes dans l’écran de consentement, 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}
```

<div id="complete-connected-accounts-request">
  ## Terminer une requête de comptes connectés
</div>

Pour terminer une requête de comptes connectés, envoyez une requête `POST` au point de terminaison `/me/v1/connected-accounts/complete` avec les paramètres suivants :

<table class="table">
  <thead>
    <tr>
      <th><strong>Paramètre</strong></th>
      <th><strong>Description</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><code>auth\_session</code></td>
      <td>ID de session qui représente la session actuelle authentifiée de l’utilisateur principal. L’application cliente enregistre l’ID de session pour une vérification ultérieure.</td>
    </tr>

    <tr>
      <td><code>connect\_code</code></td>
      <td>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 pour récupérer les jetons d’accès définitifs pour l’API externe.</td>
    </tr>

    <tr>
      <td><code>redirect\_uri</code></td>
      <td>L’URL de rappel exacte de votre application où l’utilisateur a été redirigé après avoir autorisé avec succès la connexion au fournisseur externe. Cette valeur doit correspondre au `redirect_uri` utilisé pour lancer le flux.</td>
    </tr>
  </tbody>
</table>

```bash lines theme={null}
curl --location "https://{yourDomain}/me/v1/connected-accounts/complete" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer <MY_ACCOUNT_API_TOKEN>" \
--data '{
    "auth_session": "<AUTH_SESSION>",
    "connect_code": "<CONNECT_CODE>",
    "redirect_uri": "<REDIRECT_URI>"
}'
```

En cas de réussite, l’API My Account renvoie une réponse semblable à ce qui suit :

<table class="table">
  <thead>
    <tr>
      <th><strong>Paramètre</strong></th>
      <th><strong>Description</strong></th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><code>id</code></td>
      <td>Identifiant unique du compte connecté.</td>
    </tr>

    <tr>
      <td><code>connection</code></td>
      <td>Nom de la connexion.</td>
    </tr>

    <tr>
      <td><code>created\_at</code></td>
      <td>Horodatage indiquant le moment où le compte connecté a été créé et lié au profil de l'utilisateur.</td>
    </tr>

    <tr>
      <td><code>scopes</code></td>
      <td>Les portées OAuth spécifiques (autorisations) que l'utilisateur a accordées à votre application au moment de la connexion au fournisseur externe. Ces portées déterminent quelles actions sur l'API externe votre application peut effectuer.</td>
    </tr>

    <tr>
      <td><code>access\_type</code></td>
      <td>Indique le type d'accès accordé. Une valeur courante est <code>offline</code>, ce qui signifie qu'un Jeton d’actualisation a été obtenu et stocké avec succès, permettant à votre application de conserver l'accès même lorsque l'utilisateur est hors ligne.</td>
    </tr>
  </tbody>
</table>

```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"
}
```

<div id="manage-connected-accounts">
  ## Gérer les comptes connectés
</div>

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 Connected Accounts](#get-access-token-for-connected-accounts).

<div id="query-connected-accounts-connections">
  ### Interroger les connexions des comptes connectés
</div>

Effectuez une requête `GET` vers le point de terminaison `/me/v1/connected-accounts/connections` afin d’obtenir une liste de connexions associées au profil de l’utilisateur :

```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/me/v1/connected-accounts/connections" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer <MY_ACCOUNT_API_TOKEN>"
```

En cas de succès, l’API My Accounts renvoie une réponse semblable à la suivante :

```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"
      ]
    }
  ]
}
```

<div id="query-connected-accounts">
  ### Interroger les comptes connectés
</div>

Effectuez une requête `GET` vers le point de terminaison `/me/v1/connected-accounts/accounts` pour obtenir une liste des comptes connectés associés au profil de l’utilisateur :

```bash lines theme={null}
curl -X GET --location "https://{yourDomain}/me/v1/connected-accounts/accounts" \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer <MY_ACCOUNT_API_TOKEN>"
```

Si l’opération réussit, l’API My Accounts renvoie une réponse semblable à la suivante :

```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 une liste de comptes connectés pour le profil d’un utilisateur en effectuant une requête `GET` vers le 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 <YOUR_MANAGEMENT_API_TOKEN>"
```

En cas de succès, la Management API renvoie une réponse semblable à 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"
    }
  ]
}
```

<div id="query-connected-accounts-for-a-given-connection">
  ### Interroger les comptes connectés pour une connexion donnée
</div>

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 pour obtenir une liste de comptes connectés filtrée par la connexion spécifié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 <MY_ACCOUNT_API_TOKEN>"
```

Si l’opération réussit, l’API My Accounts renvoie une réponse semblable à la suivante, 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"
    }
  ]
}
```

<div id="delete-connected-account">
  ### Supprimer un compte connecté
</div>

Effectuez une requête `DELETE` sur le point de terminaison `/me/v1/connected-accounts/accounts/{connectedAccountId}` pour supprimer un compte connecté associé à 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 <MY_ACCOUNT_API_TOKEN>"
```

Lorsque vous supprimez un compte connecté, Auth0 supprime les jetons d’accès et d’actualisation du fournisseur externe du coffre-fort de jetons (Token Vault). Cela ne révoque pas automatiquement les jetons du fournisseur externe, et le jeton d’actualisation pourrait encore être utilisé pour 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 retourne une réponse semblable à la suivante :

```
HTTP/1.1 204 No Content
```