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

> Describe cómo implementar la autenticación sin contraseña con las API de Auth0.

# Uso de las API de autenticación sin contraseña

export const ReleaseStageNotice = ({feature, stage, plans, contact, terms}) => {
  const stageTextMap = {
    "beta": "Beta",
    "ea": "Acceso anticipado"
  };
  const stageText = stageTextMap[stage] || "una etapa de lanzamiento del producto";
  const prsLink = "/docs/troubleshoot/product-lifecycle/product-release-stages";
  const linkify = (text, url) => {
    return <a href={url} target="_blank" rel="noreferrer" class="link">{text}</a>;
  };
  const includeDetails = (plans, contact, terms) => {
    const hasDetails = terms || plans || contact;
    if (!hasDetails) return null;
    return <span data-as="p">
            {plans && <>Esta funcionalidad está disponible en los {linkify(`planes ${plans}`, "https://auth0.com/pricing")}. </>}
            {contact && "Para participar, ponte en contacto con " + contact + ". "}
            {terms && <>Al usar esta funcionalidad, aceptas los términos aplicables de la prueba gratuita incluidos en el {linkify("Master Subscription Agreement", "https://www.okta.com/legal")} de Okta.</>}
        </span>;
  };
  return <Warning>
            <span data-as="p">
                <strong>La funcionalidad {feature} está en {linkify(stageText, prsLink)}.</strong>
            </span>

            {includeDetails(plans, contact, terms)}
        </Warning>;
};

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

<Tooltip tip="Sin contraseña: forma de autenticación que no depende de una contraseña como primer factor." cta="Ver glosario" href="/es/docs/glossary?term=Passwordless">Sin contraseña</Tooltip> Las API se pueden usar en dos situaciones:

* Al implementar <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 querer personalizar la página de inicio de sesión con auth0.js para interactuar con Auth0.
* Cuando desea integrar el flujo de inicio de sesión en su aplicación.

Para obtener más información sobre cómo implementar la autenticación sin contraseña para Universal Login y el inicio de sesión integrado en distintos casos de uso, consulte [Autenticación sin contraseña con Universal Login](/es/docs/authenticate/passwordless/implement-login/universal-login) o [Autenticación sin contraseña con inicio de sesión integrado](/es/docs/authenticate/passwordless/implement-login/embedded-login).

<div id="passwordless-endpoints">
  ## Endpoints de autenticación sin contraseña
</div>

<div id="post-passwordlessstart">
  ### POST /passwordless/start
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Debes habilitar el tipo de concesión **Passwordless OTP** en [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), en la configuración de tu aplicación, en **Advanced Settings** > **Grant Types**.
</Callout>

Puedes llamar al endpoint [POST /passwordless/start](https://auth0.com/docs/api/authentication#get-code-or-link) para iniciar el proceso de autenticación sin contraseña tanto para Classic Login como para Embedded Login.

Según los parámetros proporcionados al endpoint, Auth0 inicia el proceso de verificación del usuario enviando una de las siguientes opciones:

* Un código de un solo uso por correo electrónico o SMS
* Un enlace de un solo uso por correo electrónico

La llamada a la API debe tener la siguiente estructura:

export const codeExample1 = `POST https://{yourDomain}/passwordless/start
Content-Type: application/json
{
  "client_id": "{yourClientID}",
  "client_secret": "{yourClientSecret}", // Para aplicaciones web tradicionales
  "connection": "email|sms",
  "email": "{email}", // se establece para connection=email
  "phone_number": "{phoneNumber}", // se establece para connection=sms
  "send": "link|code", // si se deja como null, el valor predeterminado es link
  "authParams": { // cualquier parámetro de autenticación que quiera agregar
    "scope": "openid",     // se usa al solicitar un enlace mágico
    "state": "{yourState}"  // se usa al solicitar un enlace mágico o desde la página de inicio de sesión personalizada
  }
}`;

<AuthCodeBlock children={codeExample1} language="json" />

Si utiliza un enlace mágico, los usuarios recibirán un enlace generado por la API de autenticación. Los usuarios seleccionarán el enlace y activarán una llamada a \{`yourAuth0Tenant}.auth0.com/passwordless/verify-redirect`. Auth0 redirigirá al usuario a la aplicación y el usuario iniciará sesión.

Si utiliza un code, su aplicación deberá solicitar ese code y, a continuación, debe usar el endpoint `/oauth/token` o el método `passwordlessLogin` del SDK de Auth0.js para intercambiar ese code por tokens de autenticación.

<div id="post-oauthtoken">
  ### POST /oauth/token
</div>

Si está implementando el inicio de sesión sin contraseña para aplicaciones nativas o aplicaciones web tradicionales, debe usar `/oauth/token` para intercambiar el código OTP por tokens de autenticación. No puede usar este endpoint desde aplicaciones de una sola página.

Para ello, primero debe habilitar la concesión **Passwordless OTP** para su aplicación en [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), dentro de la configuración de su aplicación, en **Advanced Settings** > **Grant Types**.

El usuario recibirá el código OTP y su aplicación nativa o web se lo solicitará. Cuando el usuario introduzca el código, puede completar el flujo de autenticación llamando al endpoint `/oauth/token` con los siguientes parámetros:

export const codeExample2 = `POST https://{yourAuth0Domain}/oauth/token
Content-Type: application/json
{
  "grant_type" : "http://auth0.com/oauth/grant-type/passwordless/otp",
  "client_id": "{yourAuth0ClientID}",
  "client_secret": "{yourClientSecret}", // solo para aplicaciones web; las aplicaciones nativas no tienen un Secreto del cliente
  "username":"<dirección de correo electrónico>", // o "<número de teléfono>"
  "otp": "CODE",
  "realm": "email", // o "sms" 
  "audience" : "your-api-audience", // si necesitas un token de acceso para una API específica
  "scope": "openid profile email" // los alcances que necesites
}`;

<AuthCodeBlock children={codeExample2} language="json" />

Si todo sale bien, Auth0 devolverá una respuesta similar a la siguiente:

```json lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token":"eyJz93a...k4laUWw",
"refresh_token":"GEbRxBN...edjnXbL",
"id_token":"eyJ0XAi...4faeEoQ",
"token_type":"Bearer",
"expires_in":86400
}
```

Luego, puedes decodificar el <Tooltip tip="ID Token: Credencial destinada al cliente en sí, y no a acceder a un recurso." cta="Ver glosario" href="/es/docs/glossary?term=ID+Token">ID Token</Tooltip> para obtener información sobre el usuario, o usar el <Tooltip tip="Token de acceso: Credencial de autorización, en forma de una cadena opaca o un JWT, utilizada para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">Token de acceso</Tooltip> para llamar a tu API con normalidad.

<div id="using-auth0js">
  ## Uso de Auth0.js
</div>

Al implementar la autenticación sin contraseña en aplicaciones de una sola página o en una página personalizada de Universal Login, debe [usar Auth0.js y el método passwordlessLogin incluido](/es/docs/libraries/auth0js). La implementación es compleja, por lo que le recomendamos usar la biblioteca en lugar de llamar directamente a las API.

<div id="rate-limiting-in-passwordless-endpoints">
  ## Límites de velocidad en endpoints sin contraseña
</div>

Las funciones de limitación de velocidad y <Tooltip tip="Protección contra ataques: funciones que Auth0 proporciona para detectar y mitigar ataques, incluida la protección contra fuerza bruta, la limitación de IP sospechosas, la detección de contraseñas comprometidas, la detección de bots y la autenticación multifactor adaptativa." cta="Ver glosario" href="/es/docs/glossary?term=attack+protection">protección contra ataques</Tooltip> de Auth0 solo consideran la IP de la máquina que realiza la llamada a la API. Cuando la llamada a la API se realiza desde un servidor backend, normalmente querrá que Auth0 tenga en cuenta la IP del usuario final, no la del servidor.

Auth0 admite especificar un encabezado `auth0-forwarded-for` en las llamadas a la API, pero solo se tiene en cuenta cuando:

* la llamada a la API se realiza para una aplicación confidencial.
* la llamada a la API incluye el <Tooltip tip="Secreto del cliente: secreto que usa un cliente (aplicación) para autenticarse con el Servidor de autorización; solo deberían conocerlo el cliente y el Servidor de autorización, y debe ser lo suficientemente aleatorio como para que no pueda adivinarse." cta="Ver glosario" href="/es/docs/glossary?term=client+secret">secreto del cliente</Tooltip>.
* la opción **Confiar en el encabezado IP del <Tooltip tip="Endpoint del token: endpoint del Servidor de autorización que se usa para solicitar tokens de forma programática." cta="Ver glosario" href="/es/docs/glossary?term=Token+Endpoint">endpoint del token</Tooltip>** está activada.

Para obtener una explicación completa, lea [Evitar problemas comunes con el flujo de contraseña del propietario del recurso y la protección contra ataques](/es/docs/get-started/authentication-and-authorization-flow/resource-owner-password-flow/avoid-common-issues-with-resource-owner-password-flow-and-attack-protection).

<div id="customize-mfa">
  ## Personalizar MFA
</div>

<ReleaseStageNotice feature="MFA personalizable con los flujos Resource Owner Password Grant, Embedded o Token de actualización" stage="ea" terms="true" contact="Auth0 Support" />

Personaliza <Tooltip tip="Autenticación multifactor (MFA): proceso de autenticación del usuario que utiliza un factor adicional al nombre de usuario y la contraseña, como un código por SMS." cta="Ver glosario" href="/es/docs/glossary?term=MFA">MFA</Tooltip> con la API sin contraseña. Cuando tu aplicación llama al endpoint `/oauth/token` para solicitar un token de acceso, el <Tooltip tip="Servidor de autorización: servidor centralizado que contribuye a definir los límites del acceso de un usuario. Por ejemplo, tu servidor de autorización puede controlar los datos, las tareas y las funcionalidades disponibles para un usuario." cta="Ver glosario" href="/es/docs/glossary?term=authorization+server">servidor de autorización</Tooltip> devuelve un error `mfa_required` que proporciona:

* El `mfa_token` que necesitas para llamar a la API de MFA para la inscripción y los desafíos.

* El parámetro `mfa_requirements`, que proporciona el `type` del factor que tu aplicación admite para los desafíos.

```json lines theme={null}
{
  "error": "mfa_required",
  "error_description": "Multifactor authentication required",
  "mfa_token": "Fe26...Ha",
  "mfa_requirements": {
    "challenge": [
      { "type": "otp" },
      { "type": "push-notification" },
      { "type": "phone" },
      { "type": "recovery-code" }
    ]
  }
}
```

Usa el `mfa_token` para llamar al endpoint [`mfa/authenticator`](https://auth0.com/docs/api/authentication/muti-factor-authentication/list-authenticators), enumerar todos los factores en los que el usuario se ha inscrito y hacer coincidir el mismo `type` que admite tu aplicación. También debes obtener el `authenticator_type` correspondiente para emitir desafíos:

```json lines theme={null}
[
  {
    "type": "recovery-code",
    "id": "recovery-code|dev_qpOkGUOxBpw6R16t",
    "authenticator_type": "recovery-code",
    "active": true
  },
  {
    "type": "otp",
    "id": "totp|dev_6NWz8awwC8brh2dN",
    "authenticator_type": "otp",
    "active": true
  }
]
```

Refuerce el desafío de MFA llamando al endpoint [`request/mfa/challenge`](https://auth0.com/docs/api/authentication/muti-factor-authentication/request-mfa-challenge).

Personalice aún más su flujo de MFA con Auth0 Actions. Para obtener más información, consulte [Actions Triggers: post-challenge - API Object](/es/docs/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-api-object).