mintlify__docs/fr/deploy/authentication-setup.mdx

---
title: "Configuration de l'authentification"
description: "Configurez l'authentification pour contrôler l'accès aux pages et références d'API avec mot de passe, OAuth, JWT ou accès privé géré par Mintlify."
keywords: ['authentication', 'auth', 'OAuth', 'JWT', 'password', 'private']
---

<Info>
  L'authentification privée pour votre organisation Mintlify est disponible sur toutes les offres.

  L'authentification par mot de passe nécessite une [offre Pro ou Enterprise](https://mintlify.com/pricing?ref=authentication).

  L'authentification OAuth et JWT nécessite une [offre Enterprise](https://mintlify.com/pricing?ref=authentication).
</Info>

L’authentification exige que les utilisateurs se connectent avant d’accéder à votre contenu.

Vous pouvez configurer une authentification complète pour toutes les pages ou une authentification partielle où certaines pages sont publiques et d'autres nécessitent une authentification.

L'authentification n'est disponible que pour les sites hébergés sur un domaine personnalisé ou un sous-domaine Mintlify. Par exemple, `docs.exemple.com` ou `exemple.mintlify.site`. L'authentification **n'est pas prise en charge** pour les sites avec un [sous-chemin personnalisé](/fr/deploy/docs-subpath). Par exemple, `exemple.com/docs`.

Pour identifier les visiteurs tout en gardant les pages publiques, utilisez la [personnalisation](/fr/create/personalization). La personnalisation prend en charge les sous-chemins personnalisés et peut préremplir les entrées du bac à sable d'API sans obliger les visiteurs à s'authentifier avant de consulter une page.

<div id="choose-an-authentication-method">
  ## Choisir une méthode d'authentification
</div>

Utilisez ce comparatif pour choisir la méthode adaptée à votre cas d'usage. Consultez [Disponibilité des fonctionnalités](#feature-availability) pour savoir comment chaque méthode interagit avec les autres fonctionnalités de Mintlify.

| Méthode | Idéal pour | Offre | Accès basé sur les groupes | Pré-remplissage du bac à sable d'API | Personnalisation |
| :--- | :--- | :--- | :---: | :---: | :---: |
| Password | Accès partagé simple sans suivi par utilisateur | Pro ou Enterprise | — | — | — |
| Private authentication | Documentation interne pour les membres de votre organisation Mintlify | Toutes les offres | — | — | — |
| OAuth 2.0 | Fournisseur d'identité existant ou SSO avec sessions par utilisateur | Enterprise | ✓ | ✓ | ✓ |
| JWT | Backend d'authentification personnalisé ou documentation intégrée derrière votre propre connexion | Enterprise | ✓ | ✓ | ✓ |

<div id="configure-authentication">
  ## Configurer l’authentification
</div>

<Tabs>
  <Tab title="Mot de passe">
    <Info>
      L'authentification par mot de passe fournit uniquement un contrôle d'accès et ne prend **pas** en charge les fonctionnalités spécifiques aux utilisateurs comme le contrôle d'accès basé sur les groupes ou le pré-remplissage du bac à sable d’API.
    </Info>

    <div id="password-prerequisites">
      ### Prérequis du mot de passe
    </div>

    * Vos exigences de sécurité autorisent le partage de mots de passe entre les utilisateurs.

    <div id="password-setup">
      ### Configuration du mot de passe
    </div>

    <Steps>
      <Step title="Créer un mot de passe.">
        1. Dans votre Dashboard, accédez à [Authentication](https://dashboard.mintlify.com/products/authentication).
        2. Dans la section **Authentication method**, définissez la visibilité du site sur **Private**.
        3. Cliquez sur **Password**.
        4. Saisissez un mot de passe sécurisé.
        5. Cliquez sur **Save changes**.

        Après avoir enregistré, votre site est redéployé. Une fois le déploiement terminé, toute personne visitant votre site doit entrer le mot de passe pour accéder à votre contenu.
      </Step>

      <Step title="Distribuer l'accès.">
        Partagez de manière sécurisée le mot de passe et l'URL de la documentation avec les utilisateurs autorisés.
      </Step>
    </Steps>

    <div id="password-example">
      ### Exemple de mot de passe
    </div>

    Vous hébergez votre documentation sur `docs.foo.com` et vous avez besoin d'un contrôle d'accès de base sans suivi des utilisateurs individuels. Vous voulez empêcher l'accès public tout en gardant la configuration simple.

    **Créez un mot de passe robuste** dans votre Dashboard. **Partagez les identifiants de connexion** avec les utilisateurs autorisés.
  </Tab>

  <Tab title="Authentification privée">
    <div id="private-authentication-prerequisites">
      ### Prérequis de l’authentification privée
    </div>

    * Toutes les personnes qui doivent accéder à votre site doivent être membres de votre organisation Mintlify.

    <div id="private-authentication-setup">
      ### Configuration de l’authentification privée
    </div>

    <Steps>
      <Step title="Activer l’authentification privée.">
        1. Dans votre Dashboard, accédez à [Authentication](https://dashboard.mintlify.com/products/authentication).
        2. Dans la section **Authentication method**, définissez la visibilité du site sur **Private**.
        3. Cliquez sur **Authenticated**.
        4. Cliquez sur **Save changes**.

        Après avoir enregistré, votre site est redéployé. Lorsque le déploiement est terminé, toute personne qui visite votre site doit se connecter à votre organisation Mintlify pour accéder à votre contenu.
      </Step>

      <Step title="Ajouter des utilisateurs autorisés.">
        1. Dans votre Tableau de bord Mintlify, allez à [Members](https://dashboard.mintlify.com/settings/organization/members).
        2. Ajoutez chaque personne qui doit avoir accès à votre documentation.
        3. Attribuez des rôles appropriés en fonction de leurs droits de modification.
      </Step>
    </Steps>

    <div id="private-example">
      ### Exemple d’authentification privée
    </div>

    Vous hébergez votre documentation sur `docs.foo.com` et toute votre équipe a accès à votre Tableau de bord Mintlify. Vous souhaitez restreindre l’accès aux seuls membres de l’équipe.

    **Activez l’authentification privée** dans les paramètres de votre Tableau de bord Mintlify.

    **Vérifiez l’accès de l’équipe** en vous assurant que tous les membres de l’équipe sont actifs dans votre organisation.
  </Tab>

  <Tab title="OAuth 2.0">
    <div id="oauth-20-prerequisites">
      ### Prérequis OAuth 2.0
    </div>

    * Un serveur OAuth ou OIDC qui prend en charge le flux Authorization Code (Authorization Code Flow).
    * Capacité à créer un endpoint d'API accessible via des jetons d'accès OAuth (facultatif, pour activer le contrôle d'accès basé sur les groupes).

    <div id="oauth-20-setup">
      ### Configuration OAuth 2.0
    </div>

    <Steps>
      <Step title="Configurez vos paramètres OAuth.">
        1. Dans votre Dashboard, allez dans [Authentication](https://dashboard.mintlify.com/products/authentication).
        2. Dans la section **Authentication method**, définissez la visibilité du site sur **Private**.
        3. Cliquez sur **Custom**.
        4. Cliquez sur **OAuth**.
        5. Configurez les champs suivants :

        * **Authorization URL** : Votre endpoint OAuth.
        * **Client ID** : Votre identifiant client OAuth 2.0.
        * **Client Secret** : Votre secret client OAuth 2.0.
        * **Scopes** (facultatif) : Autorisations à demander. Copiez la chaîne de scope **entière** (par exemple, pour un scope comme `provider.users.docs`, copiez l’intégralité de `provider.users.docs`). Utilisez plusieurs scopes si vous avez besoin de niveaux d’accès différents.
        * **Additional authorization parameters** (facultatif) : Paramètres de requête supplémentaires à ajouter à la requête d’autorisation initiale.
        * **Token URL** : Votre endpoint d’échange de jeton OAuth.
        * **Info API URL** (facultatif) : Endpoint sur votre serveur que Mintlify appelle pour récupérer les informations utilisateur. Utilisez ce champ pour l’approche Info API du contrôle d’accès basé sur les groupes. Vous pouvez également utiliser les claims des jetons OAuth. Si aucune de ces options n’est configurée, le flux OAuth vérifie uniquement l’identité.
        * **Logout URL** (facultatif) : L’URL de déconnexion native de votre fournisseur OAuth. Lorsque les utilisateurs se déconnectent, Mintlify valide la redirection de déconnexion par rapport à l’URL configurée, pour des raisons de sécurité. La redirection ne réussit que si elle correspond exactement à la valeur de `logoutUrl` configurée. Si vous ne configurez pas d’URL de déconnexion, les utilisateurs sont redirigés vers `/login`. Mintlify redirige les utilisateurs avec une requête `GET` et n’ajoute aucun paramètre de requête. Incluez donc directement tous les paramètres (par exemple, `returnTo`) dans l’URL.
        * **Redirect URL** (facultatif) : L’URL vers laquelle rediriger les utilisateurs après l’authentification.

        6. Cliquez sur **Enregistrer les modifications**.

        Une fois vos paramètres OAuth configurés, votre site est redéployé. Quand le déploiement est terminé, toute personne qui visite votre site doit se connecter à votre fournisseur OAuth pour accéder à votre contenu.
      </Step>

      <Step title="Configurez votre serveur OAuth.">
        1. Copiez la **Redirect URL** à partir de vos [paramètres d’authentification](https://dashboard.mintlify.com/products/authentication).
        2. Ajoutez cette URL de redirection comme URL de redirection autorisée pour votre serveur OAuth.
      </Step>

      <Step title="Créez votre endpoint d’informations utilisateur pour l’accès basé sur les groupes (facultatif).">
        Pour utiliser l’approche Info API du contrôle d’accès basé sur les groupes, créez un endpoint d’API qui :

        * Répond aux requêtes `GET`.
        * Accepte un en-tête `Authorization: Bearer <access_token>` pour l’authentification.
        * Renvoie les données utilisateur au format `User`. Voir [User data format](#user-data-format) pour plus d’informations.

        Mintlify appelle cet endpoint avec le jeton d’accès OAuth pour récupérer les informations utilisateur. Aucun paramètre de requête supplémentaire n’est envoyé.

        Ajoutez l’URL de cet endpoint dans le champ **Info API URL** de vos [paramètres d’authentification](https://dashboard.mintlify.com/products/authentication).
      </Step>
    </Steps>

    <div id="use-groups-from-oauth-token-claims">
      ### Utiliser les groupes issus des claims des jetons OAuth
    </div>

    Si votre fournisseur d’identité inclut l’appartenance aux groupes dans l’ID token ou l’access token, vous pouvez utiliser ces claims à la place d’une URL Info API. Cette option est disponible pour les configurations OAuth qui utilisent un secret client.

    Lors de la configuration des claims des jetons OAuth pour votre déploiement, utilisez des valeurs telles que :

    ```json
    {
      "source": "id_token",
      "groupsClaim": "groups",
      "groupsDelimiter": ","
    }
    ```

    * `source` : Sélectionne `id_token` ou `access_token`. Si vous sélectionnez `id_token`, incluez le scope `openid` dans vos scopes OAuth.
    * `groupsClaim` : Identifie le claim du token qui contient les groupes. Sa valeur par défaut est `groups`.
    * `groupsDelimiter` : Délimiteur facultatif de 1 à 4 caractères. Mintlify l’utilise uniquement pour diviser les valeurs de claim qui sont des chaînes.

    Par exemple, avec `"groups": "general,clienta_eur"` et `groupsDelimiter` défini sur `","`, Mintlify utilise `general` et `clienta_eur` comme groupes distincts.

    Mintlify supprime les espaces autour de chaque groupe et ignore les segments vides. Sans `groupsDelimiter`, la chaîne complète est traitée comme un seul groupe. Chaque élément de type chaîne d’un claim sous forme de tableau est traité comme un groupe distinct et n’est pas divisé.

    Omettez `groupsDelimiter` lorsque le délimiteur peut faire partie du nom d’un groupe.

    <div id="oauth-20-example">
      ### Exemple OAuth 2.0
    </div>

    Vous hébergez votre documentation sur `docs.foo.com` et vous disposez d’un serveur OAuth existant sur `auth.foo.com` qui prend en charge le flux « Authorization Code ».

    **Configurez les détails de votre serveur OAuth** dans votre Dashboard :

    * **Authorization URL** : `https://auth.foo.com/authorization`
    * **Client ID** : `ydybo4SD8PR73vzWWd6S0ObH`
    * **Scopes** : `['provider.users.docs']`
    * **Token URL** : `https://auth.foo.com/exchange`
    * **Info API URL** : `https://api.foo.com/docs/user-info`
    * **Logout URL** : `https://auth.foo.com/logout?returnTo=https%3A%2F%2Fdocs.foo.com`

    **Créez un endpoint d’informations utilisateur** à `api.foo.com/docs/user-info`, qui requiert un jeton d’accès OAuth avec le scope `provider.users.docs`, et renvoie :

    ```json
    {
      "groups": ["engineering", "admin"],
      "expiresAt": 1893456000,
      "apiPlaygroundInputs": {
        "header": {
          "Authorization": "Bearer user_abc123"
        }
      }
    }
    ```

    <Note>
      Contrôlez la durée de la session avec le champ `expiresAt` dans votre réponse d'informations utilisateur. Il s'agit d'un horodatage Unix (en secondes depuis l'époque Unix) indiquant quand la session doit expirer. Consultez le [format des données utilisateur](#user-data-format) pour plus de détails.
    </Note>

    **Configurez votre serveur OAuth pour autoriser les redirections** vers votre URL de rappel.
  </Tab>

  <Tab title="JWT">
    <div id="jwt-prerequisites">
      ### Prérequis JWT
    </div>

    * Un système d'authentification capable de générer et de signer des JWT.
    * Un service backend capable de créer des URL de redirection.

    <div id="jwt-setup">
      ### Configuration JWT
    </div>

    <Steps>
      <Step title="Générez une clé privée.">
        1. Dans votre Dashboard, accédez à [Authentication](https://dashboard.mintlify.com/products/authentication).
        2. Dans la section **Authentication method**, définissez la visibilité du site sur **Private**.
        3. Cliquez sur **Custom**.
        4. Cliquez sur **JWT**.
        5. Saisissez l’URL de votre flux de connexion existant.
        6. Pour proposer plusieurs flux de connexion, cliquez sur **Add login URL** et saisissez un nom d’affichage et une URL pour chaque option. Vous pouvez configurer jusqu’à 10 URL de connexion.
        7. Cliquez sur **Enregistrer les modifications**.
        8. Cliquez sur **Générer une nouvelle clé**.
        9. Stockez votre clé en toute sécurité, là où votre backend peut y accéder.

        Après avoir généré une clé privée, votre site est redéployé. Une fois le déploiement terminé, toute personne qui visite votre site doit se connecter à votre système d’authentification JWT pour accéder à votre contenu.
      </Step>

      <Step title="Intégrez l’authentification Mintlify dans votre flux de connexion.">
        Modifiez votre flux de connexion existant pour inclure ces étapes après l’authentification de l’utilisateur :

        * Créez un JWT contenant les informations de l’utilisateur authentifié au format `User`. Voir [Format des données utilisateur](#user-data-format) pour plus d’informations.
        * Signez le JWT avec votre clé secrète, en utilisant l’algorithme EdDSA.
        * Créez une URL de redirection vers le chemin `/login/jwt-callback` de votre documentation, en incluant le JWT comme hash.
      </Step>
    </Steps>

    Lorsque l'authentification JWT n'a qu'une seule URL de connexion, les visiteurs non authentifiés y sont automatiquement redirigés. Avec au moins deux URL de connexion nommées, les visiteurs voient d'abord une page de sélection puis poursuivent vers le flux de connexion choisi. Mintlify transmet le paramètre `redirect` validé afin que le visiteur revienne à la page de documentation qu'il avait initialement demandée.

    <Note>
      Les URL de connexion multiples sont disponibles pour l'authentification JWT complète et partielle. La [personnalisation](/fr/create/personalization) JWT accepte une seule URL de connexion, car elle identifie les visiteurs sans exiger de connexion avant qu'ils puissent consulter le contenu public.
    </Note>

    <div id="jwt-example">
      ### Exemple JWT
    </div>

    Vous hébergez votre documentation sur `docs.foo.com` avec un système d'authentification existant sur `foo.com`. Vous voulez étendre votre flux de connexion pour accorder l'accès à la documentation tout en gardant votre documentation séparée de votre Dashboard (ou vous n'avez pas de Dashboard).

    Créez un point de terminaison de connexion à `https://foo.com/docs-login` qui étend votre authentification existante.

    Après vérification des identifiants de l'utilisateur :

    * Générez un JWT avec les données utilisateur au format de Mintlify.
    * Signez le JWT et redirigez vers `https://docs.foo.com/login/jwt-callback#{SIGNED_JWT}`.

    <CodeGroup>
      ```ts TypeScript
      import * as jose from 'jose';
      import { Request, Response } from 'express';

      const TWO_WEEKS_IN_MS = 1000 * 60 * 60 * 24 * 7 * 2;
      const DOCS_HOST = 'docs.example.com';

      const signingKey = await jose.importPKCS8(process.env.MINTLIFY_PRIVATE_KEY, 'EdDSA');

      export async function handleRequest(req: Request, res: Response) {
        const user = {
          host: DOCS_HOST, // Doit correspondre à l'URL de votre documentation
          expiresAt: Math.floor((Date.now() + TWO_WEEKS_IN_MS) / 1000), // expiration de session de 2 semaines
          groups: res.locals.user.groups,
          apiPlaygroundInputs: {
            header: {
              "Authorization": `Bearer ${res.locals.user.apiKey}`,
            },
          },
        };

        const jwt = await new jose.SignJWT(user)
          .setProtectedHeader({ alg: 'EdDSA' })
          .setExpirationTime('10 s') // expiration du JWT de 10 secondes
          .sign(signingKey);

        return res.redirect(`https://${DOCS_HOST}/login/jwt-callback#${jwt}`);
      }
      ```

      ```python Python
      import jwt # pyjwt
      import os

      from datetime import datetime, timedelta
      from fastapi.responses import RedirectResponse

      private_key = os.getenv(MINTLIFY_JWT_PEM_SECRET_NAME, '')
      DOCS_HOST = 'docs.example.com'

      @router.get('/auth')
      async def return_mintlify_auth_status(current_user):
        jwt_token = jwt.encode(
          payload={
            'host': DOCS_HOST, # Doit correspondre à l'URL de votre documentation
            'exp': int((datetime.now() + timedelta(seconds=10)).timestamp()),    # expiration du JWT de 10 secondes
            'expiresAt': int((datetime.now() + timedelta(weeks=2)).timestamp()), # expiration de session de 2 semaines
            'groups': ['admin'] if current_user.is_admin else [],
            'apiPlaygroundInputs': {
              'header': {
                'Authorization': f'Bearer {current_user.api_key}',
              },
            },
          },
          key=private_key,
          algorithm='EdDSA'
        )

        return RedirectResponse(url=f'https://{DOCS_HOST}/login/jwt-callback#{jwt_token}', status_code=302)
      ```
    </CodeGroup>

    <div id="redirect-unauthenticated-users">
      ### Rediriger les utilisateurs non authentifiés
    </div>

    Lorsqu'un utilisateur non authentifié tente d'accéder à une page protégée, la redirection vers votre URL de connexion préserve la destination souhaitée par l'utilisateur.

    1. L’utilisateur tente de visiter une page protégée : `https://docs.foo.com/quickstart`.
    2. Redirection vers votre URL de connexion avec un paramètre de requête `redirect` : `https://foo.com/docs-login?redirect=%2Fquickstart`.
    3. Après l’authentification, redirection vers `https://docs.foo.com/login/jwt-callback?redirect=%2Fquickstart#{SIGNED_JWT}`.
    4. L’utilisateur arrive à sa destination d’origine.
  </Tab>
</Tabs>

<div id="make-pages-public">
  ## Rendre des pages publiques
</div>

Lorsque vous utilisez l’authentification, toutes les pages nécessitent par défaut une authentification pour y accéder. Vous pouvez autoriser l’accès à certaines pages sans authentification, au niveau de la page ou du groupe, à l’aide de la propriété `public`.

<div id="individual-pages">
  ### Pages individuelles
</div>

Pour rendre une page publique, ajoutez `public: true` au frontmatter de la page.

```mdx Public page example
---
title: "Page publique"
public: true
---
```

<div id="groups-of-pages">
  ### Groupes de pages
</div>

Pour rendre toutes les pages d’un groupe publiques, ajoutez "public": true sous le nom du groupe dans l’objet `navigation` de votre `docs.json`.

```json Public group example
{
  "navigation": {
    "groups": [
      {
        "group": "Groupe public",
        "public": true,
        "icon": "play",
        "pages": [
          "quickstart",
          "installation",
          "settings"
        ]
      },
      {
        "group": "Groupe privé",
        "icon": "pause",
        "pages": [
          "private-information",
          "secret-settings"
        ]
      }
    ]
  }
}
```

<div id="control-access-with-groups">
  ## Contrôler l’accès avec des groupes
</div>

Lorsque vous utilisez l’authentification OAuth ou des JWT (JSON Web Tokens), vous pouvez restreindre certaines pages à des groupes d’utilisateurs spécifiques. C’est utile si vous souhaitez que différents utilisateurs voient des contenus différents selon leur rôle ou leurs attributs.

Gérez les groupes via les données utilisateur transmises lors de l’authentification. Voir [Format des données utilisateur](#user-data-format) pour plus de détails.

```json Example user info
{
  "groups": ["admin", "beta-users"],
  "expiresAt": 1893456000
}
```

Indiquez quels groupes peuvent accéder à des pages spécifiques à l’aide de la propriété `groups` dans le frontmatter.

```mdx Example page restricted to the admin group highlight={3}
---
title: "Dashboard administrateur"
groups: ["admin"]
---
```

Les utilisateurs doivent appartenir à au moins un des groupes répertoriés pour accéder à la page. Si un utilisateur tente d’accéder à une page sans le groupe requis, il recevra une erreur 404.

<div id="how-groups-interact-with-public-pages">
  ### Fonctionnement des groupes avec les pages publiques
</div>

* Par défaut, toutes les pages nécessitent une authentification.
* Les pages comportant une propriété `groups` ne sont accessibles qu’aux utilisateurs authentifiés appartenant à ces groupes.
* Les pages sans propriété `groups` sont accessibles à tous les utilisateurs authentifiés.
* Les pages avec `public: true` et sans propriété `groups` sont accessibles à tout le monde.

<CodeGroup>
  ```mdx Page publique
  ---
  title: "Guide public"
  public: true
  ---
  ```

  ```mdx Page protégée
  ---
  title: "Référence API"
  ---
  ```

  ```mdx Page protégée avec groupes
  ---
  title: "Configurations avancées"
  groups: ["pro", "enterprise"]
  ---
  ```
</CodeGroup>

<div id="user-data-format">
  ## Format des données utilisateur
</div>

Lorsque vous utilisez l’authentification OAuth ou JWT, ou la personnalisation autonome, votre système renvoie des données utilisateur qui contrôlent la durée de la session et l’appartenance à des groupes, ainsi que la [personnalisation du contenu](/fr/create/personalization).

<CodeGroup>
  ```tsx Format
  type User = {
    host?: string;
    expiresAt?: number;
    groups?: string[];
    content?: Record<string, any>;
    apiPlaygroundInputs?: {
      server?: Record<string, string>;
      header?: Record<string, unknown>;
      query?: Record<string, unknown>;
      cookie?: Record<string, unknown>;
      path?: Record<string, unknown>;
    };
  };
  ```

  ```json Example
  {
    "host": "docs.example.com",
    "expiresAt": 1893456000,
    "groups": ["admin", "beta-users"],
    "content": {
      "firstName": "Jane",
      "company": "Acme Corp"
    },
    "apiPlaygroundInputs": {
      "header": {
        "Authorization": "Bearer user_abc123"
      },
      "server": {
        "baseUrl": "https://api.foo.com"
      }
    }
  }
  ```
</CodeGroup>

<ParamField path="host" type="string">
  **Requis pour l’authentification JWT.** Le nom d’hôte de votre site de documentation. La chaîne doit correspondre exactement au domaine sur lequel vous déployez votre documentation. Mintlify valide que l’hôte du JWT correspond à l’hôte de la requête afin d’empêcher la réutilisation du jeton sur différents sites.
</ParamField>

<ParamField path="expiresAt" type="number">
  Heure d’expiration de la session, en secondes depuis l’époque Unix. Lorsque l’heure actuelle dépasse cette valeur, Mintlify expire les données utilisateur stockées. Le visiteur doit alors s’authentifier à nouveau ou répéter le flux d’identification pour les actualiser.

  <Warning>**Pour les JWT :** cela diffère de la revendication `exp` d’un JWT, qui détermine le moment où un JWT est considéré comme invalide. Par mesure de sécurité, définissez la revendication `exp` du JWT sur une durée courte (10 secondes ou moins). Utilisez `expiresAt` pour la durée réelle de la session (de quelques heures à plusieurs semaines).</Warning>
</ParamField>

<ParamField path="groups" type="string[]">
  Liste des groupes auxquels l’utilisateur appartient. Avec l’authentification, les pages dont le frontmatter contient un `groups` correspondant sont accessibles à cet utilisateur. Avec la personnalisation autonome, les groupes contrôlent la visibilité des pages et du contenu, mais ne restreignent pas l’accès à l’URL directe d’une page.

  **Exemple** : Un utilisateur avec `groups: ["admin", "engineering"]` correspond aux contenus étiquetés avec les groupes `admin` ou `engineering`.
</ParamField>

<ParamField path="content" type="Record<string, any>">
  Données personnalisées accessibles dans les pages MDX via la variable `user` pour le [contenu personnalisé](/fr/create/personalization#dynamic-mdx-content).
</ParamField>

<ParamField path="apiPlaygroundInputs" type="object">
  Préremplit les champs du bac à sable d’API avec des valeurs propres à l’utilisateur. Lorsqu’un utilisateur s’authentifie, ces valeurs renseignent les champs de saisie correspondants dans le bac à sable d’API. Les utilisateurs peuvent remplacer les valeurs préremplies, et leurs remplacements sont conservés dans le stockage local.

  Mintlify n'applique que les valeurs qui correspondent au schéma de sécurité du point de terminaison actuel.

  <Expandable title="propriétés">
    <ParamField path="header" type="Record<string, unknown>">
      Valeurs d’en-tête à préremplir, indexées par nom d’en-tête.
    </ParamField>

    <ParamField path="query" type="Record<string, unknown>">
      Valeurs de paramètres de requête à préremplir, indexées par nom de paramètre.
    </ParamField>

    <ParamField path="cookie" type="Record<string, unknown>">
      Valeurs de cookie à préremplir, indexées par nom de cookie.
    </ParamField>

    <ParamField path="server" type="Record<string, string>">
      Valeurs de variables de serveur à préremplir, indexées par nom de variable.
    </ParamField>

    <ParamField path="path" type="Record<string, unknown>">
      Valeurs de paramètres de chemin à préremplir, indexées par nom de paramètre.
    </ParamField>
  </Expandable>
</ParamField>

<div id="feature-availability">
  ## Disponibilité des fonctionnalités
</div>

Certaines fonctionnalités se comportent différemment ou ne sont pas disponibles lorsque vous activez l’authentification. Mintlify ne prend pas en charge l’hébergement de fichiers publics arbitraires sur un site authentifié. Tous les fichiers hébergés, y compris `llms.txt`, `llms-full.txt` et `skill.md`, sont soumis aux mêmes exigences d’authentification que vos pages de documentation.

| Fonctionnalité                                           | Public                   | Entièrement authentifié (toutes les pages protégées)                                                 | Partiellement authentifié (certaines pages publiques)                                                       |
| :------------------------------------------------------- | :----------------------- | :--------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------- |
| [llms.txt and llms-full.txt](/fr/ai/llmstxt)                | Prise en charge complète | Disponible derrière l’authentification, les outils d’IA peuvent donc ne pas avoir accès aux fichiers | Disponible derrière l’authentification, les outils d’IA peuvent donc ne pas avoir accès aux fichiers |
| [MCP server](/fr/ai/model-context-protocol)                 | Prise en charge complète | Nécessite une authentification pour se connecter                                                     | Disponible sans authentification pour les pages publiques et avec authentification pour les pages protégées |
| [Markdown export](/fr/ai/markdown-export)                   | Prise en charge complète | Prise en charge complète, respecte les groupes d’utilisateurs                                        | Prise en charge complète, respecte les groupes d’utilisateurs                                               |
| [Export PDF](/fr/optimize/pdf-exports)                      | Prise en charge complète | Prise en charge complète, respecte les groupes d'utilisateurs. Les pages authentifiées sont exportées avec les images et les ressources incluses. | Prise en charge complète, respecte les groupes d'utilisateurs. Les pages authentifiées sont exportées avec les images et les ressources incluses. |
| [Search](/fr/assistant/index)                                  | Prise en charge complète | Prise en charge complète, respecte les groupes d’utilisateurs                                        | Prise en charge complète, respecte les groupes d’utilisateurs                                               |
| [Assistant](/fr/assistant/index)                               | Prise en charge complète | Prise en charge complète, respecte les groupes d’utilisateurs                                        | Prise en charge complète, respecte les groupes d’utilisateurs                                               |
| [skill.md](/fr/ai/skillmd)                                  | Prise en charge complète | Non pris en charge                                                                                   | Non pris en charge                                                                                          |
| [Sitemap](/fr/optimize/seo#sitemaps-and-robotstxt-files)    | Prise en charge complète | Disponible derrière l’authentification, mais exclut les pages dans des groupes                       | Disponible derrière l’authentification, mais exclut les pages dans des groupes                              |
| [robots.txt](/fr/optimize/seo#sitemaps-and-robotstxt-files) | Prise en charge complète | Disponible derrière l’authentification                                                               | Disponible derrière l’authentification                                                                      |
| [Aperçu en direct](/fr/editor/review#live-preview)                 | Prise en charge complète | Pris en charge avec authentification automatique de l’éditeur                                        | Pris en charge avec authentification automatique de l’éditeur                                               |