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

# Aplicaciones propias y de terceros

> Conozca la diferencia entre las aplicaciones propias y las de terceros en Auth0.

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

Al registrar una aplicación en Auth0, decide si es de primera parte o de terceros en función de quién es su propietario y quién la opera.

* Aplicaciones de primera parte: Son propiedad de su organización y esta las opera. Usted controla su implementación, credenciales y comportamiento.
* Aplicaciones de terceros: Son propiedad de una organización externa y esta las opera, como un partner, un desarrollador independiente o un agente de IA. Usted les concede acceso a sus recursos, pero no puede controlar directamente qué hacen con ese acceso.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  "De terceros" se refiere al control operativo, no a la autoría. Muchas organizaciones subcontratan el desarrollo de sus propias aplicaciones. Por ejemplo, que un contratista desarrolle su aplicación no la convierte en una aplicación de terceros. La distinción clave es: quién la implementa, quién custodia las credenciales y quién puede detenerla.
</Callout>

Las clasificaciones confidencial/pública y de primera parte/de terceros son independientes. Confidencial o pública describe la capacidad de autenticación de la aplicación (si puede almacenar un secreto). De primera parte o de terceros describe la relación de confianza (quién es su propietario y quién la opera).

Tanto las aplicaciones de primera parte como las de terceros pueden ser confidenciales (Regular Web App) o públicas (SPA, Native). Una Regular Web App de terceros es a la vez confidencial y de terceros.

<div id="first-party-applications">
  ## Aplicaciones de primera parte
</div>

Las aplicaciones de primera parte están controladas por la misma organización o persona propietaria del dominio de Auth0. Por ejemplo, supongamos que creó una API de Contoso y una aplicación que inicia sesión en `contoso.com` y consume la API de Contoso. Registraría tanto la API como la aplicación en el mismo dominio de Auth0, y la aplicación sería de primera parte. De forma predeterminada, todas las aplicaciones creadas mediante el [Auth0 Dashboard](https://manage.auth0.com/#/applications) son aplicaciones de primera parte.

<div id="third-party-applications">
  ## Aplicaciones de terceros
</div>

Las aplicaciones de terceros están controladas por alguien que, muy probablemente, no debería tener acceso administrativo a tu dominio de Auth0. Las aplicaciones de terceros permiten que partes externas o partners accedan de forma segura a los recursos protegidos por tu API.

Por ejemplo, si una empresa partner crea un dashboard de análisis de datos para visualizar información de tu servicio, primero debe registrar su aplicación en tu inquilino de Auth0 para obtener un <Tooltip tip="ID de cliente: valor de identificación que Auth0 asigna a tu recurso registrado." cta="Ver glosario" href="/es/docs/glossary?term=client+ID">ID de cliente</Tooltip> y un secreto. Aunque esta aplicación esté registrada en tu entorno, se considera una aplicación de terceros porque el código y las credenciales pertenecen al partner y los gestiona este, no tu organización.

Todas las aplicaciones creadas mediante [Dynamic Client Registration](/es/docs/get-started/applications/dynamic-client-registration) son aplicaciones de terceros. Para obtener más información sobre las aplicaciones de terceros en Auth0, consulta [Third-Party Applications](/es/docs/get-started/applications/third-party-applications).

<div id="first-party-vs-third-party-in-auth0">
  ## Aplicaciones de primera parte frente a aplicaciones de terceros en Auth0
</div>

La siguiente tabla resume las diferencias entre las aplicaciones de primera parte y las aplicaciones de terceros en Auth0:

|                                       | **De primera parte**                              | **De terceros**                                                                                                                                                                                                                                |
| ------------------------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Acceso a la API**                   | Sigue la política de acceso configurada de la API | Siempre requiere un [client grant](/es/docs/get-started/applications/application-access-to-apis-client-grants) explícito                                                                                                                       |
| **APIs del sistema de Auth0**         | Accesibles en los flujos de usuario               | No accesibles en los flujos de usuario                                                                                                                                                                                                         |
| **Consent del usuario**               | Se puede omitir (si está habilitado en la API)    | Siempre es obligatorio                                                                                                                                                                                                                         |
| **Tipos de concesión**                | Todos los tipos de concesión admitidos            | `authorization_code`, `refresh_token` y `client_credentials`                                                                                                                                                                                   |
| **OIDC**                              | Compatible                                        | No compatible. Previsto para una versión futura.                                                                                                                                                                                               |
| **Rules**                             | Se ejecutan                                       | No compatible. Produce un error.                                                                                                                                                                                                               |
| **Protocolos no OAuth** (SAML, WsFed) | Compatibles                                       | No compatibles                                                                                                                                                                                                                                 |
| **Organizaciones**                    | Compatibles                                       | Se admite el acceso Machine-to-Machine mediante [organization client grants](/es/docs/manage-users/organizations/configure-organizations/configure-organization-client-grants). Los flujos de usuario están previstos para una versión futura. |
| **Formato del ID de cliente**         | Formato estándar                                  | Prefijo `tpc_`                                                                                                                                                                                                                                 |
| **Conexiones**                        | Todas las conexiones habilitadas                  | Conexiones a nivel de dominio                                                                                                                                                                                                                  |

Para obtener más información sobre las aplicaciones de terceros en Auth0, consulta [Third-Party Applications](/es/docs/get-started/applications/third-party-applications).

<div id="application-ownership">
  ## Propiedad de la aplicación
</div>

La propiedad de una aplicación se determina en el momento de su creación y no puede cambiarse después. De forma predeterminada, las aplicaciones se crean como de primera parte, lo que implica una configuración de seguridad menos restrictiva. Para garantizar que se apliquen los [controles de seguridad](/es/docs/get-started/applications/third-party-applications/security-controls) adecuados, debe identificar correctamente como aplicaciones de terceros las aplicaciones que pertenecen a partes externas al crearlas desde el Auth0 Dashboard o la Management API. Para saber cómo hacerlo, consulte [Configurar aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/configure-third-party-applications).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propiedad de una aplicación es inmutable. No puede convertir una aplicación de terceros en una de primera parte ni viceversa.
</Callout>

<div id="check-application-ownership">
  ## Comprobar la titularidad de la aplicación
</div>

Para comprobar si una aplicación es de primera parte o de terceros:

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Vaya a **Applications > Applications**.
    2. Seleccione la aplicación. Las aplicaciones de terceros muestran una insignia que indica que son de terceros.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/third-party-badge.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=682354244f06a1fdeeb5cea2036e2cde" alt="Configuración de la aplicación en Dashboard con la insignia de terceros" width="433" height="67" data-path="docs/images/third-party-applications/third-party-badge.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Realiza una llamada `GET` al [endpoint Get a Client](https://auth0.com/docs/api/management/v2#!/Clients/get_clients_by_id). Asegúrate de reemplazar los valores de marcador de posición `{YOUR_CLIENT_ID}`
    y `{YOUR_MANAGEMENT_API_ACCESS_TOKEN}` con tu <Tooltip tip="ID de cliente: valor de identificación asignado a tu recurso registrado en Auth0." cta="Ver glosario" href="/es/docs/glossary?term=client+ID">ID de cliente</Tooltip> y el <Tooltip tip="Token de acceso: credencial de autorización en forma de cadena opaca o JWT, utilizada para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">Token de acceso</Tooltip> de la Management API, respectivamente.

    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true' \
        --header 'authorization: Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'
      ```

      ```csharp C# theme={null}
      var client = new RestClient("https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true");
      var request = new RestRequest(Method.GET);
      request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}");
      IRestResponse response = client.Execute(request);
      ```

      ```go Go theme={null}
      package main

      import (
      	"fmt"
      	"net/http"
      	"io/ioutil"
      )

      func main() {

      	url := "https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true"

      	req, _ := http.NewRequest("GET", url, nil)

      	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}")

      	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 response = Unirest.get("https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true")
        .header("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}")
        .asString();
      ```

      ```javascript Node.JS theme={null}
      var axios = require("axios").default;

      var options = {
        method: 'GET',
        url: 'https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}',
        params: {fields: 'is_first_party', include_fields: 'true'},
        headers: {authorization: 'Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'}
      };

      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://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_ENCODING => "",
        CURLOPT_MAXREDIRS => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        CURLOPT_CUSTOMREQUEST => "GET",
        CURLOPT_HTTPHEADER => [
          "authorization: Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}"
        ],
      ]);

      $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("")

      headers = { 'authorization': "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}" }

      conn.request("GET", "/{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true", headers=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://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true")

      http = Net::HTTP.new(url.host, url.port)
      http.use_ssl = true
      http.verify_mode = OpenSSL::SSL::VERIFY_NONE

      request = Net::HTTP::Get.new(url)
      request["authorization"] = 'Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'

      response = http.request(request)
      puts response.read_body
      ```
    </AuthCodeGroup>

    | Valor                              | Descripción                                                                                                                                             |
    | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `YOUR_CLIENT_ID`                   | El id de la aplicación que se actualizará.                                                                                                              |
    | `YOUR_MANAGEMENT_API_ACCESS_TOKEN` | [Tokens de acceso para la Management API](https://auth0.com/docs/api/management/v2/tokens) con el [scope](/es/docs/glossary?term=scope) `read:clients`. |

    Si la aplicación es de origen propio, el campo `is_first_party` tendrá el valor `true`. Si la aplicación es de terceros, el campo `is_first_party` tendrá el valor `false`.
  </Tab>
</Tabs>

<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)
* [Aplicaciones confidenciales y públicas](/es/docs/get-started/applications/confidential-and-public-applications)
* [Consent del usuario y aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)