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

# Agrega el inicio de sesión a tu aplicación Laravel

> Esta guía muestra cómo integrar Auth0 en una aplicación de Laravel nueva o existente mediante el SDK de Auth0 para Laravel.

export const QuickstartButtons = ({githubLink}) => {
  const text = {
    viewOnGithub: "Ver en GitHub",
    loginAndDownload: "Descargar ejemplo"
  };
  const parseGithubUrl = url => {
    try {
      const urlObj = new URL(url);
      const pathParts = urlObj.pathname.split("/").filter(Boolean);
      if (pathParts.length >= 4 && pathParts[2] === "tree") {
        const repoName = pathParts[1];
        const branch = pathParts[3];
        const path = pathParts.slice(4).join("/") || undefined;
        return {
          repo: repoName,
          branch,
          path
        };
      }
      console.warn("No se pudo analizar la URL de GitHub:", url);
      return null;
    } catch (error) {
      console.error("Error al analizar la URL de GitHub:", error);
      return null;
    }
  };
  const handleDownload = async () => {
    const params = parseGithubUrl(githubLink);
    if (!params) {
      console.error("Formato de URL de GitHub no válido");
      return;
    }
    try {
      await window.Auth0DocsUI?.getSample(params);
    } catch (error) {
      console.error("No se pudo descargar el ejemplo:", error);
    }
  };
  return <div className="quickstart_buttons flex flex-wrap gap-3 mb-4">
      <a href={githubLink} target="_blank" rel="noopener noreferrer" className="no_external_icon quickstart_button inline-flex items-center justify-center px-6 py-3 text-sm font-medium rounded-[18px] bg-black dark:bg-white !text-white dark:!text-black hover:bg-gray-800 dark:hover:bg-gray-100 transition-colors">
        {text.viewOnGithub}
      </a>
      <button onClick={handleDownload} type="button" className="no_external_icon quickstart_button inline-flex items-center justify-center px-6 py-3 text-sm font-medium rounded-[18px] border border-gray-300 dark:border-[#454545] bg-white dark:bg-[#272728] !text-black dark:!text-white hover:bg-gray-50 dark:hover:bg-neutral-800 transition-colors">
        {text.loginAndDownload}
      </button>
    </div>;
};

export const CreateInteractiveApp = ({placeholderText = "Auth0", appType = "regular_web", allowedCallbackUrls = ["localhost:3000"], allowedLogoutUrls = ["localhost:3000"], allowedOriginUrls = ["localhost:3000"]}) => {
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const [storeReady, setStoreReady] = useState(false);
  const [displayForm, setDisplayForm] = useState(true);
  useEffect(() => {
    const init = () => setStoreReady(true);
    if (window.rootStore) {
      window.rootStore.clientStore.setSelectedClient(null);
      window.rootStore.clientStore.setSelectedClientSecret(undefined);
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
    };
  }, []);
  useEffect(() => {
    if (!storeReady) return;
    const disposer = autorun(() => {
      const rootStore = window.rootStore;
      setIsAuthenticated(rootStore.sessionStore.isAuthenticated);
    });
    return () => {
      disposer();
    };
  }, [storeReady]);
  if (!storeReady || typeof window === "undefined" || !displayForm) {
    return <></>;
  }
  const login = () => {
    const baseUrl = window.rootStore.config.apiBaseUrl;
    const returnTo = encodeURIComponent(window.location.href);
    window.location.href = `${baseUrl}/auth/user/login?returnTo=${returnTo}`;
  };
  const Card = ({className = "", children}) => {
    return <div className={`
          flex border rounded-2xl
          border-gray-950/10 dark:border-white/10
          py-3.5 px-4 gap-2
          text-sm text-gray-900 dark:text-gray-200
          ${className}
        `}>
        {children}
      </div>;
  };
  const Button = ({children, ...props}) => {
    return <button className="bg-[--button-primary] text-[--foreground-inverse] px-[1.125rem] py-1.5 rounded-lg font-medium" {...props}>
        {children}
      </button>;
  };
  const CreateApplicationForm = () => {
    const [name, setName] = useState("");
    const [isLoading, setIsLoading] = useState(false);
    const [error, setError] = useState("");
    const handleSubmit = async () => {
      if (!name.trim()) {
        setError("El nombre de la aplicación es obligatorio");
        return;
      }
      setIsLoading(true);
      setError(null);
      try {
        await window.rootStore.clientStore.createClient({
          name: name.trim(),
          app_type: appType,
          callbacks: allowedCallbackUrls,
          allowed_logout_urls: allowedLogoutUrls,
          web_origins: allowedOriginUrls,
          client_metadata: {
            created_by: "quickstart-docs-app-creation-component"
          }
        });
        setDisplayForm(false);
      } catch (err) {
        console.error("Error creating client:", err);
        const errorMessage = err instanceof Error ? err.message : "No se pudo crear la aplicación";
        setError(errorMessage);
      } finally {
        setIsLoading(false);
      }
    };
    return <Card className="flex-col items-start p-4 gap-3.75">
        <span className="font-medium text-gray-900 dark:text-gray-200">Crear aplicación de Auth0</span>
        <div className="w-full flex gap-2">
          <input id="app-name" name={name} className="
              w-full max-w-[448px] h-11 py-2 px-4 
              border rounded-lg border-gray-950/10 dark:border-white/10 
              text-gray-900 dark:text-gray-200
              focus:outline-none dark:focus:outline-none
            " placeholder={`My ${placeholderText} App`} value={name} onChange={e => setName(e.target.value)} />
          <Button onClick={handleSubmit}>{isLoading ? "Creando..." : "Crear"}</Button>
        </div>
        {error && <p className="text-red-500">{error}</p>}
      </Card>;
  };
  const SignInForm = () => {
    return <Card className="items-center">
        <Button onClick={login}>Iniciar sesión</Button> <span>para crear la aplicación</span>
      </Card>;
  };
  return isAuthenticated ? <CreateApplicationForm /> : <SignInForm />;
};

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

<QuickstartButtons githubLink="https://github.com/auth0-samples/laravel/tree/7.x/sample" />

export const envSnippet = `AUTH0_DOMAIN={yourDomain}
AUTH0_CLIENT_ID={yourClientId}
AUTH0_CLIENT_SECRET={yourClientSecret}`;

<Accordion title="Usa la 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 mediante [agent skills](https://agentskills.io/home).

  **Instala:**

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

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

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

  Tu asistente de IA creará automáticamente tu aplicación de Auth0, recuperará las credenciales, instalará `auth0/login`, configurará las variables de entorno y registrará las rutas de autenticación. [Documentación completa de agent skills →](/es/docs/quickstart/agent-skills)
</Accordion>

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

  * **[PHP](https://www.php.net/downloads.php)** 8.2 o una versión posterior
  * **[Composer](https://getcomposer.org/download/)** 2.x
  * **[Laravel](https://laravel.com/docs/installation)** 11, 12 o 13

  Verifica la instalación: `php --version && composer --version`
</Note>

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

Esta guía de inicio rápido muestra cómo añadir la autenticación de Auth0 a una aplicación de Laravel. Configurarás el inicio de sesión, el cierre de sesión, las rutas protegidas y el acceso al perfil del usuario de forma segura mediante el [Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0).

<Steps>
  <Step title="Crear un nuevo proyecto de Laravel" stepNumber={1}>
    Si ya tiene una aplicación Laravel, vaya al paso 2.

    Cree un nuevo proyecto de Laravel:

    ```bash theme={null}
    composer create-project laravel/laravel auth0-laravel-app
    ```

    Abra el directorio del proyecto:

    ```bash theme={null}
    cd auth0-laravel-app
    ```
  </Step>

  <Step title="Instala el SDK de Auth0 para Laravel" stepNumber={2}>
    Ejecute el siguiente comando en el directorio de su proyecto para instalar el [Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0):

    ```bash theme={null}
    composer require auth0/login:^7 --update-with-all-dependencies
    ```

    Luego, publique el archivo de configuración del SDK:

    ```bash theme={null}
    php artisan vendor:publish --tag auth0
    ```
  </Step>

  <Step title="Configurar las credenciales de Auth0" stepNumber={3}>
    Debe crear una aplicación en Auth0 y agregar sus credenciales al proyecto. Elija uno de los siguientes métodos:

    <Tabs>
      <Tab title="Configuración rápida (recomendada)">
        Cree una aplicación de Auth0 y copie las credenciales preconfiguradas de `.env` con los valores correctos.

        <CreateInteractiveApp placeholderText="Laravel" appType="regular_web" allowedCallbackUrls={["http://localhost:8000/callback"]} allowedLogoutUrls={["http://localhost:8000"]} />

        Agregue estos valores al archivo `.env` de su proyecto:

        <AuthCodeBlock children={envSnippet} language="shellscript" filename=".env" />
      </Tab>

      <Tab title="CLI">
        Instale la [Auth0 CLI](https://github.com/auth0/auth0-cli#installation) e inicie sesión en su cuenta:

        <CodeGroup>
          ```bash Mac theme={null}
          brew tap auth0/auth0-cli && brew install auth0
          auth0 login
          ```

          ```powershell Windows theme={null}
          scoop bucket add auth0 https://github.com/auth0/scoop-auth0-cli.git
          scoop install auth0
          auth0 login
          ```
        </CodeGroup>

        Cree una aplicación y una API en Auth0, y guarde las credenciales en archivos JSON que el SDK lee automáticamente:

        ```bash theme={null}
        auth0 apps create \
          --name "My Laravel Application" \
          --type "regular" \
          --auth-method "post" \
          --callbacks "http://localhost:8000/callback" \
          --logout-urls "http://localhost:8000" \
          --reveal-secrets \
          --no-input \
          --json > .auth0.app.json

        auth0 apis create \
          --name "My Laravel Application's API" \
          --identifier "https://github.com/auth0/laravel-auth0" \
          --offline-access \
          --no-input \
          --json > .auth0.api.json
        ```

        <Note>
          Estos archivos contienen sus credenciales. Agréguelos a `.gitignore` para que no se incluyan en el control de versiones:

          ```bash theme={null}
          echo ".auth0.*.json" >> .gitignore
          ```
        </Note>
      </Tab>

      <Tab title="Dashboard">
        1. Vaya a [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > Applications**
        2. Haga clic en **Create Application**, escriba un nombre, seleccione **Regular Web Application** y haga clic en **Create**
        3. Vaya a la pestaña **Settings** y copie **Domain**, **Client ID** y **Client Secret**

        Configure las siguientes URL en la pestaña **Settings** de su aplicación:

        | Field                 | Value                            |
        | --------------------- | -------------------------------- |
        | Allowed Callback URLs | `http://localhost:8000/callback` |
        | Allowed Logout URLs   | `http://localhost:8000`          |

        Haga clic en **Save Changes**.

        Luego, agregue sus credenciales al archivo `.env` de su proyecto:

        ```bash .env theme={null}
        AUTH0_DOMAIN=YOUR_AUTH0_DOMAIN
        AUTH0_CLIENT_ID=YOUR_AUTH0_CLIENT_ID
        AUTH0_CLIENT_SECRET=YOUR_AUTH0_CLIENT_SECRET
        ```

        <Warning>
          Nunca suba su `AUTH0_CLIENT_SECRET` al control de versiones. Guárdelo en `.env` y asegúrese de que `.env` esté en su `.gitignore`.
        </Warning>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Añadir rutas de autenticación" stepNumber={4}>
    El SDK de Auth0 registra automáticamente las siguientes rutas para tu aplicación; no se requiere ninguna configuración de rutas adicional:

    | Ruta        | Propósito                                       |
    | ----------- | ----------------------------------------------- |
    | `/login`    | Inicia el flujo de inicio de sesión de Auth0    |
    | `/logout`   | Cierra la sesión del usuario y redirige a Auth0 |
    | `/callback` | Procesa el callback de autenticación de Auth0   |

    <Note>
      Si tu aplicación usa Laravel Breeze, Fortify o Jetstream, las rutas `/login`, `/logout` y `/callback` del SDK pueden entrar en conflicto con las rutas registradas por esos paquetes. Consulta el [SDK README](https://github.com/auth0/laravel-auth0) para obtener instrucciones sobre el registro manual de rutas.
    </Note>

    Actualiza `routes/web.php` para agregar tu ruta de inicio:

    ```php routes/web.php lines theme={null}
    <?php

    use Illuminate\Support\Facades\Route;

    Route::get('/', function () {
        if (! auth()->check()) {
            return response('You are not logged in. <a href="/login">Log in</a>');
        }

        $user = auth()->user();
        $name = $user->name ?? 'User';
        $email = $user->email ?? '';

        return response("Hello {$name}! Your email address is {$email}.");
    });
    ```
  </Step>

  <Step title="Protege rutas con middleware" stepNumber={5}>
    Usa el middleware `auth` de Laravel para exigir autenticación en cualquier ruta. También puedes exigir [permisos](https://auth0.com/docs/manage-users/access-control/rbac) específicos mediante el middleware `can`:

    ```php routes/web.php lines theme={null}
    <?php

    use Illuminate\Support\Facades\Route;

    // Requiere cualquier usuario autenticado
    Route::get('/private', function () {
        return response('Welcome! You are logged in.');
    })->middleware('auth');

    // Requiere autenticación Y el permiso 'read:messages'
    Route::get('/scope', function () {
        return response('You have the read:messages permission.');
    })->middleware('auth')->can('read:messages');
    ```

    <Info>
      Los permisos se definen en la configuración de tu API de Auth0 y se asignan a los usuarios a través de roles. Consulta [Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac) para obtener más información.
    </Info>
  </Step>

  <Step title="Ejecuta la aplicación" stepNumber={6}>
    ```bash theme={null}
    php artisan serve
    ```

    <Info>
      Tu aplicación se ejecuta en [http://localhost:8000](http://localhost:8000). Si el puerto 8000 ya está en uso, ejecuta `php artisan serve --port=8001` y actualiza los valores de **Allowed Callback URLs** y **Allowed Logout URLs** de tu aplicación de Auth0 para que usen el nuevo puerto.
    </Info>
  </Step>
</Steps>

<Check>
  **Comprobación**

  Abre [http://localhost:8000](http://localhost:8000) en tu navegador. Prueba estas rutas para verificar tu integración:

  * [http://localhost:8000/login](http://localhost:8000/login) — inicia el flujo de inicio de sesión de Auth0
  * [http://localhost:8000/private](http://localhost:8000/private) — redirige al inicio de sesión si no has iniciado sesión; muestra un mensaje de bienvenida cuando has iniciado sesión
  * [http://localhost:8000/logout](http://localhost:8000/logout) — cierra la sesión y vuelve a la página de inicio
</Check>

***

<div id="troubleshooting">
  ## Solución de problemas
</div>

<AccordionGroup>
  <Accordion title="Error de URL de callback no coincidente">
    **Causa:** La URL de callback enviada a Auth0 no coincide con ninguna URL de la lista **Allowed Callback URLs** de tu aplicación.

    **Solución:**

    1. Ve al [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > Applications** → tu aplicación → **Settings**
    2. Agrega `http://localhost:8000/callback` a **Allowed Callback URLs**
    3. Haz clic en **Save Changes**

    Asegúrate de que no haya barras diagonales al final y de que el puerto coincida con el de tu servidor.
  </Accordion>

  <Accordion title="Error de state no válido / CSRF después de iniciar sesión">
    **Causa:** Hay un problema de configuración de la sesión o de las cookies: la sesión de Laravel no mantiene el estado entre la redirección de inicio de sesión y el callback.

    **Solución:**

    1. Asegúrate de que `SESSION_DRIVER` en `.env` esté configurado como `file`, `database` o `redis` (no `array`)
    2. Borra la configuración y la caché:

    ```bash theme={null}
    php artisan config:clear && php artisan cache:clear
    ```

    3. Reinicia tu servidor de desarrollo
  </Accordion>

  <Accordion title="AUTH0_DOMAIN no está configurado o las credenciales no se cargan">
    **Causa:** El SDK no puede encontrar tus credenciales de Auth0.

    **Solución:** Asegúrate de que exista uno de los siguientes elementos en la raíz de tu proyecto:

    * Un archivo `.env` con `AUTH0_DOMAIN`, `AUTH0_CLIENT_ID` y `AUTH0_CLIENT_SECRET`
    * Un archivo `.auth0.app.json` generado por Auth0 CLI

    Después de actualizar `.env`, borra la caché de configuración:

    ```bash theme={null}
    php artisan config:clear
    ```
  </Accordion>

  <Accordion title="404 en /login, /logout o /callback">
    **Causa:** Las rutas del SDK no están registradas, normalmente porque el proveedor de servicios no se cargó.

    **Solución:**

    1. Confirma que ejecutaste `php artisan vendor:publish --tag auth0`
    2. Verifica que la autodetección del paquete esté habilitada (revisa `composer.json` para `"dont-discover": []`)
    3. Ejecuta `php artisan route:list | grep auth0` para confirmar que las rutas estén registradas
    4. Si faltan rutas, registra manualmente el proveedor de servicios. En Laravel 11+, agrégalo a `bootstrap/providers.php`:

    ```php bootstrap/providers.php theme={null}
    return [
        App\Providers\AppServiceProvider::class,
        Auth0\Laravel\Auth0ServiceProvider::class,
    ];
    ```
  </Accordion>
</AccordionGroup>

***

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

<AccordionGroup>
  <Accordion title="Management API — actualizar los metadatos del usuario">
    Puede actualizar la información del usuario mediante la [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). Todos los endpoints de la Management API están disponibles a través del método `Auth0::management()` del SDK.

    **Antes de hacer llamadas a la Management API**, autorice a su aplicación para acceder a la Management API:

    1. Vaya al [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > APIs** → **Management API**
    2. Seleccione la pestaña **Machine to Machine Applications**
    3. Autorice su aplicación de Laravel y conceda los alcances `read:users` y `update:users`

    ```php routes/web.php lines theme={null}
    <?php

    use Auth0\Laravel\Facade\Auth0;
    use Illuminate\Support\Facades\Route;

    Route::get('/colors', function () {
        $colors = ['red', 'blue', 'green', 'black', 'white', 'yellow', 'purple', 'orange'];

        $users = Auth0::management()->users();

        // Actualiza los metadatos del usuario autenticado con un color favorito aleatorio
        $users->update(
            id: auth()->id(),
            body: [
                'user_metadata' => [
                    'color' => $colors[random_int(0, count($colors) - 1)],
                ],
            ]
        );

        // Recupera y muestra los metadatos actualizados
        $metadata = Auth0::json($users->get(auth()->id()));
        $color = $metadata['user_metadata']['color'] ?? 'unknown';
        $name = auth()->user()->name;

        return response("Hello {$name}! Your favorite color is {$color}.");
    })->middleware('auth');
    ```

    Puede consultar una referencia completa de todos los métodos de la Management API en la [documentación del SDK](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md).
  </Accordion>

  <Accordion title="Modelos y repositorios de usuario personalizados">
    El SDK admite modelos y repositorios de usuario personalizados, lo que le permite almacenar y recuperar usuarios desde su propia base de datos mientras mantiene Auth0 como proveedor de identidad.

    Consulte [User Repositories and Models](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) para obtener la guía de implementación completa.
  </Accordion>

  <Accordion title="Escuchar eventos del SDK">
    El SDK genera eventos en puntos clave del ciclo de vida de la autenticación —como al iniciar sesión, cerrar sesión, renovar tokens y más—, lo que le permite personalizar por completo el comportamiento sin modificar el código base del SDK.

    Consulte [Hooking Events](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) para ver la lista completa de eventos y ejemplos de implementación.
  </Accordion>

  <Accordion title="Control de acceso basado en roles (RBAC)">
    Use Auth0 RBAC para asignar permisos a los usuarios mediante roles y luego aplicarlos en Laravel con el middleware `can`:

    ```php routes/web.php theme={null}
    <?php

    use Illuminate\Support\Facades\Route;

    Route::get('/admin', function () {
        return response('Admin area.');
    })->middleware('auth')->can('admin:dashboard');
    ```

    Para configurar RBAC:

    1. Vaya al [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > APIs** → su API → **Permissions**
    2. Añada los permisos que necesita su aplicación (por ejemplo, `admin:dashboard`, `read:messages`)
    3. Vaya a **User Management > Roles**, cree un rol y asígnele permisos
    4. Asigne el rol a los usuarios desde su página de perfil

    Consulte [Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac) para obtener la guía completa.
  </Accordion>
</AccordionGroup>

***

<div id="next-steps">
  ## Próximos pasos
</div>

Ahora que ya tienes la autenticación funcionando en tu aplicación Laravel, explora más funcionalidades de Auth0:

* [Auth0 Dashboard](https://manage.auth0.com/) — Configura y administra tu inquilino de Auth0 y tus aplicaciones
* [laravel-auth0 SDK](https://github.com/auth0/laravel-auth0) — Documentación completa del SDK e integraciones avanzadas
* [Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac) — Asigna permisos a los usuarios mediante roles
* [Auth0 Marketplace](https://marketplace.auth0.com/) — Descubre integraciones para ampliar la funcionalidad de Auth0