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

> Esta guía de inicio rápido muestra cómo agregar la autenticación de Auth0 a una aplicación Java Servlet. Creará una aplicación web segura con funciones de inicio de sesión, cierre de sesión y perfil de usuario mediante el SDK Auth0 Java MVC Commons.

# Agregue el inicio de sesión a su aplicación Java Servlet

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

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

<HowToSchema />

<Note>
  **Requisitos previos:** Antes de empezar, asegúrate de tener instalado lo siguiente:

  * **Java Development Kit (JDK)**: versión 8 o superior
  * **Herramienta de compilación**: [Maven](https://maven.apache.org/download.cgi) 3.6+ o [Gradle](https://gradle.org/install/) 6.0+
  * **Servidor de aplicaciones**: [Apache Tomcat](https://tomcat.apache.org/download-90.cgi) 9.0+ o cualquier contenedor de servlets
  * **Cuenta de Auth0**: [Regístrate gratis](https://auth0.com/signup) si aún no tienes una
</Note>

<Accordion title="Usa IA para integrar Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si usas un asistente de programación con IA como Claude Code, Cursor o GitHub Copilot, puedes añadir la autenticación de Auth0 automáticamente en cuestión de minutos con [agent skills](https://agentskills.io/home).

  **Instala:**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-java-mvc-common
  ```

  **Luego, pídele a tu asistente de IA:**

  ```text theme={null}
  Add Auth0 authentication to my Java servlet app
  ```

  Tu asistente de IA creará automáticamente tu aplicación de Auth0, obtendrá las credenciales, añadirá la dependencia del SDK Auth0 Java MVC Commons, configurará tu `web.xml` e implementará los flujos de inicio y cierre de sesión con filtros de servlet. [Documentación completa sobre agent skills →](/es/docs/quickstart/agent-skills)
</Accordion>

<div id="get-started">
  ## Primeros pasos
</div>

Esta guía de inicio rápido muestra cómo agregar la autenticación de Auth0 a una aplicación Java Servlet. Creará una aplicación web segura con funciones de inicio de sesión, cierre de sesión y perfil de usuario mediante el SDK Auth0 Java MVC Commons.

<Steps>
  <Step title="Crear un nuevo proyecto web en Java" stepNumber={1}>
    Cree un nuevo proyecto de aplicación web en Java para esta guía de inicio rápido.

    <Tabs>
      <Tab title="Maven">
        ```bash theme={null}
        mvn archetype:generate \
          -DgroupId=com.auth0.example \
          -DartifactId=auth0-servlet-app \
          -DarchetypeArtifactId=maven-archetype-webapp \
          -DinteractiveMode=false
        ```

        Vaya al directorio del proyecto:

        ```bash theme={null}
        cd auth0-servlet-app
        ```
      </Tab>

      <Tab title="Gradle">
        Cree un directorio nuevo e inicialice un proyecto de Gradle:

        ```bash theme={null}
        mkdir auth0-servlet-app && cd auth0-servlet-app
        gradle init --type java-application
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Instala el SDK Auth0 Java MVC Commons" stepNumber={2}>
    Agrega la dependencia de Auth0 al archivo de compilación del proyecto.

    <Tabs>
      <Tab title="Maven">
        Agrega la siguiente dependencia a tu `pom.xml`:

        ```xml theme={null}
        <dependencies>
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>mvc-auth-commons</artifactId>
                <version>1.11.1</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>1.2</version>
            </dependency>
        </dependencies>
        ```
      </Tab>

      <Tab title="Gradle">
        Agrega las siguientes dependencias a tu `build.gradle`:

        ```gradle theme={null}
        plugins {
            id 'java'
            id 'war'
        }

        dependencies {
            implementation 'com.auth0:mvc-auth-commons:1.11.1'
            implementation 'javax.servlet:javax.servlet-api:3.1.0'
            implementation 'javax.servlet:jstl:1.2'
        }
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurar la aplicación de Auth0" stepNumber={3}>
    A continuación, debes crear una nueva aplicación en tu inquilino de Auth0 y agregar la configuración a tu proyecto.

    1. Ve al [Auth0 Dashboard](https://manage.auth0.com/dashboard)
    2. Haz clic en **Applications** > **Applications** > **Create Application**
    3. En la ventana emergente, ingresa un nombre para tu aplicación, selecciona **Regular Web Application** como tipo de aplicación y haz clic en **Create**
    4. Ve a la pestaña **Settings** en la página de detalles de la aplicación
    5. Anota los valores de **dominio**, **ID de cliente** y **Secreto del cliente** del Auth0 Dashboard
    6. Por último, en la pestaña **Settings** de la página de detalles de la aplicación, configura las siguientes URL:

    **Allowed Callback URLs:**

    ```
    http://localhost:8080/callback
    ```

    **URL permitidas para el cierre de sesión:**

    ```
    http://localhost:8080/login
    ```

    **Orígenes web permitidos:**

    ```
    http://localhost:8080
    ```

    <Note>
      * **Allowed Callback URLs** son una medida de seguridad fundamental para garantizar que los usuarios regresen de forma segura a su aplicación después de la autenticación. Sin una URL que coincida, el proceso de inicio de sesión fallará y los usuarios verán una página de error de Auth0 en lugar de acceder a su aplicación.
      * **Allowed Logout URLs** son esenciales para ofrecer una experiencia fluida al cerrar sesión. Sin una URL que coincida, los usuarios no serán redirigidos de vuelta a su aplicación después de cerrar sesión y, en su lugar, permanecerán en una página genérica de Auth0.
      * **Allowed Web Origins** es fundamental para la autenticación silenciosa. Sin esta configuración, los usuarios cerrarán sesión al actualizar la página o al volver a su aplicación más tarde.
    </Note>
  </Step>

  <Step title="Configura el SDK de Auth0" stepNumber={4}>
    Configure su aplicación servlet para usar el SDK de Auth0. Para ello, configure `web.xml` con las credenciales de Auth0 generadas anteriormente.

    Cree o actualice `src/main/webapp/WEB-INF/web.xml` y sustituya los valores de marcador de posición por la configuración real de su aplicación de Auth0:

    ```xml expandable theme={null}
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">

        <display-name>Auth0 Servlet Example</display-name>

        <!-- Configuración de Auth0 -->
        <context-param>
            <param-name>com.auth0.domain</param-name>
            <param-value>YOUR_AUTH0_DOMAIN</param-value>
        </context-param>
        <context-param>
            <param-name>com.auth0.clientId</param-name>
            <param-value>YOUR_AUTH0_CLIENT_ID</param-value>
        </context-param>
        <context-param>
            <param-name>com.auth0.clientSecret</param-name>
            <param-value>YOUR_AUTH0_CLIENT_SECRET</param-value>
        </context-param>
    </web-app>
    ```

    **Importante**: Reemplace `YOUR_AUTH0_DOMAIN`, `YOUR_AUTH0_CLIENT_ID` y `YOUR_AUTH0_CLIENT_SECRET` por los valores reales de la configuración de su aplicación en Auth0.
  </Step>

  <Step title="Crear componentes de autenticación y filtros" stepNumber={5}>
    Crea las clases Java necesarias para gestionar los flujos de autenticación y proteger las páginas protegidas.

    <AuthCodeGroup>
      ```java src/main/java/com/auth0/example/AuthenticationControllerProvider.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;
      import com.auth0.jwk.JwkProvider;
      import com.auth0.jwk.JwkProviderBuilder;

      import javax.servlet.ServletConfig;
      import java.io.UnsupportedEncodingException;

      /**
       * Gestiona una instancia singleton de AuthenticationController para la aplicación.
       */
      public class AuthenticationControllerProvider {

          private AuthenticationControllerProvider() {}

          private static AuthenticationController INSTANCE;

          public static synchronized AuthenticationController getInstance(ServletConfig config)
                  throws UnsupportedEncodingException {
              if (INSTANCE == null) {
                  String domain = config.getServletContext().getInitParameter("com.auth0.domain");
                  String clientId = config.getServletContext().getInitParameter("com.auth0.clientId");
                  String clientSecret = config.getServletContext().getInitParameter("com.auth0.clientSecret");

                  if (domain == null || clientId == null || clientSecret == null) {
                      throw new IllegalArgumentException(
                          "Missing domain, clientId, or clientSecret. Check your web.xml configuration.");
                  }

                  // JwkProvider necesario para tokens RS256
                  JwkProvider jwkProvider = new JwkProviderBuilder(domain).build();
                  INSTANCE = AuthenticationController.newBuilder(domain, clientId, clientSecret)
                          .withJwkProvider(jwkProvider)
                          .build();
              }
              return INSTANCE;
          }
      }
      ```

      ```java src/main/java/com/auth0/example/LoginServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;

      import javax.servlet.ServletConfig;
      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;
      import java.io.UnsupportedEncodingException;

      @WebServlet(urlPatterns = {"/login"})
      public class LoginServlet extends HttpServlet {

          private AuthenticationController authenticationController;

          @Override
          public void init(ServletConfig config) throws ServletException {
              super.init(config);
              try {
                  authenticationController = AuthenticationControllerProvider.getInstance(config);
              } catch (UnsupportedEncodingException e) {
                  throw new ServletException("Couldn't create the AuthenticationController instance. Check the configuration.", e);
              }
          }

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {
              // Construir la URL de callback
              String redirectUri = req.getScheme() + "://" + req.getServerName();
              if ((req.getScheme().equals("http") && req.getServerPort() != 80) ||
                  (req.getScheme().equals("https") && req.getServerPort() != 443)) {
                  redirectUri += ":" + req.getServerPort();
              }
              redirectUri += "/callback";

              // Generar la URL de autorización de Auth0
              String authorizeUrl = authenticationController.buildAuthorizeUrl(req, res, redirectUri)
                      .build();
              res.sendRedirect(authorizeUrl);
          }
      }
      ```

      ```java src/main/java/com/auth0/example/CallbackServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;
      import com.auth0.IdentityVerificationException;
      import com.auth0.SessionUtils;
      import com.auth0.Tokens;

      import javax.servlet.ServletConfig;
      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;
      import java.io.UnsupportedEncodingException;

      @WebServlet(urlPatterns = {"/callback"})
      public class CallbackServlet extends HttpServlet {

          private AuthenticationController authenticationController;

          @Override
          public void init(ServletConfig config) throws ServletException {
              super.init(config);
              try {
                  authenticationController = AuthenticationControllerProvider.getInstance(config);
              } catch (UnsupportedEncodingException e) {
                  throw new ServletException("Couldn't create the AuthenticationController instance. Check the configuration.", e);
              }
          }

          @Override
          public void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws IOException, ServletException {
              handleCallback(req, res);
          }

          @Override
          public void doPost(HttpServletRequest req, HttpServletResponse res)
                  throws IOException, ServletException {
              handleCallback(req, res);
          }

          private void handleCallback(HttpServletRequest req, HttpServletResponse res)
                  throws IOException {
              try {
                  // Procesar el callback de autenticación
                  Tokens tokens = authenticationController.handle(req, res);

                  // Almacenar tokens en la sesión
                  SessionUtils.set(req, "accessToken", tokens.getAccessToken());
                  SessionUtils.set(req, "idToken", tokens.getIdToken());

                  // Redirigir al área segura
                  res.sendRedirect("/profile");
              } catch (IdentityVerificationException e) {
                  // Error de autenticación
                  e.printStackTrace();
                  res.sendRedirect("/login?error=auth_failed");
              }
          }
      }
      ```

      ```java src/main/java/com/auth0/example/ProfileServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebServlet(urlPatterns = {"/profile"})
      public class ProfileServlet extends HttpServlet {

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {

              String accessToken = (String) SessionUtils.get(req, "accessToken");
              String idToken = (String) SessionUtils.get(req, "idToken");

              if (accessToken == null && idToken == null) {
                  res.sendRedirect("/login");
                  return;
              }

              // Redirigir al JSP de perfil
              req.setAttribute("accessToken", accessToken);
              req.setAttribute("idToken", idToken);
              req.getRequestDispatcher("/WEB-INF/jsp/profile.jsp").forward(req, res);
          }
      }
      ```

      ```java src/main/java/com/auth0/example/LogoutServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebServlet(urlPatterns = {"/logout"})
      public class LogoutServlet extends HttpServlet {

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {

              // Limpiar sesión
              SessionUtils.set(req, "accessToken", null);
              SessionUtils.set(req, "idToken", null);
              req.getSession().invalidate();

              // Redirigir al inicio de sesión

              res.sendRedirect("/login");
          }
      }
      ```

      ```java src/main/java/com/auth0/example/AuthenticationFilter.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.*;
      import javax.servlet.annotation.WebFilter;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebFilter(urlPatterns = {"/profile"})
      public class AuthenticationFilter implements Filter {

          @Override
          public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                  throws IOException, ServletException {

              HttpServletRequest req = (HttpServletRequest) request;
              HttpServletResponse res = (HttpServletResponse) response;

              String accessToken = (String) SessionUtils.get(req, "accessToken");
              String idToken = (String) SessionUtils.get(req, "idToken");

              if (accessToken == null && idToken == null) {
                  res.sendRedirect("/login");
                  return;
              }

              chain.doFilter(request, response);
          }

          @Override
          public void init(FilterConfig filterConfig) throws ServletException {
              // Inicializar filtro
          }

          @Override
          public void destroy() {
              // Liberar recursos
          }
      }
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Crear páginas de interfaz de usuario" stepNumber={6}>
    Cree las páginas JSP y los archivos HTML para su aplicación.

    <AuthCodeGroup>
      ```jsp src/main/webapp/WEB-INF/jsp/profile.jsp expandable lines theme={null}
      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <!DOCTYPE html>
      <html>
      <head>
          <title>Perfil - Ejemplo de Auth0</title>
          <style>
              body { font-family: Arial, sans-serif; margin: 40px; }
              .profile-container { max-width: 600px; margin: 0 auto; }
              .token-section { margin: 20px 0; padding: 15px; background-color: #f5f5f5; border-radius: 5px; }
              .logout-btn {
                  background-color: #dc3545;
                  color: white;
                  padding: 10px 20px;
                  text-decoration: none;
                  border-radius: 5px;
                  display: inline-block;
                  margin-top: 20px;
              }
              .logout-btn:hover { background-color: #c82333; }
              code { background-color: #e9ecef; padding: 2px 4px; border-radius: 3px; }
          </style>
      </head>
      <body>
          <div class="profile-container">
              <h1>¡Bienvenido a tu perfil!</h1>
              <p>Se autenticó correctamente con Auth0.</p>

              <div class="token-section">
                  <h3>Token de acceso</h3>
                  <p><code>${accessToken}</code></p>
              </div>

              <div class="token-section">
                  <h3>ID Token</h3>
                  <p><code>${idToken}</code></p>
              </div>

              <a href="/logout" class="logout-btn">Cerrar sesión</a>
          </div>
      </body>
      </html>
      ```

      ```html src/main/webapp/index.html expandable lines theme={null}
      <!DOCTYPE html>
      <html>
        <head>
          <title>Ejemplo de servlet Java de Auth0</title>
          <style>
            body {
              font-family: Arial, sans-serif;
              margin: 0;
              padding: 40px;
              background-color: #f8f9fa;
            }
            .container {
              max-width: 600px;
              margin: 0 auto;
              text-align: center;
              background-color: white;
              padding: 40px;
              border-radius: 8px;
              box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
            }
            .login-btn {
              background-color: #007bff;
              color: white;
              padding: 12px 30px;
              text-decoration: none;
              border-radius: 5px;
              display: inline-block;
              font-size: 16px;
              margin-top: 20px;
              transition: background-color 0.3s;
            }
            .login-btn:hover {
              background-color: #0056b3;
            }
            h1 {
              color: #333;
            }
            p {
              color: #666;
              line-height: 1.6;
            }
          </style>
        </head>
        <body>
          <div class="container">
            <h1>Ejemplo de servlet Java de Auth0</h1>
            <p>
              Este ejemplo muestra cómo agregar autenticación a una aplicación de
              servlet Java mediante el SDK Auth0 Java MVC Commons.
            </p>
            <p>
              Haga clic en el botón de abajo para autenticarse con Auth0 y acceder
              a su perfil.
            </p>

            <a href="/login" class="login-btn">Iniciar sesión con Auth0</a>
          </div>
        </body>
      </html>
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Compila y ejecuta tu aplicación" stepNumber={7}>
    Ahora ya está listo para compilar y ejecutar la aplicación.

    <Tabs>
      <Tab title="Maven">
        Compile la aplicación:

        ```bash theme={null}
        mvn clean compile war:war
        ```

        Impleméntela en Tomcat:

        ```bash theme={null}
        # Copie el archivo WAR al directorio webapps de Tomcat
        cp target/auth0-servlet-app.war $CATALINA_HOME/webapps/ROOT.war
        ```
      </Tab>

      <Tab title="Gradle">
        Compile la aplicación:

        ```bash theme={null}
        gradle clean build
        ```

        Impleméntela en Tomcat:

        ```bash theme={null}
        # Copie el archivo WAR al directorio webapps de Tomcat
        cp build/libs/auth0-servlet-app.war $CATALINA_HOME/webapps/
        ```
      </Tab>
    </Tabs>

    Inicie Tomcat (o el contenedor de servlets que prefiera):

    ```bash theme={null}
    $CATALINA_HOME/bin/startup.sh  # En Unix/Linux/Mac
    # o
    $CATALINA_HOME/bin/startup.bat  # En Windows
    ```
  </Step>
</Steps>

<Check>
  **Punto de control**

  Ahora deberías tener una aplicación servlet completamente funcional integrada con Auth0 y ejecutándose en [http://localhost:8080/](http://localhost:8080/)

  **Prueba la implementación:**

  1. Ve a la URL de tu aplicación
  2. Haz clic en "Iniciar sesión con Auth0"
  3. Completa el proceso de inicio de sesión de Auth0
  4. Deberías ser redirigido a tu página de perfil, donde se muestran los tokens
  5. Haz clic en "Cerrar sesión" para cerrar la sesión
</Check>

***

<div id="advanced-usage">
  ## Uso avanzado
</div>

<Accordion title="Optimice su aplicación">
  Ahora que ya tiene la autenticación básica en funcionamiento, tenga en cuenta estas mejoras:

  * **Información del perfil de usuario**: Decodifique el token de ID para mostrar la información del usuario
  * **Llamadas a API**: Use el token de acceso para llamar a la Management API de Auth0 o a sus propias API
  * **Acceso basado en roles**: Implemente la autorización mediante roles y permisos de Auth0
  * **Inicio de sesión único**: Configure SSO en varias aplicaciones
</Accordion>

<Accordion title="Recursos adicionales">
  * [Documentación de Auth0 Java MVC Commons
    ](https://github.com/auth0/auth0-java-mvc-common) - [Auth0 Dashboard
    ](https://manage.auth0.com/) - Administre sus aplicaciones de Auth0 -
    [Repositorio de ejemplo de Auth0 Servlet
    ](https://github.com/auth0-samples/auth0-servlet-sample) - Ejemplos completos
  * [Documentación del SDK de Java de Auth0
    ](https://auth0.com/docs/libraries/auth0-java) - Uso avanzado del SDK
</Accordion>

<Accordion title="Solución de problemas">
  **Problemas comunes**

  **La autenticación falla con "Invalid callback URL"**

  * Verifique que la URL de callback en la configuración de su aplicación de Auth0 coincida exactamente con: `http://localhost:8080/callback`

  **Error "Missing domain, clientId, or clientSecret"**

  * Compruebe que la configuración de `web.xml` tenga los valores correctos de la aplicación de Auth0
  * Asegúrese de que los nombres de los parámetros coincidan exactamente: `com.auth0.domain`, `com.auth0.clientId`, `com.auth0.clientSecret`

  **La aplicación no se inicia**

  * Verifique que todas las dependencias necesarias estén en su classpath
  * Compruebe que su contenedor de servlets sea compatible con Servlet API 3.0+
  * Revise los registros del servidor para identificar mensajes de error específicos

  **La sesión no se mantiene**

  * Asegúrese de que su contenedor de servlets esté configurado para la administración de sesiones
  * Compruebe que las cookies estén habilitadas en su navegador
  * Verifique que se use HTTPS en los entornos de producción

  Para obtener soporte adicional, visite la [Auth0 Community](https://community.auth0.com/).
</Accordion>