> ## 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 application Laravel nouvelle ou existante à l’aide de l’Auth0 Laravel SDK.

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 obligatoire");
        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 du client :", 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 Auth0 App</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) + "*****MASQUÉ*****";
          }
          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 programmation comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter l’authentification Auth0 automatiquement en quelques minutes à l’aide d’[Agent Skills](https://agentskills.io/home).

  **Installer :**

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

  **Ensuite, demandez à 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 ajoutera les routes d’authentification. [Documentation complète d’Agent Skills →](/docs/fr-ca/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 plus récente
  * **[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 Quickstart montre comment ajouter l’authentification Auth0 à une application Laravel. Vous y configurerez une connexion sécurisée, le logout, des routes protégées et l’accès au profil utilisateur à l’aide du [Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0).

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

    Créez un nouveau projet Laravel :

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

    Ouvrez le dossier du projet :

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

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

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

    Ensuite, publiez le fichier de configuration du SDK :

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

  <Step title="Configurer les identifiants 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 Auth0 App et copiez les identifiants `.env` préremplis avec les bonnes valeurs de configuration.

        <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">
        Exécutez la commande suivante dans le répertoire racine de votre projet afin de créer une application Auth0 et de générer un fichier `.env` :

        <CodeGroup>
          ```bash Mac theme={null}
          # Installez Auth0 CLI (s’il n’est pas déjà installé)
          brew tap auth0/auth0-cli && brew install auth0

          # Configurez l’application Auth0 et générez le fichier .env
          auth0 qs setup --app --type regular --framework laravel --build-tool composer --name "My Laravel App" --port 8000
          ```

          ```powershell Windows theme={null}
          # Installez Auth0 CLI (s’il n’est pas déjà installé)
          scoop bucket add auth0 https://github.com/auth0/scoop-auth0-cli.git
          scoop install auth0

          # Configurez l’application Auth0 et générez le fichier .env
          auth0 qs setup --app --type regular --framework laravel --build-tool composer --name "My Laravel App" --port 8000
          ```
        </CodeGroup>

        <Note>
          Cette commande va :

          1. Vérifier si vous êtes authentifié (et vous inviter à vous connecter au besoin)
          2. Créer une Regular Web Application Auth0 configurée pour `http://localhost:8000`
          3. Générer un fichier `.env` contenant vos identifiants Auth0
        </Note>
      </Tab>

      <Tab title="Dashboard">
        1. Accédez au [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 **Domain**, le **Client ID** et le **Client Secret**

        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 validez jamais votre `AUTH0_CLIENT_SECRET` dans le contrôle de version. 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 des routes n’est nécessaire :

    | Route       | Description                                        |
    | ----------- | -------------------------------------------------- |
    | `/login`    | Lance le flux de connexion Auth0                   |
    | `/logout`   | Déconnecte l’utilisateur et le redirige vers Auth0 |
    | `/callback` | Traite le retour 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 les routes 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 avec un middleware" stepNumber={5}>
    Utilisez le `middleware` `auth` de Laravel pour exiger l’authentification sur toute route. Vous pouvez aussi appliquer des [permissions](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 l'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 [le contrôle d’accès basé sur les rôles](https://auth0.com/docs/manage-users/access-control/rbac) pour plus de détails.
    </Info>
  </Step>

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

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

<Check>
  **Vérification**

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

  * [http://localhost:8000/login](http://localhost:8000/login) — déclenche le flux de connexion 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 ramène à la page d’accueil
</Check>

***

<div id="troubleshooting">
  ## Résolution des problèmes
</div>

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

    **Correctif :**

    1. Accédez à [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 de votre serveur en cours d’exécution.
  </Accordion>

  <Accordion title="Erreur invalid state / CSRF après la connexion">
    **Cause :** Mauvaise configuration de la session ou du cookie — la session Laravel ne conserve pas le paramètre 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 non défini ou identifiants non chargés">
    **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` avec `AUTH0_DOMAIN`, `AUTH0_CLIENT_ID` et `AUTH0_CLIENT_SECRET`
    * Un fichier `.auth0.app.json` généré par l’Auth0 CLI

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

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

  <Accordion title="Erreur 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. Assurez-vous d’avoir exécuté `php artisan vendor:publish --tag auth0`
    2. Vérifiez que la découverte automatique des packages 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 des routes sont manquantes, 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 utilisateur">
    Vous pouvez mettre à jour les informations utilisateur à l’aide de l’[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 via 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 au [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 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 offerte dans la [documentation du SDK](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md).
  </Accordion>

  <Accordion title="Modèles utilisateur personnalisés et repositories">
    Le SDK prend en charge les modèles utilisateur personnalisés et les repositories, ce qui vous permet de stocker et de récupérer des 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 complet de mise en œuvre.
  </Accordion>

  <Accordion title="Écoute des événements du SDK">
    Le SDK déclenche des événements à des moments clés du cycle de vie de l’authentification — à la connexion, à la déconnexion, à l’actualisation du token, et plus encore — ce qui vous permet de personnaliser entièrement son 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 de mise en œuvre.
  </Accordion>

  <Accordion title="Role-Based Access Control (RBAC)">
    Utilisez Auth0 RBAC pour attribuer des permissions aux utilisateurs par l’intermédiaire de rôles, puis les appliquer 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 RBAC :

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

    Consultez [Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac) pour le guide complet.
  </Accordion>
</AccordionGroup>

***

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

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

* [Auth0 Dashboard](https://manage.auth0.com/) — Configurez et gérez votre tenant Auth0 et vos applications
* [laravel-auth0 SDK](https://github.com/auth0/laravel-auth0) — Documentation complète du SDK et intégrations avancées
* [Role-Based Access Control](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