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

> Cómo instalar, inicializar y usar Auth0.js

# Auth0.js

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

La biblioteca de Auth0.js es una biblioteca de JavaScript del lado del cliente para Auth0. Admite tanto el [inicio de sesión alojado como el inicio de sesión integrado](/es/docs/authenticate/login/universal-vs-embedded-login). Este artículo cubre **v10**, la versión actual.

Revisa la [documentación completa de la API de la biblioteca](https://auth0.github.io/auth0.js/index.html).

<div id="migrate-from-v9-to-v10">
  ## Migra de v9 a v10
</div>

Auth0.js v10 contiene una corrección de seguridad para CVE-2026-42280 y un cambio incompatible:

| Afectado                    | Detalles                                                                                                                                                                                                                                                                            |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Aplicaciones que usan RS256 | No hay cambios incompatibles                                                                                                                                                                                                                                                        |
| Aplicaciones que usan HS256 | `parseHash()` ahora devuelve un error `invalid_token` en lugar de completarse correctamente en silencio. Cambia a RS256 en el Auth0 Dashboard: **Applications** > tu aplicación > **Settings** > **Advanced Settings** > **OAuth** > **JsonWebToken Signature Algorithm** > `RS256` |

Si necesitas la referencia de la API de v9, consulta el [paquete auth0-js en npm](https://www.npmjs.com/package/auth0-js?activeTab=versions) y selecciona tu versión v9, o revisa el [código fuente y el registro de cambios de v9 en GitHub](https://github.com/auth0/auth0.js).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  El inicio de sesión integrado para aplicaciones web utiliza [autenticación entre orígenes](/es/docs/authenticate/login/cross-origin-authentication), a menos que [configures un dominio personalizado](/es/docs/customize/custom-domains) para tu tenant. La autenticación entre orígenes utiliza cookies de terceros para permitir transacciones de autenticación seguras entre distintos orígenes.
</Callout>

<div id="ready-to-go-example">
  ## Ejemplo listo para usar
</div>

El [directorio de ejemplo](https://github.com/auth0/auth0.js/tree/master/example) de la biblioteca de Auth0.js es una aplicación lista para usar que puede ayudarte a probar Auth0.js de forma rápida y sencilla. Para ejecutarla:

1. Si no tienes [node](http://nodejs.org/) instalado, instálalo ahora
2. Descarga las dependencias ejecutando `npm install` desde la raíz de este proyecto
3. Por último, ejecuta `npm start` desde la raíz de este proyecto y luego abre en el navegador la aplicación que se está ejecutando en el servidor de Node, probablemente en `http://localhost:3000/example`.

<div id="setup-and-initialization">
  ## Configuración e inicialización
</div>

Las siguientes secciones cubren los [métodos de instalación](#installation-options), [cómo inicializar Auth0.js](#initialization), [registro](#signup), [inicio de sesión](#login), [cierre de sesión](#logout) y mucho más.

<div id="configure-your-auth0-application-for-embedded-login">
  ### Configura tu aplicación de Auth0 para el inicio de sesión integrado
</div>

Al implementar el inicio de sesión integrado, la biblioteca usa solicitudes entre orígenes dentro de iframes ocultos para realizar la autenticación. Para garantizar que esto pueda hacerse de forma segura, Auth0 necesita conocer los dominios donde alojas tus aplicaciones.

Agrega el dominio al campo **Allowed Web Origins**. Puedes encontrar este campo en la sección de [Application Settings](https://manage.auth0.com/#/applications) de tu Dashboard.

<div id="installation-options">
  ### Opciones de instalación
</div>

Tienes varias opciones para usar Auth0.js en tu proyecto. Elige una de las siguientes según tus necesidades:

Instálalo mediante [npm](https://npmjs.org) o [yarn](https://yarnpkg.com):

```bash lines theme={null}
npm install auth0-js

yarn add auth0-js
```

Después de instalar el módulo `auth0-js`, inclúyelo en el paquete junto con todas sus dependencias o impórtalo con:

```js lines theme={null}
import auth0 from 'auth0-js';
```

Como alternativa, incluye el script desde el CDN:

```html wrap lines theme={null}
<script src="https://cdn.auth0.com/js/auth0/10.0.0/auth0.min.js"></script>
```

<div id="initialization">
  ### Inicialización
</div>

Inicializa una instancia nueva de la aplicación Auth0 de la siguiente manera:

export const codeExample1 = `<script type="text/javascript">
  var webAuth = new auth0.WebAuth({
    domain:       '{yourDomain}',
    clientID:     '{yourClientId}'
  });
</script>`;

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

<div id="available-parameters">
  #### Parámetros disponibles
</div>

Hay dos parámetros obligatorios que deben pasarse en el objeto `options` al instanciar `webAuth`, y varios más que son opcionales.

| **Parámetro**                 | **Obligatorio** | **Descripción**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ----------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `domain`                      | obligatorio     | (String) El dominio de tu cuenta de Auth0 (p. ej., myaccount.auth0.com)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `clientID`                    | obligatorio     | (String) Tu ID de cliente de Auth0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `redirectUri`                 | opcional\*      | (String) El `redirectUri` predeterminado que se utilizará. De forma predeterminada, es una cadena vacía (ninguno). **Si no proporcionas aquí un valor global de `redirectUri`, tendrás que proporcionar un valor de `redirectUri` para *cada* método que uses.**                                                                                                                                                                                                                                                                             |
| `scope`                       | opcional        | (String) El <Tooltip tip="Scope: Mecanismo que determina las acciones que las aplicaciones pueden realizar en nombre de un usuario con información creada previamente en un recurso en línea." cta="Ver glosario" href="/es/docs/glossary?term=scope%28s%29">scope(s)</Tooltip> predeterminado que usa la aplicación. El uso de scopes puede permitirte devolver claims específicos para campos concretos de tu solicitud. Debes consultar nuestra [documentación sobre scopes](/es/docs/get-started/apis/scopes) para obtener más detalles. |
| `audience`                    | opcional        | (String) La audiencia predeterminada que se utilizará para solicitar acceso a la API.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `responseType`                | opcional\*      | (String) El `responseType` predeterminado que se utilizará. Puede ser cualquier lista separada por espacios de los valores `code`, `token`, `id_token`. El valor predeterminado es `'token'`, a menos que se proporcione un `redirectUri`, en cuyo caso será `'code'`. **Si no proporcionas un valor global de `responseType`, tendrás que proporcionar un valor de `responseType` para *cada* método que uses.**                                                                                                                            |
| `responseMode`                | opcional        | (String) Esta opción se omite de forma predeterminada. Puede establecerse en `'form_post'` para enviar el token o código al `'redirectUri'` mediante POST. Los valores admitidos son `query`, `fragment` y `form_post`.                                                                                                                                                                                                                                                                                                                      |
| `leeway`                      | opcional        | (Integer) Un valor en segundos; margen permitido para compensar la desincronización del reloj con respecto a los tiempos de expiración del ID Token.                                                                                                                                                                                                                                                                                                                                                                                         |
| `_disableDeprecationWarnings` | opcional        | (Boolean) Desactiva las advertencias de obsolescencia; el valor predeterminado es `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

Debido a problemas de desincronización del reloj, es posible que ocasionalmente te encuentres con el error `The token was issued in the future`. El parámetro `leeway` puede usarse para permitir unos segundos de margen en los tiempos de expiración del ID Token y evitar que esto ocurra.

<div id="scope">
  ##### Scope
</div>

El valor predeterminado de `scope` en Auth0.js v10 es `openid profile email`.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  **Ejecutar Auth0.js de forma local**

  Si no especificas al menos el scope indicado arriba al inicializar Auth0.js y ejecutas tu sitio web desde `http://localhost` o `http://127.0.0.1`, al llamar al método `getSSOData()` se mostrará el siguiente error en la consola del navegador:

  `Consent required. When using getSSOData, the user has to be authenticated with the following scope: openid profile email`

  Esto no ocurrirá cuando ejecutes tu aplicación en producción o si especificas el scope `openid profile email`. Puedes obtener más información en el documento [Consentimiento del usuario y aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications).
</Callout>

<div id="login">
  ## Inicio de sesión
</div>

Puedes elegir un método de inicio de sesión en función del tipo de autenticación que necesites en tu aplicación.

<div id="webauthauthorize">
  ### webAuth.authorize()
</div>

El método `authorize()` puede usarse para iniciar sesión mediante <Tooltip tip="Universal Login: Tu aplicación redirige a Universal Login, alojado en el Authorization Server de Auth0, para verificar la identidad de un usuario." cta="Ver glosario" href="/es/docs/glossary?term=Universal+Login">Universal Login</Tooltip> o conexiones sociales, como se muestra en los ejemplos a continuación. Este método invoca el endpoint `/authorize` de la Authentication API y puede recibir distintos parámetros a través del objeto `options`.

| **Parámetro**  | **Obligatorio** | **Descripción**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| -------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `audience`     | opcional        | (String) La audiencia predeterminada que se usará para solicitar acceso a la API.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `connection`   | opcional        | (String) Especifica la conexión que se usará, en lugar de mostrar todas las conexiones disponibles para la aplicación.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `scope`        | opcional        | (String) Los scopes para los que deseas solicitar autorización. Deben estar separados por espacios. Puedes solicitar cualquiera de los scopes estándar de OIDC relacionados con el usuario, como `profile` y `email`, claims personalizados que deben [ajustarse a un formato con espacio de nombres](/es/docs/secure/tokens/json-web-tokens/create-custom-claims), o cualquier scope compatible con la API de destino (por ejemplo, `read:contacts`). Incluye `offline_access` para obtener un <Tooltip tip="Refresh Token: Token utilizado para obtener un Access Token renovado sin obligar a los usuarios a iniciar sesión de nuevo." cta="Ver glosario" href="/es/docs/glossary?term=Refresh+Token">Refresh Token</Tooltip>. |
| `responseType` | opcional        | (String) Puede ser cualquier lista de valores separada por espacios entre `code`, `token`, `id_token`. Su valor predeterminado es `'token'`, a menos que se proporcione un `redirectUri`, en cuyo caso será `'code'`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `clientID`     | opcional        | (String) Tu ID de cliente de Auth0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `redirectUri`  | opcional        | (String) La URL a la que Auth0 redirigirá el navegador una vez que se haya concedido la autorización al usuario.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `state`        | opcional        | (String) Un valor arbitrario que debe mantenerse entre redirecciones. Es útil para mitigar ataques CSRF y para cualquier información contextual (por ejemplo, una URL de retorno) que puedas necesitar una vez finalizado el proceso de autenticación. Para obtener más información, consulta [State Parameter](/es/docs/secure/attack-protection/state-parameters). Auth0.js, cuando se usa en aplicaciones de una sola página, gestiona automáticamente la generación y validación de `state` si no se especifica.                                                                                                                                                                                                              |
| `prompt`       | opcional        | (String) Un valor de `login` forzará que se muestre la página de inicio de sesión independientemente de la sesión actual. Un valor de `none` intentará omitir las pantallas de inicio de sesión si ya existe una sesión (consulta la documentación de [autenticación silenciosa](/es/docs/authenticate/single-sign-on#silent-authentication) para más detalles).                                                                                                                                                                                                                                                                                                                                                                  |

Para el inicio de sesión alojado, se debe llamar al método `/authorize()`.

`webAuth.authorize({//Cualquier opción adicional puede ir aquí});`

Para los inicios de sesión sociales, será necesario especificar el parámetro `connection`:

`webAuth.authorize({connection: 'twitter'});`

<div id="webauthpopupauthorize">
  ### webAuth.popup.authorize()
</div>

Para la autenticación mediante ventana emergente se puede usar el método `popup.authorize`. La autenticación mediante ventana emergente no puede utilizarse en páginas de inicio de sesión alojadas. Normalmente, este tipo de autenticación se usa en aplicaciones de una sola página para no perder el estado actual al hacer una redirección de página completa.

Autorización predeterminada mediante ventana emergente (Universal Login):

```js lines theme={null}
webAuth.popup.authorize({
  responseType: 'token'
  redirectUri: 'https://YOUR_APP/popup_response_handler.html'
  //Aquí pueden ir opciones adicionales
}, function(err, authResult) {
  //hacer algo
});
```

Y para iniciar sesión con redes sociales mediante una ventana emergente usando `authorize`:

```js lines theme={null}
webAuth.popup.authorize({
  responseType: 'token'
  redirectUri: 'https://{yourApp}/popup_response_handler.html',
  connection: 'twitter'
}, function(err, authResult) {
  //hacer algo
});
```

<div id="handle-popup-authentication-results">
  #### Gestiona los resultados de autenticación con ventana emergente
</div>

Al usar la autenticación con ventana emergente, tendrás que proporcionar un `redirectUri` en el que la página de destino comunique los resultados de la autorización al callback mediante el método `webAuth.popup.callback`. Una implementación sencilla sería algo así:

```html lines theme={null}
<!-- popup_response_handler.html -->
<html>
  <body>
    <script src="https://cdn.auth0.com/js/auth0/10.0.0/auth0.min.js"></script>
    <script type="text/javascript">
      var webAuth = new auth0.WebAuth({
        domain:       'YOUR_DOMAIN',
        clientID:     'YOUR_CLIENT_ID'
      });
      webAuth.popup.callback();
    </script>
  </body>
</html>
```

Un manejador ideal contendría solo esta funcionalidad mínima (es decir, que evite recargar toda la aplicación solo para procesar la respuesta).

Tendrás que añadir el `redirectUri` a la lista de **Allowed Callback URLs** en la página de configuración de la aplicación del Dashboard.

<div id="webauthlogin">
  ### webAuth.login()
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  El inicio de sesión integrado para aplicaciones web usa la [autenticación entre orígenes](/es/docs/authenticate/login/cross-origin-authentication), a menos que [configure un dominio personalizado](/es/docs/customize/custom-domains) para su tenant. La autenticación entre orígenes utiliza cookies de terceros para permitir transacciones de autenticación seguras entre distintos orígenes.
</Callout>

El método `login` puede utilizarse para el inicio de sesión integrado mediante [autenticación entre orígenes](/es/docs/authenticate/login/cross-origin-authentication) en conexiones de base de datos, usando `/co/authenticate`.

| **Parámetro** | **Obligatorio** | **Descripción**                                                                                                  |
| ------------- | --------------- | ---------------------------------------------------------------------------------------------------------------- |
| `username`    | opcional        | (String) El nombre de usuario que se usará para la autenticación. **Debe proporcionarse** `username` o `email`.  |
| `email`       | opcional        | (String) El correo electrónico que se usará para la autenticación. **Debe proporcionarse** `username` o `email`. |
| `password`    | obligatorio     | (String) La contraseña que se usará para la autenticación.                                                       |
| `realm`       | obligatorio     | (String) El nombre de la conexión de base de datos con la que se autenticará.                                    |

```js lines theme={null}
webAuth.login({
  realm: 'tests',
  username: 'testuser',
  password: 'testpass',
});
```

<div id="webauthcrossoriginverification">
  ### webAuth.crossOriginVerification()
</div>

El método `crossOriginVerification()` puede utilizarse para facilitar la autenticación entre orígenes a los clientes que tienen deshabilitadas las cookies de terceros en sus navegadores. Para obtener más información sobre su uso, consulta [Autenticación entre orígenes](/es/docs/authenticate/login/cross-origin-authentication).

<div id="buildauthorizeurloptions">
  ### buildAuthorizeUrl(options)
</div>

El método `buildAuthorizeUrl` puede usarse para construir la URL `/authorize` a fin de iniciar una nueva transacción. Usa este método si quieres implementar autenticación basada en el navegador (pasiva).

export const codeExample2 = `// Calcular la URL de redirección
var url = webAuth.client.buildAuthorizeUrl({
  clientID: '{yourClientId}', // cadena
  responseType: 'token id_token', // código
  redirectUri: 'https://{yourApp}/callback',
  state: '{yourState}',
  nonce: '{yourNonce}'
});

// Redirigir a la URL
// ...`;

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

El parámetro `state` es un valor opaco que Auth0 te devolverá. Este método ayuda a prevenir ataques CSRF y debe especificarse si rediriges a la URL tú mismo en lugar de llamar a `webAuth.authorize()`. Para obtener más información, consulta [State Parameter](/es/docs/secure/attack-protection/state-parameters).

<div id="single-sign-on-with-embedded-authentication">
  ### Inicio de sesión único con autenticación integrada
</div>

El inicio de sesión integrado admite <Tooltip tip="Inicio de sesión único (SSO): servicio que, después de que un usuario inicia sesión en una aplicación, lo inicia automáticamente en otras aplicaciones." cta="Ver glosario" href="/es/docs/glossary?term=Single+Sign-on">inicio de sesión único</Tooltip> (SSO) cuando sus aplicaciones comparten la siguiente arquitectura:

1. Las aplicaciones que intentan usar SSO son aplicaciones de primera parte. No se admite compartir sesiones integradas con aplicaciones de terceros.
2. Las aplicaciones y su tenant de Auth0 comparten un dominio de nivel superior mediante un [dominio personalizado](/es/docs/customize/custom-domains). Los dominios tradicionales de Auth0 usan el formato `foo.auth0.com`; los dominios personalizados permiten que sus aplicaciones y su tenant de Auth0 compartan el mismo dominio de nivel superior, lo que también ayuda a prevenir ataques CSRF.

Cuando su arquitectura cumple estos criterios, el SSO integrado con Auth0.js es una buena opción. Universal Login gestiona automáticamente el SSO en varios dominios o con [aplicaciones de terceros](/es/docs/get-started/applications/third-party-applications/configure-third-party-applications) mediante su capa de sesión, y ambos pueden coexistir en la misma aplicación; por ejemplo, Universal Login para el inicio de sesión principal y Auth0.js para la inscripción integrada de factores o los flujos step-up. Para comparar las ventajas y desventajas, consulte [Inicio de sesión alojado vs. inicio de sesión integrado](/es/docs/authenticate/login/universal-vs-embedded-login).

<div id="passwordless-login">
  ## Inicio de sesión sin contraseña
</div>

La autenticación <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> permite a los usuarios iniciar sesión recibiendo un código de un solo uso por correo electrónico o mensaje de texto. El proceso requiere que inicies el flujo sin contraseña, generando y enviando un código al usuario (o un código dentro de un enlace) y, a continuación, validando sus credenciales mediante el método de verificación. Esto puede presentarse en forma de una pantalla de inicio de sesión que solicite su correo electrónico o número de teléfono y el código que acabas de enviarle. También puede implementarse como un enlace sin contraseña en lugar de un código enviado al usuario. Bastaría con que hicieran clic en el enlace de su correo electrónico o mensaje de texto para que este llame a tu endpoint y verifique estos datos automáticamente usando el mismo método de verificación (solo que sin que el usuario tenga que introducir manualmente un código).

Para usar la autenticación sin contraseña, inicializa Auth0.js con un `redirectUri` y establece `responseType: 'token'`.

export const codeExample3 = `var webAuth = new auth0.WebAuth({
  clientID: '{yourClientId}',
  domain: '{yourDomain}',
  redirectUri: 'http://example.com',
  responseType: 'token id_token'
});`;

<AuthCodeBlock children={codeExample3} language="js" />

<div id="start-passwordless-authentication">
  ### Iniciar la autenticación sin contraseña
</div>

El primer paso para la autenticación sin contraseña con Auth0.js es el método `passwordlessStart`, que admite varios parámetros dentro de su objeto `options`:

| **Parameter** | **Required** | **Description**                                                                                         |
| ------------- | ------------ | ------------------------------------------------------------------------------------------------------- |
| `connection`  | obligatorio  | (String) Especifica cómo enviar el código o el enlace al usuario. El valor debe ser `email` o `sms`.    |
| `send`        | obligatorio  | (String) El valor debe ser `code` o `link`. Si es `null`, se enviará un enlace.                         |
| `phoneNumber` | opcional     | (String) El número de teléfono del usuario al que se enviará un código o enlace por SMS.                |
| `email`       | opcional     | (String) El correo electrónico del usuario al que se enviará un código o enlace por correo electrónico. |

Ten en cuenta que, para iniciar el proceso de autenticación sin contraseña, debes enviar exactamente uno de los parámetros opcionales `phoneNumber` y `email`.

```js lines theme={null}
webAuth.passwordlessStart({
    connection: 'email',
    send: 'code',
    email: 'foo@bar.com'
  }, function (err,res) {
    // manejar errores o continuar
  }
);
```

<div id="complete-passwordless-authentication">
  ### Completar la autenticación sin contraseña
</div>

Si envías un código, tendrás que pedirle al usuario que lo introduzca. Procesarás el código y autenticarás al usuario con el método `passwordlessLogin`, que tiene varios parámetros que pueden enviarse en su objeto `options`:

| **Parámetro**      | **Obligatorio** | **Descripción**                                                                                                                                               |
| ------------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connection`       | obligatorio     | (String) Especifica cómo se envía el código/enlace al usuario. El valor debe ser `email` o `sms`, y debe coincidir con el valor pasado a `passwordlessStart`. |
| `verificationCode` | obligatorio     | (String) El código enviado al usuario, ya sea como código o integrado en un enlace.                                                                           |
| `phoneNumber`      | opcional        | (String) El número de teléfono del usuario al que se envió el código o enlace por SMS.                                                                        |
| `email`            | opcional        | (String) El correo electrónico del usuario al que se envió el código o enlace por correo electrónico.                                                         |

Al igual que con `passwordlessStart`, debe enviarse exactamente uno de los parámetros opcionales `phoneNumber` o `email` para verificar la transacción sin contraseña.

Para usar `passwordlessLogin`, especifica `redirectUri` y `responseType` al inicializar WebAuth.

```js lines theme={null}
webAuth.passwordlessLogin({
    connection: 'email',
    email: 'foo@bar.com',
    verificationCode: '389945'
  }, function (err,res) {
    // gestionar errores o continuar
  }
);
```

<div id="extract-the-authresult-and-get-user-info">
  ## Extrae el authResult y obtén información del usuario
</div>

Una vez completada la autenticación, puedes usar el método `parseHash` para analizar el fragmento hash de una URL cuando se redirige al usuario de vuelta a tu aplicación y extraer así el resultado de una respuesta de autenticación de Auth0. Puedes hacerlo en una página de callback que luego redirija a tu aplicación principal o directamente en la propia página, según convenga en cada caso.

El método `parseHash` recibe un objeto `options` que contiene los siguientes parámetros:

| **Parámetro**                                                                                                                                                                                                        | **Obligatorio** | **Descripción**                                                                                                                                                                      |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `state`                                                                                                                                                                                                              | opcional        | (String) Un valor opaco que la aplicación añade a la solicitud inicial y que Auth0 incluye al redirigir de vuelta a la aplicación. auth0.js usa este valor para evitar ataques CSRF. |
| <Tooltip tip="Nonce: Número arbitrario emitido una sola vez en un protocolo de autenticación para detectar y prevenir ataques de repetición." cta="Ver glosario" href="/es/docs/glossary?term=nonce">nonce</Tooltip> | opcional        | (String) Se utiliza para verificar el ID Token                                                                                                                                       |
| `hash`                                                                                                                                                                                                               | opcional        | (String) El hash de la URL (si no se proporciona, se usará `window.location.hash` de forma predeterminada)                                                                           |

El contenido del objeto authResult que devuelve `parseHash` depende de los parámetros de autenticación que se hayan utilizado. Puede incluir:

| **Elemento**  | **Descripción**                                                                                                                                                                                                                                                      |
| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `accessToken` | Un <Tooltip tip="token de acceso: Credencial de autorización, en forma de una cadena opaca o JWT, utilizada para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">token de acceso</Tooltip> para la API especificada por `audience` |
| `expiresIn`   | Una cadena que contiene el tiempo de expiración (en segundos) del `accessToken`                                                                                                                                                                                      |
| `idToken`     | Un JWT de ID Token que contiene información del perfil del usuario                                                                                                                                                                                                   |

```js lines theme={null}
webAuth.parseHash({ hash: window.location.hash }, function(err, authResult) {
  if (err) {
    return console.log(err);
  }

  webAuth.client.userInfo(authResult.accessToken, function(err, user) {
    // Ahora tienes la información del usuario
  });
});
```

Como se muestra arriba, se puede llamar al método `client.userInfo` pasando el `accessToken` devuelto. Este hará una solicitud al endpoint `/userinfo` y devolverá el objeto `user`, que contiene la información del usuario, con un formato similar al del ejemplo siguiente.

```json lines theme={null}
{
    "sub": "auth0|123456789012345678901234",
    "nickname": "johnfoo",
    "name": "johnfoo@gmail.com",
    "picture": "https://gravatar.com/avatar/example.png",
    "updated_at": "2018-05-07T14:16:52.013Z",
    "email": "johnfoo@gmail.com",
    "email_verified": "false"
}
```

Ahora puede hacer otras cosas con esta información según las necesidades de su aplicación, como obtener toda la información del perfil del usuario 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>, como se describe a continuación.

<div id="using-nonces">
  ## Uso de `nonce`
</div>

De forma predeterminada (y si `responseType` contiene `id_token`), Auth0.js generará un `nonce` aleatorio cuando llames a `webAuth.authorize`, lo almacenará en el almacenamiento local y lo recuperará en `webAuth.parseHash`. El comportamiento predeterminado debería funcionar en la mayoría de los casos, pero en algunos escenarios puede ser necesario que el desarrollador controle el `nonce`.
Si quieres usar un `nonce` generado por el desarrollador, debes proporcionarlo como una opción tanto en `webAuth.authorize` como en `webAuth.parseHash`.
`webAuth.authorize({<Tooltip tip="Nonce: Arbitrary number issued once in an authentication protocol to detect and prevent replay attacks." cta="View Glossary" href="/docs/glossary?term=nonce">nonce</Tooltip>: '1234', responseType: 'token id_token'});
webAuth.parseHash({nonce: '1234'}, callback);`

Si llamas a `webAuth.checkSession` en lugar de `webAuth.authorize`, solo tienes que especificar tu `nonce` personalizado como una opción en `checkSession`:

```js lines theme={null}
webAuth.checkSession({
  nonce: '1234',
}, function (err, authResult) {
    ...
});
```

El método `webAuth.checkSession` verificará automáticamente que la claim `nonce` del <Tooltip tip="ID Token: credencial destinada al propio cliente, en lugar de usarse para acceder a un recurso." cta="Ver glosario" href="/es/docs/glossary?term=ID+Token">ID Token</Tooltip>' devuelto sea la misma que la opción.

<div id="error-codes-and-descriptions">
  ## Códigos de error y descripciones
</div>

Cuando Auth0.js se usa para el inicio de sesión integrado, utiliza el endpoint `/co/authenticate`, que puede generar los siguientes errores:

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Las descripciones de los errores están pensadas para que las personas puedan entenderlas. La descripción **no debe ser analizada por ningún código** y puede cambiar en cualquier momento.
</Callout>

| **Status** | **Code**                      | **Description**                                                                                                                                                                                      |
| ---------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400        | invalid\_request              | Cuerpo de la solicitud no válido. Se requieren todos y únicamente client\_id, credential\_type, username, otp y realm.                                                                               |
| 401        | unauthorized\_client          | No se permite el inicio de sesión entre orígenes.                                                                                                                                                    |
| 400        | unsupported\_credential\_type | Parámetro de tipo de credencial desconocido.                                                                                                                                                         |
| 400        | invalid\_request              | Realm desconocido: non-existent-connection.                                                                                                                                                          |
| 403        | access\_denied                | Correo electrónico o contraseña incorrectos.                                                                                                                                                         |
| 403        | access\_denied                | Error de autenticación                                                                                                                                                                               |
| 403        | blocked\_user                 | Usuario bloqueado                                                                                                                                                                                    |
| 401        | password\_leaked              | Este intento de inicio de sesión se ha bloqueado porque la contraseña que estás usando ya se había visto comprometida en una filtración de datos (no en esta aplicación).                            |
| 429        | too\_many\_attempts           | Tu cuenta se ha bloqueado tras varios intentos consecutivos de inicio de sesión. Te hemos enviado una notificación a través de tu método de contacto preferido con instrucciones para desbloquearla. |
| 429        | too\_many\_attempts           | Hemos detectado un comportamiento sospechoso en el inicio de sesión y se bloquearán los siguientes intentos. Ponte en contacto con el administrador.                                                 |

Además, también puedes recibir un error 403 genérico sin una propiedad `error` ni `error_description`. El cuerpo de la respuesta simplemente incluiría algo similar a lo siguiente:
`Origin https://test.app is not allowed.`

<div id="logout">
  ## Cerrar sesión
</div>

Para cerrar la sesión de un usuario, usa el método `logout()`. Este método acepta un objeto de opciones que puede incluir los siguientes parámetros.

Si se incluye el parámetro `clientID`, la URL `returnTo` proporcionada debe figurar en las **Allowed Logout URLs** de la aplicación en el [Dashboard de Auth0](https://manage.auth0.com/#). Sin embargo, si no se incluye el parámetro `clientID`, la URL `returnTo` debe figurar en las **Allowed Logout URLs** configuradas a nivel de cuenta en el [Dashboard de Auth0](https://manage.auth0.com/#).

```js lines theme={null}
webAuth.logout({
  returnTo: 'some url here',
  clientID: 'some client ID here'
});
```

<div id="signup">
  ## Registro
</div>

Para registrar un usuario, usa el método `signup`. Este método acepta un objeto de opciones que puede incluir los siguientes parámetros.

| **Parámetro**   | **Obligatorio** | **Descripción**                                                                                                                                       |
| --------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `email`         | obligatorio     | (String) Dirección de correo electrónico del usuario                                                                                                  |
| `password`      | obligatorio     | (String) Contraseña que desea usar el usuario                                                                                                         |
| `username`      | obligatorio\*   | (String) Nombre de usuario que desea usar el usuario. \*Obligatorio si usas una conexión de base de datos y has habilitado **Requires Username**      |
| `connection`    | obligatorio     | (String) Nombre de la conexión de base de datos de tu aplicación en la que se intentará crear la cuenta de usuario                                    |
| `user_metadata` | opcional        | (JSON object) Atributos adicionales para la información del usuario. Se almacenarán en [user\_metadata](/es/docs/manage-users/user-accounts/metadata) |

Los registros deben realizarse en conexiones de base de datos. Aquí tienes un ejemplo del método `signup` y código de ejemplo para un formulario.

```html lines theme={null}
<h2>Signup Database Connection</h2>
<input class="signup-email" />
<input type="password" class="signup-password" />
<input type="button" class="signup-db" value="Signup!" />
<script type="text/javascript">
    $('.signup-db').click(function (e) {
        e.preventDefault();
        webAuth.signup({
            connection: 'Username-Password-Authentication',
            email: $('.signup-email').val(),
            password: $('.signup-password').val(),
            user_metadata: { plan: 'silver', team_id: 'a111' }
        }, function (err) {
            if (err) return alert('Something went wrong: ' + err.message);
            return alert('success signup without login!')
        });
    });
</script>
```

<div id="using-checksession-to-acquire-new-tokens">
  ## Uso de `checkSession` para obtener nuevos tokens
</div>

El método `checkSession` te permite obtener un nuevo token de Auth0 para un usuario que ya está autenticado con Auth0 en tu dominio. El método acepta cualquier parámetro válido de OAuth2 que normalmente se enviaría a `authorize`. Si los omites, usará los que se proporcionaron al inicializar Auth0.

La llamada a `checkSession` puede usarse para obtener un nuevo token para la API que se especificó como la <Tooltip tip="Audiencia: identificador único de la audiencia de un token emitido. Se denomina aud en un token y su valor contiene el ID de una aplicación (Client ID) para un ID Token o de una API (API Identifier) para un token de acceso." cta="Ver glosario" href="/es/docs/glossary?term=audience">audiencia</Tooltip> al inicializar `webAuth`:

```js lines theme={null}
webAuth.checkSession({}, function (err, authResult) {
  // err si falla el parseHash automático
  ...
});
```

Consulta [Extraer el AuthResult y obtener la información del usuario](#extract-the-authresult-and-get-user-info) para conocer el formato de `authResult`.

O bien, se puede obtener el token para una API distinta de la usada al inicializar `webAuth` especificando un `audience` y un `scope`:

```js lines theme={null}
webAuth.checkSession(
  {
    audience: `https://mydomain/another-api/˜`,
    scope: 'read:messages'
  }, function (err, authResult) {
  // err si el parseHash automático falla
  ...
});
```

Ten en cuenta que `checkSession()` activa cualquier [regla](/es/docs/customize/rules) que hayas configurado, por lo que deberías revisar tus reglas en el [Dashboard](https://manage.auth0.com/#/rules) antes de usarla.

La redirección real a `/authorize` se produce dentro de un iframe, por lo que no recargará tu aplicación ni te redirigirá fuera de ella.

Sin embargo, el navegador **debe** tener habilitadas las cookies de terceros. De lo contrario, **checkSession()** no podrá acceder a la sesión actual del usuario (lo que hace imposible obtener un nuevo token sin mostrar nada al usuario). Lo mismo ocurrirá si los usuarios tienen [la ITP de Safari habilitada](https://support.auth0.com/center/s/article/troubleshoot-auth0-token-renewal-issues-in-safari-with-itp-enabled).

Recuerda añadir la URL desde la que se origina la solicitud de autorización a la lista de **Allowed Web Origins** de tu aplicación de Auth0 en el [Dashboard](https://manage.auth0.com/#), dentro de **Settings** de tu aplicación.

<Warning>
  Si se trata de una conexión social y estás usando claves de desarrollo de Auth0, la llamada a `checkSession` siempre devolverá `login_required`.
</Warning>

<div id="polling-with-checksession">
  ### Sondeo con `checkSession()`
</div>

En algunos escenarios con varias aplicaciones, en los que se desea Single Logout (cuando un usuario cierra sesión en una aplicación, también debe cerrarse en las demás), una aplicación puede configurarse para consultar periódicamente a Auth0 mediante `checkSession()` y comprobar si existe una sesión. Si la sesión no existe, puedes cerrar la sesión del usuario en la aplicación. El mismo método de sondeo puede utilizarse para implementar autenticación silenciosa en un escenario de inicio de sesión único (SSO).

El intervalo de sondeo entre comprobaciones con `checkSession()` debe ser de al menos 15 minutos entre llamadas para evitar posibles problemas futuros con la limitación de tasa de esta llamada.

<div id="password-reset-requests">
  ## Solicitudes de restablecimiento de contraseña
</div>

Si quieres configurar la funcionalidad de restablecimiento de contraseña, usarás el método `changePassword` y pasarás un objeto `options` con un parámetro `connection` y otro `email`.

```js lines theme={null}
$('.change_password').click(function () {
    webAuth.changePassword({
      connection: 'db-conn',
      email:   'foo@bar.com'
    }, function (err, resp) {
      if(err){
        console.log(err.message);
      }else{
        console.log(resp);
      }
    });
  });
```

El usuario recibe un correo electrónico con un enlace para restablecer su contraseña.

<div id="user-management">
  ## Gestión de usuarios
</div>

La Management API ofrece funciones que te permiten vincular y desvincular cuentas de usuario independientes de distintos proveedores, así como actualizar los metadatos del usuario. Para obtener más información, consulta [Vinculación de cuentas de usuario](/es/docs/manage-users/user-accounts/user-account-linking).

Para empezar, primero debes obtener un <Tooltip tip="Token de acceso: credencial de autorización, en forma de una cadena opaca o JWT, utilizada para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=access+token">token de acceso</Tooltip> que pueda utilizarse para llamar a la Management API. Puedes hacerlo especificando la audiencia `https://{yourDomain}/api/v2/` al inicializar Auth0.js; en ese caso, obtendrás el token de acceso como parte del flujo de autenticación.

Si usas [dominios personalizados](/es/docs/customize/custom-domains), tendrás que crear una nueva instancia de `webAuth` con tu dominio de Auth0 en lugar del dominio personalizado para usarla en las llamadas a la Management API, ya que esta solo funciona con dominios de Auth0.

export const codeExample4 = `var webAuth = new auth0.WebAuth({
  clientID: '{yourClientId}',
  domain: '{yourDomain}',
  redirectUri: 'http://example.com',
  audience: \`https://{yourDomain}/api/v2/\`,
  scope: 'read:current_user',
  responseType: 'token id_token'
});`;

<AuthCodeBlock children={codeExample4} language="js" />

También puedes hacerlo con `checkSession()`:

export const codeExample5 = `webAuth.checkSession(
  {
    audience: \`https://{yourDomain}/api/v2/\`,
    scope: 'read:current_user'
  }, function(err, result) {
     // usa result.accessToken
  }
);`;

<AuthCodeBlock children={codeExample5} language="js" />

Debes especificar los permisos concretos que necesitas. Puedes solicitar los siguientes permisos:

* `read:current_user`
* `update:current_user_identities`
* `create:current_user_metadata`
* `update:current_user_metadata`
* `delete:current_user_metadata`
* `create:current_user_device_credentials`
* `delete:current_user_device_credentials`

Una vez que tengas el token de acceso, puedes crear una nueva instancia de `auth0.Management` pasándole el dominio de Auth0 de la cuenta y el token de acceso.

export const codeExample6 = `var auth0Manage = new auth0.Management({
  domain: '{yourDomain}',
  token: 'ACCESS_TOKEN'
});`;

<AuthCodeBlock children={codeExample6} language="js" />

<div id="get-the-user-profile">
  ### Obtener el perfil del usuario
</div>

Para obtener los datos del perfil del usuario, utiliza el método `getUser()` con `userId` y un callback como parámetros. El método devuelve el perfil del usuario. Ten en cuenta que el `userID` requerido aquí será el mismo que se obtuvo mediante el método `client.userInfo`.
`auth0Manage.getUser(userId, cb);`

<div id="update-the-user-profile">
  ### Actualizar el perfil de usuario
</div>

Al actualizar los metadatos del usuario, primero deberá crear un objeto `userMetadata` y luego llamar al método `patchUserMetadata`, pasándole el ID del usuario y el objeto `userMetadata` que haya creado. Los valores de este objeto sobrescribirán los valores existentes que tengan la misma clave o agregarán otros nuevos para las claves que aún no existan en los metadatos del usuario. Para obtener más información, consulte [Metadata](/es/docs/manage-users/user-accounts/metadata).
`auth0Manage.patchUserMetadata(userId, userMetadata, cb);`

<div id="link-users">
  ### Vincular usuarios
</div>

Vincular cuentas de usuario permitirá que una persona pueda autenticarse con cualquiera de sus cuentas y, sin importar cuál use, siga accediendo al mismo perfil al iniciar sesión. Auth0 trata todas estas cuentas como perfiles independientes de forma predeterminada, así que, si quieres que las cuentas de un usuario estén vinculadas, esta es la forma de hacerlo.

El método `linkUser` acepta dos parámetros: el `userId` principal y el ID Token del usuario secundario (el token obtenido después de iniciar sesión con esta identidad). El ID de usuario en cuestión es el identificador único de la cuenta de usuario principal. El ID debe pasarse con el prefijo del proveedor, por ejemplo, `auth0|1234567890` o `facebook|1234567890`, al usar este método. Consulta [User Account Linking](/es/docs/manage-users/user-accounts/user-account-linking) para obtener más información.
`auth0Manage.linkUser(userId, secondaryUserToken, cb);`

Después de vincular las cuentas, la segunda cuenta dejará de existir como una entrada independiente en la base de datos de usuarios y solo se podrá acceder a ella como parte de la cuenta principal.
Cuando las cuentas están vinculadas, los metadatos de la cuenta secundaria no se fusionan con los de la cuenta principal y, si en algún momento se desvinculan, la cuenta secundaria tampoco conservará los metadatos de la cuenta principal cuando vuelva a quedar separada.