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

# Ajouter la connexion à votre application Laravel

> Ce guide explique comment intégrer Auth0 à une nouvelle application Laravel ou à une application existante à l’aide du SDK Laravel d’Auth0.

export const QuickstartButtons = ({githubLink}) => {
  const text = {
    viewOnGithub: "Voir sur GitHub",
    loginAndDownload: "Télécharger l’exemple"
  };
  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("Impossible d’analyser l’URL GitHub :", url);
      return null;
    } catch (error) {
      console.error("Erreur lors de l’analyse de l’URL GitHub :", error);
      return null;
    }
  };
  const handleDownload = async () => {
    const params = parseGithubUrl(githubLink);
    if (!params) {
      console.error("Format d’URL GitHub non valide");
      return;
    }
    try {
      await window.Auth0DocsUI?.getSample(params);
    } catch (error) {
      console.error("Impossible de télécharger l’exemple :", 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("Le nom de l'application est requis");
        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("Erreur lors de la création de l'application :", err);
        const errorMessage = err instanceof Error ? err.message : "Échec de la création de l'application";
        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">Créer une application 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={`Mon application ${placeholderText}`} value={name} onChange={e => setName(e.target.value)} />
          <Button onClick={handleSubmit}>{isLoading ? "Création en cours..." : "Créer"}</Button>
        </div>
        {error && <p className="text-red-500">{error}</p>}
      </Card>;
  };
  const SignInForm = () => {
    return <Card className="items-center">
        <Button onClick={login}>Se connecter</Button> <span>pour créer l'application</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) + "*****MASKED*****";
          }
          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="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant IA de codage comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes grâce aux [agent skills](https://agentskills.io/home).

  **Installez :**

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

  **Demandez ensuite à votre assistant IA :**

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

  Votre assistant IA créera automatiquement votre application Auth0, récupérera les identifiants, installera `auth0/login`, configurera les variables d’environnement et enregistrera les routes d’authentification. [Documentation complète des agent skills →](/fr-CA/docs/quickstart/agent-skills)
</Accordion>

<Note>
  **Prérequis :** Avant de commencer, assurez-vous d’avoir installé les éléments suivants :

  * **[PHP](https://www.php.net/downloads.php)** 8.2 ou une version ultérieure
  * **[Composer](https://getcomposer.org/download/)** 2.x
  * **[Laravel](https://laravel.com/docs/installation)** 11, 12 ou 13

  Vérifiez l’installation : `php --version && composer --version`
</Note>

<div id="get-started">
  ## Pour commencer
</div>

Ce guide de démarrage rapide montre comment ajouter l’authentification Auth0 à une application Laravel. Vous configurerez une ouverture de session sécurisée, la fermeture de session, des routes protégées et l’accès au profil utilisateur à l’aide du [SDK Auth0 Laravel](https://github.com/auth0/laravel-auth0).

<Steps>
  <Step title="Créer un projet Laravel" stepNumber={1}>
    Si vous avez déjà une application Laravel, passez à l’étape 2.

    Créez un projet Laravel :

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

    Ouvrez le répertoire du projet :

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

  <Step title="Installez le SDK Laravel d’Auth0" stepNumber={2}>
    Exécutez la commande suivante dans le répertoire de votre projet pour installer le [SDK Auth0 pour Laravel](https://github.com/auth0/laravel-auth0) :

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

    Publiez ensuite le fichier de configuration du SDK :

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

  <Step title="Configurer les identifiants d’Auth0" stepNumber={3}>
    Vous devez créer une application Auth0 et ajouter vos identifiants au projet. Choisissez l’une des méthodes suivantes :

    <Tabs>
      <Tab title="Configuration rapide (recommandée)">
        Créez une application Auth0 et copiez les identifiants `.env` préremplis avec les valeurs de configuration appropriées.

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

        Ajoutez ces valeurs au fichier `.env` de votre projet :

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

      <Tab title="CLI">
        Installez l’[Auth0 CLI](https://github.com/auth0/auth0-cli#installation) et connectez-vous à votre compte :

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

        Créez une application Auth0 et une API, puis enregistrez les identifiants dans des fichiers JSON que le SDK lit automatiquement :

        ```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>
          Ces fichiers contiennent vos identifiants. Ajoutez-les à `.gitignore` pour qu’ils ne soient pas inclus dans le contrôle de version :

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

      <Tab title="Dashboard">
        1. Accédez à l’[Auth0 Dashboard](https://manage.auth0.com/) → **Applications > Applications**
        2. Cliquez sur **Create Application**, entrez un nom, sélectionnez **Regular Web Application**, puis cliquez sur **Create**
        3. Accédez à l’onglet **Settings** et copiez le **Domaine**, l’**ID client** et le **Secret client**

        Configurez les URL suivantes dans l’onglet **Settings** de votre application :

        | Champ                 | Valeur                           |
        | --------------------- | -------------------------------- |
        | Allowed Callback URLs | `http://localhost:8000/callback` |
        | Allowed Logout URLs   | `http://localhost:8000`          |

        Cliquez sur **Save Changes**.

        Ajoutez ensuite vos identifiants au fichier `.env` de votre projet :

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

        <Warning>
          Ne versionnez jamais votre `AUTH0_CLIENT_SECRET`. Conservez-le dans `.env` et assurez-vous que `.env` figure dans votre `.gitignore`.
        </Warning>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Ajouter des routes d’authentification" stepNumber={4}>
    Le SDK Auth0 enregistre automatiquement les routes suivantes pour votre application — aucune configuration supplémentaire n’est nécessaire :

    | Route       | Objectif                                        |
    | ----------- | ----------------------------------------------- |
    | `/login`    | Lance le flux de connexion Auth0                |
    | `/logout`   | Déconnecte l’utilisateur et redirige vers Auth0 |
    | `/callback` | Traite le rappel d’authentification Auth0       |

    <Note>
      Si votre application utilise Laravel Breeze, Fortify ou Jetstream, les routes `/login`, `/logout` et `/callback` du SDK peuvent entrer en conflit avec celles enregistrées par ces packages. Consultez le [README du SDK](https://github.com/auth0/laravel-auth0) pour savoir comment enregistrer manuellement les routes.
    </Note>

    Mettez à jour `routes/web.php` pour ajouter votre route d’accueil :

    ```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="Protégez les routes à l’aide d’un middleware" stepNumber={5}>
    Utilisez le middleware `auth` de Laravel pour exiger une authentification sur n’importe quelle route. Vous pouvez aussi appliquer des [autorisations](https://auth0.com/docs/manage-users/access-control/rbac) précises à l’aide du middleware `can` :

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

    use Illuminate\Support\Facades\Route;

    // Nécessite un utilisateur authentifié
    Route::get('/private', function () {
        return response('Welcome! You are logged in.');
    })->middleware('auth');

    // Nécessite une authentification ET la permission 'read:messages'
    Route::get('/scope', function () {
        return response('You have the read:messages permission.');
    })->middleware('auth')->can('read:messages');
    ```

    <Info>
      Les autorisations sont définies dans les paramètres de votre API Auth0 et attribuées aux utilisateurs par l’intermédiaire de rôles. Consultez [Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac) pour en savoir plus.
    </Info>
  </Step>

  <Step title="Lancez votre application" stepNumber={6}>
    ```bash theme={null}
    php artisan serve
    ```

    <Info>
      Votre application s’exécute à l’adresse [http://localhost:8000](http://localhost:8000). Si le port 8000 est déjà utilisé, exécutez `php artisan serve --port=8001`, puis mettez à jour les **Allowed Callback URLs** et les **Allowed Logout URLs** de votre application Auth0 pour qu’elles utilisent le nouveau port.
    </Info>
  </Step>
</Steps>

<Check>
  **Vérification**

  Ouvrez [http://localhost:8000](http://localhost:8000) dans votre navigateur. Essayez les routes suivantes pour vérifier votre intégration :

  * [http://localhost:8000/login](http://localhost:8000/login) — déclenche le flux de connexion d’Auth0
  * [http://localhost:8000/private](http://localhost:8000/private) — redirige vers la page de connexion si l’utilisateur n’est pas authentifié; affiche un message de bienvenue lorsqu’il est connecté
  * [http://localhost:8000/logout](http://localhost:8000/logout) — déconnecte l’utilisateur et le redirige vers la page d’accueil
</Check>

***

<div id="troubleshooting">
  ## Dépannage
</div>

<AccordionGroup>
  <Accordion title="Erreur de non-correspondance de l’URL de rappel">
    **Cause :** L’URL de rappel envoyée à Auth0 ne correspond à aucune URL de la liste **Allowed Callback URLs** de votre application.

    **Correctif :**

    1. Accédez au [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > Applications** → votre application → **Settings**
    2. Ajoutez `http://localhost:8000/callback` à **Allowed Callback URLs**
    3. Cliquez sur **Save Changes**

    Assurez-vous qu’il n’y a pas de barre oblique à la fin et que le port correspond à celui du serveur que vous exécutez.
  </Accordion>

  <Accordion title="Erreur state invalide / CSRF après la connexion">
    **Cause :** Mauvaise configuration de la session ou des témoins — la session Laravel ne conserve pas le state entre la redirection de connexion et l’URL de rappel.

    **Correctif :**

    1. Assurez-vous que `SESSION_DRIVER` dans `.env` est défini à `file`, `database` ou `redis` (et non `array`)
    2. Videz la configuration et le cache :

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

    3. Redémarrez votre serveur de développement
  </Accordion>

  <Accordion title="AUTH0_DOMAIN n’est pas défini ou les identifiants ne se chargent pas">
    **Cause :** Le SDK ne trouve pas vos identifiants Auth0.

    **Correctif :** Assurez-vous que l’un des éléments suivants existe à la racine de votre projet :

    * Un fichier `.env` contenant `AUTH0_DOMAIN`, `AUTH0_CLIENT_ID` et `AUTH0_CLIENT_SECRET`
    * Un fichier `.auth0.app.json` généré par l’interface de ligne de commande Auth0

    Après avoir mis à jour `.env`, videz le cache de configuration :

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

  <Accordion title="404 sur /login, /logout ou /callback">
    **Cause :** Les routes du SDK ne sont pas enregistrées, généralement parce que le fournisseur de services ne s’est pas chargé.

    **Correctif :**

    1. Confirmez que vous avez exécuté `php artisan vendor:publish --tag auth0`
    2. Vérifiez que la découverte automatique du package est activée (vérifiez `composer.json` pour `"dont-discover": []`)
    3. Exécutez `php artisan route:list | grep auth0` pour confirmer que les routes sont enregistrées
    4. Si les routes sont absentes, enregistrez manuellement le fournisseur de services. Dans Laravel 11+, ajoutez-le à `bootstrap/providers.php` :

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

***

<div id="advanced-usage">
  ## Utilisation avancée
</div>

<AccordionGroup>
  <Accordion title="Management API — mettre à jour les métadonnées de l’utilisateur">
    Vous pouvez mettre à jour les renseignements de l’utilisateur à l’aide de la [Auth0 Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). Tous les points de terminaison de la Management API sont accessibles au moyen de la méthode `Auth0::management()` du SDK.

    **Avant d’effectuer des appels à la Management API**, autorisez votre application à accéder à la Management API :

    1. Accédez à [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > APIs** → **Auth0 Management API**
    2. Sélectionnez l’onglet **Machine to Machine Applications**
    3. Autorisez votre application Laravel et accordez-lui les scopes `read:users` et `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();

        // Met à jour les métadonnées de l’utilisateur authentifié avec une couleur préférée aléatoire
        $users->update(
            id: auth()->id(),
            body: [
                'user_metadata' => [
                    'color' => $colors[random_int(0, count($colors) - 1)],
                ],
            ]
        );

        // Récupère et affiche les métadonnées mises à jour
        $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');
    ```

    La référence complète de toutes les méthodes de la Management API est disponible dans la [documentation du SDK](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md).
  </Accordion>

  <Accordion title="Modèles et référentiels d’utilisateurs personnalisés">
    Le SDK prend en charge les modèles et référentiels d’utilisateurs personnalisés, ce qui vous permet de stocker et de récupérer les utilisateurs dans votre propre base de données tout en conservant Auth0 comme fournisseur d’identité.

    Consultez [User Repositories and Models](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) pour obtenir le guide d’implémentation complet.
  </Accordion>

  <Accordion title="Intercepter les événements du SDK">
    Le SDK déclenche des événements à des étapes clés du cycle de vie de l’authentification — connexion, déconnexion, actualisation des jetons, et plus encore — ce qui vous permet de personnaliser entièrement le comportement sans modifier le code de base du SDK.

    Consultez [Hooking Events](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) pour obtenir la liste complète des événements et des exemples d’implémentation.
  </Accordion>

  <Accordion title="Contrôle d’accès basé sur les rôles (RBAC)">
    Utilisez le RBAC d’Auth0 pour attribuer des autorisations aux utilisateurs au moyen de rôles, puis appliquez-les dans Laravel à l’aide du 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');
    ```

    Pour configurer le RBAC :

    1. Accédez à [Auth0 Dashboard](https://manage.auth0.com/) → **Applications > APIs** → votre API → **Permissions**
    2. Ajoutez les autorisations dont votre application a besoin (par ex., `admin:dashboard`, `read:messages`)
    3. Accédez à **User Management > Roles**, créez un rôle et attribuez-lui des autorisations
    4. Attribuez le rôle aux utilisateurs depuis leur page de profil

    Consultez [Contrôle d’accès basé sur les rôles](https://auth0.com/docs/manage-users/access-control/rbac) pour obtenir le guide complet.
  </Accordion>
</AccordionGroup>

***

<div id="next-steps">
  ## Prochaines étapes
</div>

Maintenant que l’authentification fonctionne dans votre application Laravel, explorez d’autres fonctionnalités d’Auth0 :

* [Auth0 Dashboard](https://manage.auth0.com/) — Configurez et gérez votre locataire Auth0 ainsi que vos applications
* [SDK laravel-auth0](https://github.com/auth0/laravel-auth0) — Documentation complète du SDK et intégrations avancées
* [Contrôle d’accès basé sur les rôles](https://auth0.com/docs/manage-users/access-control/rbac) — Attribuez des permissions aux utilisateurs à l’aide de rôles
* [Auth0 Marketplace](https://marketplace.auth0.com/) — Découvrez des intégrations pour étendre les fonctionnalités d’Auth0