# Inscription des utilisateurs hébergée par Stripe

Inscrivez des comptes connectés en les redirigeant vers un flux d'inscription hébergé par Stripe.

L’inscription hébergée par Stripe gère la collecte des informations sur l’entreprise et sur la vérification de l’identité des comptes connectés, réduisant drastiquement les efforts requis de la part de la plateforme. Il s’agit d’un formulaire Web hébergé par Stripe qui s’affiche de manière dynamique selon les fonctionnalités, le pays et le type d’entreprise de chaque compte connecté.
![](https://b.stripecdn.com/docs-statics-srv/assets/hosted_onboarding_form.e59ba8300f563e43489953f06127f52c.png)

Le formulaire d’inscription hébergée dans l’exemple d’intégration Stripe, [Furever](https://furever.dev/).

L’onboarding hébergé par Stripe prend en charge l’[onboarding en réseau](https://docs.stripe.com/connect/networked-onboarding.md), qui permet aux propriétaires de plusieurs comptes Stripe de partager des informations d’entreprise entre leurs comptes. Lorsqu’ils procèdent à l’onboarding d’un nouveau compte, ils peuvent réutiliser les informations d’un compte existant au lieu de les soumettre à nouveau.

## Personnaliser le formulaire d'inscription [Dashboard]

Vous pouvez personnaliser l’aspect visuel du formulaire avec le nom, la couleur et l’icône de votre marque en accédant à la [page des paramètres Connect](https://dashboard.stripe.com/account/applications/settings) dans le Dashboard. L’inscription hébergée par Stripe nécessite ces informations. Stripe recommande également de [recueillir les informations bancaires](https://dashboard.stripe.com/settings/connect/payouts/onboarding) de vos comptes connectés lors de leur inscription.

## Créer un compte et pré-remplir les informations [Côté serveur]

Créez un [compte connecté](https://docs.stripe.com/api/accounts.md) avec les propriétés par défaut du [contrôleur](https://docs.stripe.com/api/accounts/create.md#create_account-controller). Pour en savoir plus sur les propriétés des contrôleurs, consultez la section [Concevoir une intégration](https://docs.stripe.com/connect/interactive-platform-guide.md). Vous pouvez également créer un compte connecté en spécifiant un [type](https://docs.stripe.com/api/accounts/create.md#create_account-type) de compte.

Si vous spécifiez le pays du compte ou demandez des fonctionnalités pour celui-ci, le propriétaire du compte ne peut pas modifier son pays. Sinon, cela dépend de l’accès au Dashboard du compte :

- **Dashboard Stripe complet** : lors de l’inscription, le propriétaire du compte peut sélectionner n’importe quel pays acquéreur, de la même manière que lors de l’inscription à un compte Stripe classique. Stripe demande automatiquement un ensemble de fonctionnalités pour le compte en fonction du pays sélectionné.
- **Dashboard Express** : lors de l’inscription, le titulaire du compte peut choisir parmi une liste de pays que vous configurez dans votre plateforme Dashboard les [options d’inscription](https://dashboard.stripe.com/settings/connect/onboarding-options/countries). Vous pouvez également configurer ces options pour préciser les fonctionnalités par défaut à demander pour les comptes de chaque pays.
- **Pas de Dashboard Stripe** : si Stripe est responsable de la collecte des exigences, le flux d’inscription permet au titulaire du compte de sélectionner n’importe quel pays acquéreur. Sinon, votre flux d’inscription personnalisé doit définir le pays et demander des fonctionnalités.

#### Avec les propriétés du contrôleur

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "controller[fees][payer]=application" \
  -d "controller[losses][payments]=application" \
  -d "controller[stripe_dashboard][type]=express"
```

#### Avec un type de compte

```curl
curl https://api.stripe.com/v1/accounts \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d type=standard
```

La réponse inclut l’ID, que vous utilisez pour référencer le `Account` tout au long de votre intégration.

### Demandez des fonctionnalités

Vous pouvez demander des [fonctionnalités](https://docs.stripe.com/connect/account-capabilities.md#creating) lors de la création d’un compte en attribuant la valeur true à la propriété `requested` des fonctionnalités souhaitées. Pour les comptes ayant accès au Dashboard Express, vous pouvez également configurer vos [options d’inscription](https://dashboard.stripe.com/settings/connect/onboarding-options/countries) de manière à demander automatiquement certaines fonctionnalités lors de la création d’un compte.

Les interfaces utilisateur d’inscription de Stripe recueillent automatiquement les conditions requises pour les fonctionnalités demandées. Pour réduire les efforts d’inscription, demandez uniquement les fonctionnalités dont vous avez besoin.

### Préremplissage des informations

Si vous disposez d’informations sur le titulaire du compte (comme son nom, son adresse, etc.), vous pouvez simplifier l’inscription en les fournissant lors de la création ou de la modification du compte. L’interface d’inscription demande au titulaire du compte de confirmer les informations préremplies avant d’accepter le [contrat d’utilisation du service Connect](https://docs.stripe.com/connect/service-agreement-types.md). Le titulaire du compte peut modifier toutes les informations préremplies avant d’accepter le contrat d’utilisation du service, même si vous avez fourni les informations à l’aide de l’API Accounts.

Si vous inscrivez un compte et que votre plateforme lui fournit une URL, préremplissez la [business_profile.url](https://docs.stripe.com/api/accounts/create.md#create_account-business_profile-url) du compte. Si l’entreprise n’a pas d’URL, vous pouvez préremplir sa [business_profile.product_description](https://docs.stripe.com/api/accounts/create.md#create_account-business_profile-product_description) à la place.

Lorsque vous testez votre intégration, utilisez des [données de test](https://docs.stripe.com/connect/testing.md) pour simuler différents résultats, notamment la vérification d’identité, la vérification des informations de l’entreprise, les échecs de virement, etc.

## Déterminer les informations à collecter

En tant que plateforme, vous devez décider entre collecter toutes les informations requises auprès de vos comptes connectés au début du processus *(inscription complète)* (Upfront onboarding is a type of onboarding where you collect all required verification information from your users at sign-up), ou les recueillir progressivement *(inscription progressive)* (Incremental onboarding is a type of onboarding where you gradually collect required verification information from your users. You collect a minimum amount of information at sign-up, and you collect more information as the connected account earns more revenue). L’inscription complète collecte les exigences `eventually_due` pour le compte, tandis que l’inscription progressive collecte uniquement les exigences `currently_due`.

| Type d’inscription | Avantages                                                                                                                                                                                                                                                                               |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \**En amont **     | - Ne nécessite normalement qu’une seule requête pour l’ensemble des informations
  - Évite les problèmes de paiement et de traitement dus au non-respect des délais
  - Permet de détecter en amont les risques potentiels lorsque les clients refusent de communiquer des informations |
| **Progressive**    | - Les comptes peuvent s’inscrire rapidement parce qu’ils n’ont pas à fournir autant d’informations                                                                                                                                                                                      |

Pour déterminer si vous devez utiliser l’inscription complète ou progressive, consultez les [exigences](https://docs.stripe.com/connect/required-verification-information.md) relatives aux emplacements et aux fonctionnalités de vos comptes connectés. Stripe s’efforce de minimiser son impact sur les comptes connectés, cependant, les exigences sont susceptibles d’évoluer.

Dans le cas des comptes connectés pour lesquels vous êtes responsable de la collecte des exigences, vous pouvez personnaliser le comportement des [exigences futures](https://docs.stripe.com/connect/handle-verification-updates.md) à l’aide du paramètre `collection_options`. Pour collecter les futurs besoins du compte, définissez [`collection_options.future_requirements`](https://docs.stripe.com/api/account_links/create.md#create_account_link-collection_options-future_requirements) sur `include`.

## Créer un lien de compte [Côté serveur]

Créez un [lien de compte](https://docs.stripe.com/api/account_links/create.md) en utilisant l’ID du compte connecté et en incluant une [URL de rafraîchissement](https://docs.stripe.com/connect/hosted-onboarding.md#refresh-url) ainsi qu’une [URL de redirection](https://docs.stripe.com/connect/hosted-onboarding.md#return-url). Stripe redirige le compte connecté vers l’URL de rafraîchissement si l’URL du lien de compte a déjà été visitée, a expiré ou n’est pas valide. Stripe redirige les comptes connectés vers l’URL de redirection lorsqu’ils ont terminé ou quitté le flux d’inscription. De plus, en fonction des informations que vous avez besoin de recueillir, vous pouvez transmettre soit `currently_due`, soit `eventually_due` pour le paramètre `collection_options.fields`. Dans cet exemple, l’option `eventually_due` est transmise pour utiliser l’inscription complète. L’option `currently_due` est quant à elle transmise pour l’inscription progressive.

```curl
curl https://api.stripe.com/v1/account_links \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account={{CONNECTEDACCOUNT_ID}}" \
  --data-urlencode "refresh_url=https://example.com/refresh" \
  --data-urlencode "return_url=https://example.com/return" \
  -d type=account_onboarding \
  -d "collection_options[fields]=eventually_due"
```

### Rediriger votre compte connecté vers l’URL de lien de compte

Redirigez le compte connecté vers l’URL de lien de compte pour l’envoyer vers le flux d’inscription des utilisateurs. Vous ne pouvez utiliser chaque URL de lien de compte temporaire qu’une seule fois, car elle donne accès aux informations personnelles du titulaire du compte. Authentifiez le compte dans votre application avant de le rediriger vers cette URL.[Pré-remplissez](https://docs.stripe.com/connect/hosted-onboarding.md#prefill-information) toutes les informations du compte avant de générer le lien de compte, car vous ne pourrez plus lire ni écrire d’informations pour le compte connecté par la suite.

> N’envoyez pas d’URL de lien de compte par e-mail, SMS ou autre moyen de paiement en dehors de l’application de votre plateforme. Fournissez-les plutôt au titulaire du compte authentifié dans votre application.

#### iOS

#### Swift

```swift
import UIKit
import SafariServices

let BackendAPIBaseURL: String = "" // Set to the URL of your backend server

class ConnectOnboardViewController: UIViewController {

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        let connectWithStripeButton = UIButton(type: .system)
        connectWithStripeButton.setTitle("Connect with Stripe", for: .normal)
        connectWithStripeButton.addTarget(self, action: #selector(didSelectConnectWithStripe), for: .touchUpInside)
        view.addSubview(connectWithStripeButton)

        // ...
    }

    @objc
    func didSelectConnectWithStripe() {
        if let url = URL(string: BackendAPIBaseURL)?.appendingPathComponent("onboard-user") {
          var request = URLRequest(url: url)
          request.httpMethod = "POST"
          let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
              guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any],
                  let accountURLString = json["url"] as? String,
                  let accountURL = URL(string: accountURLString) else {
                      // handle error
              }

              let safariViewController = SFSafariViewController(url: accountURL)
              safariViewController.delegate = self

              DispatchQueue.main.async {
                  self.present(safariViewController, animated: true, completion: nil)
              }
          }
        }
    }

    // ...
}

extension ConnectOnboardViewController: SFSafariViewControllerDelegate {
    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
        // the user may have closed the SFSafariViewController instance before a redirect
        // occurred. Sync with your backend to confirm the correct state
    }
}

```

#### Android

```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".activity.ConnectWithStripeActivity">

    <Button
        android:id="@+id/connect_with_stripe"
        android:text="Connect with Stripe"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        style="?attr/materialButtonOutlinedStyle"
        />

</androidx.constraintlayout.widget.ConstraintLayout>
```

#### Kotlin

```kotlin
class ConnectWithStripeActivity : AppCompatActivity() {

    private val viewBinding: ActivityConnectWithStripeViewBinding by lazy {
        ActivityConnectWithStripeViewBinding.inflate(layoutInflater)
    }
    private val httpClient = OkHttpClient()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(viewBinding.root)

        viewBinding.connectWithStripe.setOnClickListener {
            val weakActivity = WeakReference<Activity>(this)
            val request = Request.Builder()
                .url(BACKEND_URL + "onboard-user")
                .post("".toRequestBody())
                .build()
            httpClient.newCall(request)
                .enqueue(object: Callback {
                    override fun onFailure(call: Call, e: IOException) {
                        // Request failed
                    }
                    override fun onResponse(call: Call, response: Response) {
                        if (!response.isSuccessful) {
                            // Request failed
                        } else {
                            val responseData = response.body?.string()
                            val responseJson =
                                responseData?.let { JSONObject(it) } ?: JSONObject()
                            val url = responseJson.getString("url")

                            weakActivity.get()?.let {
                                val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
                                val customTabsIntent = builder.build()
                                customTabsIntent.launchUrl(it, Uri.parse(url))
                            }
                        }
                    }
                })
        }
    }

    internal companion object {
        internal const val BACKEND_URL = "https://example-backend-url.com/"
    }
}
```

## Identifier et traiter les mises à jour des exigences [Côté serveur]

Configurez votre intégration pour [écouter les modifications](https://docs.stripe.com/connect/handling-api-verification.md#verification-process) des exigences du compte. Vous pouvez tester la gestion des nouvelles exigences (et la désactivation des paiements et virements qui peut en résulter) en utilisant les [cartes de test dotées de déclencheurs](https://docs.stripe.com/connect/testing.md#trigger-cards).

Renvoyez un compte connecté via l’inscription lorsqu’il est associé à des exigences `currently_due` ou `eventually_due`. Il n’est pas nécessaire d’identifier les exigences spécifiques, car l’interface d’inscription sait quelles informations elle doit collecter. Par exemple, si une faute de frappe empêche la vérification de l’identité du propriétaire du compte, l’inscription invite ce dernier à charger une pièce d’identité.

Stripe vous informe de toute [future mise à jour des exigences](https://support.stripe.com/user/questions/onboarding-requirements-updates) ayant une incidence sur vos comptes connectés. Vous pouvez collecter ces informations de manière proactive en consultant les [futures exigences](https://docs.stripe.com/api/accounts/object.md#account_object-future_requirements) applicables à vos comptes.

Dans le cas des comptes connectés pour lesquels [controller.requirement_collection](https://docs.stripe.com/api/accounts/object.md#account_object-controller-requirement_collection) est `stripe`, vous cessez de recevoir des mises à jour concernant les informations d’identité après avoir créé un [lien de compte](https://docs.stripe.com/api/account_links.md) ou une [session de compte](https://docs.stripe.com/api/account_sessions.md).

Les comptes stockent les informations d’identité dans les hachages `company` et `individual`.

### Gérer les erreurs de vérification

Écoutez l’événement [account.updated](https://docs.stripe.com/api/events/types.md#event_types-account.updated). Si le compte contient des champs `currently_due` à l’arrivée de la date `current_deadline`, la fonctionnalité correspondante est désactivée et ces champs sont ajoutés à `past_due`.

Laissez vos comptes remplir les exigences de vérification en les dirigeant vers le formulaire de l’inscription hébergée par Stripe.
 (See full diagram at https://docs.stripe.com/connect/hosted-onboarding)
## Gérer le retour du compte connecté vers votre plateforme [Côté serveur]

Le lien de compte nécessite une `refresh_url` et une `return_url` pour gérer tous les cas de redirection des comptes connectés vers votre plateforme. Il est important de les mettre en œuvre correctement afin de fournir le meilleur flux d’inscription pour vos comptes connectés.

> Vous pouvez utiliser le protocole HTTP pour vos `refresh_url` et `return_url` lorsque vous êtes dans un environnement de test (par exemple, pour effectuer des tests localement), mais notez que le mode production n’accepte que le protocole&nbsp;HTTPS. Assurez-vous d’avoir remplacé les URL de test par des URL&nbsp;HTTPS avant le lancement en production.

### URL d’actualisation

Votre compte connecté est redirigé vers l’URL `refresh_url` lorsque&nbsp;:

- Le lien a expiré (quelques minutes se sont écoulées depuis la création du lien).
- Le lien a déjà été visité (le compte connecté a actualisé la page ou a cliqué sur le bouton **précédent** ou **suivant**).
- Le lien a été partagé dans une application tierce, comme un client de messagerie, qui tente d’accéder à l’URL pour afficher un aperçu. De nombreux clients visitent automatiquement les liens, ce qui entraîne leur expiration.

La `refresh_url` doit appeler une méthode sur votre serveur pour créer un nouveau lien de compte avec les mêmes paramètres et rediriger le compte connecté vers la nouvelle URL de lien de compte.

### URL de redirection

Stripe redirige le compte connecté vers cette URL lorsqu’il termine le flux d’inscription ou qu’il clique sur **Enregistrer pour plus tard** à n’importe quel moment du flux. Cela **ne signifie pas** que toutes les informations ont été recueillies ou que toutes les exigences du compte ont été satisfaites. Cela signifie uniquement que l’entrée et la sortie du flux ont fonctionné correctement.

Aucun état n’est transmis avec cette URL. Une fois qu’un compte connecté est redirigé vers `return_url`, vérifiez si le compte a terminé son inscription. [Récupérer le compte](https://docs.stripe.com/api/accounts/retrieve.md) et vérifiez le hachage des [exigences](https://docs.stripe.com/api/accounts/object.md#account_object-requirements) pour connaître les exigences en attente. Vous pouvez aussi écouter l’événement `account.updated` envoyé à votre endpoint de webhook et mettre en cache l’état du compte dans votre application. Si le compte n’a pas terminé son inscription, incluez des invites dans votre application pour permettre de poursuivre l’inscription plus tard.

## Gestion des mises à jour initiées par le compte connecté [Côté serveur]

L’inscription hébergée par Stripe prend également en charge les mises à jour des informations déjà fournies par les comptes connectés. Écoutez l’événement `account.updated` envoyé à votre endpoint de webhook pour recevoir une notification lorsque le compte satisfait aux exigences et met à jour ses informations.

Lorsque vous créez un lien de compte, vous pouvez définir le `type` sur `account_onboarding` ou `account_update`.

> #### Restriction de type de lien de compte
> 
> Vous pouvez créer des liens de compte de type `account_update` uniquement pour les comptes connectés où votre plateforme est responsable de la collecte des exigences, y compris les comptes personnalisés. Vous ne pouvez pas les créer pour les comptes qui ont accès à un Dashboard hébergé par Stripe. Si vous utilisez des [composants intégrés Connect](https://docs.stripe.com/connect/get-started-connect-embedded-components.md), vous pouvez inclure des composants qui permettent à vos comptes connectés de mettre à jour leurs propres informations. Pour un compte sans accès au tableau de bord hébergé par Stripe où Stripe est responsable des soldes négatifs, vous devez utiliser des composants intégrés.

### Liens de compte pour account_onboarding

Les liens de compte de ce type fournissent un formulaire permettant de saisir des exigences en attente. Utilisez-le lors de l’inscription d’un nouveau compte connecté ou lorsqu’un utilisateur existant a de nouvelles exigences (par exemple, lorsqu’un compte connecté a déjà fourni suffisamment d’informations mais que vous avez demandé une nouvelle fonctionnalité qui nécessite des informations supplémentaires). Dirigez l’utilisateur vers ce type de lien de compte pour recueillir les nouvelles informations dont vous avez besoin.

### Liens de compte pour account_update

Les liens de compte de ce type sont activés pour les comptes dont votre plateforme est responsable du recouvrement des exigences. Les liens `account_update` affichent les attributs déjà renseignés sur l’objet compte et permettent à votre compte connecté de modifier les informations précédemment fournies (par exemple, pour mettre à jour leur adresse). Ajoutez une option dans votre application (par exemple, «&nbsp;Modifier mon profil&nbsp;» ou «&nbsp;Mettre à jour mes informations de vérification&nbsp;») pour permettre aux comptes connectés d’effectuer eux-mêmes les mises à jour.

## Prise en charge des navigateurs

L’inscription hébergée par Stripe n’est prise en charge que dans les navigateurs Web. Vous ne pouvez pas l’utiliser dans des vues Web intégrées à des applications mobiles ou de bureau.