> ## 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 registrar dinámicamente aplicaciones de terceros con Auth0.

# Registro dinámico de clientes

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

Puede registrar dinámicamente aplicaciones de terceros en su inquilino. El Registro dinámico de clientes (DCR) se basa en la [especificación de Registro dinámico de clientes de OpenID Connect](https://openid.net/specs/openid-connect-registration-1_0.html).

Todas las aplicaciones creadas mediante el Registro dinámico de clientes son [aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications) con [controles de seguridad mejorados](/es/docs/get-started/applications/third-party-applications/security-controls). Esto significa que los clientes de DCR:

* Reciben el prefijo `tpc_` en el ID de cliente
* Requieren PKCE para los flujos de código de autorización
* Solo admiten los tipos de concesión `authorization_code` y `refresh_token`. El tipo de concesión `client_credentials` no está disponible mediante DCR.
* Solo pueden acceder a las API mediante [Client Grants](/es/docs/get-started/applications/application-access-to-apis-client-grants) explícitos
* Solo pueden usar [conexiones a nivel de dominio](/es/docs/authenticate/identity-providers/promote-connections-to-domain-level) para la autenticación

<div id="enable-dynamic-client-registration">
  ## Habilitar el registro dinámico de clientes
</div>

<Warning>
  Auth0 es compatible con Open Dynamic Registration. Si se habilita, cualquier persona podrá crear aplicaciones en su inquilino sin necesidad de un token.
</Warning>

De forma predeterminada, el registro dinámico de clientes está deshabilitado para todos los inquilinos. Para habilitar el registro dinámico de clientes, use Auth0 Dashboard o Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a [Dashboard > Settings > Advanced](https://manage.auth0.com/#/tenant/advanced) y habilite **Registro dinámico de clientes (DCR)**.
  </Tab>

  <Tab title="Management API">
    Establezca el indicador `enable_dynamic_client_registration` en `true` en la configuración de su inquilino mediante el endpoint [`/api/v2/tenants/settings`](https://auth0.com/docs/api/management/v2#!/Tenants/patch_settings).

    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request PATCH \
        --url 'https://{yourDomain}/api/v2/tenants/settings' \
        --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
        --header 'content-type: application/json' \
        --data '{ "flags": { "enable_dynamic_client_registration": true } }'
      ```
    </AuthCodeGroup>

    Debe reemplazar `{YOUR_MANAGEMENT_API_TOKEN}` por un token válido con el scope `update:tenant_settings`. Para obtener más información, consulte [Management API Access Tokens](/es/docs/secure/tokens/access-tokens/management-api-access-tokens).
  </Tab>
</Tabs>

<div id="configure-api-access-for-dcr-clients">
  ## Configurar el acceso a la API para clientes DCR
</div>

Antes de habilitar DCR, configure los [permisos predeterminados para aplicaciones de terceros](/es/docs/get-started/applications/application-access-to-apis-client-grants#default-permissions-for-third-party-applications) en las API a las que deben acceder los clientes registrados dinámicamente. Sin permisos predeterminados, los clientes DCR no podrán acceder a ninguna API.

Los permisos predeterminados definen un conjunto básico de API y alcances disponibles automáticamente para todas las aplicaciones de terceros. Esto es esencial para DCR porque no puede configurar client grants por aplicación durante el flujo de registro.

Para saber cómo configurar los permisos predeterminados, lea [Configurar aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/configure-third-party-applications#default-permissions-for-all-third-party-applications).

<div id="register-an-application">
  ## Registrar una aplicación
</div>

Para registrar dinámicamente una aplicación, realice una solicitud `POST` al endpoint `/oidc/register`. Dado que Auth0 admite Open Dynamic Registration, el endpoint `/oidc/register` acepta solicitudes de registro sin un token de acceso.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oidc/register' \
    --header 'content-type: application/json' \
    --data '{
      "client_name": "My Dynamic Application",
      "redirect_uris": ["https://application.example.com/callback"],
      "token_endpoint_auth_method": "none",
      "grant_types": ["authorization_code", "refresh_token"],
      "response_types": ["code"]
    }'
  ```
</AuthCodeGroup>

| **Parámetro**                | **Descripción**                                                                                                                                                                                              |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `client_name`                | El nombre de la aplicación que se va a crear.                                                                                                                                                                |
| `redirect_uris` (required)   | Una lista de URL que Auth0 aceptará como URL de devolución de llamada válidas al final de un flujo de autenticación.                                                                                         |
| `token_endpoint_auth_method` | El método de autenticación para el endpoint de token. Use `none` para clientes públicos (SPA, Native) o `client_secret_post` (predeterminado) para clientes confidenciales.                                  |
| `grant_types`                | Los tipos de concesión que la aplicación desea usar. Se filtran en la respuesta para reflejar aquellos que podrá usar. Las aplicaciones creadas mediante DCR admiten `authorization_code` y `refresh_token`. |
| `response_types`             | Los tipos de respuesta que usará la aplicación. Use `code` para el flujo de código de autorización.                                                                                                          |

Si la operación se completa correctamente, Auth0 devuelve las credenciales de la aplicación:

```json theme={null}
{
  "client_name": "My Dynamic Application",
  "client_id": "tpc_8SXWY6j3afl2CP5ntwEOpMdPxxy49Gt2",
  "client_secret": "Q5O...33P",
  "redirect_uris": [
    "https://application.example.com/callback"
  ],
  "client_secret_expires_at": 0,
  "grant_types": ["authorization_code", "refresh_token"],
  "token_endpoint_auth_method": "none"
}
```

| **Campo**                  | **Descripción**                                                                                                      |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `client_id`                | Identificador único de la aplicación con el prefijo `tpc_`. Úselo al iniciar flujos de autenticación.                |
| `client_secret`            | Secreto de la aplicación para clientes confidenciales. No se devuelve cuando `token_endpoint_auth_method` es `none`. |
| `client_secret_expires_at` | Hora de expiración del secreto del cliente. Para Auth0, siempre es `0` (nunca expira).                               |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Los desarrolladores externos no pueden modificar la configuración de la aplicación después del registro. Si es necesario hacer cambios, deben ponerse en contacto con el propietario del inquilino.
</Callout>

Después del registro, la aplicación puede iniciar un [Flujo de código de autorización con PKCE](/es/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce) mediante `client_id` y los `redirect_uris` configurados.

<div id="tenant-access-control-list-acl">
  ## Lista de control de acceso del inquilino (ACL)
</div>

Auth0 proporciona una [Lista de control de acceso del inquilino (ACL)](/es/docs/secure/tenant-access-control-list) para administrar el tráfico hacia el endpoint `/oidc/register`. Puede restringir quién puede enviar solicitudes de DCR configurando reglas de ACL en función de lo siguiente:

* Direcciones IP de origen y rangos CIDR
* Geolocalización
* Otras señales de la solicitud

Para configurar reglas de ACL para DCR, agregue el scope `dcr` a una regla de ACL. Para obtener más información, consulte la [Referencia de Tenant ACL](/es/docs/secure/tenant-access-control-list/reference).

<div id="rate-limits">
  ## Límites de frecuencia
</div>

El endpoint `/oidc/register` está sujeto a un límite de 5 solicitudes por segundo por inquilino. Para obtener más información sobre los límites de frecuencia, consulta [Configuración del límite de tasa](/es/docs/troubleshoot/customer-support/operational-policies/rate-limit-policy/rate-limit-configurations).

<div id="permissive-mode-for-dcr">
  ## Modo permisivo para DCR
</div>

Algunos clientes que usaban aplicaciones de terceros antes de abril de 2026 pueden configurar DCR para crear aplicaciones con el comportamiento preexistente en lugar de controles de seguridad mejorados. Para obtener más información, consulte [Registro dinámico de clientes en modo permisivo](/es/docs/get-started/applications/third-party-applications/permissive-mode#dynamic-client-registration-in-permissive-mode).

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

* [Aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications)
* [Controles de seguridad para aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/security-controls)
* [Acceso de las aplicaciones a las API: Client Grants](/es/docs/get-started/applications/application-access-to-apis-client-grants)
* [Aplicaciones de primera parte y de terceros](/es/docs/get-started/applications/first-party-and-third-party-applications)
* [Consent del usuario y aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)