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

# Ajoutez la fonction de connexion à votre application .NET Android et iOS

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

<HowToSchema />

<Accordion title="Utilisez l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de codage par IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide d’[Agent Skills](https://agentskills.io/home).

  **Installation :**

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

  **Demandez ensuite à votre assistant IA :**

  ```text theme={null}
  Add Auth0 authentication to my .NET Android & iOS app
  ```

  Votre assistant IA créera automatiquement votre application Auth0, récupérera les identifiants, installera le SDK Auth0 OidcClient, configurera les paramètres propres à chaque plateforme et implémentera les flux de connexion et de déconnexion. [Documentation complète sur Agent Skills →](/docs/fr-ca/quickstart/agent-skills)
</Accordion>

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

<Steps>
  <Step title="Créer un nouveau projet .NET" stepNumber={1}>
    Créez un projet .NET MAUI ou .NET Android/iOS pour ce Quickstart.

    <Tabs>
      <Tab title=".NET MAUI">
        **Dans Visual Studio 2022 ou une version ultérieure :**

        1. **File** → **New** → **Project**
        2. Sélectionnez le modèle **.NET MAUI App**
        3. Configurez votre projet :
           * **Project name** : `Auth0MauiSample`
           * **Location** : Choisissez l’emplacement de votre choix
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Create**
      </Tab>

      <Tab title=".NET Android">
        **Dans Visual Studio 2022 ou une version ultérieure :**

        1. **File** → **New** → **Project**
        2. Sélectionnez le modèle **Android App (.NET)**
        3. Configurez votre projet :
           * **Project name** : `Auth0AndroidSample`
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Create**
      </Tab>

      <Tab title=".NET iOS">
        **Dans Visual Studio 2022 (Mac) ou Visual Studio for Mac :**

        1. **File** → **New** → **Project**
        2. Sélectionnez le modèle **iOS App (.NET)**
        3. Configurez votre projet :
           * **Project name** : `Auth0iOSSample`
           * **Framework** : **.NET 8.0 ou version ultérieure**
        4. Cliquez sur **Create**
      </Tab>
    </Tabs>

    <Info>
      Ce Quickstart porte sur .NET Android et iOS, la nouvelle génération de Xamarin.Android et Xamarin.iOS. Si vous utilisez encore Xamarin, vous pouvez suivre ce guide, car l’intégration est identique et les SDKs sont compatibles.
    </Info>
  </Step>

  <Step title="Installer le SDK Auth0" stepNumber={2}>
    Ajoutez le SDK Auth0 OIDC Client à votre projet.

    <Tabs>
      <Tab title="Console du gestionnaire de packages">
        Ouvrez la console du gestionnaire de packages (**View** → **Other Windows** → **Package Manager Console**) et installez le package approprié :

        **Pour .NET Android :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.AndroidX
        ```

        **Pour .NET iOS :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.iOS
        ```

        **Pour .NET MAUI (les deux plateformes) :**

        ```bash Package Manager Console theme={null}
        Install-Package Auth0.OidcClient.MAUI
        ```
      </Tab>

      <Tab title="Visual Studio pour Mac">
        1. Dans le **Solution Pad**, faites un Ctrl+clic (ou un clic droit) sur le dossier **Packages**
        2. Sélectionnez **Add Packages...**
        3. Recherchez :
           * `Auth0.OidcClient.AndroidX` pour Android
           * `Auth0.OidcClient.iOS` pour iOS
           * `Auth0.OidcClient.MAUI` pour les projets MAUI
        4. Sélectionnez le package, puis cliquez sur **Add Package**
      </Tab>

      <Tab title=".NET CLI">
        Exécutez la commande suivante dans le répertoire de votre projet :

        **Pour .NET Android :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.AndroidX
        ```

        **Pour .NET iOS :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.iOS
        ```

        **Pour .NET MAUI :**

        ```bash Terminal theme={null}
        dotnet add package Auth0.OidcClient.MAUI
        ```
      </Tab>
    </Tabs>

    <Tip>
      Le SDK Auth0 OIDC Client prend en charge tous les détails du protocole OAuth 2.0 et d’OIDC, et fournit une API simple pour l’authentification.
    </Tip>
  </Step>

  <Step title="Configurez votre Auth0 App" stepNumber={3}>
    Créez une nouvelle application dans votre tenant Auth0 et configurez-la pour le mobile.

    1. Accédez à l’[Auth0 Dashboard](https://manage.auth0.com/dashboard/)
    2. Cliquez sur **Applications** → **Applications** → **Create Application**
    3. Saisissez un nom pour votre application, sélectionnez **Native** comme type d’application, puis cliquez sur **Create**
    4. Allez à l’onglet **Settings** dans la page Details de l’application
    5. Prenez en note votre **Domain** et votre **Client ID** — vous en aurez besoin à l’étape suivante

    **Configurer les URL de rappel :**

    Dans l’onglet **Settings**, ajoutez les URL suivantes :

    **Allowed Callback URLs :**

    <Tabs>
      <Tab title="Android">
        ```
        YOUR_ANDROID_PACKAGE_NAME://{yourDomain}/android/YOUR_ANDROID_PACKAGE_NAME/callback
        ```

        Remplacez :

        * `YOUR_ANDROID_PACKAGE_NAME` par le nom du package de votre application (p. ex., `com.mycompany.myapp`)
        * `{yourDomain}` par votre domaine Auth0 (p. ex., `dev-abc123.us.auth0.com`)

        Exemple : `com.mycompany.myapp://dev-abc123.us.auth0.com/android/com.mycompany.myapp/callback`
      </Tab>

      <Tab title="iOS">
        ```
        YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
        ```

        Remplacez :

        * `YOUR_BUNDLE_IDENTIFIER` par l’identifiant du bundle de votre application (p. ex., `com.mycompany.myapp`)
        * `{yourDomain}` par votre domaine Auth0 (p. ex., `dev-abc123.us.auth0.com`)

        Exemple : `com.mycompany.myapp://dev-abc123.us.auth0.com/ios/com.mycompany.myapp/callback`
      </Tab>
    </Tabs>

    **Allowed Logout URLs :**

    Utilisez les mêmes URL que pour vos callback URLs.

    <Warning>
      Assurez-vous que les URL de rappel et de logout sont en **minuscules**. Si les URL ne correspondent pas, l’authentification échouera.
    </Warning>

    <Info>
      Les **Allowed Callback URLs** sont essentielles à la sécurité — elles garantissent que les utilisateurs sont redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera.

      Les **Allowed Logout URLs** assurent une expérience fluide lorsque les utilisateurs se déconnectent, en les redirigeant vers votre application plutôt que de les laisser sur une page Auth0.
    </Info>
  </Step>

  <Step title="Initialiser le client Auth0" stepNumber={4}>
    Créez une instance de `Auth0Client` pour communiquer avec Auth0.

    <Tabs>
      <Tab title="Android - MainActivity">
        ```cs MainActivity.cs lines theme={null}
        using Auth0.OidcClient;
        using Android.App;
        using Android.Content;

        [Activity(Label = "Auth0Sample", MainLauncher = true, Icon = "@drawable/icon",
            LaunchMode = LaunchMode.SingleTask)]
        [IntentFilter(
            new[] { Intent.ActionView },
            Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
            DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
            DataHost = "{yourDomain}",
            DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
        public class MainActivity : Activity
        {
            private Auth0Client auth0Client;

            protected override void OnCreate(Bundle savedInstanceState)
            {
                base.OnCreate(savedInstanceState);

                // Initialiser le client Auth0
                auth0Client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                }, this);
            }

            protected override async void OnNewIntent(Intent intent)
            {
                base.OnNewIntent(intent);
                Auth0.OidcClient.ActivityMediator.Instance.Send(intent.DataString);
            }
        }
        ```

        <Warning>
          Remplacez `YOUR_ANDROID_PACKAGE_NAME`, `{yourDomain}` et `{yourClientId}` par vos valeurs réelles. Assurez-vous que tout le texte dans `DataScheme`, `DataHost` et `DataPathPrefix` est en **minuscules**.
        </Warning>

        <Info>
          Le `IntentFilter` enregistre votre application pour qu’elle puisse gérer l’URL de rappel. `LaunchMode.SingleTask` garantit qu’Android ne crée pas de nouvelle instance d’activité lorsque le rappel est déclenché.
        </Info>
      </Tab>

      <Tab title="iOS - AppDelegate">
        Commencez par enregistrer le schéma d’URL dans votre `Info.plist` :

        ```xml Info.plist lines theme={null}
        <key>CFBundleURLTypes</key>
        <array>
            <dict>
                <key>CFBundleTypeRole</key>
                <string>None</string>
                <key>CFBundleURLName</key>
                <string>Auth0</string>
                <key>CFBundleURLSchemes</key>
                <array>
                    <string>YOUR_BUNDLE_IDENTIFIER</string>
                </array>
            </dict>
        </array>
        ```

        Ensuite, configurez votre `AppDelegate.cs` :

        ```cs AppDelegate.cs lines theme={null}
        using Auth0.OidcClient;
        using Foundation;
        using UIKit;

        [Register("AppDelegate")]
        public class AppDelegate : UIApplicationDelegate
        {
            private Auth0Client auth0Client;

            public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
            {
                // Initialiser le client Auth0
                auth0Client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                });

                return true;
            }

            public override bool OpenUrl(UIApplication application, NSUrl url,
                string sourceApplication, NSObject annotation)
            {
                ActivityMediator.Instance.Send(url.AbsoluteString);
                return true;
            }
        }
        ```

        <Warning>
          Remplacez `YOUR_BUNDLE_IDENTIFIER`, `{yourDomain}` et `{yourClientId}` par vos valeurs réelles.
        </Warning>
      </Tab>
    </Tabs>

    <Tip>
      Stockez votre domaine Auth0 et votre ID client dans un fichier de configuration ou dans les paramètres de l’application au lieu de les coder en dur, afin d’en faciliter la maintenance.
    </Tip>
  </Step>

  <Step title="Implémenter la connexion et la déconnexion" stepNumber={5}>
    Ajoutez des méthodes pour gérer l’authentification des utilisateurs.

    **Implement Login :**

    ```cs Authentication.cs lines theme={null}
    public async Task LoginAsync()
    {
        var loginResult = await auth0Client.LoginAsync();

        if (!loginResult.IsError)
        {
            // Authentification réussie
            var accessToken = loginResult.AccessToken;
            var idToken = loginResult.IdentityToken;
            var user = loginResult.User;

            // Stocker les identifiants et mettre à jour l'interface
            Console.WriteLine($"Logged in as: {user.FindFirst("name")?.Value}");
        }
        else
        {
            // Gérer l'erreur d'authentification
            Console.WriteLine($"Login error: {loginResult.Error}");
        }
    }
    ```

    **Implement Logout :**

    ```cs Authentication.cs lines theme={null}
    public async Task LogoutAsync()
    {
        var logoutResult = await auth0Client.LogoutAsync();

        if (logoutResult == BrowserResultType.Success)
        {
            // Effacer les informations d'identification stockées
            // Mettre à jour l'interface utilisateur vers l'état déconnecté
            Console.WriteLine("Logged out successfully");
        }
    }
    ```

    <Info>
      La méthode `LoginAsync()` lance le navigateur système (ou Chrome Custom Tabs sur Android) pour afficher la page Universal Login d’Auth0. Après l’authentification, l’utilisateur est redirigé vers votre application au moyen de l’URL de rappel.
    </Info>

    <Tip>
      Ajoutez ces méthodes à votre MainActivity (Android) ou à un ViewController (iOS), puis appelez-les quand les utilisateurs touchent aux boutons Login/Logout.
    </Tip>
  </Step>

  <Step title="Exécutez votre application" stepNumber={6}>
    Compilez et exécutez votre application.

    <Tabs>
      <Tab title="Visual Studio (Windows)">
        **Pour Android :**

        1. Sélectionnez un émulateur Android ou un appareil connecté dans la liste déroulante des appareils
        2. Appuyez sur **F5** ou cliquez sur le bouton **Run**
        3. L’application sera compilée, déployée et lancée

        **Pour iOS (nécessite un hôte de compilation Mac) :**

        1. Connectez-vous à votre hôte de compilation Mac
        2. Sélectionnez un simulateur iOS ou un appareil dans la liste déroulante des appareils
        3. Appuyez sur **F5** ou cliquez sur le bouton **Run**
      </Tab>

      <Tab title="Visual Studio for Mac">
        1. Sélectionnez votre plateforme cible (Android/iOS) dans la liste déroulante des appareils
        2. Sélectionnez un émulateur/simulateur ou un appareil connecté
        3. Appuyez sur **⌘+Return** ou cliquez sur le bouton **Run**
        4. L’application sera compilée et lancée
      </Tab>

      <Tab title=".NET CLI">
        **Pour Android :**

        ```bash Terminal theme={null}
        dotnet build -f net8.0-android
        dotnet run -f net8.0-android
        ```

        **Pour iOS :**

        ```bash Terminal theme={null}
        dotnet build -f net8.0-ios
        dotnet run -f net8.0-ios
        ```
      </Tab>
    </Tabs>

    **Déroulement prévu :**

    1. L’application s’ouvre avec un bouton Se connecter
    2. Touchez **Se connecter** → Le navigateur ou un onglet personnalisé Chrome s’ouvre → Terminez l’authentification
    3. Redirection automatique vers votre application
    4. L’utilisateur est authentifié avec succès

    <Tip>
      Au premier lancement, iOS peut vous demander de confirmer l’ouverture du navigateur pour l’authentification. Il s’agit d’un comportement normal et attendu.
    </Tip>
  </Step>
</Steps>

<Check>
  **Point de contrôle**

  Vous disposez maintenant d’une expérience de connexion Auth0 entièrement fonctionnelle dans votre application .NET Android ou iOS. L’application utilise le navigateur du système pour assurer une authentification sécurisée et gère automatiquement le flux de retour.
</Check>

***

<div id="access-user-information">
  ## Accéder aux renseignements de l’utilisateur
</div>

Après une authentification réussie, vous pouvez accéder aux renseignements de l’utilisateur dans le résultat de la connexion.

<div id="authentication-result">
  ### Résultat d’authentification
</div>

La méthode `LoginAsync()` renvoie un objet `LoginResult` contenant :

```cs UserInfo.cs lines theme={null}
var loginResult = await auth0Client.LoginAsync();

if (!loginResult.IsError)
{
    // Jetons d'accès
    var accessToken = loginResult.AccessToken;
    var idToken = loginResult.IdentityToken;
    var refreshToken = loginResult.RefreshToken;

    // Accéder aux claims de l'utilisateur
    var user = loginResult.User;
    var name = user.FindFirst("name")?.Value;
    var email = user.FindFirst("email")?.Value;
    var picture = user.FindFirst("picture")?.Value;

    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Email: {email}");
}
```

<div id="iterate-through-all-claims">
  ### Parcourir l’ensemble des claims
</div>

Pour voir toutes les informations utilisateur disponibles :

```cs UserClaims.cs lines theme={null}
if (!loginResult.IsError)
{
    foreach (var claim in loginResult.User.Claims)
    {
        Console.WriteLine($"{claim.Type}: {claim.Value}");
    }
}
```

<Info>
  Les claims renvoyés dépendent des scopes demandés. Pour en savoir plus, consultez [Utilisation des scopes](https://auth0.github.io/auth0-oidc-client-net/documentation/advanced-scenarios/scopes.html) dans la documentation d’Auth0 OIDC Client.
</Info>

<div id="request-custom-scopes">
  ### Demander des scopes personnalisés
</div>

Pour demander des renseignements supplémentaires sur l’utilisateur, précisez les scopes lors de la création de l’Auth0Client :

```cs CustomScopes.cs lines theme={null}
var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Scope = "openid profile email offline_access read:posts"
});
```

***

<div id="troubleshooting-advanced">
  ## Dépannage et options avancées
</div>

<Accordion title="Problèmes courants et solutions">
  ### Le navigateur ne redirige pas vers l’application

  **Solutions :**

  1. Vérifiez que les URL de rappel dans l’Auth0 Dashboard correspondent exactement au nom du package ou à l’identificateur de bundle de votre application
  2. Assurez-vous que les URL de rappel sont en **minuscules**
  3. Vérifiez que `DataScheme`, `DataHost` et `DataPathPrefix` (Android) ou le schéma d’URL (iOS) correspondent à votre configuration
  4. Nettoyez et regénérez votre projet

  ### L’authentication échoue avec l’erreur « Invalid Callback URL »

  **Correctif :**

  * Vérifiez de nouveau que votre URL de rappel dans l’Auth0 Dashboard respecte le format suivant :
    * Android: `packagename://yourdomain/android/packagename/callback`
    * iOS: `bundleidentifier://yourdomain/ios/bundleidentifier/callback`
  * Assurez-vous que l’URL est en minuscules
  * Vérifiez que le `Domain` dans votre code correspond au `Domain` dans l’Auth0 Dashboard

  ### LoginAsync() se bloque ou ne se termine jamais

  **Solutions :**

  * Assurez-vous que le filtre d’intention (Android) ou le schéma d’URL (iOS) est correctement configuré
  * Vérifiez que `OnNewIntent()` (Android) ou `OpenUrl()` (iOS) appelle `ActivityMediator`
  * Vérifiez que votre application peut ouvrir le navigateur système
  * Vérifiez la connectivité réseau

  ### Error : « Default App must use Token Endpoint Authentication Method 'None' »

  **Correctif :**

  1. Accédez à **Application Settings** de votre Auth0 Application dans le Dashboard
  2. Faites défiler jusqu’à **Application Properties**
  3. Réglez **Application Type** sur **Native**
  4. Réglez **Token Endpoint Authentication Method** sur **None**
  5. Cliquez sur **Save Changes**

  ### iOS : le navigateur ne s’ouvre pas

  **Solutions :**

  * Vérifiez que `Info.plist` contient la bonne configuration de schéma d’URL
  * Vérifiez que `OpenUrl()` est implémenté dans `AppDelegate`
  * Assurez-vous que la cible de déploiement iOS est compatible avec la version de votre Auth0 SDK
</Accordion>

<Accordion title="Considérations pour la production">
  ### Bonnes pratiques de sécurité

  * **Stockage sécurisé des jetons** : utilisez un stockage sécurisé propre à la plateforme (Android Keystore, iOS Keychain) pour stocker les jetons
  * **Actualisation des jetons** : implémentez la gestion des jetons d’actualisation pour maintenir les sessions utilisateur
  * **Certificate Pinning** : envisagez l’épinglage de certificat pour renforcer la sécurité de l’API
  * **ProGuard/obscurcissement du code** : ajoutez les règles appropriées si vous utilisez l’obscurcissement du code sur Android

  ### Exigences des boutiques d’applications

  * **Politique de confidentialité** : assurez-vous que votre application a une politique de confidentialité qui décrit l’utilisation d’Auth0
  * **Gestion des données utilisateur** : suivez les directives de la plateforme pour le traitement des données d’authentication des utilisateurs
  * **Liens profonds** : testez en profondeur la gestion des URL de rappel dans différents scénarios
  * **Exigences réseau** : gérez adéquatement les scénarios hors ligne

  ### Optimisation des performances

  * **Mettre Auth0Client en cache** : créez une seule instance et réutilisez-la dans toute votre application
  * **Chargement différé** : initialisez Auth0Client seulement au besoin
  * **Actualisation en arrière-plan** : implémentez l’actualisation des jetons en arrière-plan pour les sessions de longue durée
</Accordion>

<Accordion title="Configuration avancée">
  ### Scopes personnalisés et audience

  Demandez des scopes précis et définissez une audience pour votre API :

  ```cs AdvancedAuth.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Scope = "openid profile email offline_access read:posts write:posts",
      Audience = "https://myapi.example.com"
  });

  var loginResult = await auth0Client.LoginAsync();
  ```

  ### Paramètres supplémentaires

  Ajoutez des paramètres supplémentaires à la demande d’autorisation :

  ```cs ExtraParams.cs expandable lines theme={null}
  var extraParameters = new Dictionary<string, string>
  {
      { "prompt", "login" },
      { "ui_locales", "es" },
      { "custom_param", "value" }
  };

  var loginResult = await auth0Client.LoginAsync(extraParameters);
  ```

  ### Jetons d’actualisation

  Utilisez des jetons d’actualisation pour obtenir de nouveaux jetons d’accès sans intervention de l’utilisateur :

  ```cs RefreshToken.cs expandable lines theme={null}
  var refreshResult = await auth0Client.RefreshTokenAsync(loginResult.RefreshToken);

  if (!refreshResult.IsError)
  {
      var newAccessToken = refreshResult.AccessToken;
      var newIdToken = refreshResult.IdentityToken;
      // Enregistrer les nouveaux jetons
  }
  ```

  <Info>
    Pour recevoir un jeton d’actualisation, incluez le scope `offline_access` dans votre demande d’authentification.
  </Info>

  ### Configuration du navigateur propre à la plateforme

  **Android - Utilisez Chrome Custom Tabs avec des couleurs personnalisées :**

  ```cs AndroidBrowser.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Browser = new AndroidBrowser
      {
          ToolbarColor = Android.Graphics.Color.ParseColor("#FF6B35")
      }
  }, this);
  ```

  **iOS - Utilisez SFSafariViewController avec une présentation personnalisée :**

  ```cs iOSBrowser.cs expandable lines theme={null}
  var auth0Client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Browser = new ASWebAuthenticationSessionBrowser
      {
          PrefersEphemeralWebBrowserSession = false
      }
  });
  ```
</Accordion>

***

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

<CardGroup cols={2}>
  <Card title="Configurer les fournisseurs d’identité" icon="key" href="/docs/fr-ca/authenticate/identity-providers" iconType="solid">
    Ajoutez des fournisseurs de connexion sociale comme Google, Facebook et GitHub
  </Card>

  <Card title="Activer l’authentification multifacteur" icon="shield-halved" href="/docs/fr-ca/secure/multi-factor-authentication" iconType="solid">
    Ajoutez une couche de sécurité supplémentaire grâce à la MFA
  </Card>

  <Card title="Protection contre les attaques" icon="shield" href="/docs/fr-ca/secure/attack-protection" iconType="solid">
    Découvrez comment vous protéger contre les attaques par force brute et par bots
  </Card>

  <Card title="Personnaliser l’expérience de connexion" icon="paintbrush" href="/docs/fr-ca/customize/universal-login-pages" iconType="solid">
    Personnalisez la page Universal Login pour l’harmoniser avec votre image de marque
  </Card>
</CardGroup>