Identitätsnachweise Ihrer Nutzer/innen verifizieren

SDK installieren Client-side

Das Stripe Android SDK ist Open Source und vollständig dokumentiert.

Um das SDK zu installieren, fügen Sie identity in den Block dependencies Ihrer app/build.gradle-Datei ein:

plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Identity Android SDK
  implementation("com.stripe:identity:21.23.0")
}

TFLite in Google Play verwenden, um die Größe der Binärdatei zu reduzieren Client-side

Identity Android SDK verwendet eine portable TFLite-Laufzeit, um KI-Modelle auszuführen. Wenn Ihre Anwendung über Google Play veröffentlicht wird, können Sie die Google Play-Laufzeitumgebung verwenden, um die SDK-Größe um etwa 1,2 MB zu reduzieren.

dependencies {
  // ...

  // Stripe Identity Android SDK
  implementation('com.stripe:identity:21.23.0') {
    exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
  }
  implementation('com.stripe:ml-core-googleplay:21.23.0') // include the Google Play TFLite runtime
}

Material Theme einrichten Client-side

Das Stripe Identity Android SDK erfordert, dass die Hosting-Aktivität das Material Theme verwendet. So aktivieren Sie das Material Theme:

1. Öffnen Sie die Datei app/src/main/AndroidManifest.xml Ihres Projekts.
2. Stellen Sie sicher, dass das auf die application angewendete android:theme ein untergeordnetes Element eines der Material Themes ist (zum Beispiel Theme.MaterialComponents.DayNight).

Weitere Details zum Material Theme finden Sie hier.

Stripe auf dem Server installieren Server-side

Registrieren Sie sich zunächst für ein Stripe-Konto.

Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:

# Available as a gem
sudo gem install stripe

# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

VerificationSession erstellen

Eine VerificationSession ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche Prüfung durchgeführt werden soll). Sie können das Feld verifizierte Ergebnisse erweitern, um Details zu den verifizierten Daten anzuzeigen.

Sie benötigen einen serverseitigen Endpoint zum Erstellen der VerificationSession. Die serverseitige Erstellung der VerificationSession verhindert, dass böswillige Nutzer/innen die Verifizierungsoptionen außer Kraft setzen und Abwicklungskosten für Ihr Konto verursachen. Fügen Sie dem Endpoint eine Authentifizierung hinzu, indem Sie einen Verweis auf die Nutzer/innen in die Metadaten der Sitzung einschließen oder die Sitzungs-ID in Ihrer Datenbank speichern.

Erstellen Sie aus Sicherheitsgründen kein VerificationSession-Objekt, das direkt über den mobilen Client zugänglich ist. Stattdessen stellt Ihr Server dem SDK einen temporären Schlüssel zur Verfügung – einen kurzlebigen API-Schlüssel mit eingeschränktem Zugriff auf die VerificationSession. Einen temporären Schlüssel können Sie sich als Sitzung vorstellen, die das SDK autorisiert, ein bestimmtes VerificationSession-Objekt für die Dauer der Sitzung abzurufen und zu aktualisieren.

Nach der erfolgreichen Erstellung einer VerificationSession und eines temporären Schlüssels senden Sie die VerificationSession-ID und den temporären Geheimschlüssel an den Client, um das Formular zum Hochladen von Dokumenten anzuzeigen.

// Set your secret key. Remember to switch to your live secret key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')(
'sk_test_BQokikJOvBiI2HlWgH4olfQ2');

// In the route handler for /create-verification-session:
// Authenticate your user.

// Create the session.
const verificationSession = await stripe.identity.verificationSessions.create({
  type: 'document',
  provided_details: {
    email: 'user@example.com',
  },
  metadata: {
    user_id: '{{USER_ID}}',
  },
});

// Create an ephemeral key for the VerificationSession
const ephemeralKey = await stripe.ephemeralKeys.create(
  {verification_session: verificationSession.id},
  {apiVersion: '2025-07-30.basil'}
);

// Return only the ID and ephemeral key secret to the frontend.
const verficationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;

Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. localhost:4242) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:

curl -X POST -is "http://localhost:4242/create-verification-session" -d ""

Die Antwort in Ihrem Terminal sieht folgendermaßen aus:

HTTP/1.1 200 OK
Content-Type: application/json

{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }

Richten Sie eine Schaltfläche zum Anzeigen eines Verifizierungsformulars ein. Nachdem sie auf die Schaltfläche geklickt haben, können Ihre Nutzer/innen ein Bild ihres Reisepasses, Führerscheins oder Personalausweises erfassen und hochladen.

Bevor Sie loslegen, sollte Ihre Verifizierungsseite Folgendes enthalten:

• Erläuterungen für die Nutzer/innen zur Notwendigkeit der Identitätsprüfung.
• Eine Schaltfläche zum Verifizieren der Identität über die Nutzeroberfläche von Stripe.

Schaltfläche hinzufügen

Erstellen Sie zunächst eine Activity mit einer Schaltfläche, die auswählbar ist und über eine Ladeanzeige verfügt. Stellen Sie sicher, dass MyHostingActivity AppCompatActivity übernimmt und ein Design verwendet, wobei Theme.MaterialComponents übernommen wird.

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }
}

Stripe Identity SDK importieren

Importieren Sie das Identity SDK in Ihre Aktivität, initialisieren Sie es in der onCreate-Methode. (Dadurch wird ein ActivityResultLauncher für diese AppCompatActivity oder dieses Fragment registriert).

import com.stripe.android.identity.IdentityVerificationSheet

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }

  lateinit var identityVerificationSheet: IdentityVerificationSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(binding.root)
    identityVerificationSheet =
      IdentityVerificationSheet.create(
          this,
          IdentityVerificationSheet.Configuration(
              // Pass your square brand logo by creating it from local resource or
              // Uri.parse("https://path/to/your/brandlogo.jpg")
              brandLogo = logoUri
          )
      ) { verificationResult->
          when (verificationResult) {
            is Completed -> {
                // The user has completed uploading their documents.
                // Let them know that the verification is processing.
                ...
                Log.d(TAG, "Verification Completed!")
            }
            is Canceled -> {
                // The user did not complete uploading their documents.
                // You should allow them to try again.
                ...
                Log.d(TAG, "Verification Canceled!")
            }
            is Failed -> {
                // If the flow fails, you should display the localized error
                // message to your user using throwable.getLocalizedMessage()
                ...
                Log.d(TAG, "Verification Failed!")
            }
         }
      }
  }
}

Eine Aktion zur Schaltfläche „Verifizieren“ hinzufügen

Da Sie nun über eine Schaltfläche und einen Endpoint zum Erstellen einer VerificationSession verfügen, können Sie die Schaltfläche so anpassen, dass das Formular zum Hochladen von Dokumenten nach dem Antippen angezeigt wird.

Fügen Sie einen Aufruf hinzu, um folgende Schritte auszuführen:

• Die VerificationSession-ID und den temporären Geheimschlüssel von Ihrem Endpoint abrufen.
• Ein IdentityVerificationSheet mit Ihrem Marken-Logo instanziieren und dem/der Nutzer/in anzeigen.
• Das VerificationFlowResult verarbeiten, um zu ermitteln, ob der/die Nutzer/in den Verifizierungsablauf abgeschlossen hat.

import com.stripe.android.identity.*

class MyHostingActivity : AppCompatActivity() {
  // binding has a button and a loading indicator
  private val binding by lazy {
    MyHostingActivityBinding.inflate(layoutInflater)
  }
  lateinit var identityVerificationSheet: IdentityVerificationSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    ...
    binding.button.setOnClickListener(::onButtonClick)
  }

  fun onButtonClick() {
    // show loading UI
    // Request the session ID with Fuel or other network libraries
    Fuel.post("https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")
      .responseString { _, _, result ->
          when (result) {
              is Result.Failure -> {
                  // show error UI
              }
              is Result.Success -> {
                  val responseJson = JSONObject(result.value)
                  try {
                      // start verification session
                      identityVerificationSheet.present(
                          verificationSessionId =
                            responseJson.getString("id"),
                          ephemeralKeySecret =
                            responseJson.getString("ephemeral_key_secret")
                      )
                  } catch (t: Throwable) {
                      // show error UI
                  }
              }
          }
      }
  }
}

Verifizierungsformular testen

Testen Sie, ob die Schaltfläche „Verifizieren“ ein Formular zum Hochladen von Dokumenten anzeigt:

• Klicken Sie auf die Schaltfläche Identität verifizieren.
• Stellen Sie sicher, dass keine Fehlermeldungen angezeigt werden.

Wenn Ihre Integration nicht funktioniert:

1. Legen Sie einen Haltepunkt an der Stelle fest, an der Sie die VerificationSession-ID und den temporären Geheimschlüssel abrufen.
2. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine VerificationSession-ID und einen temporären Geheimschlüssel zurückgibt.

Dokumentprüfungen werden in der Regel abgeschlossen, wenn Nutzer/innen zu Ihrer Website zurückgeleitet werden, und Sie können das Ergebnis sofort über die API abrufen. Manchmal steht die Dokumentenprüfung noch nicht bereit und muss asynchron fortgesetzt werden. In diesem Fall werden Sie über Webhooks benachrichtigt, wenn das Verifizierungsergebnis bereitsteht. Nachdem die Verarbeitung abgeschlossen ist, wechselt der Status der VerificationSession von processing zu verified.

Stripe übermittelt die folgenden Ereignisse, wenn sich der Status einer Sitzung ändert:

Verwenden Sie einen Webhook-Handler, um diese Ereignisse zu empfangen und Aktionen wie das Senden einer E-Mail zur Bestätigung, das Aktualisieren der Verifizierungsergebnisse in Ihrer Datenbank oder das Abschließen eines Onboarding-Schritts zu automatisieren. Sie können die Verifizierungsereignisse auch im Dashboard anzeigen.

Ereignisse empfangen und Geschäftsaktionen ausführen

Mit Code

Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Verifizierungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben.

Nutzerdefinierten Webhook erstellen

Ohne Code

Verwenden Sie das Dashboard, um alle Ihre Verifizierungen anzuzeigen, die erfassten Daten zu prüfen und fehlgeschlagene Verifizierungen nachvollziehen zu können.

Testverifizierungen im Dashboard anzeigen