> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Découvrez comment configurer les routes de connexion par défaut de votre tenant et de votre application.

# Configurer les routes de connexion par défaut

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>;
};

Dans certains cas (décrits ci-dessous), Auth0 შეიძლება devoir rediriger l’utilisateur vers le point de terminaison Login Initiation de l’application, en utilisant le third-party initiated login OIDC. Pour en savoir plus, consultez [Initiating Login from a Third Party](https://openid.net/specs/openid-connect-core-1_0.html#ThirdPartyInitiatedLogin) sur le site de l’[OpenID Foundation](https://openid.net).

Vous pouvez configurer ces URI dans le Dashboard, sous [Application Settings](https://manage.auth0.com/#/applications/settings) ou [Tenant Advanced Settings](https://manage.auth0.com/#/tenant/advanced), ou avec l’<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>.

<Tabs>
  <Tab title="Niveau de l’application">
    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request PATCH \
        --url 'https://{yourDomain}/api/v2/clients/{yourClientId}' \
        --header 'authorization: Bearer API2_ACCESS_TOKEN' \
        --header 'cache-control: no-cache' \
        --header 'content-type: application/json' \
        --data '{"initiate_login_uri": "<login_url>"}'
      ```

      ```csharp C# theme={null}
      var client = new RestClient("https://{yourDomain}/api/v2/clients/{yourClientId}");
      var request = new RestRequest(Method.PATCH);
      request.AddHeader("content-type", "application/json");
      request.AddHeader("authorization", "Bearer API2_ACCESS_TOKEN");
      request.AddHeader("cache-control", "no-cache");
      request.AddParameter("application/json", "{"initiate_login_uri": "<login_url>"}", 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/clients/{yourClientId}"

      	payload := strings.NewReader("{"initiate_login_uri": "<login_url>"}")

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

      	req.Header.Add("content-type", "application/json")
      	req.Header.Add("authorization", "Bearer API2_ACCESS_TOKEN")
      	req.Header.Add("cache-control", "no-cache")

      	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.patch("https://{yourDomain}/api/v2/clients/{yourClientId}")
        .header("content-type", "application/json")
        .header("authorization", "Bearer API2_ACCESS_TOKEN")
        .header("cache-control", "no-cache")
        .body("{"initiate_login_uri": "<login_url>"}")
        .asString();
      ```

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

      var options = {
        method: 'PATCH',
        url: 'https://{yourDomain}/api/v2/clients/{yourClientId}',
        headers: {
          'content-type': 'application/json',
          authorization: 'Bearer API2_ACCESS_TOKEN',
          'cache-control': 'no-cache'
        },
        data: {initiate_login_uri: '<login_url>'}
      };

      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/clients/{yourClientId}",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_ENCODING => "",
        CURLOPT_MAXREDIRS => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        CURLOPT_CUSTOMREQUEST => "PATCH",
        CURLOPT_POSTFIELDS => "{"initiate_login_uri": "<login_url>"}",
        CURLOPT_HTTPHEADER => [
          "authorization: Bearer API2_ACCESS_TOKEN",
          "cache-control: no-cache",
          "content-type: application/json"
        ],
      ]);

      $response = curl_exec($curl);
      $err = curl_error($curl);

      curl_close($curl);

      if ($err) {
        echo "cURL Error #:" . $err;
      } else {
        echo $response;
      }
      ```

      ```python Python theme={null}
      import http.client

      conn = http.client.HTTPSConnection("")

      payload = "{"initiate_login_uri": "<login_url>"}"

      headers = {
          'content-type': "application/json",
          'authorization': "Bearer API2_ACCESS_TOKEN",
          'cache-control': "no-cache"
          }

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

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

      request = Net::HTTP::Patch.new(url)
      request["content-type"] = 'application/json'
      request["authorization"] = 'Bearer API2_ACCESS_TOKEN'
      request["cache-control"] = 'no-cache'
      request.body = "{"initiate_login_uri": "<login_url>"}"

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

  <Tab title="Niveau du tenant">
    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request PATCH \
        --url 'https://{yourDomain}/api/v2/tenants/settings' \
        --header 'authorization: Bearer API2_ACCESS_TOKEN' \
        --header 'cache-control: no-cache' \
        --header 'content-type: application/json' \
        --data '{"default_redirection_uri": "<login_url>"}'
      ```

      ```csharp C# theme={null}
      var client = new RestClient("https://{yourDomain}/api/v2/tenants/settings");
      var request = new RestRequest(Method.PATCH);
      request.AddHeader("content-type", "application/json");
      request.AddHeader("authorization", "Bearer API2_ACCESS_TOKEN");
      request.AddHeader("cache-control", "no-cache");
      request.AddParameter("application/json", "{"default_redirection_uri": "<login_url>"}", 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/tenants/settings"

      	payload := strings.NewReader("{"default_redirection_uri": "<login_url>"}")

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

      	req.Header.Add("content-type", "application/json")
      	req.Header.Add("authorization", "Bearer API2_ACCESS_TOKEN")
      	req.Header.Add("cache-control", "no-cache")

      	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.patch("https://{yourDomain}/api/v2/tenants/settings")
        .header("content-type", "application/json")
        .header("authorization", "Bearer API2_ACCESS_TOKEN")
        .header("cache-control", "no-cache")
        .body("{"default_redirection_uri": "<login_url>"}")
        .asString();
      ```

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

      var options = {
        method: 'PATCH',
        url: 'https://{yourDomain}/api/v2/tenants/settings',
        headers: {
          'content-type': 'application/json',
          authorization: 'Bearer API2_ACCESS_TOKEN',
          'cache-control': 'no-cache'
        },
        data: {default_redirection_uri: '<login_url>'}
      };

      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/tenants/settings",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_ENCODING => "",
        CURLOPT_MAXREDIRS => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        CURLOPT_CUSTOMREQUEST => "PATCH",
        CURLOPT_POSTFIELDS => "{"default_redirection_uri": "<login_url>"}",
        CURLOPT_HTTPHEADER => [
          "authorization: Bearer API2_ACCESS_TOKEN",
          "cache-control: no-cache",
          "content-type: application/json"
        ],
      ]);

      $response = curl_exec($curl);
      $err = curl_error($curl);

      curl_close($curl);

      if ($err) {
        echo "cURL Error #:" . $err;
      } else {
        echo $response;
      }
      ```

      ```python Python theme={null}
      import http.client

      conn = http.client.HTTPSConnection("")

      payload = "{"default_redirection_uri": "<login_url>"}"

      headers = {
          'content-type': "application/json",
          'authorization': "Bearer API2_ACCESS_TOKEN",
          'cache-control': "no-cache"
          }

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

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

      request = Net::HTTP::Patch.new(url)
      request["content-type"] = 'application/json'
      request["authorization"] = 'Bearer API2_ACCESS_TOKEN'
      request["cache-control"] = 'no-cache'
      request.body = "{"default_redirection_uri": "<login_url>"}"

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

***

Le `login_url` doit pointer vers une route de l’application qui redirige ultimement vers le point de terminaison `/authorize` d’Auth0, par exemple `https://mycompany.org/login`. Notez qu’il doit utiliser `https` et qu’il ne peut pas pointer vers `localhost`. `login_url` peut inclure des paramètres de requête et un fragment d’URI.

Conformément à la spécification OIDC Third Party Initiated Login, le paramètre `iss` contenant l’identifiant de l’émetteur sera ajouté à `login_url` en tant que paramètre de chaîne de requête avant la redirection.

<div id="dynamic-login-uris-with-metadata-placeholders">
  ## URI de connexion dynamiques avec des espaces réservés de métadonnées
</div>

Si vous utilisez [Multiple Custom Domains](/docs/fr-ca/customize/custom-domains/multiple-custom-domains) ou [Organizations](/docs/fr-ca/manage-users/organizations/organizations-overview), vous pouvez configurer `initiate_login_uri` au niveau de l’application pour y inclure des espaces réservés de métadonnées. Ces espaces réservés sont remplacés dynamiquement à l’exécution.

<div id="supported-placeholders">
  ### Espaces réservés pris en charge
</div>

| Espace réservé                 | Source                                                      | Exemple                                                   |
| ------------------------------ | ----------------------------------------------------------- | --------------------------------------------------------- |
| `{custom_domain.metadata.KEY}` | Métadonnées du domaine personnalisé utilisé dans la requête | `https://{custom_domain.metadata.public_app_host}/login`  |
| `{organization.metadata.KEY}`  | Métadonnées de l’Organisation associée à la requête         | `https://{organization.metadata.public_login_host}/login` |

Les clés de métadonnées doivent commencer par `public_` (par exemple, `public_app_host`). Les deux types d’espaces réservés peuvent être combinés dans la même URI si la requête comprend à la fois un domaine personnalisé et un contexte d’organisation.

Pour consulter la liste complète des règles de validation et des restrictions, lisez [Espaces réservés d’URL de domaine personnalisé](/docs/fr-ca/get-started/applications/wildcards-for-subdomains#custom-domain-url-placeholders).

<Note>
  Les espaces réservés de métadonnées sont pris en charge uniquement pour `initiate_login_uri` au niveau de l’application, et non pour `default_redirection_uri` au niveau du tenant.
</Note>

<div id="fallback-behavior">
  ### Comportement de secours
</div>

Auth0 utilise le `default_redirection_uri` au niveau du tenant comme solution de secours lorsqu’un espace réservé ne peut pas être résolu. Par exemple, si l’organisation est inconnue ou si la clé de métadonnées n’existe pas. Si `default_redirection_uri` n’est pas non plus configuré, Auth0 affiche une page d’erreur. Nous recommandons de configurer un `default_redirection_uri` au niveau du tenant comme solution de secours fiable.

<div id="redirect-default-login-route-scenarios">
  ## Scénarios de redirection pour la route de connexion par défaut
</div>

<div id="users-bookmark-login-page">
  ### Les utilisateurs ajoutent la page de connexion à leurs signets
</div>

Lorsqu’une application lance le processus de connexion, elle accède à `https://{yourDomain}/authorize` avec un ensemble de [paramètres requis](https://auth0.com/docs/api/authentication#login). Auth0 redirige ensuite les utilisateurs finaux vers une page `https://{yourDomain}/login`, avec une URL semblable à :

`https://{yourDomain}/login?state=g6Fo2SBjNTRyanlVa3ZqeHN4d1htTnh&...`

Le paramètre `state` pointe vers un enregistrement dans une base de données interne où nous suivons l’état de la transaction d’autorisation. Une fois la transaction terminée, ou après un certain délai, l’enregistrement est supprimé de la base de données interne.

Si vous utilisez Organizations et que l’utilisateur final ajoute l’invite de connexion de l’organization à ses signets, Auth0 inclut aussi le paramètre `organization` lorsqu’il redirige l’utilisateur vers la route de connexion par défaut.

Il arrive que des utilisateurs ajoutent la page de connexion à leurs signets et que, lorsqu’ils accèdent à l’URL `/login` enregistrée, l’enregistrement de transaction n’existe plus et qu’Auth0 ne puisse pas poursuivre le flux de connexion. Dans ce cas, Auth0 redirigera l’utilisateur vers l’URL du client par défaut si elle est configurée, ou vers l’URL au niveau du tenant dans le cas contraire. Si aucune URL de connexion par défaut n’est définie, Auth0 affichera une page d’erreur.

<div id="complete-password-reset-flow">
  ### Flux complet de réinitialisation du mot de passe
</div>

Une fois le flux de réinitialisation du mot de passe terminé et l’URI par défaut de l’application ou du tenant configuré, les utilisateurs verront un bouton leur permettant de revenir à la page de connexion.

Ce comportement se produit uniquement lorsque vous activez l’expérience <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur le serveur d’autorisation d’Auth0, pour vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip>. Avec Classic Login, vous devez configurer l’URL de redirection dans le modèle Change Password. Pour en savoir plus, consultez [Personnaliser les modèles de courriel](/docs/fr-ca/customize/email/email-templates).

Pour les tenants qui utilisent Universal Login, le point de terminaison [`/post-password-change`](https://auth0.com/docs/api/management/v2/#!/Tickets/post_password_change) permet de rediriger les utilisateurs vers une application précise. Lorsque `client_id` est spécifié et que l’URI de connexion de l’application est définie, les utilisateurs verront un bouton qui les ramènera vers l’application après avoir terminé la réinitialisation du mot de passe.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/tickets/password-change' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/tickets/password-change");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("application/json", "{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }", 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/tickets/password-change"

  	payload := strings.NewReader("{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }")

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

  	req.Header.Add("content-type", "application/json")
  	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/tickets/password-change")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/tickets/password-change',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN'
    },
    data: {user_id: 'A_USER_ID', client_id: 'A_CLIENT_ID'}
  };

  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/tickets/password-change",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN"
      }

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

  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["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "user_id": "A_USER_ID", "client_id": "A_CLIENT_ID" }"

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

<div id="complete-email-verification-flow">
  ### Processus complet de vérification du courriel
</div>

Dans le cadre du processus d’inscription, les utilisateurs qui choisissent le courriel comme identifiant reçoivent un courriel pour vérifier leur adresse courriel. S’ils cliquent sur le lien, ils arriveront sur une page indiquant que leur courriel a été vérifié, avec un bouton pour revenir à l’application. En cliquant sur ce bouton, ils seront redirigés vers la page de connexion et, s’ils ont déjà une session valide, ils seront ensuite redirigés vers l’application.

Ce comportement se produit uniquement lorsque l’expérience Universal Login est activée. Avec Classic Login, vous devez configurer l’URL de redirection dans le gabarit Verification Email.

<div id="invite-organization-members">
  ### Inviter des membres d’une organisation
</div>

Lorsque des utilisateurs sont invités à se joindre à une [Organisation](/docs/fr-ca/manage-users/organizations/organizations-overview), ils reçoivent un lien d’invitation par courriel. S’ils cliquent sur ce lien, ils sont redirigés vers la route de connexion par défaut configurée, à laquelle sont ajoutés des paramètres propres à l’invitation.

Par exemple, si vous avez une application pour laquelle les organisations sont activées et qu’un **URI de connexion de l’application** est défini sur `https://myapp.com/login`, le lien envoyé dans le courriel d’invitation que recevra l’utilisateur final sera : `https://myapp.com/login?invitation={invitation_ticket_id}&organization={organization_id}&organization_name={organization_name}`.

La route de votre application doit donc accepter les paramètres `invitation` et `organization` dans la chaîne de requête. Pour lancer la transaction d’acceptation de l’invitation, elle doit transmettre ces deux paramètres, ainsi que l’utilisateur final, à votre point de terminaison Auth0 `/authorize`.

<div id="disabled-cookies">
  ### Cookies désactivés
</div>

Si un utilisateur accède à `https://{yourDomain}/authorize` alors que les cookies sont désactivés dans son navigateur, Auth0 le redirige vers l’URI de connexion de l’application. Si l’URI de connexion de l’application n’est pas définie, la redirection est plutôt envoyée vers l’URI de connexion du tenant.

Renvoyer l’utilisateur à la page de connexion peut entraîner une boucle de redirection. Pour éviter ce problème, utilisez une page de destination pour vérifier la disponibilité des cookies ; s’ils sont désactivés, avertissez l’utilisateur qu’il doit les activer s’il souhaite continuer.

<div id="learn-more">
  ## En savoir plus
</div>

* [Personnaliser les modèles de courriel](/docs/fr-ca/customize/email/email-templates)
* [Gérer les facteurs d’authentification avec l’API d’authentification](/docs/fr-ca/secure/multi-factor-authentication/manage-mfa-auth0-apis/manage-authenticator-factors-mfa-api)