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

# Configurar aplicaciones de terceros

> Cree y configure aplicaciones de terceros mediante el Auth0 Dashboard o la Management API.

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

Cree aplicaciones de terceros que permitan a desarrolladores externos, partners o agentes de IA acceder a sus APIs con controles de seguridad reforzados.

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

Antes de crear una aplicación de terceros, asegúrate de tener lo siguiente:

* Un inquilino de Auth0 con al menos una [API (servidor de recursos)](/es/docs/get-started/apis) configurada
* Al menos una [conexión](/es/docs/authenticate/identity-providers) promovida al [nivel de dominio](/es/docs/authenticate/identity-providers/promote-connections-to-domain-level) (para flujos destinados al usuario final)

<div id="create-a-third-party-application">
  ## Crear una aplicación de terceros
</div>

Cree una aplicación de terceros con Auth0 Dashboard o la Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a **Applications > Applications**.
    2. Seleccione **Create Application**.
    3. Escriba un nombre para la aplicación y seleccione el tipo de aplicación:
       * Regular Web App para clientes confidenciales del lado del servidor
       * Single Page App para clientes públicos basados en navegador
       * Native para clientes públicos móviles o de escritorio
    4. Active el interruptor **This application is owned by a third party**.
    5. Seleccione **Create**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/create-application-dialog.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=40a37dfc84c4d1323bc22244e405d846" alt="Cuadro de diálogo Create Application de Dashboard con la opción de terceros habilitada" width="800" height="875" data-path="docs/images/third-party-applications/create-application-dialog.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Realice una solicitud `POST` al endpoint `/api/v2/clients` con el siguiente cuerpo de la solicitud:

    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/clients' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "name": "Partner Application",
          "is_first_party": false,
          "app_type": "regular_web",
          "callbacks": ["https://partner.example.com/callback"],
          "grant_types": ["authorization_code", "refresh_token"],
          "token_endpoint_auth_method": "client_secret_post"
        }'
      ```
    </AuthCodeGroup>

    | **Parámetro**                | **Tipo** | **Descripción**                                                                                                                                                                                                                                                                                                                                  |
    | ---------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
    | `name`                       | String   | Obligatorio. El nombre de la aplicación.                                                                                                                                                                                                                                                                                                         |
    | `is_first_party`             | Boolean  | Indica si la aplicación es propia (`true`) o de terceros (`false`).                                                                                                                                                                                                                                                                              |
    | `app_type`                   | String   | El tipo de aplicación (por ejemplo, `regular_web`, `native`, `spa`, `non_interactive`).                                                                                                                                                                                                                                                          |
    | `callbacks`                  | Array    | Una lista de URL de callback permitidas para la redirección después de la autenticación.                                                                                                                                                                                                                                                         |
    | `grant_types`                | Array    | Una lista de tipos de concesión de OAuth2 que este cliente puede usar. Las aplicaciones de terceros admiten `authorization_code`, `refresh_token` y `client_credentials`. Para obtener más información, consulte [Security Controls for Third-Party Applications](/es/docs/get-started/applications/third-party-applications/security-controls). |
    | `token_endpoint_auth_method` | String   | El método de autenticación para el endpoint de token (por ejemplo, `client_secret_post`).                                                                                                                                                                                                                                                        |

    Si la solicitud se realiza correctamente, Auth0 crea la aplicación con un prefijo `tpc_` en el ID de cliente, los tipos de concesión `authorization_code` y `refresh_token`, y establece `third_party_security_mode` en `strict`, lo que indica que los controles de seguridad reforzados están habilitados.

    ```json wrap lines theme={null}
    {
      "client_id": "tpc_aBcDeFgHiJkLmNoPqRsTuV",
      "third_party_security_mode": "strict",
      "is_first_party": false,
      "name": "Partner Application",
      "grant_types": ["authorization_code", "refresh_token"],
      ...
    }
    ```

    | **Parámetro**               | **Tipo** | **Descripción**                                                                                                                                     |
    | --------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `client_id`                 | String   | El identificador único de la aplicación con un prefijo `tpc` para indicar que es una aplicación de terceros creada con el modo estricto habilitado. |
    | `third_party_security_mode` | String   | Define el perfil de seguridad. Se establece en `strict` para aplicar restricciones de seguridad reforzadas a las aplicaciones de terceros.          |
    | `is_first_party`            | Boolean  | Debe establecerse en `false` cuando se use el modo de seguridad `strict` para identificar la aplicación como de terceros.                           |
    | `name`                      | String   | El nombre para mostrar de la aplicación.                                                                                                            |
    | `grant_types`               | Array    | Los tipos de concesión de OAuth2 que esta aplicación está autorizada a usar (por ejemplo, `authorization_code`).                                    |
  </Tab>
</Tabs>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propiedad `third_party_security_mode` se establece al crear la aplicación y no puede cambiarse. Para usar otro modo de seguridad, cree una aplicación nueva.
</Callout>

<div id="configure-api-access-policies">
  ## Configurar políticas de acceso a las API
</div>

Las aplicaciones de terceros requieren concesiones de cliente explícitas para acceder a las API. Puede configurar las políticas de acceso a las API de las siguientes maneras:

* [Permisos por aplicación](#per-application-permissions): Aplique permisos granulares a cada aplicación de su inquilino.
* [Permisos predeterminados para todas las aplicaciones de terceros](#default-permissions-for-all-third-party-applications): Aplique permisos predeterminados a todas las aplicaciones de terceros de su inquilino.

Cuando existen permisos por aplicación y permisos predeterminados para aplicaciones de terceros para la misma API, los permisos por aplicación tienen prioridad. Para obtener más información, consulte [Acceso de las aplicaciones a las API: concesiones de cliente](/es/docs/get-started/applications/application-access-to-apis-client-grants).

<div id="per-application-permissions">
  ### Permisos por aplicación
</div>

Para conceder a una aplicación de terceros específica un acceso más amplio o más restringido que el predeterminado, cree una concesión de cliente para el `client_id` de esa aplicación:

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a **Applications > APIs** y seleccione la API.
    2. Abra la pestaña **Settings**.
    3. Desplácese hasta **Application Access Policy** y establezca **User-Delegated Access** y **Client Access** en **Per-app authorization**.
    4. Seleccione **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/application_access_policy.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=99767f91f6ed62363a1a0fde1a8f41b4" alt="Configuración de la API en el Dashboard para la política de acceso de la aplicación" width="1958" height="600" data-path="docs/images/third-party-applications/application_access_policy.png" />
    </Frame>

    Al configurar permisos por aplicación, debe autorizar individualmente el acceso a la API para cada aplicación:

    1. Vaya a **Applications > APIs** y seleccione la API.
    2. Abra la pestaña **Application Access**.
    3. Desplácese hasta la aplicación, seleccione **Edit** y luego **Grant Access** para **User-Delegated Access** y/o **Client Access**. Después, seleccione los permisos deseados.
    4. Seleccione **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/grant-api-access.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=57f8a27e6e446ae919139b0ca3caebd9" alt="Configuración de la API en el Dashboard para conceder acceso a la API a una aplicación" width="2002" height="128" data-path="docs/images/third-party-applications/grant-api-access.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/client-grants' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "client_id": "tpc_aBcDeFgHiJkLmNoPqRsTuV",
          "audience": "https://api.example.com",
          "scope": ["read:items", "write:items", "delete:items"],
          "subject_type": "user"
        }'
      ```

      | **Parameter**  | **Type** | **Description**                                                                                                                                                                                                                                                                                                     |
      | -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `client_id`    | String   | Especifica la aplicación para la que desea crear la concesión de cliente.                                                                                                                                                                                                                                           |
      | `audience`     | String   | El identificador único (URI) de la API para la que se crea la concesión.                                                                                                                                                                                                                                            |
      | `scope`        | Array    | Una lista de permisos (alcances) permitidos como parte de esta concesión.                                                                                                                                                                                                                                           |
      | `subject_type` | String   | Define el tipo de acceso de aplicación permitido para la API:<br /><ul><li>`user`: Se usa para el acceso delegado por el usuario, que corresponde a flujos que generan un token asociado a un usuario final.</li><li>`client`: Se usa para acceso de máquina a máquina, como el flujo Client Credentials.</li></ul> |
    </AuthCodeGroup>
  </Tab>
</Tabs>

<div id="default-permissions-for-all-third-party-applications">
  ### Permisos predeterminados para todas las aplicaciones de terceros
</div>

Los permisos predeterminados definen un conjunto básico de API y alcances disponibles para todas las aplicaciones de terceros. Esto es necesario para [Dynamic Client Registration](/es/docs/get-started/applications/dynamic-client-registration), ya que no puede configurar el acceso de cada aplicación de forma individual.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a **Applications > APIs** y seleccione la API.
    2. Abra la pestaña **Settings**.
    3. Desplácese hasta **Default Permissions for Third Party Apps**.
    4. Seleccione **Authorized** en **User-Delegated Access** o **Client Access**.
    5. Seleccione los alcances que quiere conceder y, a continuación, haga clic en **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/default-permissions-settings.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=b39ad27ef58bf44bde053a01cd514202" alt="Configuración de la API en el Dashboard con permisos predeterminados para aplicaciones de terceros" width="1954" height="1022" data-path="docs/images/third-party-applications/default-permissions-settings.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Realice una solicitud `POST` al endpoint `/api/v2/client-grants` con el siguiente cuerpo de la solicitud:

    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/client-grants' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "default_for": "third_party_clients",
          "audience": "https://api.example.com",
          "scope": ["read:items", "write:items"],
          "subject_type": "user"
        }'
      ```
    </AuthCodeGroup>

    | **Parámetro**  | **Tipo** | **Descripción**                                                                                                                                                                                                                                                                                                |
    | -------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `default_for`  | String   | Especifica si esta concesión se aplica automáticamente a determinados tipos de aplicaciones. Establézcalo en `third_party_clients` para garantizar que todas las aplicaciones de terceros tengan acceso a esta API de forma predeterminada.                                                                    |
    | `audience`     | String   | El identificador único (URI) de la API para la que se crea la concesión.                                                                                                                                                                                                                                       |
    | `scope`        | Array    | Una lista de permisos (alcances) permitidos como parte de esta concesión.                                                                                                                                                                                                                                      |
    | `subject_type` | String   | Define el tipo de acceso a la aplicación permitido para la API:<br /><ul><li>`user`: Se usa para acceso delegado por el usuario, que corresponde a flujos que generan un token asociado a un usuario final.</li><li>`client`: Se usa para acceso de máquina a máquina, como Client Credentials Flow.</li></ul> |
  </Tab>
</Tabs>

<div id="configure-connections">
  ## Configurar conexiones
</div>

Las aplicaciones de terceros solo pueden autenticar usuarios mediante conexiones a nivel de dominio. Una vez que una conexión se eleva al nivel de dominio, queda disponible para todas las aplicaciones de terceros del inquilino.

Para elevar una conexión al nivel de dominio:

1. Vaya a **Auth0 Dashboard > Authentication** y seleccione el tipo de conexión (Database, Social, Enterprise).
2. Seleccione la conexión que desea usar con aplicaciones de terceros.
3. Active el interruptor **Promote Connection to Domain Level**.

Para obtener más información, consulte [Promover conexiones al nivel de dominio](/es/docs/authenticate/identity-providers/promote-connections-to-domain-level).

<div id="configure-open-redirect-protection">
  ## Configurar la protección contra redirecciones abiertas
</div>

Las aplicaciones de terceros con controles de seguridad reforzados tienen **Open Redirect Protection** habilitada de forma predeterminada. Cuando está habilitada, Auth0 no:

* Redirige a la URL de callback de la aplicación cuando se producen errores de autenticación
* Expone `application.callback_domain` en las plantillas de correo electrónico

Solo deshabilite **Open Redirect Protection** para aplicaciones de terceros cuyos URI de callback configurados sean de confianza. Para obtener más información, consulte [Redirect Protection](/es/docs/get-started/applications/third-party-applications/security-controls#redirect-protection).

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a **Applications > Applications** y seleccione la aplicación de terceros.
    2. Vaya a la pestaña **Settings** y desplácese hasta **Open Redirect Protection**.
    3. Active o desactive la opción.
    4. Seleccione **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/open-redirect-protection.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=5219fdc46874d2892accf5fd161a16af" alt="Interruptor de Open Redirect Protection en Auth0 Dashboard" width="581" height="177" data-path="docs/images/third-party-applications/open-redirect-protection.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Establezca la propiedad `redirection_policy` al crear o actualizar la aplicación:

    ```bash theme={null}
    curl --request PATCH \
      --url 'https://{yourDomain}/api/v2/clients/{CLIENT_ID}' \
      --header 'Authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
      --header 'Content-Type: application/json' \
      --data '{
        "redirection_policy": "allow_always"
      }'
    ```

    Establézcala en `open_redirect_protection` para habilitarla (predeterminado) o en `allow_always` para deshabilitarla.
  </Tab>
</Tabs>

<div id="dynamic-client-registration">
  ## Registro dinámico de clientes
</div>

Todos los [clientes registrados dinámicamente](/es/docs/get-started/applications/dynamic-client-registration) son aplicaciones de terceros. Antes de habilitar DCR, configure los [permisos predeterminados de la API](#default-permissions-for-all-third-party-applications) para que los clientes registrados dinámicamente puedan acceder a sus APIs.

<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)
* [Consentimiento del usuario y aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)
* [Registro dinámico de clientes](/es/docs/get-started/applications/dynamic-client-registration)
* [Promover conexiones al nivel de dominio](/es/docs/authenticate/identity-providers/promote-connections-to-domain-level)