> ## 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 vous connecter à des fournisseurs d’identité OpenID Connect (OIDC) à l’aide d’une connexion d’entreprise.

# Se connecter à un fournisseur d’identité OpenID Connect

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) + "*****MASQUÉ*****";
          }
          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>;
};

<div id="prerequisites">
  ## Prérequis
</div>

* [Enregistrez votre application auprès d’Auth0](/docs/fr-ca/get-started/auth0-overview/create-applications).

  * Sélectionnez un **Type d’application** approprié.
  * Ajoutez une **URL de rappel autorisée** : **`{https://yourApp/callback}`**.
  * Assurez-vous que les [Types d’octroi](/docs/fr-ca/get-started/applications/update-grant-types) de votre application incluent les flux appropriés.

<div id="steps">
  ## Étapes
</div>

Pour connecter votre application à un <Tooltip tip="Fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> OIDC, vous devez :

1. [Configurer votre application dans le fournisseur d’identité OpenID Connect](#set-up-your-app-in-the-openid-connect-identity-provider)
2. [Créer une connexion d’entreprise dans Auth0](#create-an-enterprise-connection-in-auth0)
3. [Activer la connexion d’entreprise pour votre application Auth0](#enable-the-enterprise-connection-for-your-auth0-application)
4. [Tester la connexion](#test-the-connection)

<div id="set-up-your-app-in-the-openid-connect-identity-provider">
  ## Configurez votre application dans le fournisseur d’identité OpenID Connect
</div>

Pour permettre aux utilisateurs de se connecter à l’aide d’un fournisseur d’identité OIDC, vous devez enregistrer votre application auprès de l’IdP. Le processus varie selon le fournisseur d’identité OIDC; vous devrez donc suivre la documentation de votre IdP pour effectuer cette tâche.

En général, vous devrez vous assurer de saisir, à un moment donné, votre URL de rappel : `https://{YOUR_AUTH0_DOMAIN}/login/callback`.

<Card title="Trouvez votre nom de domaine Auth0 pour les redirections">
  Si votre nom de domaine Auth0 n’est pas indiqué ci-dessus et que vous n’utilisez pas notre fonctionnalité [domaines personnalisés](/docs/fr-ca/customize/custom-domains), votre nom de domaine est formé du nom de votre tenant, de votre sous-domaine régional et de `auth0.com`, séparés par des points (`.`).

  Par exemple, si le nom de votre tenant est `exampleco-enterprises` et que votre tenant se trouve dans la région des États-Unis, votre nom de domaine Auth0 serait `exampleco-enterprises.us.auth0.com` et votre **Redirect URI** serait `https://exampleco-enterprises.us.auth0.com/login/callback`.

  Cependant, si votre tenant se trouve dans la région des États-Unis et a été créé avant juin 2020, votre nom de domaine Auth0 serait `exampleco-enterprises.auth0.com` et votre **Redirect URI** serait `https://exampleco-enterprises.auth0.com/login/callback`.

  Si vous utilisez des [domaines personnalisés](/docs/fr-ca/customize/custom-domains), votre **Redirect URI** serait `https://<YOUR CUSTOM DOMAIN>/login/callback`.
</Card>

Pendant ce processus, votre fournisseur d’identité OIDC générera un identifiant unique pour l’API enregistrée, habituellement appelé **<Tooltip tip="Client ID: Valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Client+ID">Client ID</Tooltip>** ou **Application ID**. Prenez cette valeur en note; vous en aurez besoin plus tard.

<div id="create-an-enterprise-connection-in-auth0">
  ## Créer une Enterprise Connection dans Auth0
</div>

Avant de configurer une Enterprise Connection OIDC dans Auth0, assurez-vous d’avoir l’ID d’Application (Client) ainsi que le **<Tooltip tip="Client Secret : Secret utilisé par un client (application) pour s’authentifier auprès de l’Authorization Server; il ne devrait être connu que du client et de l’Authorization Server et être suffisamment aléatoire pour qu’on ne puisse pas le deviner." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Client+secret">Client Secret</Tooltip>** générés lorsque vous configurez votre application auprès du fournisseur OIDC.

<div id="create-an-enterprise-connection-using-the-auth0-dashboard">
  ### Créer une connexion d’entreprise à l’aide de l’Auth0 Dashboard
</div>

<Warning>
  Pour pouvoir être configuré dans l’Auth0 Dashboard, le fournisseur d’identité (IdP) OpenID Connect (OIDC) doit prendre en charge [OIDC Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html). Sinon, vous pouvez [configurer la connexion à l’aide de la Management API](#configure-the-connection-using-the-management-api).
</Warning>

1. Accédez à [Auth0 Dashboard > Authentication > Enterprise](https://manage.auth0.com/#/connections/enterprise), repérez **Open ID Connect** et sélectionnez **Create**.

   <Frame>
     <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1fSTcrZpkgkPR64NnI1lr8/b3454e60a4463e99353603fd11a71983/Enterprise_Connections_-_EN.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=d70364390d8c16ca8efe20e3e1795db4" alt="Dashboard - Connexions - Enterprise" width="600" height="561" data-path="docs/images/cdy7uua7fh8z/1fSTcrZpkgkPR64NnI1lr8/b3454e60a4463e99353603fd11a71983/Enterprise_Connections_-_EN.png" />
   </Frame>

2. Entrez les détails de votre connexion, puis sélectionnez **Create** :

<Frame>
  <img src="https://mintcdn.com/translations/pvjQqAy3EB2TK6NP/docs/images/cdy7uua7fh8z/4PO4eBhEM3R0ZMhaTlDVfB/a46be0e0bdd58c4230ea118a9bca0eed/create-enterprise-oidc-connection.png?fit=max&auto=format&n=pvjQqAy3EB2TK6NP&q=85&s=14147a380e08d47095ef70dccd86c6ef" alt="Saisir les détails de la connexion OIDC" width="600" height="1256" data-path="docs/images/cdy7uua7fh8z/4PO4eBhEM3R0ZMhaTlDVfB/a46be0e0bdd58c4230ea118a9bca0eed/create-enterprise-oidc-connection.png" />
</Frame>

| **Champ**                                        | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Purpose**                                      | Détermine comment vous comptez utiliser la connexion : pour l’authentification de l’utilisateur, pour connecter des comptes externes à Auth0, ou pour les deux. Pour en savoir plus, consultez [Authentification de l’utilisateur vs comptes connectés](/docs/fr-ca/secure/tokens/token-vault/connected-accounts-for-token-vault#user-authentication-vs-connected-accounts)                                                                                                                                                                                                                                                                                                                                                                                   |
| **Connection name**                              | Identifiant logique de votre connexion; il doit être unique dans votre tenant. Une fois défini, ce nom ne peut plus être modifié.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **OpenID Connect Discovery URL**                 | URL où Auth0 peut trouver le <strong><a href="https://openid.net/specs/openid-connect-discovery-1_0.html">point de terminaison well-known de découverte OpenID Connect</a></strong>, généralement accessible au point de terminaison <code>/.well-known/openid-configuration</code>. Vous pouvez entrer l’URL de base ou l’URL complète. Une coche verte s’affichera si Auth0 la trouve à cet emplacement, un indicateur rouge s’il ne la trouve pas, ou un message d’erreur si le fichier est trouvé mais que les renseignements requis ne figurent pas dans le fichier de configuration. Pour en savoir plus, consultez [Configurer des applications avec OIDC Discovery](/docs/fr-ca/get-started/applications/configure-applications-with-oidc-discovery). |
| **Client ID**                                    | L’identifiant fourni par votre fournisseur. Il s’agit de l’identifiant unique de votre application enregistrée. Entrez la valeur enregistrée du Client ID pour l’application que vous avez enregistrée auprès du fournisseur d’identité OIDC. Chaque fournisseur gère cette étape différemment.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **Communication Channel**                        | Réglez-le sur <strong>canal frontal</strong> ou <strong>canal arrière</strong>. canal frontal utilise le protocole OIDC avec <code>response\_mode=form\_post</code> et <code>response\_type=id\_token</code>. Le canal arrière utilise <code>response\_type=code</code>.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| **Authentication Method**                        | Choisissez comment votre application s’authentifie auprès d’Auth0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| **Client Secret**                                | Disponible si vous avez choisi <strong>canal arrière</strong> plus tôt. Il s’agit du secret fourni par votre fournisseur, et chaque fournisseur gère cette étape différemment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| **Callback URL**                                 | URL vers laquelle Auth0 redirige les utilisateurs après leur authentification. Assurez-vous que cette valeur est configurée pour l’application que vous avez enregistrée auprès du fournisseur d’identité OIDC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **Sync user profile attributes at each login**   | Si cette option est sélectionnée, votre tenant met à jour les Root Attributes pertinents <code>name</code>, <code>nickname</code>, <code>given\_name</code>, <code>family\_name</code> ou <code>picture</code> chaque fois qu’un utilisateur se connecte.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| **promouvoir la connexion au niveau du domaine** | Permet aux applications tierces d’accéder à la connexion.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

3. Dans la vue **Settings**, apportez des ajustements de configuration supplémentaires, au besoin.

| **Champ**                                        | **Description**                                                                                                                                                                                                                                                                                                                                                                                                   |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Nom de la connexion**                          | Le nom que vous avez fourni lors de la création de cette connexion. Il ne peut pas être modifié.                                                                                                                                                                                                                                                                                                                  |
| **Métadonnées de la connexion**                  | Générées automatiquement à partir de l’URL du point de terminaison well-known que vous avez fournie à l’écran précédent, elles peuvent être remplacées en téléversant un nouveau fichier de métadonnées.                                                                                                                                                                                                          |
| **Authentification**                             | Réglez cette option sur **canal frontal** ou **canal arrière**. Le canal frontal utilise le protocole OIDC avec `response_mode=form_post` et `response_type=id_token`. Le canal arrière utilise `response_type=code`. Sélectionnez **Gérer l’authentification** pour mettre à jour ce paramètre dans l’onglet Credentials.                                                                                        |
| **Portées**                                      | Liste de portées Auth0 séparées par des virgules à demander lors de la connexion au fournisseur d’identité. Cela a une incidence sur les données stockées dans le profil utilisateur. Vous devez inclure au minimum la portée `openid`. Notez que la connexion n’effectue pas de requête au point de terminaison `/userinfo` et s’attend à ce que les claims de l’utilisateur soient présents dans le `id_token`. |
| **URL de rappel**                                | Certains fournisseurs ont besoin de cette URL pour compléter votre connexion OIDC.                                                                                                                                                                                                                                                                                                                                |
| **Mappage des utilisateurs**                     | Fournit des modèles permettant de mapper des attributs utilisateur précis à des variables de connexion.                                                                                                                                                                                                                                                                                                           |
| **Profil de connexion**                          | Pour savoir comment modifier votre profil de connexion, consultez [Configurer PKCE et le mappage des claims pour les connexions OIDC](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc).                                                                                                                                                           |
| **Objectif**                                     | Détermine comment vous comptez utiliser la connexion : pour l’authentification de l’utilisateur, pour connecter des comptes externes à Auth0, ou pour les deux. Pour en savoir plus, consultez [Authentification de l’utilisateur vs comptes connectés](/docs/fr-ca/secure/tokens/token-vault/connected-accounts-for-token-vault#user-authentication-vs-connected-accounts)                                       |
| **Global Token Revocation**                      | Utilisez le point de terminaison fourni pour mettre fin à la session Auth0 d’un utilisateur en révoquant les refresh tokens. Peut être utilisé avec Universal Logout et Okta Workforce Identity Cloud.                                                                                                                                                                                                            |
| **Promouvoir la connexion au niveau du domaine** | Permet aux applications tierces d’accéder à la connexion.                                                                                                                                                                                                                                                                                                                                                         |

<br />

4. Dans la vue **Provisionnement**, configurez la façon dont les profils utilisateur sont créés et mis à jour dans Auth0.

| **Champ**                                                               | **Description**                                                                                                                                                                                                                                            |
| ----------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Synchroniser les attributs du profil utilisateur à chaque connexion** | Lorsqu’elle est activée, Auth0 synchronise automatiquement les données du profil utilisateur à chaque connexion de l’utilisateur, ce qui garantit que les modifications apportées dans la source de connexion sont automatiquement répercutées dans Auth0. |
| **Fréquence de synchronisation**                                        | Déterminez à quelle fréquence le profil utilisateur doit être mis à jour.                                                                                                                                                                                  |
| **Synchroniser les profils utilisateur à l’aide de SCIM**               | Lorsqu’elle est activée, Auth0 permet de synchroniser les données du profil utilisateur à l’aide de SCIM. Pour en savoir plus, consultez <a href="/docs/fr-ca/authenticate/protocols/scim/configure-inbound-scim">Configurer Inbound SCIM</a>.             |

5. Dans la vue **Expérience de connexion**, configurez la façon dont les utilisateurs se connectent avec cette connexion.

| Champ                               | Description                                                                                                                                                                                                                                                       |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Home Realm Discovery**            | Compare le domaine de l’adresse courriel d’un utilisateur aux domaines de fournisseurs d’identité fournis. Pour en savoir plus, consultez [Configurer l’authentification Identifier First](/docs/fr-ca/authenticate/login/auth0-universal-login/identifier-first) |
| **Afficher le bouton de connexion** | Cette option affiche les choix suivants pour personnaliser le bouton de connexion de votre application.                                                                                                                                                           |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les champs facultatifs sont offerts uniquement avec Universal Login. Les clients qui utilisent Classic Login ne verront pas le bouton Add, le Nom d’affichage du bouton ni l’URL du logo du bouton.
</Callout>

6. Sélectionnez **Enregistrer les modifications**.

<div id="create-an-enterprise-connection-using-the-management-api">
  ### Créer une connexion d’entreprise à l’aide de la Management API
</div>

Ces exemples vous montreront les différentes façons de créer cette connexion à l’aide de la <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> d’Auth0. Vous pouvez configurer la connexion soit en fournissant un URI de métadonnées, soit en définissant explicitement les URL OIDC.

Pour les connexions OIDC, Auth0 applique une limite de taille de 128 Ko au document de découverte des métadonnées et génère l’erreur `Discovery document exceeds the maximum allowed size of 128 KB` lorsque cette limite est dépassée.

Pour en savoir plus, consultez [Fournisseurs d’identité](/docs/fr-ca/authenticate/identity-providers).

<div id="use-front-channel-with-discovery-endpoint">
  #### Utiliser le front-channel avec le point de terminaison de découverte
</div>

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --data '{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("undefined", "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }", 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}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")

  	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.post("https://{yourDomain}/api/v2/connections")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {authorization: 'Bearer MGMT_API_ACCESS_TOKEN'},
    data: {
      strategy: 'oidc',
      name: 'CONNECTION_NAME',
      options: {
        type: 'front_channel',
        discovery_url: 'https://IDP_DOMAIN/.well-known/openid-configuration',
        client_id: 'IDP_CLIENT_ID',
        scopes: 'openid profile'
      }
    }
  };

  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/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $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 = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

  conn.request("POST", "/{yourDomain}/api/v2/connections", 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}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

<div id="use-back-channel-with-discovery-endpoint">
  #### Utiliser le back-channel avec le point de terminaison de découverte
</div>

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --data '{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("undefined", "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }", 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}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")

  	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.post("https://{yourDomain}/api/v2/connections")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {authorization: 'Bearer MGMT_API_ACCESS_TOKEN'},
    data: {
      strategy: 'oidc',
      name: 'CONNECTION_NAME',
      options: {
        type: 'back_channel',
        discovery_url: 'https://IDP_DOMAIN/.well-known/openid-configuration',
        client_id: 'IDP_CLIENT_ID',
        client_secret: 'IDP_CLIENT_SECRET',
        scopes: 'openid profile'
      }
    }
  };

  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/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $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 = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }"

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

  conn.request("POST", "/{yourDomain}/api/v2/connections", 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}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "discovery_url": "https://IDP_DOMAIN/.well-known/openid-configuration", "client_id" : "IDP_CLIENT_ID", "client_secret" : "IDP_CLIENT_SECRET", "scopes": "openid profile" } }"

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

<div id="use-back-channel-specifying-issuer-settings">
  #### Utiliser le back-channel en précisant les paramètres de l’émetteur
</div>

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --data '{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("undefined", "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }", 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}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")

  	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.post("https://{yourDomain}/api/v2/connections")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {authorization: 'Bearer MGMT_API_ACCESS_TOKEN'},
    data: {
      strategy: 'oidc',
      name: 'CONNECTION_NAME',
      options: {
        type: 'back_channel',
        issuer: 'https://IDP_DOMAIN',
        authorization_endpoint: 'https://IDP_DOMAIN/authorize',
        client_secret: 'IDP_CLIENT_SECRET',
        client_id: 'IDP_CLIENT_ID',
        scopes: 'openid profile'
      }
    }
  };

  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/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $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 = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

  conn.request("POST", "/{yourDomain}/api/v2/connections", 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}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "back_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "client_secret" : "IDP_CLIENT_SECRET", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

<div id="use-front-channel-specifying-issuer-settings">
  #### Utiliser le front-channel en indiquant les paramètres de l’émetteur
</div>

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --data '{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("undefined", "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }", 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}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")

  	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.post("https://{yourDomain}/api/v2/connections")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {authorization: 'Bearer MGMT_API_ACCESS_TOKEN'},
    data: {
      strategy: 'oidc',
      name: 'CONNECTION_NAME',
      options: {
        type: 'front_channel',
        issuer: 'https://IDP_DOMAIN',
        authorization_endpoint: 'https://IDP_DOMAIN/authorize',
        token_endpoint: 'https://IDP_DOMAIN/oauth/token',
        client_id: 'IDP_CLIENT_ID',
        scopes: 'openid profile'
      }
    }
  };

  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/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $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 = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

  conn.request("POST", "/{yourDomain}/api/v2/connections", 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}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "strategy": "oidc", "name": "CONNECTION_NAME", "options": { "type": "front_channel", "issuer": "https://IDP_DOMAIN", "authorization_endpoint": "https://IDP_DOMAIN/authorize", "token_endpoint": "https://IDP_DOMAIN/oauth/token", "client_id" : "IDP_CLIENT_ID",  "scopes": "openid profile" } }"

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

<div id="configure-pkce-and-claims-mapping">
  ## Configurer PKCE et le mappage des claims
</div>

Cette connexion Enterprise prend en charge la clé de preuve pour l’échange de code (PKCE), ainsi que le mappage des attributs et des tokens. Pour en savoir plus, consultez [Configurer PKCE et le mappage des claims pour les connexions OIDC](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/configure-pkce-claim-mapping-for-oidc).

<div id="enable-the-enterprise-connection-for-your-auth0-application">
  ## Activez la connexion d’entreprise pour votre application Auth0
</div>

Pour utiliser votre nouvelle connexion d’entreprise, vous devez d’abord [activer cette connexion](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/enable-enterprise-connections) pour vos applications Auth0.

<div id="test-the-connection">
  ## Tester la connexion
</div>

Vous êtes maintenant prêt à [tester la connexion](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/test-enterprise-connections).

<div id="manually-configure-issuer-metadata">
  ## Configurer manuellement les métadonnées de l’émetteur
</div>

Si vous cliquez sur **Afficher les détails de l’émetteur** pour l’endpoint URL de l’émetteur, vous pouvez consulter les données et les modifier au besoin.

<div id="federate-with-auth0">
  ## Fédérer avec Auth0
</div>

La connexion d’entreprise <Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker les informations de connexion." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> Connect est utile pour fédérer avec un autre tenant Auth0. Entrez l’URL de votre tenant Auth0 (par exemple, `https://<tenant>.us.auth0.com`) dans le champ **Issuer**, puis saisissez le Client ID de n’importe quelle application du tenant avec lequel vous souhaitez fédérer dans le champ **Client ID**.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les nouveaux tenants auront `us` dans leur URL. Les tenants créés avant l’ajout du domaine régional continueront de fonctionner. Par exemple, `https://{YOUR ACCOUNT}.auth0.com`.
</Callout>

<div id="configure-global-token-revocation">
  ## Configurer Global Token Revocation
</div>

Ce type de connexion prend en charge un endpoint de Global Token Revocation, ce qui permet à un fournisseur d’identité conforme de révoquer les sessions utilisateur Auth0, de révoquer les <Tooltip tip="Refresh Token : jeton utilisé pour obtenir un nouveau jeton d’accès sans obliger les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=refresh+tokens">jetons d’actualisation</Tooltip> et de déclencher la déconnexion back-channel pour les applications qui utilisent un canal back-channel sécurisé.

Cette fonctionnalité peut être utilisée avec Universal Logout dans Okta Workforce Identity.

Pour en savoir plus et obtenir les instructions de configuration, consultez [Universal Logout](/docs/fr-ca/authenticate/login/logout/universal-logout).