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

> Découvrez comment configurer et gérer plusieurs domaines personnalisés dans un même tenant Auth0 pour des déploiements visant plusieurs marques et régions.

# Domaines personnalisés multiples

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 Auth0, un <Tooltip tip="Domaine personnalisé : domaine tiers portant un nom spécialisé ou personnalisé." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=custom+domain">domaine personnalisé</Tooltip> vous permet d’unifier l’expérience de connexion avec votre propre image de marque et vos produits. Domaines personnalisés multiples vous permet de configurer plusieurs domaines personnalisés dans un même tenant Auth0. Cette fonctionnalité est offerte aux clients Enterprise, tant dans les déploiements Public Cloud que Private Cloud.

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

Avant de commencer avec MCD, prenez connaissance des exigences ci-dessous :

* Votre tenant dispose d’un plan Enterprise ([déploiements Public Cloud ou Private Cloud](/docs/fr-ca/deploy-monitor/deployment-options)). Pour en savoir plus, consultez
  Gérer les abonnements.
* Votre plan Enterprise comprend une allocation de base pouvant aller jusqu’à 20 domaines personnalisés par tenant.
* Des domaines personnalisés supplémentaires au-delà de l’allocation de base sont offerts au moyen d’un SKU de module complémentaire. Veuillez communiquer avec l’équipe des ventes d’Auth0 pour en savoir plus.
* Vous devez être en mesure de prouver que vous êtes propriétaire des domaines personnalisés configurés.

<div id="configure-multiple-custom-domains">
  ## Configurer Domaines personnalisés multiples
</div>

Vous pouvez ajouter et gérer plusieurs domaines personnalisés pour votre tenant à l’aide de 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=Auth0+Dashboard">Auth0 Dashboard</Tooltip> ou 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>.

<Tabs>
  <Tab title="Auth0 Dashboard">
    Pour créer un domaine personnalisé dans l’**Auth0 Dashboard** :

    1. Accédez à **Auth0 Dashboard** > **Branding > Custom Domains**.
    2. Sélectionnez **+Add custom domain**.
    3. Dans le formulaire de configuration, fournissez les renseignements suivants :

       * **Domain :** Un [nom de domaine pleinement qualifié](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) qui vous appartient. Par exemple : `my.custom-domain.com`.
       * **Certificate type :** Choisissez les [**certificats gérés par Auth0**](/docs/fr-ca/customize/custom-domains/auth0-managed-certificates) ou les [**certificats autogérés**](/docs/fr-ca/customize/custom-domains/self-managed-certificates).
       * **Metadata (Key/Value) :** Ajoutez des métadonnées facultatives comme `region`, `client_name` ou `client_id` pour vous aider à organiser et à filtrer vos domaines.
    4. Une fois les détails du domaine personnalisé configurés, sélectionnez **Save**.

    Le nom de domaine que vous venez d’ajouter s’affichera comme `pending` jusqu’à ce que la vérification soit terminée.

    #### Afficher et gérer les domaines

    La page **Custom Domains** affiche tous les domaines configurés. Vous pouvez :

    * **Search** : Rechercher des domaines par nom à l’aide de la zone de recherche
    * **Filter** : Filtrer les domaines selon l’état de vérification, le type de certificat ou les valeurs de métadonnées
    * **Sort** : Trier les domaines par nom, date de création ou état de vérification
    * **View details** : Cliquer sur n’importe quel domaine pour voir la configuration détaillée, l’état de vérification et les renseignements sur le certificat
    * **Set default** : Désigner un domaine comme domaine par défaut pour votre tenant

    Ces fonctionnalités vous aident à gérer efficacement un grand nombre de domaines personnalisés dans votre tenant.
  </Tab>

  <Tab title="Management API">
    Pour créer un domaine personnalisé avec l’API de gestion (Management API), vous avez besoin d’une application machine-à-machine (M2M) autorisée à utiliser l’API de gestion. Pour en savoir plus, consultez [Management API Access Tokens](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens).

    1. Accédez à [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) et sélectionnez **Create Application**.
    2. Saisissez un nom descriptif pour votre application et choisissez **Machine to Machine Applications**. Ensuite, sélectionnez **Create**.
    3. Passez à la vue **APIs**, puis activez la bascule de l'`Auth0 Management API`.
    4. Développez la ligne pour configurer les autorisations de l’API. Pour le MCD, vous devez sélectionner les éléments suivants :

       * `read:custom_domains`
       * `create:custom_domains`
       * `update:custom_domains`
       * `delete:custom_domains`
    5. Sélectionnez **Update**.
    6. Accédez à l’onglet **Paramètres** pour noter votre **Client ID**, votre **Client Secret** et votre **Domain**.
    7. Consultez [Obtenir des jetons d’accès pour l’API de gestion](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) pour récupérer et stocker votre jeton d’accès.

    #### Créer un domaine personnalisé

    Vous pouvez créer un nouveau domaine personnalisé en envoyant une requête `POST` à l’endpoint `/api/v2/custom-domains`. Consultez l’exemple ci‑dessous pour créer un nouveau domaine personnalisé à l’aide du Management API Explorer, en utilisant les identifiants récupérés ci‑dessus :

    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request POST \
        --url 'https://{yourDomain}/api/v2/custom-domains' \
        --header 'accept: application/json' \
        --header 'authorization: Bearer {yourMgmtApiAccessToken}' \
        --header 'content-type: application/json' \
        --data '{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }'
      ```

      ```csharp C# theme={null}
      var client = new RestClient("https://{yourDomain}/api/v2/custom-domains");
      var request = new RestRequest(Method.POST);
      request.AddHeader("authorization", "Bearer {yourMgmtApiAccessToken}");
      request.AddHeader("content-type", "application/json");
      request.AddHeader("accept", "application/json");
      request.AddParameter("application/json", "{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
       "environment": "development"} 
      }", 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/custom-domains"

      	payload := strings.NewReader("{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }")

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

      	req.Header.Add("authorization", "Bearer {yourMgmtApiAccessToken}")
      	req.Header.Add("content-type", "application/json")
      	req.Header.Add("accept", "application/json")

      	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/custom-domains")
        .header("authorization", "Bearer {yourMgmtApiAccessToken}")
        .header("content-type", "application/json")
        .header("accept", "application/json")
        .body("{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }")
        .asString();
      ```

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

      var options = {
        method: 'POST',
        url: 'https://{yourDomain}/api/v2/custom-domains',
        headers: {
          authorization: 'Bearer {yourMgmtApiAccessToken}',
          'content-type': 'application/json',
          accept: 'application/json'
        },
        data: {
          domain: 'your.example-custom-domain.com',
          type: 'auth0_managed_certs',
          tls_policy: 'recommended',
          custom_client_ip_header: 'true-client-ip',
          domain_metadata: {environment: 'development'}
        }
      };

      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/custom-domains",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_ENCODING => "",
        CURLOPT_MAXREDIRS => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        CURLOPT_CUSTOMREQUEST => "POST",
        CURLOPT_POSTFIELDS => "{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }",
        CURLOPT_HTTPHEADER => [
          "accept: application/json",
          "authorization: Bearer {yourMgmtApiAccessToken}",
          "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 = "{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }"

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

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

      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 {yourMgmtApiAccessToken}'
      request["content-type"] = 'application/json'
      request["accept"] = 'application/json'
      request.body = "{ 
       "domain": "your.example-custom-domain.com", 
       "type": "auth0_managed_certs", 
       "tls_policy": "recommended", 
       "custom_client_ip_header": "true-client-ip", 
       "domain_metadata": {
          "environment": "development"} 
      }"

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

    Si l'opération réussit, vous devriez voir les éléments suivants retournés avec les détails de votre nouveau domaine personnalisé, y compris son état de vérification. Le `status` est initialement retourné comme `pending`.

    ```json lines theme={null}
    {
        "custom_domain_id": "cd_abc123def456",
        "domain": "your.example-custom-domain.com",
        "primary": false,
        "status": "pending",
        "type": "auth0_managed_certs",
        "verification": {
            "methods": [
                {
                    "name": "CNAME",
                    "record": "yourtenant.auth0.com",
                    "domain": "your.example-custom-domain.com"
                }
            ]
        },
        "tls_policy": "recommended",
        "domain_metadata": {
            "environment": "development"
        }
    }
    ```
  </Tab>
</Tabs>

<div id="mcd-features">
  ## Fonctionnalités de MCD
</div>

MCD offre de nombreuses fonctionnalités clés pour gérer plus efficacement votre mise en œuvre d’Auth0 et améliorer l’expérience utilisateur. Vous êtes responsable d’être propriétaire des domaines personnalisés souhaités et de les enregistrer auprès d’un registraire de noms de domaine.

L’[Auth0 Management API](https://auth0.com/docs/api/management/v2/custom-domains/get-custom-domains) offre une prise en charge complète des opérations **Create, Read, Update, Delete, and Verify** pour ces domaines personnalisés, ce qui vous donne un contrôle programmatique complet sur leur cycle de vie.

MCD est pris en charge par les Auth0 Management SDKs suivants : [Node.js](https://github.com/auth0/node-auth0), [Go](https://github.com/auth0/go-auth0), [Python](https://github.com/auth0/auth0-python), [Java](https://github.com/auth0/auth0-java) et [.NET](https://github.com/auth0/auth0.net). Les SDK d’authentication fonctionnent automatiquement avec les domaines personnalisés lorsqu’ils sont configurés dans votre application.

<div id="default-domain">
  ### Domaine par défaut
</div>

Lorsque plusieurs domaines personnalisés sont configurés, vous pouvez désigner l’un d’eux comme **domaine par défaut**. Le domaine par défaut est utilisé lorsque des renseignements sur le domaine sont requis pour les points de terminaison de l’Auth0 Management API, mais qu’aucun domaine personnalisé n’est explicitement précisé au moyen de l’en-tête `auth0-custom-domain`. Ces renseignements servent à personnaliser les notifications par courriel (p. ex. les réinitialisations de mot de passe et la vérification de l’adresse courriel) en fonction du domaine.

Pour définir un domaine par défaut :

1. Accédez à **Auth0 Dashboard** > **Branding > Custom Domains**
2. Dans la liste, repérez le domaine que vous voulez définir comme domaine par défaut
3. Cliquez sur le bouton **Set as Default** pour ce domaine

Vous pouvez aussi définir le domaine par défaut à l’aide de la Management API en mettant à jour la configuration d’un domaine personnalisé. Une fois défini, le domaine par défaut sera automatiquement utilisé pour personnaliser les communications par courriel, sauf si un domaine précis est fourni au moyen de l’en-tête `auth0-custom-domain`.

<Callout icon="info" color="#0EA5E9" iconType="regular">
  Le domaine par défaut rend l’en-tête `auth0-custom-domain` facultatif pour les points de terminaison de la Management API qui déclenchent des notifications. Si vous ne précisez pas de domaine personnalisé lorsque vous effectuez une requête vers ces points de terminaison, Auth0 utilisera automatiquement le domaine par défaut pour personnaliser les courriels.
</Callout>

<div id="domain-verification">
  ### Vérification du domaine
</div>

La méthode de vérification de la propriété du nom de domaine dépend du type de gestion choisi :

| Type de domaine                                                                       | Méthode de vérification  | Détails                                                                                        |
| ------------------------------------------------------------------------------------- | ------------------------ | ---------------------------------------------------------------------------------------------- |
| **[Géré par Auth0](/docs/fr-ca/customize/custom-domains/auth0-managed-certificates)** | Enregistrement DNS CNAME | Configurez cet enregistrement pour confirmer la propriété du domaine et activer votre domaine. |
| **[Autogéré](/docs/fr-ca/customize/custom-domains/self-managed-certificates)**        | Enregistrement DNS TXT   | Les détails propres à l’enregistrement TXT sont fournis dans la réponse de l’API Create.       |

Une fois votre domaine personnalisé vérifié par Auth0, vous pouvez l’utiliser immédiatement pour configurer les fonctionnalités Auth0 pour vos utilisateurs. Pour en savoir plus, consultez [Configurer les fonctionnalités pour utiliser des domaines personnalisés](/docs/fr-ca/customize/custom-domains/configure-features-to-use-custom-domains).

<div id="metadata-for-enhanced-management">
  ### Métadonnées pour une gestion simplifiée
</div>

Vous pouvez configurer jusqu’à 10 champs de métadonnées par domaine personnalisé pour faciliter l’organisation et permettre une personnalisation ultérieure. Dans les prochaines versions, ces champs de métadonnées permettront de personnaliser davantage les modèles de courriel, <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> et la logique d’authentification.

<div id="customize-email-templates">
  ### Personnaliser les modèles de courriel
</div>

Tirez parti des renseignements sur votre domaine personnalisé pour personnaliser vos modèles de courriel et renforcer votre image de marque, afin d’assurer une expérience utilisateur cohérente. Pour ce faire, MCD met la variable `custom_domain.domain` à votre disposition dans la syntaxe Liquid.

Par exemple, vous pourriez définir le **From Address** de votre modèle de courriel à `support@{{ custom_domain.domain }}` , qui s’afficherait sous la forme `support@my.custom-domain.com`. Cette variable est accessible dans la syntaxe Liquid des champs **From Address**, **Subject** et **Message**. Pour en savoir plus, consultez [Personnaliser les modèles de courriel](/docs/fr-ca/customize/email/email-templates).

<div id="customize-email-handling-using-the-management-api">
  #### Personnaliser la gestion des courriels à l’aide de la Management API
</div>

Si vous avez configuré Domaines personnalisés multiples et activé [Use Custom Domains in Emails](/docs/fr-ca/customize/custom-domains/configure-features-to-use-custom-domains#use-custom-domains-in-emails), l’en-tête HTTP `auth0-custom-domain` est disponible lorsque vous utilisez l’Auth0 Management API. L’en-tête est transmis comme valeur de l’`domain object` dans les modèles de courriel.

Les points de terminaison de la Management API suivants acceptent l’en-tête HTTP `auth0-custom-domain` :

* [Envoyer un courriel de vérification d’adresse courriel](https://auth0.com/docs/api/management/v2#!/Jobs/post_verification_email)
* [Créer un ticket de vérification du courriel](https://auth0.com/docs/api/management/v2/tickets/post-email-verification)
* [Créer des invitations pour une organisation](https://auth0.com/docs/api/management/v2/organizations/post-invitations)
* [Créer un utilisateur](https://auth0.com/docs/api/management/v2/users/post-users)
* [Créer un ticket d’inscription à l’authentification multifacteur](https://auth0.com/docs/api/management/v2/guardian/post-ticket)
* [Créer un ticket de changement de mot de passe](https://auth0.com/docs/api/management/v2/tickets/post-password-change)
* [Mettre à jour un utilisateur](https://auth0.com/docs/api/management/v2/users/patch-users-by-id)

Par exemple : pour créer un ticket de changement de mot de passe à l’aide de l’Auth0 SDK pour [Node.js](https://github.com/auth0/node-auth0).

```javascript lines theme={null}
import { ManagementClient, CustomDomainHeader } from "auth0";

// Niveau client : s'applique automatiquement aux endpoints sur liste blanche
const auth0 = new ManagementClient({
    domain: '{yourDomain}',
    clientId: '{yourClientId}',
    clientSecret: '{yourClientSecret}',
    withCustomDomainHeader: 'my-custom-domain.com',});

(async () => {
    try {
        const ticket = await auth0.tickets.changePassword({
            user_id: 'auth0|abc123',
            result_url: 'https://example.com/success'
        });
        console.log('Password change ticket created:', ticket.data.ticket);
    } catch (err) {
        console.error('Error creating password change ticket:', err);
    }
})();

// Autrement, utilisez un remplacement par requête
const reqOptions = {
    ...CustomDomainHeader('my-custom-domain.com'),
};
const ticket = await auth0.tickets.changePassword(
    { user_id: 'auth0|abc123', result_url: 'https://example.com/success' },
    reqOptions
);
```

Exemple de réponse : Le domaine personnalisé est transmis dans l’en-tête servant à générer l’URL du ticket.

```json lines theme={null}
{
    "ticket": "https://my-custom-domain.com/u/reset-verify?ticket=abc123"
}
```

<div id="response-messages">
  ##### Messages de réponse
</div>

Lorsque vous incluez l’en-tête HTTP `auth0-custom-domain`, les réponses supplémentaires suivantes sont possibles :

| code d’état HTTP | Message                                                        |
| ---------------- | -------------------------------------------------------------- |
| `409`            | Le tenant possède plusieurs domaines personnalisés vérifiés.   |
| `400`            | Le domaine personnalisé n’existe pas pour ce tenant.           |
| `400`            | L’en-tête HTTP `auth0-custom-domain` n’a pas un format valide. |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous activez MCD et utilisez le Auth0 Dashboard pour configurer des modèles de courriel, la fonction Try s’exécutera avec votre domaine personnalisé par défaut plutôt qu’avec le domaine Auth0 standard.
</Callout>

<div id="application-url-placeholders">
  ### Variables de remplacement d’URL d’application
</div>

Vous pouvez utiliser les métadonnées de domaine personnalisé comme variables de remplacement dynamiques dans les URL d’application, comme les URL de rappel, les URL de déconnexion et l’Application Login URI (`initiate_login_uri`). Ainsi, chaque domaine personnalisé peut pointer vers une URL d’application différente à l’exécution. Pour en savoir plus, consultez [Variables de remplacement d’URL de domaine personnalisé](/docs/fr-ca/get-started/applications/wildcards-for-subdomains#custom-domain-url-placeholders).

<div id="multiple-custom-domains-with-actions">
  ### Domaines personnalisés multiples avec Actions
</div>

Les [Actions](/docs/fr-ca/customize/actions) d’Auth0 vous permettent de créer une logique personnalisée pour gérer vos différentes transactions en fonction du domaine personnalisé.

Par exemple, vous pourriez créer une Action qui dirige un utilisateur vers une [Organisation](/docs/fr-ca/manage-users/organizations) associée, ou appliquer une [politique de contrôle d’accès](/docs/fr-ca/customize/actions/use-cases#api-authorization).

Pour ce faire, les Actions post-login incluent l’objet `event.custom_domain`, qui indique le domaine personnalisé utilisé pour le flux d’authentification.

<div id="use-case-restrict-user-access-to-an-organization-based-on-custom-domain">
  #### Cas d’utilisation : restreindre l’accès d’un utilisateur à une Organisation en fonction du custom domain
</div>

Stockez une liste de domaines autorisés et une liste de domaines rejetés (par exemple, `allow_domains` et `deny_domains`) dans les métadonnées de votre Organisation.

Créez une Action qui :

1. Récupère le domaine de l’utilisateur à partir de la propriété `event.custom_domain?.domain`
2. Compare ce domaine aux deux listes
3. Autorise ou rejette l’accès de l’utilisateur en conséquence

```js lines expandable theme={null}
exports.onExecutePostLogin = async (event, api) => {
    const customDomain = event?.custom_domain?.domain;
    
    console.log(`org ${event?.organization?.name} accessed from domain ${customDomain || event?.request?.hostname}`);

    if (event?.organization?.metadata?.deny_domains && event?.organization?.metadata?.allow_domains) {
        console.warn(`[WARNING] configuration issue. org ${event?.organization?.name} has both deny_domains and allow_domains`);
    }

    // Vérifier soit rejeter (A) soit autoriser (B), mais pas les deux
    // (A) vérifie la liste de rejet de l'organisation
    const isDomainDenied = () =>
        (event?.organization?.metadata?.deny_domains ? event?.organization?.metadata?.deny_domains.split(',').map(d => d.trim()).includes(customDomain) : false);
        
    if (isDomainDenied()) {
        return api.access.deny(`access to org ${event?.organization?.name} not allowed on domain ${customDomain}`);
    }

    // (B) vérifie la liste d'autorisation de l'organisation
    const isDomainAllowed = () =>
        (event?.organization?.metadata?.allow_domains ? event?.organization?.metadata?.allow_domains.split(',').map(d => d.trim()).includes(customDomain) : false);
        
    if (!isDomainAllowed()) {
        return api.access.deny(`access to org ${event?.organization?.name} not allowed on domain ${customDomain}`);
    }
};
```

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  MCD donne accès aux métadonnées du domaine personnalisé dans Actions par l’intermédiaire de l’objet `event.custom_domain`. Vous pouvez utiliser ces informations avec les métadonnées du domaine personnalisé configurées dans votre tenant afin d’implémenter une logique propre au domaine dans vos Actions.
</Callout>

<div id="custom-domain-attributes">
  ### Attributs des domaines personnalisés
</div>

MCD fournit les attributs suivants liés à la vérification des domaines personnalisés et à la gestion des certificats SSL/TLS. Ces attributs fournissent des renseignements détaillés sur l’état du provisionnement et du fonctionnement des domaines personnalisés.

<div id="updated-attributes">
  #### Attributs mis à jour
</div>

| Attribut | Description                                                                                                                                                                                                                                                          |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status` | Une nouvelle valeur d’énumération, `failed`, a été ajoutée à l’attribut `status`. Cette valeur indique que le processus de vérification du domaine personnalisé a rencontré une erreur et n’a pas abouti. Elle s’ajoute aux valeurs existantes `pending` et `ready`. |

<div id="new-attributes">
  #### Nouveaux attributs
</div>

Les attributs suivants sont pris en charge uniquement pour les domaines gérés par Auth0 :

| Attribut                            | Description                                                                                                                                                                                                                     |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `verification.status`               | Statut du processus de vérification de l’enregistrement DNS. Les valeurs possibles sont : `verified`, `pending` et `failed`.                                                                                                    |
| `verification.error_msg`            | Si `verification.status` indique un échec, cet attribut de type chaîne contiendra un message d’erreur compréhensible par l’humain fournissant du contexte sur l’échec de la vérification.                                       |
| `verification.last_verified_at`     | Cet attribut d’horodatage enregistre la date et l’heure de la dernière vérification réussie du domaine personnalisé. Le format de cet horodatage respecte la norme ISO 8601.                                                    |
| `certificate`                       | Cet objet regroupe les renseignements liés au certificat SSL/TLS associé au domaine personnalisé.                                                                                                                               |
| `certificate.status`                | Cet attribut indique l’état actuel du provisionnement du certificat SSL/TLS. Les valeurs possibles comprennent notamment `provisioning`, `provisioned`, `provisioning_failed` et `renewing_failed`.                             |
| `certificate.error_msg`             | Si `certificate.status` est `provisioning_failed` ou `renewing_failed`, cet attribut de type chaîne fournira un message d’erreur convivial détaillant la raison de l’échec.                                                     |
| `certificate.certificate_authority` | Cet attribut de type chaîne précise l’autorité de certification qui a délivré le certificat SSL/TLS pour le domaine personnalisé.                                                                                               |
| `certificate.renews_before`         | Pour les domaines personnalisés gérés par Auth0, ce nouvel attribut d’horodatage indique la date et l’heure avant lesquelles le certificat SSL/TLS doit être renouvelé. Le format de cet horodatage respecte la norme ISO 8601. |

<div id="limitations">
  ### Limitations
</div>

Les limitations suivantes s’appliquent à Domaines personnalisés multiples :

* **WebAuthn/clés d’accès**:
  * Chaque domaine personnalisé a son propre enrôlement de clé d’accès. Une clé d’accès enrôlée sur un domaine personnalisé est liée à ce Relying Party ID (RP ID) précis et ne peut pas être utilisée sur d’autres domaines.
  * Si un utilisateur a enrôlé une clé de sécurité itinérante sous le domaine A et tente de se connecter au moyen du domaine B, l’authentification n’échouera pas simplement. Comme les RP ID ne correspondent pas, le système affichera immédiatement à l’utilisateur un nouvel écran d’enrôlement.