# Von Stripe gehostetes Onboarding

Führen Sie das Onboarding verbundener Konten durch indem Sie sie zu einem von Stripe gehosteten Onboarding-Ablauf weiterleiten.

Das von Stripe gehostete Onboarding erfasst Geschäfts- und Identitätsprüfungsinformationen von verbundenen Konten mit minimalem Aufwand seitens der Plattform. Es handelt sich um ein von Stripe gehostetes Webformular, das basierend auf den Funktionen, dem Land und dem Unternehmenstyp jedes verbundenen Kontos dynamisch erzeugt wird.
![](https://b.stripecdn.com/docs-statics-srv/assets/hosted_onboarding_form.e59ba8300f563e43489953f06127f52c.png)

Das gehostete Onboarding-Formular in der Stripe-Beispielintegration, [Furever](https://furever.dev/).

Das von Stripe gehostete Onboarding unterstützt das[vernetzte Onboarding](https://docs.stripe.com/connect/networked-onboarding.md), das es Inhaberinnen und Inhabern mehrerer Stripe-Konten ermöglicht, Geschäftsinformationen zwischen diesen Konten zu teilen. Beim Onboarding eines Kontos können sie diese Informationen von einem bestehenden Konto wiederverwenden, anstatt sie erneut einzureichen.

## Onboarding-Formular anpassen [Dashboard]

Rufen Sie im Dashboard die Seite [Verbindungseinstellungen](https://dashboard.stripe.com/account/applications/settings) auf, um das Erscheinungsbild des Formulars mit dem Namen, der Farbe und dem Symbol Ihrer Marke anzupassen. Für das von Stripe gehostete Onboarding sind diese Angaben erforderlich. Stripe empfiehlt außerdem, während des Onboardings [Bankkontodaten](https://dashboard.stripe.com/settings/connect/payouts/external_accounts) aus Ihren verbundenen Konten zu erfassen.

## Konten erstellen und Informationen vorab angeben [Serverseitig]

Erstellen Sie ein [verbundenes Konto](https://docs.stripe.com/api/accounts.md) mit den Standard-[Controller](https://docs.stripe.com/api/accounts/create.md#create_account-controller)-Eigenschaften. Siehe [Entwurf einer Integration](https://docs.stripe.com/connect/interactive-platform-guide.md) Um mehr über die Eigenschaften des Controllers zu erfahren. Alternativ können Sie ein verbundenes Konto erstellen, indem Sie einen [Kontotyp](https://docs.stripe.com/api/accounts/create.md#create_account-type) angeben.

Wenn Sie das Land des Kontos angeben oder Funktionen dafür anfordern, kann der/die Kontoinhaber/in das Land nicht ändern. Andernfalls hängt es vom Dashboard-Zugriff des Kontos ab:

- **Vollständiges Stripe-Dashboard:** Während der Registrierung kann der/die Kontoinhaber/in ein beliebiges Akquisitionsland auswählen, genau wie bei der Anmeldung für ein normales Stripe-Konto. Stripe fordert je nach ausgewähltem Land automatisch eine Reihe von Funktionen für das Konto an.
- **Express-Dashboard:** Beim Onboarding kann der/die Kontoinhaber/in aus einer Liste von Ländern wählen, die Sie in den [Onboarding-Optionen](https://dashboard.stripe.com/settings/connect/onboarding-options/countries) Ihres Plattform-Dashboards konfigurieren. Sie können diese Optionen auch konfigurieren, um die Standardfunktionen anzugeben, die für Konten in jedem Land angefordert werden sollen.
- **Kein Stripe-Dashboard**: Wenn Stripe für die Erfassung der Anforderungen verantwortlich ist, kann der Kontoinhaber im Onboarding-Prozess ein beliebiges Akquisitionsland auswählen. Andernfalls müssen in Ihrem nutzerdefinierten Onboarding-Ablauf das Land festgelegt und Funktionen angefordert werden.

#### Mit Controllereigenschaften

```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"
```

#### Mit Kontotyp

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

Die Antwort enthält die ID, die Sie verwenden, um in Ihrer gesamten Integration auf das `Account` zu verweisen.

### Funktionen anfordern

Sie können [Funktionen](https://docs.stripe.com/connect/account-capabilities.md#creating) beim Erstellen eines Kontos anfordern, indem Sie die Eigenschaft `requested` der gewünschten Funktionen auf „true“ festlegen. Bei Konten mit Zugriff auf das Express-Dashboard können Sie Ihre [Onboarding-Optionen](https://dashboard.stripe.com/settings/connect/onboarding-options/countries) auch so konfigurieren, dass bestimmte Funktionen beim Erstellen eines Kontos automatisch angefordert werden.

Die Onboarding-Nutzeroberflächen von Stripe erfassen automatisch die Anforderungen für angeforderte Funktionen. Fordern Sie nur Funktionen an, die Sie benötigen, um den Onboarding-Aufwand zu reduzieren.

### Informationen vorab angeben

Wenn Sie Informationen über den/die Kontoinhaber/in haben (wie Name, Adresse oder andere Details), können Sie das Onboarding vereinfachen, indem Sie diese bei der Erstellung oder Aktualisierung des Kontos angeben. Die Onboarding-Schnittstelle fordert den/die Kontoinhaber/in auf, die vorausgefüllten Informationen zu bestätigen, bevor er/sie den [Connect-Rahmenvertrag](https://docs.stripe.com/connect/service-agreement-types.md) akzeptiert. Der/die Kontoinhaber/in kann alle vorausgefüllten Informationen bearbeiten, bevor er/sie den Rahmenvertrag akzeptiert, selbst wenn Sie die Informationen über die Accounts API bereitgestellt haben.

Wenn Sie das Onboarding eines Kontos durchlaufen haben und Ihre Plattform eine URL dafür bereitstellt, füllen Sie die [business_profile.url](https://docs.stripe.com/api/accounts/create.md#create_account-business_profile-url) des Kontos vorab aus. Wenn das Unternehmen keine URL hat, können Sie stattdessen seine [business_profile.product_description](https://docs.stripe.com/api/accounts/create.md#create_account-business_profile-product_description) vorab ausfüllen.

Verwenden Sie beim Testen Ihrer Integration [Testdaten](https://docs.stripe.com/connect/testing.md), um verschiedene Ergebnisse zu simulieren, zum Beispiel Identitätsprüfung, Verifizierung der Unternehmensinformationen, Auszahlungsfehler und mehr.

## Die zu erfassenden Informationen bestimmen

Sie als Plattform müssen entscheiden, ob die erforderlichen Informationen von den verbundenen Konten *vorab* (Upfront onboarding is a type of onboarding where you collect all required verification information from your users at sign-up) oder *inkrementell* (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) erfasst werden sollen. Beim Onboarding im Voraus werden die `eventually_due`-Anforderungen für das Konto erfasst, während beim inkrementellen Onboarding nur die `currently_due`-Anforderungen erfasst werden.

| Onboarding-Typ   | Vorteile                                                                                                                                                                                                                                                              |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Im Voraus**    | - Normalerweise ist nur eine Abfrage für alle Informationen erforderlich
  - Vermeidet die Möglichkeit von Auszahlungs- und Bearbeitungsproblemen aufgrund verpasster Fristen
  - Stellt frühzeitig ein potenzielles Risiko dar, wenn Konten Informationen verweigern |
| **Inkrementell** | - Das Onboarding von Konten kann schnell abgeschlossen werden, da sie nicht so viele Informationen bereitstellen müssen                                                                                                                                               |

Um zu bestimmen, ob Sie das Onboarding im Voraus oder inkrementelles Onboarding nutzen möchten, überprüfen Sie die [Anforderungen](https://docs.stripe.com/connect/required-verification-information.md) für die Standorte und Funktionen Ihrer verbundenen Konten. Auch wenn Stripe versucht, etwaige Auswirkungen auf verbundene Konten zu minimieren, können sich Anforderungen im Laufe der Zeit ändern.

Bei verbundenen Konten, bei denen Sie für die Anforderungserfassung verantwortlich sind, können Sie das Verhalten [zukünftiger Anforderungen](https://docs.stripe.com/connect/handle-verification-updates.md) mithilfe des Parameters `collection_options` anpassen. Um die zukünftigen Anforderungen des Kontos zu erfassen, setzen Sie [`collection_options.future_requirements`](https://docs.stripe.com/api/account_links/create.md#create_account_link-collection_options-future_requirements) auf `include`.

### Zusätzliche öffentliche Angaben erfassen

Stripe erfasst die erforderlichen öffentlichen Angaben für jedes verbundene Konto. Sie können zusätzliche Felder auswählen, deren Wert Sie beim Onboarding entsprechend den Anforderungen Ihres Unternehmens erfassen möchten. Alle Felder, die Sie auswählen, und die Stripe nicht benötigt, werden als optional angezeigt, und verbundene Konten können wählen, ob sie diese bereitstellen möchten.

1. Aktivieren Sie in den Einstellungen für [öffentliche Angaben](https://dashboard.stripe.com/settings/connect/onboarding-options/public-details) im Dashboard die Schaltfläche **öffentliche Angaben erfassen**.
1. Wählen Sie die Felder aus, die verbundenen Konten beim Onboarding angezeigt werden sollen.
1. Klicken Sie auf **Speichern**.

#### Verfügbare Felder:

Sie können die folgenden öffentlichen Angaben erfassen:

| Feld                                                                                               | Beschreibung                                                                                                                                 |
| -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| [Zahlungsbeschreibung in der Abrechnung](https://docs.stripe.com/connect/statement-descriptors.md) | Der Text, der auf der Kreditkartenabrechnung oder dem Kontoauszug einer Kundin/eines Kunden für Zahlungen an das verbundene Konto erscheint. |
| Telefonnummer des Kundensupports                                                                   | Eine Telefonnummer, unter der Kundinnen und Kunden den Support zu Fragen zum verbundenen Konto erreichen.                                    |
| Adresse des Kundensupports                                                                         | Eine E-Mail-Adresse, unter der Kundinnen und Kunden das verbundene Konto kontaktieren können.                                                |
| E-Mail-Adresse des Kundensupports                                                                  | Eine E-Mail-Adresse, unter der Kundinnen und Kunden das verbundene Konto kontaktieren können.                                                |

> #### Anforderungen variieren
> 
> Die Anforderungen von Stripe variieren je nach verbundenem Konto je nach Unternehmenstyp, Land und angeforderten Funktionen. Aktivieren Sie Felder, um sicherzustellen, dass diese beim Onboarding grundsätzlich angezeigt werden, unabhängig davon, ob sie erforderlich sind oder nicht.

## Konto-Link erstellen [Serverseitig]

Erstellen Sie einen [Konto-Link](https://docs.stripe.com/api/account_links/create.md) mit der verbundenes Konto-ID und fügen Sie eine [Aktualisierungs-URL](https://docs.stripe.com/connect/hosted-onboarding.md#refresh-URL) und eine [Rückgabe-URL](https://docs.stripe.com/connect/hosted-onboarding.md#return-URL) hinzu. Stripe leitet das verbundene Konto an die Aktualisierungs-URL weiter, wenn die URL für den Konto-Link bereits besucht wurde, abgelaufen oder anderweitig ungültig ist. Stripe leitet verbundene Konten an die Rückgabe-URL weiter, wenn sie den Onboarding-Ablauf abgeschlossen oder verlassen haben. Darüber hinaus müssen Sie, je nach den erfassten Informationen, entweder `currently_due` oder `eventually_due` als `collection_options.fields` festlegen. In diesem Beispiel wird `eventually_due` verwendet, um das Onboarding im Voraus zu verwenden. Für inkrementelles Onboarding setzen Sie es auf `currently_due`.

```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"
```

### Ihr verbundenes Konto an die Konto-Link-URL weiterleiten

Leiten Sie das verbundene Konto an die Konto-Link-URL weiter, um es an den Onboarding-Ablauf zu senden. Sie können jede temporäre Konto-Link-URL nur einmal verwenden, da sie Zugriff auf die persönlichen Daten des Kontoinhabers/der Kontoinhaberin gewährt. Authentifizieren Sie das Konto in Ihrer Anwendung, bevor Sie es an diese URL weiterleiten. [Füllen Sie](https://docs.stripe.com/connect/hosted-onboarding.md#prefill-information) alle Kontoinformationen vor der Erstellung des Konto-Links aus, da Sie danach keine Informationen für das verbundene Konto lesen oder schreiben können.

> Versenden Sie keine Konto-Link-URLs per E-Mail, Textnachricht oder anderweitig außerhalb Ihrer Plattformanwendung. Stellen Sie die URLs Ihren authentifizierten Kontoinhaberinnen und Kontoinhabern stattdessen in Ihrer Anwendung zur Verfügung.

#### 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/"
    }
}
```

## Aktualisierungen der Anforderungen identifizieren und adressieren [Serverseitig]

Richten Sie Ihre Integration so ein, [dass Änderungen](https://docs.stripe.com/connect/handling-api-verification.md#verification-process) der Kontoanforderungen überwacht werden. Sie können den Umgang mit neuen Anforderungen (und wie diese möglicherweise Zahlungen und Auszahlungen deaktivieren) mit den [Test-Auslöserkarten](https://docs.stripe.com/connect/testing.md#trigger-cards) testen.

Senden Sie ein verbundenes Konto über das Onboarding zurück, wenn es `currently_due`- oder `eventually_due`-Anforderungen erfüllt. Sie müssen die spezifischen Anforderungen nicht identifizieren, da die Onboarding-Schnittstelle weiß, welche Informationen sie erfassen muss. Wenn beispielsweise ein Tippfehler die Verifizierung der Identität des Kontoinhabers/der Kontoinhaberin verhindert, fordert das Onboarding ihn/sie auf, ein Identitätsdokument hochzuladen.

Stripe benachrichtigt Sie über alle [bevorstehenden Aktualisierungen der Anforderungen](https://support.stripe.com/user/questions/onboarding-requirements-updates), die Ihre verbundenen Konten betreffen. Sie können diese Informationen proaktiv erfassen, indem Sie die [zukünftigen Anforderungen](https://docs.stripe.com/api/accounts/object.md#account_object-future_requirements) für Ihre Konten überprüfen.

Erhalten Sie für verbundene Konten, bei denen [controller.requirement_collection](https://docs.stripe.com/api/accounts/object.md#account_object-controller-requirement_collection) `stripe` ist, nach dem Erstellen einer [Konto-Link](https://docs.stripe.com/api/account_links.md) oder einer [Kontositzung](https://docs.stripe.com/api/account_sessions.md) keine Updates mehr für Identitätsinformationen.

Konten speichern Identitätsinformationen in den Hashes `company` und `individual`.

### Verifizierungsfehler handhaben

Überwachen Sie das Ereignis [account.updated](https://docs.stripe.com/api/events/types.md#event_types-account.updated). Wenn das Konto zum Zeitpunkt der `current_deadline` Felder mit der Bezeichnung `currently_due` enthält, wird die entsprechende Funktion deaktiviert und diese Felder werden zu `past_due` hinzugefügt.

Lassen Sie Ihre Konten die Verifizierungsanforderungen regeln, indem Sie sie an das von Stripe gehostete Onboarding-Formular leiten.
 (See full diagram at https://docs.stripe.com/connect/hosted-onboarding)
## Rückkehr des verbundenen Kontos zu Ihrer Plattform steuern [Serverseitig]

Der Konto-Link benötigt eine `refresh_url` und `return_url`, um alle Fälle bearbeiten zu können, in denen das verbundene Konto zurück zu Ihrer Plattform geleitet wird. Es ist wichtig, diese korrekt zu implementieren, um Ihren verbundenen Konten den besten Onboarding-Ablauf zu bieten.

> Sie können HTTP für Ihre `refresh_url` und `return_url` verwenden, während Sie sich in einer Testumgebung befinden (z.&nbsp;B. für lokale Tests). Im Live-Modus wird jedoch nur HTTPS akzeptiert. Sie müssen alle Test-URLs gegen HTTPS-URLs austauschen, bevor Sie live gehen.

### Aktualisierungs-URL

Ihr verbundenes Konto wird an die `refresh_url` weitergeleitet, wenn:

- Der Link ist abgelaufen (seit Erstellung des Links sind ein paar Minuten vergangen).
- Der Link wurde bereits aufgerufen (das verbundene Konto hat die Seite aktualisiert oder auf die **Zurück**- oder **Vorwärts**-Schaltfläche geklickt).
- Der Link wurde in einer Anmeldeformular eines Drittanbieters freigegeben, z. B. in einem Messaging-Client, der versucht, auf die URL zuzugreifen, um eine Vorschau anzuzeigen. Viele Kunden besuchen automatisch Links, was dazu führt, dass ein Konto-Link abläuft.

Die `refresh_url` sollte eine Methode auf Ihrem Server aufrufen, um einen neuen Konto-Link mit denselben Parametern zu erstellen und das verbundenes Konto an die URL des neuen Konto-Links umzuleiten.

### Rückgabe-URL

Stripe leitet das verbundene Konto zurück zu dieser URL, wenn sie den Onboarding-Ablauf abschließen oder an einer beliebigen Stelle des Ablaufs auf **Für später speichern** klicken. Dies bedeutet nicht, dass alle Informationen erfasst wurden oder dass es keine ausstehenden Anforderungen für das Konto gibt. Es bedeutet lediglich, dass der Ablauf ordnungsgemäß gestartet und verlassen wurde.

Mit dieser URL wird kein Status übergeben. Nachdem ein verbundenes Konto an die `return_url` weitergeleitet wurde, ermitteln Sie, ob das Konto das Onboarding abgeschlossen hat. [Rufen Sie das Konto ab](https://docs.stripe.com/api/accounts/retrieve.md) und überprüfen Sie den Hash [Anforderungen](https://docs.stripe.com/api/accounts/object.md#account_object-requirements) auf ausstehende Anforderungen. Alternativ können Sie das an Ihren Webhook-Endpoint gesendete Ereignis `account.updated` überwachen und den Status des Kontos in Ihrer Anwendung zwischenspeichern. Wenn das Konto das Onboarding noch nicht abgeschlossen hat, geben Sie in Ihrer Anwendung Eingabeaufforderungen an, damit das Onboarding später fortgesetzt werden kann.

## Von verbundenen Konten initiierte Aktualisierungen verarbeiten [Serverseitig]

Von Stripe gehostetes Onboarding unterstützt auch von verbundenen Konten initiierte Aktualisierungen der Informationen, die diese bereits angegeben haben. Überwachen Sie das Ereignis `account.updated`, das an Ihren Webhook-Endpoint gesendet wird, um benachrichtigt zu werden, wenn das Konto die Anforderungen erfüllt und seine Informationen aktualisiert.

Wenn Sie einen Kontolink erstellen, können Sie den `type` entweder auf `account_onboarding` oder `account_update`festlegen.

> #### Beschränkung des Konto-Link-Typs
> 
> Sie können Konto-Links des Typs `account_update` nur für verbundene Konten erstellen, bei denen Ihre Plattform für den Einzug von Anforderungen verantwortlich ist, einschließlich benutzerdefinierter Konten. Sie können sie nicht für Konten erstellen, die Zugriff auf ein von Stripe gehostetes Dashboard haben. Wenn Sie [Eingebettete Connect-Komponenten](https://docs.stripe.com/connect/get-started-connect-embedded-components.md) verwenden, können Sie Komponenten einfügen, die es Ihren verbundenen Konten ermöglichen, ihre eigenen Informationen zu aktualisieren. Für ein Konto ohne Zugriff auf das von Stripe gehostete Dashboard, bei dem Stripe für negative Guthaben haftet, müssen Sie eingebettete Komponenten verwenden.

### Kontolinks für account_onboarding

Konto-Links dieser Art bieten ein Formular zur Eingabe ausstehender Anforderungen. Verwenden Sie es, wenn Sie das Onboarding eines neuen verbundenen Kontos durchführen oder wenn ein/e bestehende/r Nutzer/in neue Anforderungen hat (zum Beispiel wenn ein verbundenes Konto bereits genügend Informationen bereitgestellt hat, Sie jedoch eine neue Funktion angefordert haben, für die zusätzliche Informationen erforderlich sind). Senden Sie sie an diese Art von Konto-Link, um nur die neuen Informationen zu erfassen, die Sie benötigen.

### Kontolinks für account_update

Konto-Links dieses Typs sind für Konten aktiviert, bei denen Ihre Plattform für die Anforderungserfassung verantwortlich ist. `account_update`-Links zeigen die Attribute an, die bereits auf dem Kontoobjekt ausgefüllt sind, und ermöglichen es dem verbundenes Konto, zuvor bereitgestellte Informationen zu bearbeiten. Geben Sie in Ihrer Anwendung eine Option an (z. B. „Mein Profil bearbeiten“ oder „Meine Verifizierungsinformationen aktualisieren“), mit der verbundene Konten selbst Aktualisierungen vornehmen können.

## Browserunterstützung

Von Stripe gehostetes Onboarding wird nur in Webbrowsern unterstützt. Sie können es nicht in eingebetteten Webansichten in mobilen oder Desktop-Anwendungen verwenden.