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

> Aprenda a configurar y administrar varios dominios personalizados dentro de un mismo inquilino de Auth0 para implementaciones multimarca y multirregión.

# Varios dominios personalizados

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

Dentro de Auth0, un <Tooltip tip="Dominio personalizado: dominio de terceros con un nombre especializado o distintivo." cta="Ver glosario" href="/es/docs/glossary?term=custom+domain">dominio personalizado</Tooltip> le permite unificar la experiencia de inicio de sesión con su propia marca y sus productos. La función de múltiples dominios personalizados le permite configurar varios dominios personalizados dentro de un único inquilino de Auth0. Esta función está disponible para clientes Enterprise tanto en implementaciones de Public Cloud como de Private Cloud.

<div id="prerequisites">
  ## Requisitos previos
</div>

Antes de comenzar con MCD, revise los siguientes requisitos:

* Su inquilino debe tener un plan Enterprise ([implementaciones de Public Cloud o Private Cloud](/es/docs/deploy-monitor/deployment-options)). Para obtener más información, consulte
  Manage Subscriptions.
* Su plan Enterprise incluye una asignación base de hasta 20 dominios personalizados por inquilino.
* Los dominios personalizados adicionales que superen la asignación base están disponibles mediante un SKU complementario. Póngase en contacto con el equipo de ventas de Auth0 para obtener más información.
* Debe poder demostrar la titularidad de los dominios personalizados configurados.

<div id="configure-multiple-custom-domains">
  ## Configurar varios dominios personalizados
</div>

Puede agregar y administrar varios dominios personalizados para su inquilino con <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> o con la <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip>.

<Tabs>
  <Tab title="Auth0 Dashboard">
    Para crear un dominio personalizado en el Auth0 Dashboard:

    1. Vaya a **Auth0 Dashboard** > **Branding > Custom Domains**.
    2. Seleccione **+Add custom domain**.
    3. En el formulario de configuración, proporcione la siguiente información:

       * **Dominio:** Un [nombre de dominio completo](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) de su propiedad. Por ejemplo: `my.custom-domain.com`.
       * **Tipo de certificado:** Elija [**Auth0-managed certificates**](/es/docs/customize/custom-domains/auth0-managed-certificates) o [**Self-managed certificates**](/es/docs/customize/custom-domains/self-managed-certificates).
       * **Metadatos (clave/valor):** Añada metadatos opcionales como `region`, `client_name` o `client_id` para ayudar a organizar y filtrar sus dominios.
    4. Una vez que haya configurado los detalles del dominio personalizado, seleccione **Save**.

    El dominio recién añadido se mostrará como `pending` hasta que se complete la verificación.

    #### Ver y administrar dominios

    La página Custom Domains muestra todos los dominios configurados. Puede hacer lo siguiente:

    * **Buscar**: Buscar dominios por nombre mediante el cuadro de búsqueda
    * **Filtrar**: Filtrar dominios por estado de verificación, tipo de certificado o valores de metadatos
    * **Ordenar**: Ordenar dominios por nombre, fecha de creación o estado de verificación
    * **Ver detalles**: Haga clic en cualquier dominio para ver la configuración detallada, el estado de verificación y la información del certificado
    * **Establecer como predeterminado**: Designar un dominio como el dominio predeterminado de su inquilino

    Estas funciones le ayudan a administrar de forma eficiente un gran número de dominios personalizados en su inquilino.
  </Tab>

  <Tab title="Management API">
    Para crear un dominio personalizado con la Management API, necesitas una aplicación machine-to-machine (M2M) autorizada para usar la Management API. Para más información, consulta [Tokens de acceso de la Management API](/es/docs/secure/tokens/access-tokens/management-api-access-tokens).

    1. Vaya a [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) y seleccione **Crear aplicación**.
    2. Introduzca un nombre descriptivo para su aplicación y elija **Machine to Machine Applications**. A continuación, seleccione **Create**.
    3. Cambie a la vista de **APIs** y luego active el interruptor de `Auth0 Management API`.
    4. Expanda la fila para configurar los permisos de la API. Para MCD, debe seleccionar lo siguiente:

       * `read:custom_domains`
       * `create:custom_domains`
       * `update:custom_domains`
       * `delete:custom_domains`
    5. Selecciona **Update**.
    6. Vaya a la pestaña **Configuración** para recopilar su **ID de cliente**, **Secreto del cliente** y **dominio**.
    7. Consulte [Obtener tokens de acceso de Management API](/es/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) para obtener y almacenar su token de acceso.

    #### Crear un dominio personalizado

    Puede crear un nuevo dominio personalizado enviando una solicitud `POST` al endpoint `/api/v2/custom-domains`. Consulte el siguiente ejemplo para crear un nuevo dominio personalizado mediante el explorador de la Management API, usando las credenciales obtenidas anteriormente:

    <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_NONE

      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 la operación se realiza correctamente, verás la siguiente respuesta con los detalles de tu nuevo dominio personalizado, incluido su estado de verificación. El `status` se devuelve inicialmente como `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">
  ## Características de MCD
</div>

MCD ofrece numerosas características y funcionalidades clave para administrar con mayor eficacia su implementación de Auth0 y mejorar la experiencia del usuario. Usted es responsable de adquirir y registrar los dominios personalizados que desee con un registrador de nombres de dominio.

La [Auth0 Management API](https://auth0.com/docs/api/management/v2/custom-domains/get-custom-domains) proporciona compatibilidad integral con las operaciones de **crear, leer, actualizar, eliminar y verificar** estos dominios personalizados, lo que le brinda un control programático total sobre su ciclo de vida.

MCD es compatible con los siguientes SDK de Management API de Auth0: [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) y [.NET](https://github.com/auth0/auth0.net). Los SDK de autenticación funcionan automáticamente con dominios personalizados cuando se configuran en su aplicación.

<div id="default-domain">
  ### Dominio predeterminado
</div>

Cuando hay varios dominios personalizados configurados, puedes designar uno como **dominio predeterminado**. El dominio predeterminado se utiliza cuando se necesita información del dominio para los endpoints de Auth0 Management API, pero no se especifica explícitamente un dominio personalizado mediante el encabezado `auth0-custom-domain`. Esta información se usa para personalizar las notificaciones por correo electrónico (por ejemplo, el restablecimiento de contraseña y la verificación del correo electrónico) con datos específicos del dominio.

Para establecer un dominio predeterminado:

1. Ve a **Auth0 Dashboard** > **Branding > Custom Domains**
2. Busca en la lista el dominio que quieres establecer como predeterminado
3. Haz clic en el botón **Set as Default** de ese dominio

También puedes establecer el dominio predeterminado con la Management API actualizando la configuración de un dominio personalizado. Una vez configurado, el dominio predeterminado se usará automáticamente para personalizar las comunicaciones por correo electrónico, a menos que se proporcione un dominio específico mediante el encabezado `auth0-custom-domain`.

<Callout icon="info" color="#0EA5E9" iconType="regular">
  El dominio predeterminado hace que el encabezado `auth0-custom-domain` sea opcional para los endpoints de Management API que desencadenan notificaciones. Si no especificas un dominio personalizado al llamar a estos endpoints, Auth0 usará automáticamente el dominio predeterminado para las personalizaciones de correo electrónico.
</Callout>

<div id="domain-verification">
  ### Verificación del dominio
</div>

El método para verificar la propiedad del nombre de dominio depende del tipo de gestión que haya elegido:

| Tipo de dominio                                                                   | Método de verificación | Detalles                                                                                    |
| --------------------------------------------------------------------------------- | ---------------------- | ------------------------------------------------------------------------------------------- |
| **[Auth0-Managed](/es/docs/customize/custom-domains/auth0-managed-certificates)** | Registro DNS CNAME     | Configure este registro para confirmar la propiedad del dominio y activarlo.                |
| **[Self-Managed](/es/docs/customize/custom-domains/self-managed-certificates)**   | Registro DNS TXT       | Los detalles específicos del registro TXT se proporcionan en la respuesta de la API Create. |

Una vez que Auth0 haya verificado su dominio personalizado, puede usarlo de inmediato para configurar las funcionalidades de Auth0 para sus usuarios. Para obtener más información, consulte [Configure Features to Use Custom Domains](/es/docs/customize/custom-domains/configure-features-to-use-custom-domains).

<div id="metadata-for-enhanced-management">
  ### Metadatos para una administración mejorada
</div>

Puede provisionar hasta 10 campos de metadatos por dominio personalizado para facilitar la organización y la personalización futura. En próximas versiones, estos campos de metadatos permitirán una personalización avanzada de las plantillas de correo electrónico, <Tooltip tip="Universal Login: Su aplicación redirige a Universal Login, alojado en el Servidor de autorización de Auth0, para verificar la identidad del usuario." cta="Ver glosario" href="/es/docs/glossary?term=Universal+Login">Universal Login</Tooltip> y la lógica de autenticación.

<div id="customize-email-templates">
  ### Personaliza las plantillas de correo electrónico
</div>

Aprovecha la información de tu dominio personalizado para personalizar tus plantillas de correo electrónico y reforzar tu marca, lo que garantiza una experiencia de usuario coherente. Para ello, MCD proporciona la variable `custom_domain.domain`, que puedes usar en la sintaxis Liquid.

Por ejemplo, puedes establecer la **Dirección del remitente** de tu plantilla de correo electrónico como `support@{{ custom_domain.domain }}`, que se mostraría como `support@my.custom-domain.com`. Esta variable está disponible en los campos **Dirección del remitente**, **Asunto** y **Mensaje** mediante la sintaxis Liquid. Para obtener más información, consulta [Personalizar las plantillas de correo electrónico](/es/docs/customize/email/email-templates).

<div id="customize-email-handling-using-the-management-api">
  #### Personalice la gestión del correo electrónico con la Management API
</div>

Si configuró Multiple Custom Domains y habilitó [Use Custom Domains in Emails](/es/docs/customize/custom-domains/configure-features-to-use-custom-domains#use-custom-domains-in-emails), el encabezado HTTP `auth0-custom-domain` está disponible al usar la Management API de Auth0. El encabezado se pasa como valor del `domain object` en las plantillas de correo electrónico.

Los siguientes endpoints de la Management API aceptan el encabezado HTTP `auth0-custom-domain`:

* [Enviar un correo de verificación de dirección de correo electrónico](https://auth0.com/docs/api/management/v2#!/Jobs/post_verification_email)
* [Crear un ticket de verificación de correo electrónico](https://auth0.com/docs/api/management/v2/tickets/post-email-verification)
* [Crear invitaciones para una organización](https://auth0.com/docs/api/management/v2/organizations/post-invitations)
* [Crear un usuario](https://auth0.com/docs/api/management/v2/users/post-users)
* [Crear un ticket de inscripción en autenticación multifactor](https://auth0.com/docs/api/management/v2/guardian/post-ticket)
* [Crear un ticket de cambio de contraseña](https://auth0.com/docs/api/management/v2/tickets/post-password-change)
* [Actualizar un usuario](https://auth0.com/docs/api/management/v2/users/patch-users-by-id)

Por ejemplo: para crear un ticket de cambio de contraseña con el SDK de Auth0 para [Node.js](https://github.com/auth0/node-auth0).

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

// Nivel de cliente: se aplica automáticamente a los endpoints en lista blanca
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);
    }
})();

// Alternativamente, usar la anulación por solicitud
const reqOptions = {
    ...CustomDomainHeader('my-custom-domain.com'),
};
const ticket = await auth0.tickets.changePassword(
    { user_id: 'auth0|abc123', result_url: 'https://example.com/success' },
    reqOptions
);
```

Respuesta de ejemplo: el dominio personalizado se envía en el encabezado utilizado para generar la URL del ticket.

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

<div id="response-messages">
  ##### Mensajes de respuesta
</div>

Cuando incluyes el encabezado HTTP `auth0-custom-domain`, son posibles los siguientes tipos de respuesta adicionales:

| Código de estado HTTP | Mensaje                                                              |
| --------------------- | -------------------------------------------------------------------- |
| `409`                 | El inquilino tiene varios dominios personalizados verificados.       |
| `400`                 | El dominio personalizado no existe en el inquilino.                  |
| `400`                 | El encabezado HTTP `auth0-custom-domain` tiene un formato no válido. |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si habilitas MCD y usas el Auth0 Dashboard para configurar plantillas de correo electrónico, la función Try se ejecutará con tu dominio personalizado predeterminado en lugar del dominio estándar de Auth0.
</Callout>

<div id="application-url-placeholders">
  ### Marcadores de posición de URL de la aplicación
</div>

Puede usar los metadatos de dominios personalizados como marcadores de posición dinámicos en las URL de la aplicación, como las URL de callback, las URL de cierre de sesión y el URI de inicio de sesión de la aplicación (`initiate_login_uri`). Esto permite que cada dominio personalizado se resuelva en una URL de aplicación distinta en tiempo de ejecución. Para obtener más información, consulte [Marcadores de posición de URL de dominios personalizados](/es/docs/get-started/applications/wildcards-for-subdomains#custom-domain-url-placeholders).

<div id="multiple-custom-domains-with-actions">
  ### Múltiples dominios personalizados con Actions
</div>

Las [Actions](/es/docs/customize/actions) de Auth0 le permiten crear lógica personalizada para gestionar distintas transacciones en función del dominio personalizado.

Por ejemplo, podría crear una Action que dirija a un usuario a una [Organización](/es/docs/manage-users/organizations) asociada o aplicar una [política de control de acceso](/es/docs/customize/actions/use-cases#api-authorization) específica.

Para ello, las Actions de post-login incluyen el objeto `event.custom_domain`, que proporciona el dominio personalizado que se está utilizando para el flujo de autenticación.

<div id="use-case-restrict-user-access-to-an-organization-based-on-custom-domain">
  #### Caso de uso: Restringir el acceso de un usuario a una Organización según el dominio personalizado
</div>

Almacene una lista de dominios permitidos y otra de dominios denegados (por ejemplo, `allow_domains` y `deny_domains`) en los metadatos de su Organización.

Cree una Action que:

1. Obtenga el dominio del usuario a través de la propiedad `event.custom_domain?.domain`
2. Compare ese dominio con ambas listas
3. Permita o deniegue el acceso del usuario según corresponda

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

    // Verificar solo deny (A) o allow (B), no ambos
    // (A) verifica la deny_list de la org
    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) verifica la allow_list de la org
    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 proporciona acceso a los metadatos del dominio personalizado en Actions mediante el objeto `event.custom_domain`. Puede usar esta información, junto con los metadatos del dominio personalizado configurados en su inquilino, para implementar lógica específica del dominio en sus Actions.
</Callout>

<div id="custom-domain-attributes">
  ### Atributos de dominios personalizados
</div>

MCD proporciona los siguientes atributos relacionados con la verificación de dominios personalizados y la gestión de certificados SSL/TLS. Estos atributos ofrecen información detallada sobre el aprovisionamiento y el estado operativo de los dominios personalizados.

<div id="updated-attributes">
  #### Atributos actualizados
</div>

| Atributo | Descripción                                                                                                                                                                                                                                                                             |
| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status` | Se ha agregado un nuevo valor de enumeración, `failed`, al atributo `status`. Este valor indica que el proceso de verificación del dominio personalizado ha encontrado un error y no se ha completado correctamente. Se añade a los valores compatibles existentes `pending` y `ready`. |

<div id="new-attributes">
  #### Nuevos atributos
</div>

Los siguientes atributos solo se admiten para dominios administrados por Auth0:

| Atributo                            | Descripción                                                                                                                                                                                                                                   |
| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `verification.status`               | Estado del proceso de verificación del registro DNS. Los valores posibles son: `verified`, `pending` y `failed`.                                                                                                                              |
| `verification.error_msg`            | Si `verification.status` indica un error, este atributo de cadena contendrá un mensaje de error legible que proporcionará contexto sobre el error de verificación.                                                                            |
| `verification.last_verified_at`     | Este atributo de marca de tiempo registra la fecha y hora de la última verificación correcta del dominio personalizado. El formato de esta marca de tiempo seguirá la norma ISO 8601.                                                         |
| `certificate`                       | Este objeto encapsula información relacionada con el certificado SSL/TLS asociado al dominio personalizado.                                                                                                                                   |
| `certificate.status`                | Este atributo indica el estado actual de aprovisionamiento del certificado SSL/TLS. Los valores posibles incluyen estados como `provisioning`, `provisioned`, `provisioning_failed` y `renewing_failed`.                                      |
| `certificate.error_msg`             | Si `certificate.status` es `provisioning_failed` o `renewing_failed`, este atributo de cadena proporcionará un mensaje de error claro que detallará el motivo del error.                                                                      |
| `certificate.certificate_authority` | Este atributo de cadena especifica la autoridad de certificación que emitió el certificado SSL/TLS para el dominio personalizado.                                                                                                             |
| `certificate.renews_before`         | Para los dominios personalizados administrados por Auth0, este nuevo atributo de marca de tiempo indica la fecha y hora antes de la cual debe renovarse el certificado SSL/TLS. El formato de esta marca de tiempo seguirá la norma ISO 8601. |

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

Las siguientes limitaciones se aplican a Multiple Custom Domains:

* **WebAuthn/Passkeys**:
  * Cada dominio personalizado mantiene su propia inscripción de claves de acceso. Una clave de acceso inscrita en un dominio queda vinculada a ese identificador de parte de confianza (RP ID) específico y no puede usarse en otros dominios.
  * Si un usuario inscribió una llave de seguridad externa en el Dominio A e intenta iniciar sesión mediante el Dominio B, la autenticación no fallará sin más. En su lugar, como los RP ID no coinciden, el sistema mostrará inmediatamente al usuario una nueva pantalla de inscripción.