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

> Aprende a configurar y usar un dominio personalizado predeterminado en Auth0.

# Dominio personalizado predeterminado

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

Cuando tenga [varios dominios personalizados](/es/docs/customize/custom-domains/multiple-custom-domains) configurados para su inquilino de Auth0, puede designar uno como el **dominio personalizado predeterminado**. El dominio predeterminado simplifica la configuración y garantiza una experiencia de usuario uniforme cuando no se especifica explícitamente un dominio personalizado.

<div id="what-is-a-default-custom-domain">
  ## ¿Qué es un dominio personalizado predeterminado?
</div>

El dominio personalizado predeterminado es el dominio personalizado que Auth0 usa automáticamente para:

* **Comunicaciones por correo electrónico y teléfono**: enviar correos electrónicos de restablecimiento de contraseña, enlaces de verificación de correo electrónico y otras notificaciones generadas por Auth0 cuando no se especifica un dominio personalizado concreto. Esto incluye los casos en que se envían notificaciones durante la autenticación.
* **Llamadas a la Management API**: gestionar solicitudes a la API que activan notificaciones sin el encabezado `auth0-custom-domain`

Puede configurar el dominio canónico de su inquilino (`YOUR_TENANT.auth0.com` o `YOUR_TENANT.REGION.auth0.com`) como dominio personalizado predeterminado. Siempre habrá un dominio personalizado predeterminado configurado para su inquilino.

<div id="benefits-of-setting-a-default-domain">
  ## Beneficios de configurar un dominio predeterminado
</div>

Configurar un dominio personalizado predeterminado ofrece varias ventajas:

* **Configuración simplificada**: Reduce la necesidad de especificar dominios personalizados en cada llamada a la Management API o en cada configuración
* **Marca coherente**: Garantiza que los usuarios siempre vean su marca, incluso cuando no se especifique un dominio concreto
* **Encabezado `auth0-custom-domain` opcional**: Hace que el encabezado de dominio personalizado sea opcional en las solicitudes de la Management API
* **Comportamiento de respaldo**: Proporciona valores predeterminados adecuados para implementaciones con varias marcas o varios inquilinos
* **Migración más sencilla**: Simplifica la transición de un único dominio personalizado a varios dominios personalizados

<div id="configure-a-default-domain">
  ## Configurar un dominio predeterminado
</div>

Puede establecer un dominio personalizado predeterminado a través del Auth0 Dashboard o de la Management API.

<div id="using-the-auth0-dashboard">
  ### Uso del Auth0 Dashboard
</div>

Para establecer un dominio personalizado predeterminado en el Auth0 Dashboard:

1. Ve a **Auth0 Dashboard** > **Marca > Dominios personalizados**
2. Busca en la lista el dominio personalizado verificado que quieres establecer como predeterminado
3. Haz clic en el botón **Establecer como predeterminado** para ese dominio
4. Confirma la acción en el cuadro de diálogo que aparece

El dominio ahora mostrará una insignia de "Predeterminado" en la lista de dominios personalizados.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Solo se pueden establecer como predeterminados los dominios personalizados verificados. Asegúrate de que tu dominio personalizado esté completamente verificado y activo antes de designarlo como predeterminado.
</Callout>

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

Para configurar un dominio personalizado predeterminado mediante la Management API, use el endpoint `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 {
      // Gestionar el error
  }

  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">
  ## Quitar la designación predeterminada de un dominio
</div>

Para quitar la designación predeterminada de un dominio personalizado:

1. Configure otro dominio personalizado como predeterminado (solo un dominio puede ser el predeterminado a la vez), o
2. Use la Management API para establecer `is_default: false` en el dominio predeterminado actual

Si no se configura ningún dominio personalizado como predeterminado, Auth0 usará el dominio canónico de su inquilino.

<div id="how-the-default-domain-is-used">
  ## Cómo se utiliza el dominio predeterminado
</div>

<div id="email-notifications">
  ### Notificaciones por correo electrónico
</div>

Cuando Auth0 envía notificaciones por correo electrónico (restablecimiento de contraseña, verificación del correo electrónico y correos de bienvenida), se utiliza el dominio predeterminado para los links y las personalizaciones de estas notificaciones. Puede personalizar las plantillas de correo electrónico para usar la información del dominio personalizado en la dirección "From", la línea de asunto y el cuerpo del correo electrónico.

<div id="management-api-endpoints-that-trigger-notifications">
  ### Endpoints de Management API que activan notificaciones
</div>

El dominio personalizado predeterminado se usa específicamente para los endpoints de Management API que activan notificaciones por correo electrónico o por teléfono. El encabezado `auth0-custom-domain` pasa a ser opcional para estos endpoints cuando tienes configurado un dominio predeterminado.

**Endpoints que activan notificaciones por correo electrónico:**

* `POST /api/v2/tickets/password-change` - Envía un correo electrónico de restablecimiento de contraseña
* `POST /api/v2/tickets/email-verification` - Envía un correo electrónico de verificación
* `POST /api/v2/jobs/verification-email` - Envía un correo electrónico de verificación a uno o varios usuarios
* `POST /api/v2/users` - Puede activar un correo electrónico de bienvenida si está configurado
* `PATCH /api/v2/users/{id}` - Puede activar un correo electrónico de verificación cuando se actualiza el correo electrónico

**Endpoints que activan notificaciones por teléfono:**

* `POST /api/v2/users/{id}/phone/verification` - Envía un código de verificación por SMS

**Ejemplo:**

<AuthCodeGroup>
  ```bash Sin encabezado de dominio personalizado (usa el predeterminado) theme={null}
  # El ticket de restablecimiento de contraseña usa el dominio predeterminado en los enlaces del correo electrónico
  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 Con encabezado de dominio personalizado (reemplaza el predeterminado) theme={null}
  # Especifica explícitamente un dominio personalizado diferente para esta notificación
  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>

Cuando no proporcionas el encabezado `auth0-custom-domain` para estos endpoints de notificación, Auth0 usa automáticamente el dominio personalizado predeterminado para los enlaces y las personalizaciones del correo electrónico o del SMS. Puedes reemplazarlo en cada solicitud incluyendo el encabezado `auth0-custom-domain`.

<div id="using-the-default-domain-with-actions">
  ## Uso del dominio predeterminado con Actions
</div>

Use [Actions](/es/docs/customize/actions) para implementar lógica basada en el dominio personalizado:

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

  // Almacenar el dominio de inicio de sesión en los metadatos del usuario
  if (domain) {
    api.user.setAppMetadata('login_domain', domain);
  }
};
```

Para obtener más información sobre cómo usar información de dominios personalizados en Actions, consulta [Integración de Actions con varios dominios personalizados](/es/docs/customize/custom-domains/multiple-custom-domains/actions-integration).

<div id="best-practices">
  ## Prácticas recomendadas
</div>

Al configurar un dominio personalizado predeterminado, tenga en cuenta estas prácticas recomendadas:

* **Elija un dominio estable**: Seleccione un dominio que no cambie con frecuencia como dominio predeterminado
* **Verifique antes de establecerlo**: Asegúrese de que el dominio esté completamente verificado y operativo antes de establecerlo como predeterminado
* **Documente la decisión**: Registre por qué se eligió un dominio determinado como predeterminado para futuras consultas
* **Pruebe los flujos de correo electrónico**: Después de establecer un dominio predeterminado, pruebe los flujos de restablecimiento de contraseña y verificación de correo electrónico
* **Supervise los emisores de tokens**: Verifique que los tokens incluyan la reclamación `iss` esperada después de establecer un dominio predeterminado
* **Planifique escenarios de múltiples marcas**: Si presta servicio a varias marcas, elija un dominio genérico o administrativo como predeterminado
* **Actualice las integraciones**: Informe a su equipo sobre el dominio predeterminado para garantizar una configuración correcta de las integraciones

<div id="learn-more">
  ## Más información
</div>

* [Múltiples dominios personalizados](/es/docs/customize/custom-domains/multiple-custom-domains)
* [Configurar funcionalidades para usar dominios personalizados](/es/docs/customize/custom-domains/configure-features-to-use-custom-domains)
* [Descripción general de los dominios personalizados](/es/docs/customize/custom-domains)
* [Usar dominios personalizados en correos electrónicos](/es/docs/customize/custom-domains/configure-features-to-use-custom-domains#use-custom-domains-in-emails-and-phone-notifications)
* [Integración de Actions con dominios personalizados](/es/docs/customize/actions)