> ## 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 utiliser un domaine personnalisé par défaut dans Auth0.

# Domaine personnalisé 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) + "*****MASKED*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Lorsque plusieurs [domaines personnalisés](/fr-CA/docs/customize/custom-domains/multiple-custom-domains) sont configurés pour votre locataire Auth0, vous pouvez en définir un comme **domaine personnalisé par défaut**. Le domaine par défaut simplifie la configuration et assure une expérience utilisateur cohérente lorsqu’aucun domaine personnalisé n’est explicitement précisé.

<div id="what-is-a-default-custom-domain">
  ## Qu’est-ce qu’un domaine personnalisé par défaut?
</div>

Le domaine personnalisé par défaut est le domaine personnalisé qu’Auth0 utilise automatiquement pour :

* **Communications par courriel et par téléphone** : l’envoi des courriels de réinitialisation de mot de passe, des liens de vérification du courriel et d’autres notifications générées par Auth0 lorsqu’aucun domaine personnalisé précis n’est spécifié. Cela inclut les cas où des notifications sont envoyées pendant l’authentification.
* **Appels à la Management API** : le traitement des requêtes API qui déclenchent des notifications sans l’en-tête `auth0-custom-domain`

Vous pouvez configurer le domaine canonique de votre locataire (`YOUR_TENANT.auth0.com` ou `YOUR_TENANT.REGION.auth0.com`) comme domaine personnalisé par défaut. Un domaine personnalisé par défaut sera toujours configuré pour votre locataire.

<div id="benefits-of-setting-a-default-domain">
  ## Avantages de définir un domaine par défaut
</div>

Définir un domaine personnalisé par défaut présente plusieurs avantages :

* **Configuration simplifiée** : Réduit le besoin de préciser des domaines personnalisés dans chaque appel à la Management API ou dans la configuration
* **Image de marque cohérente** : Garantit que les utilisateurs voient toujours votre marque, même lorsqu’aucun domaine précis n’est spécifié
* **En-tête `auth0-custom-domain` facultatif** : Rend l’en-tête de domaine personnalisé facultatif dans les requêtes à la Management API
* **Comportement de rechange** : Fournit des valeurs par défaut pertinentes pour les implémentations multimarques ou à plusieurs locataires
* **Migration facilitée** : Simplifie le passage d’un seul domaine personnalisé à plusieurs domaines personnalisés

<div id="configure-a-default-domain">
  ## Configurer un domaine par défaut
</div>

Vous pouvez définir un domaine personnalisé par défaut à partir de l’Auth0 Dashboard ou de la Management API.

<div id="using-the-auth0-dashboard">
  ### Utilisation du Auth0 Dashboard
</div>

Pour définir un domaine personnalisé par défaut dans le Auth0 Dashboard :

1. Accédez à **Auth0 Dashboard** > **Branding > Custom Domains**
2. Dans la liste, repérez le domaine personnalisé vérifié que vous voulez définir par défaut
3. Cliquez sur le bouton **Set as Default** pour ce domaine
4. Confirmez l’action dans la boîte de dialogue qui s’affiche

Le domaine affichera maintenant le badge « Default » dans la liste des domaines personnalisés.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Seuls les domaines personnalisés vérifiés peuvent être définis par défaut. Assurez-vous que votre domaine personnalisé est entièrement vérifié et actif avant de le désigner comme domaine par défaut.
</Callout>

<div id="using-the-management-api">
  ### Utiliser la Management API
</div>

Pour définir un domaine personnalisé par défaut à l’aide de la Management API, utilisez le point de terminaison `PATCH /api/v2/custom-domains/default` :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/custom-domains/default' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}' \
    --header 'content-type: application/json' \
    --data '{
      "domain": "my-custom-domain.com"
    }'
  ```

  ```javascript Node.js theme={null}
  import { ManagementClient } from "auth0";

  const management = new ManagementClient({
    domain: '{yourDomain}',
    clientId: '{yourClientId}',
    clientSecret: '{yourClientSecret}',
  });

  await management.customDomains.setDefault({
    domain: 'my-custom-domain.com',
  });
  ```

  ```python Python theme={null}
  from auth0.management import ManagementClient

  client = ManagementClient(
      domain='{yourDomain}',
      client_id='{yourClientId}',
      client_secret='{yourClientSecret}',
  )

  client.custom_domains.set_default({
      'domain': 'my-custom-domain.com',
  })
  ```

  ```go Go theme={null}
  import (
      "context"
      "github.com/auth0/go-auth0/v2/management"
      management_client "github.com/auth0/go-auth0/v2/management/client"
      "github.com/auth0/go-auth0/v2/management/option"
  )

  mgmt, err := management_client.New(
      "{yourDomain}",
      option.WithClientCredentials("{yourClientId}", "{yourClientSecret}"),
  )
  if err != nil {
      // Gérer l’erreur
  }

  err = mgmt.CustomDomains.SetDefault(context.Background(), &management.SetDefaultCustomDomainRequestContent{
      Domain: "my-custom-domain.com",
  })
  ```

  ```java Java theme={null}
  import com.auth0.client.mgmt.ManagementAPI;
  import com.auth0.json.mgmt.customdomains.SetDefaultCustomDomainRequest;

  ManagementAPI mgmt = ManagementAPI.newBuilder(
      "{yourDomain}",
      "{yourMgmtApiAccessToken}"
  ).build();

  SetDefaultCustomDomainRequest request = new SetDefaultCustomDomainRequest("my-custom-domain.com");

  mgmt.customDomains()
      .setDefault(request)
      .execute();
  ```
</AuthCodeGroup>

<div id="remove-default-domain-designation">
  ## Supprimer la désignation par défaut d’un domaine
</div>

Pour supprimer la désignation par défaut d’un domaine personnalisé :

1. Définissez un autre domaine personnalisé comme domaine par défaut (un seul domaine peut être défini par défaut à la fois), ou
2. Utilisez la Management API pour définir `is_default: false` pour le domaine actuellement défini par défaut

Lorsqu’aucun domaine personnalisé n’est défini par défaut, Auth0 utilisera le domaine canonique de votre locataire.

<div id="how-the-default-domain-is-used">
  ## Utilisation du domaine par défaut
</div>

<div id="email-notifications">
  ### Notifications par courriel
</div>

Lorsque Auth0 envoie des notifications par courriel (réinitialisation du mot de passe, vérification du courriel, courriels de bienvenue), le domaine par défaut est utilisé pour les liens et la personnalisation de ces notifications. Vous pouvez personnaliser les modèles de courriel pour utiliser les renseignements du domaine personnalisé dans l’adresse « De », l’objet et le corps du courriel.

<div id="management-api-endpoints-that-trigger-notifications">
  ### Points de terminaison de la Management API qui déclenchent des notifications
</div>

Le domaine personnalisé par défaut est utilisé précisément pour les points de terminaison de la Management API qui déclenchent des notifications par courriel ou par téléphone. L’en-tête `auth0-custom-domain` devient facultatif pour ces points de terminaison lorsqu’un domaine par défaut est configuré.

**Points de terminaison qui déclenchent des notifications par courriel :**

* `POST /api/v2/tickets/password-change` - Envoie un courriel de réinitialisation du mot de passe
* `POST /api/v2/tickets/email-verification` - Envoie un courriel de vérification de l’adresse courriel
* `POST /api/v2/jobs/verification-email` - Envoie un courriel de vérification à un ou plusieurs utilisateurs
* `POST /api/v2/users` - Peut déclencher un courriel de bienvenue si cette option est configurée
* `PATCH /api/v2/users/{id}` - Peut déclencher un courriel de vérification lorsque l’adresse courriel est mise à jour

**Points de terminaison qui déclenchent des notifications par téléphone :**

* `POST /api/v2/users/{id}/phone/verification` - Envoie un code de vérification par SMS

**Exemple :**

<AuthCodeGroup>
  ```bash Sans en-tête de domaine personnalisé (utilise le domaine par défaut) theme={null}
  # Le ticket de réinitialisation du mot de passe utilise le domaine par défaut dans les liens du courriel
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/tickets/password-change' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}' \
    --header 'content-type: application/json' \
    --data '{
      "user_id": "auth0|123456",
      "result_url": "https://example.com/password-changed"
    }'
  ```

  ```bash Avec en-tête de domaine personnalisé (remplace le domaine par défaut) theme={null}
  # Indique explicitement un domaine personnalisé différent pour cette notification
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/tickets/password-change' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}' \
    --header 'auth0-custom-domain: brand-specific.com' \
    --header 'content-type: application/json' \
    --data '{
      "user_id": "auth0|123456",
      "result_url": "https://example.com/password-changed"
    }'
  ```
</AuthCodeGroup>

Si vous ne fournissez pas l’en-tête `auth0-custom-domain` pour ces points de terminaison de notification, Auth0 utilise automatiquement le domaine personnalisé par défaut pour les liens et les personnalisations dans le courriel ou le SMS. Vous pouvez remplacer ce comportement pour chaque requête en incluant l’en-tête `auth0-custom-domain`.

<div id="using-the-default-domain-with-actions">
  ## Utiliser le domaine par défaut avec Actions
</div>

Utilisez [Actions](/fr-CA/docs/customize/actions) pour mettre en œuvre une logique basée sur le domaine personnalisé :

```javascript theme={null}
exports.onExecutePostLogin = async (event, api) => {
  const domain = event.custom_domain?.domain;

  // Stocker le domaine de connexion dans les métadonnées de l'utilisateur
  if (domain) {
    api.user.setAppMetadata('login_domain', domain);
  }
};
```

Pour en savoir plus sur l’utilisation des informations relatives aux domaines personnalisés dans Actions, consultez [Intégration d’Actions à plusieurs domaines personnalisés](/fr-CA/docs/customize/custom-domains/multiple-custom-domains/actions-integration).

<div id="best-practices">
  ## Bonnes pratiques
</div>

Lorsque vous configurez un domaine personnalisé par défaut, tenez compte des bonnes pratiques suivantes :

* **Choisissez un domaine stable** : Sélectionnez un domaine qui ne changera pas souvent comme domaine par défaut
* **Vérifiez-le avant de le définir** : Assurez-vous que le domaine est entièrement vérifié et opérationnel avant d’en faire le domaine par défaut
* **Documentez la décision** : Consignez pourquoi un domaine précis a été choisi comme domaine par défaut pour référence ultérieure
* **Testez les flux de courriel** : Après avoir défini un domaine par défaut, testez les flux de réinitialisation du mot de passe et de vérification du courriel
* **Vérifiez les émetteurs des jetons** : Assurez-vous que les jetons contiennent la revendication `iss` attendue après avoir défini le domaine par défaut
* **Prévoyez les scénarios à plusieurs marques** : Si vous prenez en charge plusieurs marques, choisissez un domaine générique ou d’administration comme domaine par défaut
* **Mettez à jour les intégrations** : Informez votre équipe du domaine par défaut pour assurer une configuration adéquate des intégrations

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

* [Domaines personnalisés multiples](/fr-CA/docs/customize/custom-domains/multiple-custom-domains)
* [Configurer des fonctionnalités pour utiliser des domaines personnalisés](/fr-CA/docs/customize/custom-domains/configure-features-to-use-custom-domains)
* [Aperçu des domaines personnalisés](/fr-CA/docs/customize/custom-domains)
* [Utiliser des domaines personnalisés dans les courriels et les notifications téléphoniques](/fr-CA/docs/customize/custom-domains/configure-features-to-use-custom-domains#use-custom-domains-in-emails-and-phone-notifications)
* [Intégration des Actions avec les domaines personnalisés](/fr-CA/docs/customize/actions)