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

> Faites passer en toute fluidité vos utilisateurs de votre application iOS ou Android à un flux d’abonnement sécurisé et authentifié dans votre application web grâce à Native to Web Single Sign-On (SSO) et aux jetons de transfert de session.

# Cas d’utilisation : Configurer des flux de paiement du mobile vers le web à l’aide de Native to Web SSO

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

<Card title="Avant de commencer">
  1. Créez un tenant Auth0 pour enregistrer et configurer vos applications natives et Web.

  2. Installez et configurez [Auth0 CLI](https://github.com/auth0/auth0-cli) pour votre tenant Auth0.

  3. Ajoutez l’authentification Auth0 à votre application native à l’aide des Quickstarts appropriés pour votre plateforme :

  * [Quickstart iOS Swift](/docs/fr-ca/quickstart/native/ios-swift/interactive)
  * [Quickstart Android](/docs/fr-ca/quickstart/native/android/interactive)

  4. Ajoutez la prise en charge de [refresh\_token](/docs/fr-ca/secure/tokens/refresh-tokens/get-refresh-tokens) à votre application native.

  5. Ajoutez l’authentification Auth0 à votre application Web à l’aide du [Quickstart React Single Page App](/docs/fr-ca/quickstart/spa/react/interactive).
</Card>

[Native to Web Single Sign-On (SSO)](/docs/fr-ca/authenticate/single-sign-on/native-to-web) vous permet de créer une expérience utilisateur fluide et sécurisée entre votre application native et un parcours d’adhésion payante sur le Web. Native to Web <Tooltip tip="Single Sign-On (SSO) : service qui, après qu’un utilisateur s’est connecté à une application, le connecte automatiquement aux autres applications." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SSO">SSO</Tooltip> permet à l’application native d’envoyer le contexte d’authentification de l’utilisateur à l’application Web au moyen d’un `session_transfer_token` sécurisé à courte durée de vie.

Les sections ci-dessous expliquent comment ajouter :

* À votre application native, un bouton S’abonner maintenant qui permet aux utilisateurs authentifiés de souscrire à un forfait d’adhésion payant au moyen d’une expérience de paiement sécurisée sur le Web.
* À votre application Web, une page d’abonnement qui permet à l’utilisateur de sélectionner un abonnement d’adhésion sans avoir à se reconnecter.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce cas d’utilisation met l’accent sur les applications Web basées sur React qui utilisent le Auth0 React SDK.

  Si vous utilisez un autre framework, comme Node ou Express, la logique de gestion du `session_transfer_token`, que ce soit au moyen d’un paramètre d’URL ou d’un cookie, peut être adaptée en conséquence.
</Callout>

<div id="configure-auth0-cli">
  ## Configurer l’Auth0 CLI
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Utilisez l’[Auth0 CLI](https://github.com/auth0/auth0-cli) pour configurer votre tenant Auth0. Vous pouvez aussi utiliser l’[Auth0 Management API](https://auth0.com/docs/api/management/v2); pour en savoir plus, consultez [Configurer Native to Web SSO](/docs/fr-ca/authenticate/single-sign-on/native-to-web/configure-implement-native-to-web#configure-native-applications).
</Callout>

Suivez ces étapes pour vous authentifier auprès de votre tenant Auth0 à l’aide de l’[Auth0 CLI](https://github.com/auth0/auth0-cli) :

1. Initialisez l’Auth0 CLI

```bash lines theme={null}
auth0 login
```

2. Sélectionnez **En tant qu’utilisateur** et suivez le flux de connexion.

```bash lines theme={null}
How would you like to authenticate?
> As a user
  As a machine
```

3. Sélectionnez le tenant Auth0 où vous souhaitez activer Native to Web SSO.

<div id="configure-auth0">
  ## Configurer Auth0
</div>

<div id="enable-native-to-web-sso-in-your-native-application">
  ### Activez Native to Web SSO dans votre application native
</div>

Native to Web SSO utilise un `session_transfer_token` pour établir une session SSO entre une application native et une application Web. Le `session_transfer_token` permet à Auth0 d’identifier de façon sécuritaire l’utilisateur, l’application native d’origine et du contexte supplémentaire. Pour en savoir plus, consultez [Native to Web SSO](/docs/fr-ca/authenticate/single-sign-on/native-to-web/configure-implement-native-to-web).

Activez Native to Web SSO à l’aide d’Auth0 CLI :

export const codeExample1 = `auth0 apps session-transfer update {yourClientId} --can-create-token=true --enforce-device-binding=asn`;

<AuthCodeBlock children={codeExample1} language="bash" />

<div id="enable-native-to-web-sso-in-your-web-application">
  ### Activez Native to Web SSO dans votre application web
</div>

Configurez l’application web pour qu’elle accepte le `session_transfer_token` pour l’authentification au moyen d’un cookie ou d’un paramètre d’URL à l’aide d’Auth0 CLI :

export const codeExample2 = `auth0 apps session-transfer update {yourClientId}  --allowed-auth-methods=cookie,query`;

<AuthCodeBlock children={codeExample2} language="bash" />

Si le `session_transfer_token` est injecté dans le navigateur au moyen d’un cookie, aucune autre modification n’est nécessaire dans votre application web. La seule condition est que le navigateur accède à l’[URI de connexion de votre application](https://sus.auth0.com/docs/get-started/applications/application-settings#application-uris) afin de traiter la redirection de l’utilisateur vers le point de terminaison `/authorize` de votre tenant Auth0.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous pouvez configurer l’URI de connexion de l’application dans les paramètres de votre application dans l’Auth0 Dashboard. C’est la route vers laquelle Auth0 redirigera les utilisateurs lorsqu’une connexion est lancée à partir de sources externes.
</Callout>

<div id="create-a-subscription-page-in-the-web-application">
  ## Créer une page d’abonnement dans l’application Web
</div>

Ajoutez un nouveau fichier dans `/src/views/` pour créer une page d’abonnement :

<div id="step-1-add-a-new-view-file">
  ### Étape 1 : Ajouter un nouveau fichier de vue
</div>

Créez un fichier dans `src/views/JoinMembership.js`. Ce fichier invitera les utilisateurs à souscrire à un abonnement payant.

```js lines expandable theme={null}
import React, { useEffect } from "react";
import { useAuth0 } from "@auth0/auth0-react";
import { useLocation } from "react-router-dom";
import { Container, Button } from "reactstrap";
import Loading from "../components/Loading";

const JoinMembership = () => {
  const { isAuthenticated, isLoading, loginWithRedirect } = useAuth0();
  const location = useLocation();

  useEffect(() => {
    if (isLoading || isAuthenticated) return;

    const params = new URLSearchParams(location.search);
    const token = params.get("session_transfer_token");

    const redirectOptions = {
      appState: { returnTo: "/join-membership" },
      authorizationParams: {},
    };

    if (token) {
      redirectOptions.authorizationParams.session_transfer_token = token;
    }

    loginWithRedirect(redirectOptions);
  }, [isAuthenticated, isLoading, loginWithRedirect, location.search]);

  if (isLoading) {
    return <Loading />;
  }

  if (!isAuthenticated) {
    return <p>Redirecting to login...</p>;
  }

  return (
    <Container className="mt-5">
      <h1>Choose a Subscription Plan</h1>
      <Button color="primary" className="mb-3" onClick={() => alert("Subscribed to Basic!")}>
        Basic – $5/month
      </Button>
      <Button color="secondary" className="mb-3" onClick={() => alert("Subscribed to Pro!")}>
        Pro – $10/month
      </Button>
      <Button color="success" className="mb-3" onClick={() => alert("Subscribed to Premium!")}>
        Premium – $20/month
      </Button>
    </Container>
  );
};

export default JoinMembership;
```

<div id="step-2-add-a-new-route">
  ### Étape 2 : Ajouter une nouvelle route
</div>

Modifiez le fichier `src/App.js` et ajoutez une route `/join-membership` à la nouvelle page d’abonnement :

```js lines theme={null}
import JoinMembership from "./views/JoinMembership";

 {/* Rediriger vers la page d'adhésion */}
<Route path="/join-membership" component={JoinMembership} />
```

La nouvelle route `/join-membership` :

* Détermine si l’utilisateur est authentifié. Sinon, il sera redirigé vers la page <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur l’Authorization Server d’Auth0, afin de vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip>.
* Si un `session_transfer_token` est ajouté en tant que paramètre d’URL, le token est transmis dans la requête d’authentification.
* Une fois authentifié, l’utilisateur verra des boutons pour s’abonner à différents forfaits d’adhésion.

<Warning>
  Exécutez votre application React et accédez à `http://localhost:3000/join-membership`

  * Si l’utilisateur est authentifié, il verra les options d’abonnement.
  * Si l’utilisateur n’est pas authentifié, il est automatiquement redirigé vers la page Auth0 Universal Login.

    * Si l’URL comprend un `session_transfer_token`, il sera inclus dans la requête de connexion à Auth0.
    * Sinon, la connexion se poursuivra à l’aide de la Web Authentication standard.

  Lorsque l’utilisateur se connecte, il est renvoyé vers la page `/join-membership` pour sélectionner les options d’abonnement.
</Warning>

<div id="configure-the-native-application">
  ## Configurer l’application native
</div>

Votre application native doit échanger le `refresh_token` contre un `session_transfer_token` immédiatement avant de lancer l’application web. Pour ce faire, ajoutez l’échange de transfert de session et la logique de lancement de l’application web dans le même gestionnaire d’événement, par exemple la méthode `onClick` du bouton.

<div id="ios">
  ### iOS
</div>

Les étapes suivantes décrivent comment ajouter le paiement mobile-to-web aux applications natives iOS :

<div id="step-1-add-a-subscribe-to-membership-button">
  #### Étape 1 : ajouter un bouton `Subscribe to Membership`
</div>

Pour lancer le flux d’abonnement Web à partir de votre application native iOS, ajoutez un bouton `Subscribe to Membership` au fichier `ProfileView.swift`.

Modifiez le contenu du fichier `ProfileView.swift` pour y ajouter un bouton sous les renseignements de l’utilisateur :

```swift lines theme={null}
import SwiftUI

struct ProfileView: View {
    let user: User
    var onSubscribe: () -> Void = {}

    var body: some View {
        List {
            Section(header: ProfileHeader(picture: user.picture)) {
                ProfileCell(key: "ID", value: user.id)
                ProfileCell(key: "Name", value: user.name)
                ProfileCell(key: "Email", value: user.email)
                ProfileCell(key: "Email verified?", value: user.emailVerified)
                ProfileCell(key: "Updated at", value: user.updatedAt)
            }

            Section {
                Button("Subscribe to Membership", action: onSubscribe)
            }
        }
    }
}
```

Le fichier `ProfileView.swift` ajoute un bouton `S’abonner à l’adhésion` et utilise une closure `onSubscribe` pour définir le comportement lorsqu’on appuie sur ce bouton.

<div id="step-2-implement-the-subscription-flow-using-native-to-web-sso">
  #### Étape 2 : Mettez en place le flux d’abonnement à l’aide de Native to Web SSO
</div>

Modifiez le fichier `MainView.swift` pour définir le comportement du bouton `S’abonner à l’adhésion` :

export const codeExample3 = `import SwiftUI
import Auth0
import WebKit

struct MainView: View {
    @State var user: User?

    var body: some View {
        if let user = self.user {
            VStack {
                ProfileView(user: user, onSubscribe: launchSubscription)
                Button("Se déconnecter", action: self.logout)
            }
        } else {
            VStack {
                HeroView()
                Button("Se connecter", action: self.login)
            }
        }
    }

    func login() {
            Auth0
                .webAuth()
                .audience("https://sample.api.com")
                .scope("profile email offline_access openid")
                //.useHTTPS() // Utilisez une URL de rappel par lien universel sur iOS 17.4+ / macOS 14.4+
                .start { result in
                    switch result {
                    case .success(let credentials):
                        self.user = User(from: credentials.idToken)
                        let manager = CredentialsManager(authentication: Auth0.authentication())
                        let success = manager.store(credentials: credentials)
                        print("Identifiants enregistrés? \(credentials.refreshToken)")
                    case .failure(let error):
                        print("Échec : \(error)")
                    }
                }
        }

    func logout() {
        Auth0
            .webAuth()
            .useHTTPS()
            .clearSession { result in
                switch result {
                case .success:
                    self.user = nil
                case .failure(let error):
                    print("Échec : \(error)")
                }
            }
    }

    func launchSubscription() {
        let credentialsManager = CredentialsManager(authentication: Auth0.authentication())

        credentialsManager.credentials { result in
            switch result {
            case .success(let credentials):
                let refreshToken = credentials.refreshToken ?? ""

                Auth0
                    .authentication()
                    .ssoExchange(withRefreshToken: refreshToken)
                    .start { result in
                        switch result {
                        case .success(let ssoCredentials):
                            DispatchQueue.main.async {
                                let cookie = HTTPCookie(properties: [
                                    .domain: "{yourDomain}", // Remplacez par le domaine réel de votre tenant Auth0
                                    .path: "/",
                                    .name: "auth0_session_transfer_token",
                                    .value: ssoCredentials.sessionTransferToken,
                                    .expires: ssoCredentials.expiresIn,
                                    .secure: true
                                ])!

                                let webView = WKWebView()
                                let store = webView.configuration.websiteDataStore.httpCookieStore
                                store.setCookie(cookie) {
                                    let url = URL(string: "http://localhost:3000/join-membership")!
                                    let request = URLRequest(url: url)
                                    webView.load(request)

                                    let vc = UIViewController()
                                    vc.view = webView
                                    UIApplication.shared.windows.first?.rootViewController?.present(vc, animated: true)
                                }
                            }

                        case .failure(let error):
                            print("Impossible d’obtenir le jeton SSO : \(error)")
                        }
                    }

            case .failure(let error):
                print("Erreur lors du chargement des identifiants : \(error)")
            }
        }
    }
}`;

<AuthCodeBlock children={codeExample3} language="swift" />

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Cet exemple utilise l’audience `https://sample.api.com` à des fins de démonstration. Vous pouvez créer une API avec cet identifiant dans votre tenant Auth0 ou le remplacer par l’identifiant de votre propre API.

  Pour en savoir plus, consultez [Configurer les API](/docs/fr-ca/get-started/auth0-overview/set-up-apis).
</Callout>

Cela permet à l’utilisateur de sélectionner `S’abonner à l’adhésion` dans l’application native et de lancer immédiatement le processus d’abonnement dans l’application web sans avoir à se reconnecter.

<div id="android">
  ### Android
</div>

Les étapes suivantes indiquent comment ajouter le paiement mobile vers le Web aux applications natives Android :

<div id="step-1-add-a-subscribe-button-to-the-main-page">
  #### Étape 1 : Ajouter un bouton S’abonner à la page principale
</div>

Pour lancer le flux d’abonnement Web à partir de votre application native Android, ajoutez un bouton `Adhérer` à l’interface utilisateur.

Modifiez le fichier `MainActivity.kt` et ajoutez le code suivant à la méthode `onCreate()` :

```kotlin wrap lines theme={null}
binding.buttonSubscribe.setOnClickListener { launchSubscriptionFlow() }
```

Modifiez le fichier `activity_main.xml` pour y inclure le code ci-dessous après le bouton `@+id/button_patch_metadata` :

```xml lines theme={null}
<Button
    android:id="@+id/buttonSubscribe"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Subscribe to Membership" />
```

<div id="step-2-implement-subscription-flow-using-native-to-web-sso">
  #### Étape 2 : Implémenter le flux d’abonnement avec Native to Web SSO
</div>

Modifiez le fichier `MainActivity.kt` pour définir le comportement du bouton `S’abonner à l’adhésion` :

1. Étendez le flux de connexion et gérez l’action d’abonnement :

```kotlin lines theme={null}
// Importations requises
import com.auth0.android.authentication.storage.SecureCredentialsManager
import com.auth0.android.authentication.storage.SharedPreferencesStorage
import com.auth0.android.result.SSOCredentials
```

2. Mettez à jour la méthode `onCreate()` pour y inclure `credentialsManager:`

```kotlin lines theme={null}
override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Configurer l'objet de compte avec les détails de l'application Auth0
        account =  Auth0.getInstance(
            getString(R.string.com_auth0_client_id),
            getString(R.string.com_auth0_domain)
        )

        // Associer le clic du bouton à l'action de connexion
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        binding.buttonLogin.setOnClickListener { loginWithBrowser() }
        binding.buttonLogout.setOnClickListener { logout() }
        binding.buttonGetMetadata.setOnClickListener { getUserMetadata() }
        binding.buttonPatchMetadata.setOnClickListener { patchUserMetadata() }
        binding.buttonSubscribe.setOnClickListener { launchSubscriptionFlow() }

        secureCredentialsManager = SecureCredentialsManager(
            this,
            AuthenticationAPIClient(account),
            SharedPreferencesStorage(this)
        )

    }
```

3. Mettez à jour la méthode `loginwithBrowser()` pour stocker les identifiants au moyen de `credentialsManager:`

```kotlin lines theme={null}
private fun loginWithBrowser() {
    WebAuthProvider.login(account)
        .withScheme(getString(R.string.com_auth0_scheme))
        .withScope("openid profile email offline_access")
        .withAudience("https://example.api.com")
        .start(this, object : Callback<Credentials, AuthenticationException> {
            override fun onSuccess(credentials: Credentials) {
                secureCredentialsManager.saveCredentials(credentials)
                cachedCredentials = credentials
                showSnackBar("Success: ${credentials.accessToken}")
                updateUI()
                showUserProfile()
            }

            override fun onFailure(exception: AuthenticationException) {
                showSnackBar("Failure: ${exception.getCode()}")
            }
        })
}
```

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Cet exemple utilise l’audience `https://sample.api.com` à des fins de démonstration. Vous pouvez créer une API ayant cet identifiant dans votre tenant Auth0, ou le remplacer par l’identifiant de votre propre API.

  Pour en savoir plus, consultez [Configurer les API](/docs/fr-ca/get-started/auth0-overview/set-up-apis).
</Callout>

4. Ajoutez la méthode `launchSubscriptionFlow()` pour ouvrir l’application Web :

```kotlin lines expandable theme={null}
private fun launchSubscriptionFlow() {
    secureCredentialsManager.getSsoCredentials(
        mapOf(),  // paramètres facultatifs
        object : Callback<SSOCredentials, CredentialsManagerException> {
            override fun onSuccess(result: SSOCredentials) {
                val sessionToken = result.sessionTransferToken

                val cookieValue =
                    "auth0_session_transfer_token=$sessionToken; Path=/; Secure; HttpOnly; SameSite=None"
                val cookieManager = android.webkit.CookieManager.getInstance()
                cookieManager.setAcceptCookie(true)
                cookieManager.setCookie("https://${getString(R.string.com_auth0_domain)}", cookieValue)

                val webView = android.webkit.WebView(this@MainActivity)
                webView.settings.javaScriptEnabled = true
                webView.webViewClient = object : android.webkit.WebViewClient() {
                    override fun shouldOverrideUrlLoading(view: android.webkit.WebView?, url: String?) = false
                }

                webView.loadUrl("http://localhost:3000/join-membership")
                setContentView(webView)
            }

            override fun onFailure(error: CredentialsManagerException) {
                showSnackBar("Failed to get session transfer token: ${error.message}")
            }
        }
    )
}
```

Cela permet à l’utilisateur de sélectionner `S’abonner à l’adhésion` dans l’application native et de lancer immédiatement le processus d’abonnement à l’application Web sans avoir à se reconnecter.

<div id="test-your-native-to-web-sso-implementation">
  ## Testez votre mise en œuvre de Native to Web SSO
</div>

Une fois que tout est configuré, lancez votre application native iOS ou Android pour vous connecter, accédez à l’écran Profile ou Mainscreen et sélectionnez le bouton **Souscrire à l’adhésion**.

Voici ce qui se produit :

* Le `refresh_token` stocké est utilisé pour demander un `session_transfer_token` sécurisé
* Le `session_transfer_token` est injecté dans un cookie pour votre domaine Auth0
* Un `WKWebView` est utilisé pour charger la route `/join-membership` de votre application web
* L’application web reçoit le `session_transfer_token` et termine l’ouverture de session à l’aide de Native to Web SSO
* L’utilisateur voit immédiatement les options d’abonnement dans l’application web

Vous avez créé une expérience fluide où l’utilisateur d’une application native mobile peut lancer un parcours sécurisé et authentifié dans une application web sans devoir se reconnecter.

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

* Découvrez plus d’options de configuration pour Native to Web SSO :Approfondissez la durée de vie de la session, la rotation du <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau jeton d’accès sans obliger les utilisateurs à se connecter de nouveau." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=refresh+token">jeton d’actualisation</Tooltip>, la liaison de l’appareil et la révocation en cascade dans la [documentation sur Native to Web SSO](/docs/fr-ca/authenticate/single-sign-on/native-to-web).
* Personnalisez l’expérience post-login avec le profilage progressif :Utilisez le [formulaire de profil progressif](/docs/fr-ca/customize/forms/configure-progressive-profile-form) d’Auth0 pour recueillir des données utilisateur supplémentaires après la connexion — comme les préférences de forfait, l’adresse ou l’intention de paiement — avant d’afficher les options d’abonnement.