> ## Documentation Index
> Fetch the complete documentation index at: https://docs-staging.auth0-mintlify.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Ajouter la connexion à votre application Kotlin Multiplatform avec le SDK Auth0 Kotlin Multiplatform

> Ajoutez l'authentification à une application Kotlin Multiplatform (Android + iOS) avec le SDK Auth0 Kotlin Multiplatform.

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

<HowToSchema />

<Accordion title="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de programmation par IA 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).

  **Installer :**

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

  **Demandez ensuite à votre assistant IA :**

  ```text theme={null}
  Add Auth0 authentication to my Kotlin Multiplatform app.
  ```

  Votre assistant IA crée automatiquement votre application Auth0, récupère les identifiants, ajoute la dépendance du SDK Auth0 Kotlin Multiplatform, configure les espaces réservés du manifeste Android et le schéma d’URL iOS, et implémente les flux de connexion et de déconnexion. [Consultez la documentation complète des Agent Skills](/docs/fr-ca/quickstart/agent-skills).
</Accordion>

<Note>
  Utilisez ce guide de démarrage rapide avec Kotlin Multiplatform 2.0 ou une version ultérieure, Android SDK 24 ou une version ultérieure (Android 7.0) et iOS 14 ou une version ultérieure. Le SDK Auth0 Kotlin Multiplatform est actuellement en version 1.0.0-beta.0. Épinglez explicitement cette version, car l’API pourrait changer avant la version stable. Vous avez besoin d’[Android Studio](https://developer.android.com/studio) (Ladybug ou une version ultérieure) et, pour la cible iOS, de [Xcode 15+](https://developer.apple.com/xcode/) sur macOS.
</Note>

<h2 id="get-started">
  Commencer
</h2>

Utilisez ce Quickstart pour configurer votre application Kotlin Multiplatform afin que les utilisateurs finaux puissent se connecter et se déconnecter au moyen d’[Universal Login](/docs/fr-ca/authenticate/login/auth0-universal-login) d’Auth0, enregistrer les jetons de façon sécuritaire et afficher les profils utilisateur — le tout à partir d’un code Kotlin partagé qui s’exécute autant sur Android que sur iOS.

<Steps>
  <Step title="Créer un projet Kotlin Multiplatform" stepNumber={1}>
    Si vous avez déjà un projet Kotlin Multiplatform, passez à l'étape suivante.

    Créez un nouveau projet Kotlin Multiplatform doté d'une UI Compose partagée à l'aide du [wizard Kotlin Multiplatform de JetBrains](https://kmp.jetbrains.com/) (sélectionnez **Android** et **iOS**, puis partagez l'UI avec **Compose Multiplatform**), ou du plugin **Kotlin Multiplatform** dans Android Studio.

    Vous obtenez ainsi le layout standard auquel ce guide fait référence tout au long :

    ```text theme={null}
    your-app/
    ├── composeApp/
    │   ├── build.gradle.kts
    │   └── src/
    │       ├── commonMain/kotlin/    ← code partagé (client Auth0, modèle de vue, UI)
    │       ├── androidMain/          ← point d’entrée Android + AndroidManifest.xml
    │       └── iosMain/kotlin/       ← point d’entrée iOS
    ├── iosApp/                       ← projet Xcode (Info.plist se trouve ici)
    └── settings.gradle.kts
    ```

    <Info>
      Ce guide utilise `com.example.app` comme application ID / identifiant de bundle. Remplacez cet espace réservé par le vôtre, puisqu'il devient partie intégrante de vos callback URLs Auth0.
    </Info>
  </Step>

  <Step title="Ajoutez le SDK Auth0 avec Gradle" stepNumber={2}>
    Ajoutez le SDK Auth0 Kotlin Multiplatform à l'ensemble de sources `commonMain` de votre module partagé. La library est publiée sur Maven Central; aucune configuration de repository supplémentaire n'est donc requise.

    **Mettez à jour `composeApp/build.gradle.kts` :**

    ```kotlin composeApp/build.gradle.kts theme={null}
    kotlin {
        sourceSets {
            commonMain.dependencies {
                // Module parapluie — regroupe Web Auth, l'authentication et les credentials
                implementation("com.auth0.kmp:auth0:1.0.0-beta.0")
            }
        }
    }
    ```

    <Tip>
      L'artéfact global `auth0` intègre tout ce dont vous avez besoin. Pour une empreinte plus légère, vous pouvez plutôt utiliser les modules individuels suivants comme dépendances : `auth0-core`, `auth0-webauth`, `auth0-authentication`, `auth0-credentials`.
    </Tip>
  </Step>

  <Step title="Configurez votre application Auth0" stepNumber={3}>
    Créez une application Native dans Auth0 et enregistrez les callback URLs et logout URLs de la plateforme, tant pour Android que pour iOS.

    1. Accédez au [Auth0 Dashboard](https://manage.auth0.com/dashboard/).
    2. Sélectionnez **Applications** > **Applications** > **Create Application**.
    3. Dans le popup, saisissez un nom pour votre application, sélectionnez **Native** comme type d'application, puis choisissez **Create**.
    4. Passez à l'onglet Settings de la page Application Details, puis copiez le Domain et le Client ID. Vous devrez les ajouter à votre code à une étape ultérieure.

    Toujours dans l'onglet Settings, configurez les URLs suivantes. Le format du callback est propre au schéma de chaque plateforme : enregistrez donc une entrée pour Android et une autre pour iOS :

    **Allowed Callback URLs :**

    ```
    com.example.app://{yourDomain}/android/com.example.app/callback, com.example.app://{yourDomain}/ios/com.example.app/callback
    ```

    **Allowed Logout URLs :**

    ```
    com.example.app://{yourDomain}/android/com.example.app/callback, com.example.app://{yourDomain}/ios/com.example.app/callback
    ```

    Remplacez `{yourDomain}` par votre véritable domaine Auth0 (p. ex. `dev-abc123.us.auth0.com`) et `com.example.app` par l'ID d'application ou l'identifiant de bundle de votre application.

    <Info>
      Les Allowed Callback URLs garantissent que les utilisateurs finaux sont redirigés en toute sécurité vers votre application après l'authentification. Sans URL correspondante, le processus de connexion échouera. Les Allowed Logout URLs garantissent que les utilisateurs sont redirigés vers votre application après leur déconnexion.

      Le format du rappel intègre l'identifiant de votre package ou de votre bundle : `SCHEME://YOUR_DOMAIN/android/APPLICATION_ID/callback` pour Android et `SCHEME://YOUR_DOMAIN/ios/BUNDLE_ID/callback` pour iOS. Par défaut, le schéma correspond à l'ID d'application ou à l'identifiant de bundle.
    </Info>

    <Note>
      **Important** : assurez-vous que le nom du package ou du bundle dans vos callback URLs correspond exactement à votre `applicationId` (Android) et à votre identifiant de bundle (iOS). Si l'authentification échoue, vérifiez que ces valeurs sont bien identiques.
    </Note>
  </Step>

  <Step title="Enregistrez le schéma de redirection sur chaque plateforme" stepNumber={4}>
    Le SDK fournit une `RedirectActivity` (Android, fusionnée automatiquement) et utilise `ASWebAuthenticationSession` (iOS) pour intercepter le callback. Il ne vous reste qu’à déclarer le schéma d’URL sur chaque plateforme.

    **Android** : ajoutez les espaces réservés du manifest dans votre fichier de build Android. La `RedirectActivity` du SDK lit ces valeurs :

    ```kotlin composeApp/build.gradle.kts theme={null}
    android {
        defaultConfig {
            
            manifestPlaceholders["auth0Scheme"] = "{yourScheme}" // par défaut : l'ID de votre application
            manifestPlaceholders["auth0Domain"] = "{yourDomain}"
        }
    }
    ```

    Assurez-vous également que votre fichier `AndroidManifest.xml` demande la permission Internet :

    ```xml composeApp/src/androidMain/AndroidManifest.xml theme={null}
    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android">
        <uses-permission android:name="android.permission.INTERNET" />
    </manifest>
    ```

    **iOS** : enregistrez le schéma d'URL dans `iosApp/iosApp/Info.plist` (ou dans Xcode → cible → **Info** → **URL Types**) :

    ```xml iosApp/iosApp/Info.plist theme={null}
    <key>CFBundleURLTypes</key>
    <array>
        <dict>
            <key>CFBundleTypeRole</key>
            <string>Editor</string>
            <key>CFBundleURLSchemes</key>
            <array>
                <!-- Doit correspondre à votre ID de bundle -->
                <string>com.example.app</string>
            </array>
        </dict>
    </array>
    ```
  </Step>

  <Step title="Initialiser le SDK Auth0" stepNumber={5}>
    Dans votre ensemble de sources partagé `commonMain`, créez le client `Auth0` une seule fois, puis réutilisez-le. Il contient la couche de transport partagée par Web Auth, l'[Authentication API](/docs/fr-ca/api/authentication) et le Credentials Manager.

    **Créez `composeApp/src/commonMain/kotlin/Auth0Config.kt` :**

    ```kotlin composeApp/src/commonMain/kotlin/Auth0Config.kt theme={null}
    import com.auth0.kmp.Auth0
    import com.auth0.kmp.core.Auth0Account

    // Code partagé — un seul compte fonctionne pour Android et iOS
    val account = Auth0Account(
        clientId = "YOUR_AUTH0_CLIENT_ID", // Depuis Paramètres de l'application → Client ID
        domain = "{yourDomain}",           // Depuis Paramètres de l'application → Domaine
    )

    val auth0 = Auth0(account)
    ```

    <Info>
      En production, évitez de coder en dur les credentials dans le code source. L'[application d'exemple](https://github.com/auth0/auth0-kmp/tree/main/sample-app) lit `auth0.domain` et `auth0.clientId` depuis `local.properties` et les expose au moyen d'une configuration générée. Le Domain et le Client ID proviennent tous deux des Application Settings dans le Auth0 Dashboard. Le domain ne doit pas inclure le schéma `https://`.
    </Info>
  </Step>

  <Step title="Implement Login et Logout" stepNumber={6}>
    Chaque méthode d'Auth0 Kotlin Multiplatform est une fonction `suspend` (coroutine) qui retourne un `Result<Success, Error>` : aucune exception n'est levée pour les erreurs de domaine. Encapsulez les appels dans un `ViewModel` afin que votre interface Compose puisse observer le state.

    **Créez `composeApp/src/commonMain/kotlin/AuthViewModel.kt` :**

    ```kotlin composeApp/src/commonMain/kotlin/AuthViewModel.kt theme={null}
    import androidx.lifecycle.ViewModel
    import androidx.lifecycle.viewModelScope
    import com.auth0.kmp.core.result.Result
    import kotlinx.coroutines.flow.MutableStateFlow
    import kotlinx.coroutines.flow.StateFlow
    import kotlinx.coroutines.flow.asStateFlow
    import kotlinx.coroutines.launch

    sealed interface AuthState {
        data object LoggedOut : AuthState
        data object Loading : AuthState
        data class LoggedIn(val accessToken: String) : AuthState
        data class Error(val message: String) : AuthState
    }

    class AuthViewModel(val auth0: Auth0) : ViewModel() {
        
        // Enregistre et renouvelle automatiquement les jetons (Keystore/DataStore sur Android, Keychain sur iOS)
        private val credentialsManager = auth0.credentials()

        private val _state = MutableStateFlow<AuthState>(AuthState.LoggedOut)
        val state: StateFlow<AuthState> = _state.asStateFlow()

        fun login() {
            viewModelScope.launch {
                _state.value = AuthState.Loading
                // Ouvre Universal Login dans le navigateur du système
                when (val result = auth0.webAuth.login()) {
                    is Result.Success -> {
                        credentialsManager.saveCredentials(result.data)
                        _state.value = AuthState.LoggedIn(result.data.accessToken)
                    }
                    is Result.Failure -> {
                        _state.value = AuthState.Error(result.error.toString())
                    }
                }
            }
        }

        fun logout() {
            viewModelScope.launch {
                // Efface la session du navigateur, puis les credentials stockés localement
                when (val result = auth0.webAuth.logout()) {
                    is Result.Success -> {
                        credentialsManager.clearCredentials()
                        _state.value = AuthState.LoggedOut
                    }
                    is Result.Failure -> {
                        _state.value = AuthState.Error(result.error.toString())
                    }
                }
            }
        }
    }
    ```

    Intégrez le modèle de vue à un écran Compose partagé entre les deux plateformes :

    ```kotlin composeApp/src/commonMain/kotlin/App.kt theme={null}
    import androidx.compose.material3.Button
    import androidx.compose.material3.CircularProgressIndicator
    import androidx.compose.material3.MaterialTheme
    import androidx.compose.material3.Text
    import androidx.compose.runtime.Composable
    import androidx.compose.runtime.getValue
    import androidx.lifecycle.compose.collectAsStateWithLifecycle
    import androidx.lifecycle.viewmodel.compose.viewModel

    @Composable
    fun App(viewModel: AuthViewModel = viewModel { AuthViewModel() }) {
        MaterialTheme {
            val state by viewModel.state.collectAsStateWithLifecycle()
            when (val current = state) {
                is AuthState.Loading -> CircularProgressIndicator()
                is AuthState.LoggedIn -> Button(onClick = viewModel::logout) { Text("Log Out") }
                is AuthState.Error -> Text("Something went wrong: ${current.message}")
                AuthState.LoggedOut -> Button(onClick = viewModel::login) { Text("Log In") }
            }
        }
    }
    ```
  </Step>

  <Step title="Afficher le profil de l’utilisateur" stepNumber={7}>
    Après le login, effectuez une requête à `userInfo` de l'Authentication API avec l'access token afin de récupérer le profil de l'utilisateur authentifié.

    ```kotlin composeApp/src/commonMain/kotlin/AuthViewModel.kt theme={null}
    import com.auth0.kmp.authentication.UserInfo

    suspend fun fetchProfile(accessToken: String): UserInfo? {
        return when (val result = auth0.authentication.userInfo(accessToken)) {
            is Result.Success -> result.data // .name, .email, .picture, .customClaims, ...
            is Result.Failure -> null
        }
    }
    ```

    <Info>
      Au lancement de l'application, vous pouvez passer outre l'écran de connexion si des credentials valides existent déjà : `credentialsManager.hasValidCredentials()` retourne `true` lorsqu'une session stockée et non expirée est disponible. Utilisez `credentialsManager.getCredentials()` pour récupérer un access token valide et renouveler automatiquement celui-ci à l'aide du [refresh token](/docs/fr-ca/secure/tokens/refresh-tokens) lorsque nécessaire.
    </Info>
  </Step>

  <Step title="Lancez votre appli" stepNumber={8}>
    Compilez et lancez l'application sur chaque cible :

    <CodeGroup>
      ```shellscript Android theme={null}
      ./gradlew :composeApp:installDebug
      ```

      ```shellscript iOS theme={null}
      # Ouvrez le projet Xcode et exécutez-le sur un simulateur ou un appareil
      open iosApp/iosApp.xcodeproj
      ```
    </CodeGroup>

    **Déroulement attendu :**

    1. L'application démarre en affichant un bouton "Log In".
    2. Touchez "Log In" → le navigateur du système ouvre la page Auth0 Universal Login → complétez la connexion.
    3. Le contrôle revient automatiquement à l'application et le bouton devient "Log Out".
    4. Réussite !
  </Step>
</Steps>

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

  Vous disposez maintenant d’une application Compose Multiplatform avec Auth0 connexion, la déconnexion, le stockage sécurisé des jetons et la récupération du profil utilisateur — toute la logique d’authentification est partagée entre Android et iOS.
</Check>

***

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

<Accordion title="Erreur de non-correspondance de l’URL de rappel">
  **Cause :** L’URL de rappel générée par le SDK n’est pas répertoriée dans votre application Auth0, ou le schéma et le package ne correspondent pas.

  **Correctif :** Vérifiez que les Allowed Callback URLs dans Application Settings correspondent exactement au format de la plateforme — `SCHEME://YOUR_DOMAIN/android/APPLICATION_ID/callback` pour Android et `SCHEME://YOUR_DOMAIN/ios/BUNDLE_ID/callback` pour iOS. Le `SCHEME` (par défaut : l’ID de votre application) et le package ou bundle doivent correspondre exactement aux valeurs de votre projet. Les URL sont sensibles à la casse et le schéma doit être en minuscules.
</Accordion>

<Accordion title="Le navigateur s’ouvre, mais ne retourne jamais à l’application">
  **Cause :** Le schéma de rappel n’est pas déclaré sur la plateforme, donc le système d’exploitation ne peut pas rediriger vers votre application.

  **Correctif :** Sur Android, vérifiez que `manifestPlaceholders["auth0Scheme"]` et `["auth0Domain"]` sont définis dans `composeApp/build.gradle.kts`, puis effectuez une compilation propre. Sur iOS, vérifiez que l’entrée `CFBundleURLSchemes` dans `Info.plist` correspond à votre identifiant de bundle.
</Accordion>

<Accordion title="Connexion retourne Result.Failure avec une erreur réseau ou de délai d’expiration">
  **Cause :** L’appareil ne peut pas joindre votre tenant Auth0, ou une requête expire.

  **Correctif :** Vérifiez que `domain` dans `Auth0Account` correspond au domaine de votre tenant, sans le schéma `https://` (par exemple, `your-tenant.us.auth0.com`). Sur un appareil physique, assurez-vous qu’il a accès au réseau. Vous pouvez augmenter les délais d’expiration au moyen de `NetworkingConfiguration` transmis à `Auth0Account`.
</Accordion>

<Accordion title="getCredentials échoue après la connexion">
  **Cause :** Aucun jeton d’actualisation n’est émis; les identifiants expirés ne sont donc pas renouvelés.

  **Correctif :** Universal Login demande le scope `offline_access` par défaut (ce qui renvoie un jeton d’actualisation). Si vous remplacez `scope` dans `LoginOptions`, incluez `offline_access` et activez **Rotation des jetons d’actualisation** pour l’application dans l’Auth0 Dashboard.
</Accordion>

<Accordion title="La compilation Android échoue lors de la fusion de RedirectActivity">
  **Cause :** Les espaces réservés du manifeste `auth0Domain` / `auth0Scheme` sont absents; le `RedirectActivity` fusionné du SDK n’a donc aucune valeur à laquelle se lier.

  **Correctif :** Assurez-vous que les deux espaces réservés sont définis dans le bloc `defaultConfig` de `composeApp/build.gradle.kts`. Si vous utilisez plusieurs variantes de compilation, définissez-les dans chacune d’elles.
</Accordion>

<Accordion title="Restaurer une session au démarrage">
  Vérifiez si des identifiants sont stockés avant d’afficher l’écran de connexion afin que les utilisateurs qui reviennent n’aient pas à passer par Universal Login :

  ```kotlin theme={null}
  if (credentialsManager.hasValidCredentials()) {
      val credentials = credentialsManager.getCredentials() // renouvelle automatiquement si expirés
      // rediriger vers votre écran authentifié
  }
  ```
</Accordion>

<Accordion title="Appeler votre propre API avec un jeton d’accès">
  Demandez une audience afin qu’Auth0 émette un jeton d’accès pour votre API :

  ```kotlin theme={null}
  import com.auth0.kmp.webauth.LoginOptions

  auth0.webAuth.login(
      LoginOptions(
          audience = "https://your-api.example.com", // Dans API Settings → Identifier
          scope = "openid profile email offline_access",
      ),
  )
  ```
</Accordion>

<Accordion title="Déconnexion fédérée">
  Déconnectez l’utilisateur de l’identity provider upstream ainsi que d’Auth0 :

  ```kotlin theme={null}
  import com.auth0.kmp.webauth.LogoutOptions

  auth0.webAuth.logout(LogoutOptions(federated = true))
  ```
</Accordion>

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

* Explorez l'ensemble du [SDK Auth0 Kotlin Multiplatform](https://github.com/auth0/auth0-kmp) et son fichier `EXAMPLES.md` pour les organizations, DPoP, les passkeys et le stockage personnalisé.
* Exécutez l'[exemple d'application Android + iOS](https://github.com/auth0/auth0-kmp/tree/main/sample-app) complet.
* Apprenez-en plus sur [Auth0 Universal Login](/docs/fr-ca/authenticate/login/auth0-universal-login) et les [jetons d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens).