> ## 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.

> Appelez l’API d’un fournisseur d’identité social ou d’entreprise depuis votre application Auth0 à l’aide du jeton d’accès du fournisseur en amont qu’Auth0 a stocké après la connexion de l’utilisateur.

# Appeler l’API d’un fournisseur d’identité

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 <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

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 <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si [Token Vault](/fr-CA/docs/secure/tokens/token-vault) est activé pour votre connexion, les jetons d’accès et d’actualisation ne seront plus stockés dans le tableau `identities` de l’utilisateur. Ils seront plutôt stockés dans un jeu de jetons sécurisé dans Token Vault. Pour activer Token Vault, consultez [Configurer Token Vault](/fr-CA/docs/secure/tokens/token-vault/configure-token-vault).
</Callout>

Une fois que vous avez authentifié avec succès un utilisateur auprès d’un <Tooltip tip="fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> (IdP) externe, comme Facebook ou GitHub, l’IdP inclut souvent un <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+token">jeton d’accès</Tooltip> dans le profil utilisateur qu’il renvoie à Auth0.

Vous pouvez récupérer et utiliser ce jeton pour appeler l’API de l’IdP.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Cet article suppose que vous avez déjà configuré la connexion avec l’IdP de votre choix. Sinon, accédez à [Fournisseurs d’identité pris en charge par Auth0](/fr-CA/docs/authenticate/identity-providers/social-identity-providers), sélectionnez l’IdP souhaité et suivez les étapes de configuration.
</Callout>

Le processus à suivre diffère selon que votre code s’exécute dans le backend ou le frontend :

* Si votre code s’exécute dans le backend, nous pouvons supposer que votre serveur est fiable et peut stocker des secrets en toute sécurité (comme vous le verrez, nous utilisons un secret dans le scénario backend). Si c’est le cas, passez à la [section backend](#from-the-backend) de cet article.
* Si votre code s’exécute dans le frontend (par exemple, il s’agit d’une application monopage, d’une application de bureau native ou d’une application mobile), votre application ne peut pas stocker des identifiants de façon sécurisée et doit suivre une autre approche. Dans ce cas, passez à la [section frontend](#from-the-frontend) de cet article.

<div id="from-the-backend">
  ## Du backend
</div>

Une fois que vous authentifiez un utilisateur, l’IdP inclut souvent un Jeton d’accès dans le profil utilisateur qu’il renvoie à Auth0.

Pour des raisons de sécurité et de conformité, Auth0 n’envoie pas ce jeton à votre application dans le profil utilisateur. Pour l’obtenir, vous devez accéder à la <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip> d’Auth0 et récupérer le profil complet de l’utilisateur :

1. Obtenez un Jeton d’accès qui vous permet d’appeler la [Management API d’Auth0](https://auth0.com/docs/api/management/v2).
2. Appelez le [point de terminaison Get Users by ID](https://auth0.com/docs/api/management/v2#!/Users/get_users_by_id) de la Management API d’Auth0 à l’aide du Jeton d’accès obtenu à l’étape 1. Ce point de terminaison renvoie le profil complet de l’utilisateur, qui contient le Jeton d’accès de l’IdP.
3. Extrayez le Jeton d’accès de l’IdP de la réponse et utilisez-le pour appeler l’API de l’IdP.

<div id="step-1-get-a-token">
  ### Étape 1 : Obtenir un jeton
</div>

Vous aurez besoin d’un jeton d’accès pour appeler la [Management API](https://auth0.com/docs/api/management/v2).

<div id="create-a-test-application-for-the-management-api">
  #### Créer une application de test pour la Management API
</div>

Si c’est la première fois que vous demandez un [jeton Management API v2](https://auth0.com/docs/api/management/v2/tokens), vous devrez créer et configurer une application pouvant être utilisée pour appeler la Management API :

1. Accédez à [Auth0 Dashboard > Applications > APIs](https://manage.auth0.com/#/apis), puis sélectionnez [Auth0 Management API](https://manage.auth0.com/#/apis/management/authorized-clients).
2. Sélectionnez la vue **API Explorer**, puis cliquez sur **Create & Authorize a Test Application**.

Cela créera une nouvelle application et lui attribuera tous les scopes de la Management API, ce qui signifie que les jetons générés pour cette application pourront accéder à tous les points de terminaison de la Management API.

<Card title="Vous ne voyez pas le bouton ?">
  Si vous ne voyez pas ce bouton, cela signifie que vous avez déjà au moins une application autorisée pour la Management API. Dans ce cas, vous pouvez soit mettre à jour les scopes de l’application existante et l’utiliser, soit en créer une nouvelle en suivant ces étapes :

  1. Accédez à [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), puis sélectionnez **Create Application**.
  2. Sélectionnez **Machine to Machine Applications**, puis **Create**.
  3. Dans la liste déroulante **Select an API**, sélectionnez `Auth0 Management API`.
  4. Activez les scopes requis, puis sélectionnez **Authorize**.
  5. Sélectionnez la vue **APIs**, puis activez le commutateur pour **Auth0 Management API**.
</Card>

<Warning>
  Pour des raisons de sécurité, nous vous recommandons d’attribuer uniquement les scopes requis à l’application que vous utiliserez. Dans ce cas précis, les scopes dont vous avez besoin sont : `read:users`, `read:user_idp_tokens`. Les scopes requis sont indiqués pour chaque point de terminaison dans le [Management API Explorer](https://auth0.com/docs/api/management/v2).
</Warning>

Pour accorder ou retirer des scopes de l’[Auth0 Management API](https://manage.auth0.com/#/apis/management/authorized-clients) enregistrée, sélectionnez la [vue **Machine to Machine Applications**](https://manage.auth0.com/#/apis/management/authorized-clients) :

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6nuMjQMrTWhoVqtRwJBQz7/28a0f7c89c696426e273f43bd849b5e5/2025-02-25_11-11-36.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5a948f2961c567c0aa434569c9fabe68" alt="Modifier les scopes attribués à l’application" width="899" height="770" data-path="docs/images/cdy7uua7fh8z/6nuMjQMrTWhoVqtRwJBQz7/28a0f7c89c696426e273f43bd849b5e5/2025-02-25_11-11-36.png" />
</Frame>

<div id="get-the-management-api-token">
  #### Obtenir le jeton de la Management API
</div>

La configuration est maintenant terminée, et vous êtes prêt à obtenir votre jeton de la Management API :

1. Dans la [Management API d’Auth0 que vous avez enregistrée](https://manage.auth0.com/#/apis/management/authorized-clients), sélectionnez la vue [**Test**](https://manage.auth0.com/#/apis/management/test).
2. Choisissez votre application dans la liste déroulante **Application** pour préremplir les extraits de code prêts à l’emploi avec des variables personnalisées.
3. Choisissez la langue de votre choix pour l’extrait, puis copiez-le et exécutez-le.
4. Récupérez la propriété `access_token` de la réponse. C’est ce que vous utiliserez pour accéder à la Management API.

<Card title="Que font les extraits de code ?">
  Les extraits de code effectuent une opération `POST` vers le [point de terminaison /oauth/token de l’Auth0 Authentication API](https://auth0.com/docs/api/authentication#client-credentials), en utilisant le **grant Client Credentials d’OAuth 2.0**. Il s’agit du grant utilisé par les processus machine à machine pour accéder à une API. Pour en savoir plus sur ce flux, consultez [Client Credentials Flow](/fr-CA/docs/get-started/authentication-and-authorization-flow/client-credentials-flow).
</Card>

<div id="token-expiration">
  #### Expiration du jeton
</div>

Par défaut, le jeton que vous avez reçu expire après 24 heures (86 400 secondes). Pour modifier cette valeur :

1. Accédez à [Auth0 Dashboard > Applications > APIs](https://manage.auth0.com/#/apis), puis sélectionnez l’[Auth0 Management API](https://manage.auth0.com/#/apis/management/authorized-clients).
2. Sélectionnez l’onglet **Settings**, repérez le champ **Token Expiration (Seconds)**, saisissez une nouvelle valeur, puis cliquez sur **Save**. La valeur maximale que vous pouvez définir est de 2 592 000 secondes (30 jours), mais nous vous recommandons de conserver la valeur par défaut.

Le prochain jeton que vous générerez utilisera la nouvelle durée d’expiration.

<Warning>
  Ces jetons **ne peuvent pas être révoqués**. Pour réduire les risques, nous vous recommandons d’émettre des jetons de courte durée et d’accorder uniquement les scopes nécessaires à chaque application. Dans un environnement de production, vous pouvez configurer un CLI simple qui récupérera un nouveau jeton lorsque l’ancien expirera.
</Warning>

<div id="step-2-get-the-full-user-profile">
  ### Étape 2 : Obtenir le profil complet de l’utilisateur
</div>

Pour obtenir le profil d’un utilisateur, appelez le point de terminaison [Get a User](https://auth0.com/docs/api/management/v2#!/Users/get_users_by_id) du Management API à l’aide du jeton d’accès que vous avez extrait dans la section précédente :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/api/v2/users/%7BuserId%7D' \
    --header 'authorization: Bearer {yourAccessToken}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/%7BuserId%7D");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {yourAccessToken}");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

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

  func main() {

  	url := "https://{yourDomain}/api/v2/users/%7BuserId%7D"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer {yourAccessToken}")

  	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<String> response = Unirest.get("https://{yourDomain}/api/v2/users/%7BuserId%7D")
    .header("authorization", "Bearer {yourAccessToken}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/api/v2/users/%7BuserId%7D',
    headers: {authorization: 'Bearer {yourAccessToken}'}
  };

  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}/api/v2/users/%7BuserId%7D",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {yourAccessToken}"
    ],
  ]);

  $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("")

  headers = { 'authorization': "Bearer {yourAccessToken}" }

  conn.request("GET", "/{yourDomain}/api/v2/users/%7BuserId%7D", headers=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}/api/v2/users/%7BuserId%7D")

  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)
  request["authorization"] = 'Bearer {yourAccessToken}'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Remplacez ces valeurs :

* `{userId}` : ID de l’utilisateur pour lequel vous voulez appeler l’API de l’IdP.
* `{yourAccessToken}` : jeton d’accès que vous avez extrait dans la section précédente.

<Card title="Où trouver l’ID utilisateur ?">
  - À des fins de test, vous pouvez trouver un ID utilisateur dans [Auth0 Dashboard > User Management > Users](https://manage.auth0.com/#/users). Repérez un utilisateur, puis copiez la valeur du champ **user\_id**.

  - Pour votre implémentation, vous pouvez soit extraire l’ID utilisateur de la revendication `sub` dans le [ID Token](/fr-CA/docs/secure/tokens/id-tokens), soit appeler le [point de terminaison /userinfo](https://auth0.com/docs/api/authentication#get-user-info) de l’Authentication API et extraire cette valeur de la propriété `user_id` dans la réponse.
</Card>

<div id="step-3-extract-the-idp-access-token">
  ### Étape 3 : Extraire le jeton d’accès de l’IdP
</div>

Vous trouverez le jeton d’accès utilisé pour appeler l’API de l’IdP dans le tableau `identities` de l’utilisateur : `user.identities[0].access_token`.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour certains fournisseurs d’identité, Auth0 stocke également un Jeton d’actualisation, que vous pouvez utiliser pour obtenir un nouveau Jeton d’accès pour l’IdP. C’est le cas pour : BitBucket, Google (OAuth 2.0), OAuth 2.0, SharePoint et Azure AD. Pour en savoir plus, consultez [Jetons d’accès de fournisseur d’identité](/fr-CA/docs/secure/tokens/access-tokens/identity-provider-access-tokens).
</Callout>

Dans la plupart des cas, l’utilisateur n’aura qu’une seule identité, mais s’il s’est connecté plusieurs fois au moyen de différentes connexions et que vous avez utilisé la [liaison de comptes](/fr-CA/docs/manage-users/user-accounts/user-account-linking/link-user-accounts), il peut y en avoir plusieurs.

Dans cet exemple de réponse, nous voyons que notre utilisateur n’a qu’une seule identité : `google-oauth2`.

```json lines expandable theme={null}
{
  "email": "john.doe@test.com",
  "email_verified": true,
  "name": "John Doe",
  "given_name": "John",
  "family_name": "Doe",
  "picture": "https://myavatar/photo.jpg",
  "gender": "male",
  "locale": "en",
  "updated_at": "2017-03-15T07:14:32.451Z",
  "user_id": "google-oauth2|111199914890750704174",
  "nickname": "john.doe",
  "identities": [
    {
      "provider": "google-oauth2",
      "access_token": "ya29.GlsPBCS6ahokDlgCYnVLnDKNE71HBXPEzNhAPoKJLAGKDSe1De3_xclahNcdZXoU-26hCpa8h6240TV86dtaEQ4ZWoeeZduHDq_yeu9QyQqUr--S9B2CR9YJrLTD",
      "expires_in": 3599,
      "user_id": "111199914890750704174",
      "connection": "google-oauth2",
      "isSocial": true
    }
  ],
  "created_at": "2017-03-15T07:13:41.134Z",
  "last_ip": "127.0.0.1",
  "last_login": "2017-03-15T07:14:32.451Z",
  "logins_count": 99
}
```

Vous êtes maintenant prêt à appeler l’API de l’IdP. Consultez la documentation de l’IdP pour savoir exactement comment procéder.

<Warning>
  N’exposez pas les jetons de l’IdP à votre application côté client ! Si votre application est publique, consultez la [section sur le front-end](#from-the-frontend) de cet article.
</Warning>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour en savoir plus sur la façon de demander des scopes précis pour un Jeton d’accès du fournisseur d’identité, consultez [Ajouter des scopes/autorisations pour appeler les API d’un fournisseur d’identité](/fr-CA/docs/authenticate/identity-providers/adding-scopes-for-an-external-idp).
</Callout>

<div id="from-the-frontend">
  ## Depuis le frontend
</div>

Si vous travaillez avec une application publique (SPA, application de bureau native ou application mobile), c’est la section qu’il vous faut.

Lorsque vous travaillez avec une application frontend, le processus pour appeler les API d’IdP diffère de celui du backend, car les applications frontend sont des applications publiques qui **ne peuvent pas stocker des identifiants de façon sécurisée**. Comme le code d’une SPA peut être consulté et modifié, et que les applications natives et mobiles peuvent être décompilées et inspectées, on ne peut pas leur faire confiance pour stocker des renseignements sensibles comme des clés secrètes ou des mots de passe.

Plus précisément, elles ne peuvent pas stocker de façon sécurisée le **<Tooltip tip="Secret client : secret utilisé par une application pour s’authentifier auprès du serveur d’autorisation; il ne devrait être connu que de l’application et du serveur d’autorisation et doit être suffisamment aléatoire pour ne pas pouvoir être deviné." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Client+Secret">Secret client</Tooltip>** de l’application Machine to Machine, que vous utilisez pour appeler `/oauth/token` à la première étape du processus backend.

Vous devez plutôt créer un proxy pour votre backend et l’exposer à votre application sous forme d’API.

<div id="build-a-proxy">
  ### Créer un proxy
</div>

D’abord, vous mettrez en place un processus dans votre backend qui exécutera les étapes décrites dans [la section backend](#from-the-backend) de cet article, puis l’exposera à votre application sous forme d’API.

Vous appellerez l’API de l’IdP à partir du même processus backend, afin que le Jeton d’accès ne soit jamais exposé à votre application publique.

Ensuite, vous appellerez l’API de votre proxy depuis votre application publique en utilisant le [flux de code d’autorisation avec clé de preuve pour l’échange de code (PKCE)](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).

<Card title="Montrez-moi comment">
  Si vous n’avez jamais implémenté cela auparavant, notre scénario d’architecture [Applications monopages (SPA) avec API](/fr-CA/docs/get-started/architecture-scenarios/spa-api) pourrait vous être utile. Il couvre un scénario différent, mais explique comment configurer Auth0, comment appeler une API à partir d’une SPA et comment mettre en œuvre les validations d’API. Il comprend un exemple qui utilise [Angular 2](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-spa/angular) et [Node.js](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-api/node).

  Nous proposons aussi une variante [Applications mobiles avec API](/fr-CA/docs/get-started/architecture-scenarios/mobile-api) (l’exemple utilise [Android](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-mobile/android) et [Node.js](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-api/node)).
</Card>