# Identitätsnachweise Ihrer Nutzer/innen verifizieren
Erstellen Sie Sitzungen und erfassen Sie Identitätsnachweise.
In diesem Leitfaden wird erläutert, wie Sie mit Stripe Identity Identitätsnachweise sicher erfassen und verifizieren können.
Zeigen Sie ein Modal zum Hochladen von Dokumenten auf Ihrer Website an. Sie gehen wie folgt vor:
1. Fügen Sie Ihrer Webseite eine Schaltfläche zur Verifizierung hinzu, die ein Modal zum Hochladen von Dokumenten anzeigt.
1. Zeigen Sie eine Bestätigungsseite für die Übermittlung von Identitätsnachweisen an.
1. Umgang mit den Verifizierungsergebnissen.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
1. (Optional) Passen Sie Ihre Markeneinstellungen auf der Seite [Branding-Einstellungen](https://dashboard.stripe.com/settings/branding) an.
## Stripe einrichten [Serverseitig]
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Schaltfläche auf Ihrer Website hinzufügen [Clientseitig]
Erstellen Sie auf Ihrer Website eine Schaltfläche, um die Verifizierung zu starten.
#### HTML + JS
### Schaltfläche hinzufügen
Fügen Sie Ihrer Seite zunächst eine Schaltfläche zur Verifizierung hinzu:
```html
Verify your identity
```
### Stripe.js-Bibliothek zu Ihrer Seite hinzufügen
Fügen Sie [Stripe.js](https://docs.stripe.com/payments/elements.md) zu Ihrer Seite hinzu, indem Sie in Ihr HTML-Dokument einen Script-Tag einbinden:
```html
Verify your identity
```
> Laden Sie **Stripe.js** immer direkt von `https://js.stripe.com`. Sie können die Bibliothek nicht in ein Paket einfügen oder selbst hosten.
### Stripe.js initialisieren
Initialisieren Sie Stripe.js mit Ihrem veröffentlichbaren [API-Schlüssel](https://docs.stripe.com/keys.md), indem Sie das folgende JavaScript an Ihre Seite übergeben:
```html
Verify your identity
```
#### React
### Schaltfläche hinzufügen
Fügen Sie Ihrer Seite zunächst eine Schaltfläche zur Verifizierung hinzu:
```jsx
import React from 'react';
class VerifyButton extends React.Component {
render() {
return (
);
}
}
const App = () => {
return (
);
};
export default App;
```
### Stripe.js installieren
Installieren Sie das [ES-Modul von Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js):
```bash
npm install @stripe/stripe-js
```
> Wenn Sie Node.js auf Ihrem Server verwenden, müssen Sie sowohl die Pakete [stripe](https://www.npmjs.com/package/stripe) als auch [@stripe/stripe-js](https://www.npmjs.com/package/@stripe/stripe-js) installieren. `stripe` wird auf der Server-Seite verwendet, um Anforderungen an die Stripe-API zu senden, während `@stripe/stripe-js` Methoden zum Einbinden von [Stripe.js](https://docs.stripe.com/js.md) in Ihren clientseitigen Code bereitstellt.
### Stripe.js initialisieren
Rufen Sie `loadStripe` mit Ihrem öffentlichen [API-Schlüssel](https://docs.stripe.com/keys.md) auf. Dadurch erhalten Sie ein Promise, das mit dem Stripe-Objekt aufgelöst wird, sobald Stripe.js geladen wird.
```jsx
import React from 'react';import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {constructor(props) {
super(props);
this.state = {};
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
render() {const { stripe } = this.state;
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
## Modal zum Hochladen von Dokumenten anzeigen [Clientseitig] [Serverseitig]
Richten Sie die neue Schaltfläche zur Anzeige eines Modals zum Hochladen von Dokumenten ein. Nach dem Anklicken der Schaltfläche können Ihre Nutzer/innen ein Bild ihres Reisepasses, Führerscheins oder Personalausweises erfassen und hochladen.
Das Modal reduziert die Entwicklungszeit und den Wartungsaufwand und ermöglicht die Erfassung von Identitätsnachweisen im Rahmen Ihrer bestehenden Abläufe. So wird auch die Menge der auf Ihrer Website verarbeiteten privaten Informationen reduziert. Außerdem können Sie Nutzer/innen auf verschiedenen Plattformen und in verschiedenen Sprachen unterstützen und das Design individuell an Ihr Branding anzupassen.
### VerificationSession erstellen
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll). Sie können das Feld [verifizierte Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) [erweitern](https://docs.stripe.com/api/expanding_objects.md), um Details zu den verifizierten Daten anzuzeigen.
Nachdem Sie eine `VerificationSession` erfolgreich erstellt haben, senden Sie das [Client-Geheimnis](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) an das Frontend, um das Modal zum Hochladen von Dokumenten anzuzeigen.
Sie können Verifizierungsabläufe für die wiederverwendbare Konfiguration verwenden, die an den Parameter [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow) übergeben wird. Weitere Informationen finden Sie im [Leitfaden für Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md).
Sie benötigen einen serverseitigen Endpoint zum [Erstellen der VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
> Mit dem Client-Geheimnis kann Ihr Frontend sensible Verifizierungsinformationen erfassen. Es ist einmalig verwendbar und läuft nach 24 Stunden ab. Es darf nicht gespeichert, protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden. Achten Sie darauf, dass auf jeder Seite, die das Client-Geheimnis enthält, TLS aktiviert ist. Senden Sie nur das Client-Geheimnis an Ihr Frontend, damit die Konfiguration oder die Ergebnisse der Verifizierung nicht weitergegeben werden.
Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. `localhost:4242`) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
Die Antwort in Ihrem Terminal sieht folgendermaßen aus:
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", client_secret: "vs_QdfQQ6xfGNJR7ogV6_secret_live_..." }
```
### Ereignis-Handler zur Schaltfläche „Verifizieren“ hinzufügen
Nachdem Sie jetzt eine Schaltfläche und einen Endpoint zum Erstellen einer VerificationSession haben, können Sie die Schaltfläche so anpassen, dass das Modal zum Hochladen von Dokumenten nach dem Anklicken angezeigt wird. Fügen Sie den Aufruf zu [`verifyIdentity`](https://docs.stripe.com/js/identity/modal) mithilfe des Client-Geheimnisses hinzu:
#### HTML + JS
```html
Verify your identity
```
#### React
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {
constructor(props) {
super(props);
this.state = {};this.handleClick = this.handleClick.bind(this);
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
async handleClick(event) {
// Block native event handling.
event.preventDefault();
const { stripe } = this.state;
if (!stripe) {
// Stripe.js hasn't loaded yet. Make sure to disable
// the button until Stripe.js has loaded.
return;
}
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// Show the verification modal.
const { error } = await stripe.verifyIdentity(session.client_secret);
if (error) {
console.log('[error]', error);
} else {
console.log('Verification submitted!');
}
}
render() {
const { stripe } = this.state;
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Ereignisfehlercodes
| Fehlercode | Beschreibung |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `consent_declined` | Der/die Nutzer/in hat die Verifizierung durch Stripe abgelehnt. Erkundigen Sie sich bei Ihrer Rechtsberatung, ob Sie verpflichtet sind, alternative, nicht-biometrische Verifizierungsmethoden anzubieten, z. B. durch eine manuelle Überprüfung. |
| `device_unsupported` | Für die Verifizierung ist eine Kamera erforderlich, und der/die Nutzer/in verwendet ein Gerät ohne Kamera. |
| `under_supported_age` | Stripe verifiziert keine Nutzer/innen, die noch nicht volljährig sind. |
| `phone_otp_declined` | Der/die Nutzer/in kann die angegebene Telefonnummer nicht verifizieren. |
| `email_verification_declined` | Der/die Nutzer/in kann die angegebene E-Mail-Adresse nicht verifizieren. |
### Modal zum Hochladen testen
Testen Sie, ob die Schaltfläche „Verifizieren“ ein Modal zum Hochladen von Dokumenten anzeigt:
- Klicken Sie auf die Schaltfläche „Verifizieren“, woraufhin sich das Stripe-Modal zum Hochladen von Dokumenten öffnet.
- Stellen Sie sicher, dass keine Fehlermeldungen angezeigt werden.
Wenn Ihre Integration nicht funktioniert:
1. Öffnen Sie in den Entwickler-Tools Ihres Browsers die Registerkarte „Netzwerk“.
1. Klicken Sie auf die Schaltfläche zur Verifizierung und prüfen Sie, ob eine XHR-Anfrage an Ihren serverseitigen Endpoint erfolgt (`POST /create-checkout-session`).
1. Prüfen Sie, ob die Anfrage den Status 200 zurückgibt.
1. Verwenden Sie in Ihrem Button-Click-Listener `console.log(session)`, um zu prüfen, ob die richtigen Daten zurückgegeben werden.
## Bestätigungsseite anzeigen [Clientseitig]
Um den Prozess nutzerfreundlich zu gestalten, sollten Sie nach erfolgreicher Übermittlung des Identitätsnachweises eine Bestätigungsseite anzeigen. Hosten Sie die Seite auf Ihrer Website, damit die Nutzer/innen über den Bearbeitungsstatus der Prüfung informiert werden.
#### HTML + JS
So erstellen Sie eine einfache Bestätigungsseite:
```html
Your document was submitted
Thanks for submitting your identity document.
We are processing your verification.
```
Aktualisieren Sie als Nächstes den Schaltflächen-Handler, um zu dieser Seite weiterzuleiten:
```html
Verify your identity
```
#### React
Aktualisieren Sie den Schaltflächen-Handler, um eine Bestätigungsseite anzuzeigen:
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {
constructor(props) {
super(props);this.state = { submitted: false };
this.handleClick = this.handleClick.bind(this);
}
async componentDidMount() {
this.setState({ stripe: await this.props.stripePromise });
}
async handleClick(event) {
// Block native event handling.
event.preventDefault();
const { stripe } = this.state;
if (!stripe) {
// Stripe.js hasn't loaded yet. Make sure to disable
// the button until Stripe.js has loaded.
return;
}
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// Show the verification modal.
const { error } = await stripe.verifyIdentity(session.client_secret);
if (error) {
console.log('[error]', error.message);
} else {
console.log('Verification submitted!');this.setState({ submitted: true });
}
}
render() {const { stripe, submitted } = this.state;
if (submitted) {
return (
<>
Thanks for submitting your identity document
We are processing your verification.
);
}
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Bestätigungsseite testen
Testen Sie, ob Ihre Bestätigungsseite funktioniert:
- Klicken Sie auf Ihre Schaltfläche zur Verifizierung.
- Übermitteln Sie die Sitzung, indem Sie einen vordefinierten Testfall auswählen.
- Prüfen Sie, ob die neue Bestätigungsseite angezeigt wird.
- Testen Sie den gesamten Ablauf auf mögliche Fehler (z. B. fehlende Zustimmung oder Nichtgewährung des Kamerazugriffs) und stellen Sie sicher, dass Ihre App diese ohne Einschränkungen verarbeitet.
Suchen Sie anschließend die Verifizierung im Stripe-Dashboard. Verifizierungssitzungen werden in der [Liste der VerificationSessions](https://dashboard.stripe.com/identity) des Dashboards angezeigt. Klicken Sie auf eine Sitzung, um zur Seite mit den Sitzungsdetails zu gelangen. Der Abschnitt „Übersicht“ enthält Verifizierungsergebnisse, die Sie in Ihrer App verwenden können.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
## See also
- [Umgang mit Verifizierungsergebnissen](https://docs.stripe.com/identity/handle-verification-outcomes.md)
- [Erfahren Sie mehr über VerificationSessions](https://docs.stripe.com/identity/verification-sessions.md)
- [Weitere Informationen zu Stripe.js](https://docs.stripe.com/payments/elements.md)
Senden Sie Ihre Nutzer/innen an Stripe, um ihre Ausweisdokumente hochzuladen. Sie gehen wie folgt vor:
1. Fügen Sie Ihrer Webseite eine Schaltfläche zur Verifizierung hinzu, die zu Stripe Identity weiterleitet.
1. Zeigen Sie eine Bestätigungsseite für die Übermittlung von Identitätsnachweisen an.
1. Umgang mit den Verifizierungsergebnissen.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
1. (Optional) Passen Sie Ihre Markeneinstellungen auf der Seite [Branding-Einstellungen](https://dashboard.stripe.com/settings/branding) an.
## Stripe einrichten [Serverseitig]
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Schaltfläche auf Ihrer Website hinzufügen [Clientseitig]
Erstellen Sie auf Ihrer Website eine Schaltfläche, um die Verifizierung zu starten.
#### HTML + JS
### Schaltfläche hinzufügen
Fügen Sie Ihrer Seite zunächst eine Schaltfläche zur Verifizierung hinzu:
```html
Verify your identity
```
#### React
### Schaltfläche hinzufügen
Fügen Sie Ihrer Seite zunächst eine Schaltfläche zur Verifizierung hinzu:
```jsx
import React from 'react';
class VerifyButton extends React.Component {
render() {
return (
);
}
}
const App = () => {
return (
);
};
export default App;
```
## Weiterleitung zu Stripe Identity [Clientseitig] [Serverseitig]
Richten Sie die Schaltfläche für die Weiterleitung zu Stripe Identity ein. Nach dem Anklicken der Schaltfläche wird Ihr Frontend zu einer von Stripe gehosteten Seite weitergeleitet. Dort können sie ein Bild ihres Reisepasses, Führerscheins oder Personalausweises erfassen und hochladen.
Die Weiterleitung zu Stripe Checkout reduziert die Entwicklungszeit und den Wartungsaufwand und bietet Ihnen zusätzliche Sicherheit. So wird auch die Menge der auf Ihrer Website verarbeiteten privaten Informationen reduziert. Außerdem können Sie Nutzer/innen auf verschiedenen Plattformen und in verschiedenen Sprachen unterstützen und das Design individuell an Ihr Branding anpassen.
### VerificationSession erstellen
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll). Sie können das Feld [verifizierte Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) [erweitern](https://docs.stripe.com/api/expanding_objects.md), um Details zu den verifizierten Daten anzuzeigen.
Nach der erfolgreichen Erstellung einer `VerificationSession` senden Sie die [Sitzungs-URL](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) zur Weiterleitung an Stripe Identity an das Frontend.
Sie können Verifizierungsabläufe für die wiederverwendbare Konfiguration verwenden, die an den Parameter [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow) übergeben wird. Weitere Informationen finden Sie im [Leitfaden für Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md).
Sie benötigen einen serverseitigen Endpoint zum [Erstellen der VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
> Die Sitzungs-URL ist einmalig verwendbar und läuft nach 24 Stunden ab. Sie darf nicht gespeichert, protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden. Senden Sie nur die Sitzungs-URL an Ihr Frontend, damit die Konfiguration oder die Ergebnisse der Verifizierung nicht weitergegeben werden.
Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. `localhost:4242`) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
Die Antwort in Ihrem Terminal sieht folgendermaßen aus:
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", url: "https://verify.stripe.com/start/QdfQQ6xfxNJR7ogV6Z6Wp..." }
```
### Ereignis-Handler zur Schaltfläche „Verifizieren“ hinzufügen
Nachdem Sie jetzt eine Schaltfläche und einen Endpoint zum Erstellen einer VerificationSession haben, können Sie die Schaltfläche so anpassen, dass sie nach dem Anklicken an die Sitzungs-URL weiterleitet:
#### HTML + JS
```html
Verify your identity
```
#### React
```jsx
import React from 'react';
import {loadStripe} from '@stripe/stripe-js';
class VerifyButton extends React.Component {async handleClick(event) {
// Block native event handling.
event.preventDefault();
// Call your backend to create the VerificationSession.
const response = await fetch('/create-verification-session', { method: 'POST' });
const session = await response.json();
// When the user clicks on the button, redirect to the session URL.
window.location.href = session.url;
}
render() {
return (
);
}
}
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<>');
const App = () => {
return (
);
};
export default App;
```
### Weiterleitung testen
Testen Sie, ob die Schaltfläche zur Verifizierung zu Stripe Identity weiterleitet:
- Klicken Sie auf die Schaltfläche zur Verifizierung.
- Stellen Sie sicher, dass Ihr Browser zu Stripe Identity weiterleitet.
Wenn Ihre Integration nicht funktioniert:
1. Öffnen Sie in den Entwickler-Tools Ihres Browsers die Registerkarte „Netzwerk“.
1. Klicken Sie auf die Schaltfläche zur Verifizierung und prüfen Sie, ob eine XHR-Anfrage an Ihren serverseitigen Endpoint erfolgt (`POST /create-checkout-session`).
1. Prüfen Sie, ob die Anfrage den Status 200 zurückgibt.
1. Verwenden Sie in Ihrem Button-Click-Listener `console.log(session)`, um zu prüfen, ob die richtigen Daten zurückgegeben werden.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
## Optional: Bestätigungsseite anzeigen [Clientseitig]
Um den Prozess nutzerfreundlich zu gestalten, kann Identity die Nutzer/innen nach erfolgreicher Übermittlung ihres Identitätsnachweises zu einer Seite auf Ihrer Website weiterleiten.
So erstellen Sie eine einfache Bestätigungsseite:
```html
Your document was submitted
Thanks for submitting your identity document.
We are processing your verification.
```
Aktualisieren Sie als Nächstes den Aufruf zur Erstellung der VerificationSession mit einer URL für diese Seite im Parameter `return_url`:
#### Node.js
```javascript
const verificationSession = await stripe.identity.verificationSessions.create({
type: 'document',return_url: 'https://{{ YOUR_DOMAIN }}/submitted.html',
metadata: { user_id: '{{USER_ID}}' },
});
```
### Bestätigungsseite testen
Testen Sie, ob Ihre Bestätigungsseite funktioniert:
- Klicken Sie auf Ihre Schaltfläche zur Verifizierung.
- Übermitteln Sie die Sitzung, indem Sie einen vordefinierten Testfall auswählen.
- Prüfen Sie, ob die neue Bestätigungsseite angezeigt wird.
- Testen Sie den gesamten Ablauf auf mögliche Fehler (z. B. fehlende Zustimmung oder Nichtgewährung des Kamerazugriffs) und stellen Sie sicher, dass Ihre App diese ohne Einschränkungen verarbeitet.
Suchen Sie anschließend die Verifizierung im Stripe-Dashboard. Verifizierungssitzungen werden in der [Liste der VerificationSessions](https://dashboard.stripe.com/identity) des Dashboards angezeigt. Klicken Sie auf eine Sitzung, um zur Seite mit den Sitzungsdetails zu gelangen. Der Abschnitt „Übersicht“ enthält Verifizierungsergebnisse, die Sie in Ihrer App verwenden können.
## See also
- [Umgang mit Verifizierungsergebnissen](https://docs.stripe.com/identity/handle-verification-outcomes.md)
- [Erfahren Sie mehr über VerificationSessions](https://docs.stripe.com/identity/verification-sessions.md)
- [Weitere Informationen zu Stripe.js](https://docs.stripe.com/payments/elements.md)
> Um Zugriff auf das Identity iOS SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Um die Identität Ihrer iOS-Nutzer/innen zu verifizieren. zeigen Sie in Ihrer Anwendung ein Verifizierungsformular an. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Einen Server-Endpoint hinzufügen.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-ios/tree/master/Example/IdentityVerification%20Example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
> Wenn Sie beabsichtigen, dieses SDK mit dem Identitätsdienst von Stripe zu verwenden, dürfen Sie dieses SDK nicht ändern. Die Verwendung einer modifizierten Version dieses SDK mit dem Identitätsdienst von Stripe ohne die schriftliche Genehmigung von Stripe stellt einen Verstoß gegen Ihren Vertrag mit Stripe dar und kann zur Schließung Ihres Stripe-Kontos führen.
### SDK installieren (Client-side)
Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13.0 oder höher unterstützen.
#### Swift Package Manager
Führen Sie zur Installation des SDK die folgenden Schritte aus:
1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein.
1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus.
1. Fügen Sie das Produkt **StripeIdentity** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu.
#### CocoaPods
1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen:
```bash
pod init
```
1. Fügen Sie folgende Zeile in Ihre `Podfile` ein:
```podfile
pod 'StripeIdentity'
```
1. Führen Sie folgenden Befehl aus:
```bash
pod install
```
1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden.
1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus:
```bash
pod update StripeIdentity
```
#### Carthage
1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein:
```cartfile
github "stripe/stripe-ios"
```
1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking) aufgeführten erforderlichen Frameworks einbetten.
1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus:
```bash
carthage update stripe-ios --platform ios
```
#### Manuelles Framework
1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei.
1. Ziehen Sie **StripeIdentity.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig).
1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking) aufgeführten erforderlichen Frameworks.
1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3.
> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
### Kamerazugriff einrichten (Client-side)
Das Stripe Identity iOS SDK erfordert Zugriff auf die Kamera des Geräts, um Ausweisdokumente zu erfassen. So aktivieren Sie Ihre App zum Anfordern von Kameraberechtigungen:
1. Öffnen Sie die Datei **Info.plist** Ihres Projekts in Xcode.
1. Fügen Sie den Schlüssel `NSCameraUsageDescription` hinzu.
1. Fügen Sie einen Zeichenfolgenwert hinzu, der Ihren Nutzern/Nutzerinnen den Grund für den erforderlichen Kamerazugriff erläutert. Beispiel:
> Diese App verwendet Ihre Kamera, um ein Foto von Ihren Identitätsnachweisen zu machen.
Weitere Informationen zum Anfordern des Kamerazugriffs finden Sie in der [Dokumentation von Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Server-Endpoint hinzufügen [Serverseitig]
### VerificationSession erstellen
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll). Sie können das Feld [verifizierte Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) [erweitern](https://docs.stripe.com/api/expanding_objects.md), um Details zu den verifizierten Daten anzuzeigen.
Sie können Verifizierungsabläufe für die wiederverwendbare Konfiguration verwenden, die an den Parameter [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow) übergeben wird. Weitere Informationen finden Sie im [Leitfaden für Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md).
Sie benötigen einen serverseitigen Endpoint zum [Erstellen der VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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](https://docs.stripe.com/api/identity/verification_sessions.md). 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](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) und den temporären Geheimschlüssel an den Client, um das Formular zum Hochladen von Dokumenten anzuzeigen.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> Der temporäre Geheimschlüssel ist an die `VerificationSession` gebunden und ermöglicht es Ihrer App, sensible Verifizierungsinformationen wie Dokumente und Selfie-Bilddateien zu erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie ihn nicht, protokollieren Sie ihn nicht und betten Sie ihn nicht in eine URL ein und machen Sie ihn nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS für alle Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den temporäre Geheimschlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder -ergebnisse preisgegeben werden.
Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. `localhost:4242`) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
Die Antwort in Ihrem Terminal sieht folgendermaßen aus:
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Das Verifizierungsformular anzeigen [Clientseitig]
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 Ansichtssteuerung mit einer Schaltfläche, die auswählbar ist und über eine Ladeanzeige verfügt:
```swift
import UIKit
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### Stripe Identity SDK importieren
Importieren Sie `StripeIdentity` in Ihre Ansichtssteuerung:
```swift
import UIKitimport StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### 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 `VerificationResult` verarbeiten, um zu ermitteln, ob der/die Nutzer/in den Verifizierungsablauf abgeschlossen hat.
```swift
import UIKit
import StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
override func viewDidLoad() {
super.viewDidLoad()
verifyButton.addTarget(self, action: #selector(didTapVerifyButton), for: .touchUpInside)
}
@objc
func didTapVerifyButton() {
// Disable the button while the request is made
verifyButton.isEnabled = false
activityIndicator.startAnimating()
// Make request to your verification endpoint
var urlRequest = URLRequest(url: URL(string: "https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")!)
urlRequest.httpMethod = "POST"
let task = URLSession.shared.dataTask(with: urlRequest) { [weak self] data, response, error in
DispatchQueue.main.async { [weak self] in
// Re-enable button
self?.verifyButton.isEnabled = true
self?.activityIndicator.stopAnimating()
guard error == nil,
let data = data,
let responseJson = try? JSONDecoder().decode([String: String].self, from: data),
let verificationSessionId = responseJson["id"],
let ephemeralKeySecret = responseJson["ephemeral_key_secret"] else {
// Handle error
print(error as Any)
return
}
self?.presentVerificationSheet(verificationSessionId: verificationSessionId, ephemeralKeySecret: ephemeralKeySecret)
}
}
task.resume()
}
func presentVerificationSheet(verificationSessionId: String, ephemeralKeySecret: String) {
// Configure a square brand logo. Recommended image size is 32 x 32 points.
let configuration = IdentityVerificationSheet.Configuration(
brandLogo: UIImage(named: "{{YOUR_BRAND_LOGO}}")!
)
// Instantiate and present the sheet
let verificationSheet = IdentityVerificationSheet(
verificationSessionId: verificationSessionId,
ephemeralKeySecret: ephemeralKeySecret,
configuration: configuration
)
verificationSheet.present(from: self, completion: { result in
switch result {
case .flowCompleted:
// The user has completed uploading their documents.
// Let them know that the verification is processing.
print("Verification Completed!")
case .flowCanceled:
// The user did not complete uploading their documents.
// You should allow them to try again.
print("Verification Canceled!")
case .flowFailed(let error):
// If the flow fails, you should display the localized error
// message to your user using error.localizedDescription
print("Verification Failed!")
print(error.localizedDescription)
}
})
}
}
```
### 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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Um Zugriff auf das Identity iOS SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Dieser Leitfaden zeigt, wie Sie eine Stripe Identity-Integration vom [Web Redirect](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) SDK zum nativen iOS SDK oder Ihrer mobilen App migrieren. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Aktualisieren Sie Ihren Server-Endpoint.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-ios/tree/master/Example/IdentityVerification%20Example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
> Wenn Sie beabsichtigen, dieses SDK mit dem Identitätsdienst von Stripe zu verwenden, dürfen Sie dieses SDK nicht ändern. Die Verwendung einer modifizierten Version dieses SDK mit dem Identitätsdienst von Stripe ohne die schriftliche Genehmigung von Stripe stellt einen Verstoß gegen Ihren Vertrag mit Stripe dar und kann zur Schließung Ihres Stripe-Kontos führen.
### SDK installieren (Client-side)
Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13.0 oder höher unterstützen.
#### Swift Package Manager
Führen Sie zur Installation des SDK die folgenden Schritte aus:
1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein.
1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus.
1. Fügen Sie das Produkt **StripeIdentity** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu.
#### CocoaPods
1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen:
```bash
pod init
```
1. Fügen Sie folgende Zeile in Ihre `Podfile` ein:
```podfile
pod 'StripeIdentity'
```
1. Führen Sie folgenden Befehl aus:
```bash
pod install
```
1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden.
1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus:
```bash
pod update StripeIdentity
```
#### Carthage
1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein:
```cartfile
github "stripe/stripe-ios"
```
1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking) aufgeführten erforderlichen Frameworks einbetten.
1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus:
```bash
carthage update stripe-ios --platform ios
```
#### Manuelles Framework
1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei.
1. Ziehen Sie **StripeIdentity.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig).
1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity#manual-linking) aufgeführten erforderlichen Frameworks.
1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3.
> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
### Kamerazugriff einrichten (Client-side)
Das Stripe Identity iOS SDK erfordert Zugriff auf die Kamera des Geräts, um Ausweisdokumente zu erfassen. So aktivieren Sie Ihre App zum Anfordern von Kameraberechtigungen:
1. Öffnen Sie die Datei **Info.plist** Ihres Projekts in Xcode.
1. Fügen Sie den Schlüssel `NSCameraUsageDescription` hinzu.
1. Fügen Sie einen Zeichenfolgenwert hinzu, der Ihren Nutzern/Nutzerinnen den Grund für den erforderlichen Kamerazugriff erläutert. Beispiel:
> Diese App verwendet Ihre Kamera, um ein Foto von Ihren Identitätsnachweisen zu machen.
Weitere Informationen zum Anfordern des Kamerazugriffs finden Sie in der [Dokumentation von Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Aktualisieren des Server-Endpoints [Serverseitig]
### Bestehende Webintegration
Wenn Sie eine [Modal](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal)-Integration haben, wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) wurde an das Stripe-API-Objekt übergeben.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Bei einer Integration mit [Weiterleitung](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und die [URL](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) der `VerificationSession` wurde an die mobile App des Kunden/der Kundin gesendet und in einem In-App-Browser geöffnet.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Zur SDK-Integration migrieren
Um das native SDK zu verwenden, erstellen Sie dieselbe [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) und einen temporären Schlüssel.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Nachdem Sie eine `VerificationSession` und einen temporären Schlüssel erfolgreich erstellt haben, senden Sie die [ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) der `VerificationSession` und den `ephemeral key secret` an die mobile App des Kunden/der Kundin.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
> Mit dem Geheimschlüssel des temporären Schlüssels kann Ihre App sensible Verifizierungsinformationen erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie sie nicht, protokollieren Sie sie nicht, betten Sie sie in eine URL ein und machen Sie sie nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS auf allen Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den geheimen temporären Schlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder die Ergebnisse offengelegt werden.
## Das Verifizierungsformular anzeigen [Clientseitig]
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 Ansichtssteuerung mit einer Schaltfläche, die auswählbar ist und über eine Ladeanzeige verfügt:
```swift
import UIKit
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### Stripe Identity SDK importieren
Importieren Sie `StripeIdentity` in Ihre Ansichtssteuerung:
```swift
import UIKitimport StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
}
```
### 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 `VerificationResult` verarbeiten, um zu ermitteln, ob der/die Nutzer/in den Verifizierungsablauf abgeschlossen hat.
```swift
import UIKit
import StripeIdentity
class VerifyViewController: UIViewController {
@IBOutlet weak var verifyButton: UIButton!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
override func viewDidLoad() {
super.viewDidLoad()
verifyButton.addTarget(self, action: #selector(didTapVerifyButton), for: .touchUpInside)
}
@objc
func didTapVerifyButton() {
// Disable the button while the request is made
verifyButton.isEnabled = false
activityIndicator.startAnimating()
// Make request to your verification endpoint
var urlRequest = URLRequest(url: URL(string: "https://{{YOUR_SERVER_BASE_URL}}/create-verification-session")!)
urlRequest.httpMethod = "POST"
let task = URLSession.shared.dataTask(with: urlRequest) { [weak self] data, response, error in
DispatchQueue.main.async { [weak self] in
// Re-enable button
self?.verifyButton.isEnabled = true
self?.activityIndicator.stopAnimating()
guard error == nil,
let data = data,
let responseJson = try? JSONDecoder().decode([String: String].self, from: data),
let verificationSessionId = responseJson["id"],
let ephemeralKeySecret = responseJson["ephemeral_key_secret"] else {
// Handle error
print(error as Any)
return
}
self?.presentVerificationSheet(verificationSessionId: verificationSessionId, ephemeralKeySecret: ephemeralKeySecret)
}
}
task.resume()
}
func presentVerificationSheet(verificationSessionId: String, ephemeralKeySecret: String) {
// Configure a square brand logo. Recommended image size is 32 x 32 points.
let configuration = IdentityVerificationSheet.Configuration(
brandLogo: UIImage(named: "{{YOUR_BRAND_LOGO}}")!
)
// Instantiate and present the sheet
let verificationSheet = IdentityVerificationSheet(
verificationSessionId: verificationSessionId,
ephemeralKeySecret: ephemeralKeySecret,
configuration: configuration
)
verificationSheet.present(from: self, completion: { result in
switch result {
case .flowCompleted:
// The user has completed uploading their documents.
// Let them know that the verification is processing.
print("Verification Completed!")
case .flowCanceled:
// The user did not complete uploading their documents.
// You should allow them to try again.
print("Verification Canceled!")
case .flowFailed(let error):
// If the flow fails, you should display the localized error
// message to your user using error.localizedDescription
print("Verification Failed!")
print(error.localizedDescription)
}
})
}
}
```
### 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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Um Zugriff auf das Identity Android SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Um die Identität Ihrer Android-Nutzer/innen zu verifizieren. zeigen Sie in Ihrer Anwendung ein Verifizierungsformular an. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Einen Server-Endpoint hinzufügen.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-android/tree/master/identity-example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
> Wenn Sie beabsichtigen, dieses SDK mit dem Identitätsdienst von Stripe zu verwenden, dürfen Sie dieses SDK nicht ändern. Die Verwendung einer modifizierten Version dieses SDK mit dem Identitätsdienst von Stripe ohne die schriftliche Genehmigung von Stripe stellt einen Verstoß gegen Ihren Vertrag mit Stripe dar und kann zur Schließung Ihres Stripe-Kontos führen.
### SDK installieren (Client-side)
Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/).
Um das SDK zu installieren, fügen Sie `identity` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein:
#### Kotlin
```kotlin
plugins {
id("com.android.application")
}
android { ... }
dependencies {
// ...
// Stripe Identity Android SDK
implementation("com.stripe:identity:23.2.0")
}
```
> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).
### 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.
#### Groovy
```groovy
dependencies {
// ...
// Stripe Identity Android SDK
implementation('com.stripe:identity:23.2.0') {
exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
}
implementation('com.stripe:ml-core-googleplay:23.2.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](https://material.io/develop/android/theming/dark) verwendet. So aktivieren Sie das Material Theme:
1. Öffnen Sie die Datei `app/src/main/AndroidManifest.xml` Ihres Projekts.
1. Stellen Sie sicher, dass das auf die `application` angewendete `android:theme` ein untergeordnetes Element eines der Material Themes ist (zum Beispiel `Theme.MaterialComponents.DayNight`).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Server-Endpoint hinzufügen [Serverseitig]
### VerificationSession erstellen
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll). Sie können das Feld [verifizierte Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) [erweitern](https://docs.stripe.com/api/expanding_objects.md), um Details zu den verifizierten Daten anzuzeigen.
Sie können Verifizierungsabläufe für die wiederverwendbare Konfiguration verwenden, die an den Parameter [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow) übergeben wird. Weitere Informationen finden Sie im [Leitfaden für Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md).
Sie benötigen einen serverseitigen Endpoint zum [Erstellen der VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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](https://docs.stripe.com/api/identity/verification_sessions.md). 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](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) und den temporären Geheimschlüssel an den Client, um das Formular zum Hochladen von Dokumenten anzuzeigen.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> Der temporäre Geheimschlüssel ist an die `VerificationSession` gebunden und ermöglicht es Ihrer App, sensible Verifizierungsinformationen wie Dokumente und Selfie-Bilddateien zu erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie ihn nicht, protokollieren Sie ihn nicht und betten Sie ihn nicht in eine URL ein und machen Sie ihn nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS für alle Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den temporäre Geheimschlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder -ergebnisse preisgegeben werden.
Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. `localhost:4242`) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
Die Antwort in Ihrem Terminal sieht folgendermaßen aus:
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Das Verifizierungsformular anzeigen [Clientseitig]
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.
#### Kotlin
```kotlin
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](https://developer.android.com/reference/androidx/activity/result/ActivityResultLauncher) für diese `AppCompatActivity` oder dieses `Fragment` registriert).
#### Kotlin
```kotlin
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.
#### Kotlin
```kotlin
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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Um Zugriff auf das Identity Android SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Dieser Leitfaden zeigt, wie Sie eine Stripe Identity-Integration vom [Web Redirect](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) SDK zum nativen Android SDK oder Ihrer mobilen App migrieren. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Aktualisieren Sie Ihren Server-Endpoint.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-android/tree/master/identity-example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
> Wenn Sie beabsichtigen, dieses SDK mit dem Identitätsdienst von Stripe zu verwenden, dürfen Sie dieses SDK nicht ändern. Die Verwendung einer modifizierten Version dieses SDK mit dem Identitätsdienst von Stripe ohne die schriftliche Genehmigung von Stripe stellt einen Verstoß gegen Ihren Vertrag mit Stripe dar und kann zur Schließung Ihres Stripe-Kontos führen.
### SDK installieren (Client-side)
Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/).
Um das SDK zu installieren, fügen Sie `identity` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein:
#### Kotlin
```kotlin
plugins {
id("com.android.application")
}
android { ... }
dependencies {
// ...
// Stripe Identity Android SDK
implementation("com.stripe:identity:23.2.0")
}
```
> Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).
### 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.
#### Groovy
```groovy
dependencies {
// ...
// Stripe Identity Android SDK
implementation('com.stripe:identity:23.2.0') {
exclude group: 'com.stripe', module: 'ml-core-default' // exclude the default TFLite runtime
}
implementation('com.stripe:ml-core-googleplay:23.2.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](https://material.io/develop/android/theming/dark) verwendet. So aktivieren Sie das Material Theme:
1. Öffnen Sie die Datei `app/src/main/AndroidManifest.xml` Ihres Projekts.
1. Stellen Sie sicher, dass das auf die `application` angewendete `android:theme` ein untergeordnetes Element eines der Material Themes ist (zum Beispiel `Theme.MaterialComponents.DayNight`).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Aktualisieren des Server-Endpoints [Serverseitig]
### Bestehende Webintegration
Wenn Sie eine [Modal](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal)-Integration haben, wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) wurde an das Stripe-API-Objekt übergeben.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Bei einer Integration mit [Weiterleitung](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und die [URL](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) der `VerificationSession` wurde an die mobile App des Kunden/der Kundin gesendet und in einem In-App-Browser geöffnet.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Zur SDK-Integration migrieren
Um das native SDK zu verwenden, erstellen Sie dieselbe [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) und einen temporären Schlüssel.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Nachdem Sie eine `VerificationSession` und einen temporären Schlüssel erfolgreich erstellt haben, senden Sie die [ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) der `VerificationSession` und den `ephemeral key secret` an die mobile App des Kunden/der Kundin.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
> Mit dem Geheimschlüssel des temporären Schlüssels kann Ihre App sensible Verifizierungsinformationen erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie sie nicht, protokollieren Sie sie nicht, betten Sie sie in eine URL ein und machen Sie sie nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS auf allen Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den geheimen temporären Schlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder die Ergebnisse offengelegt werden.
## Das Verifizierungsformular anzeigen [Clientseitig]
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.
#### Kotlin
```kotlin
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](https://developer.android.com/reference/androidx/activity/result/ActivityResultLauncher) für diese `AppCompatActivity` oder dieses `Fragment` registriert).
#### Kotlin
```kotlin
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.
#### Kotlin
```kotlin
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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Um Zugriff auf das Identity React Native SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Um die Identität Ihrer React Native-Nutzer/innen zu verifizieren. zeigen Sie in Ihrer Anwendung ein Verifizierungsformular an. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Einen Server-Endpoint hinzufügen.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-identity-react-native/tree/main/example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
### SDK installieren (Client-side)
Das [React Native SDK](https://github.com/stripe/stripe-identity-react-native) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-identity-react-native) und mit Apps kompatibel, die iOS 13.0 oder Android 5.0 (API-Ebene 21) oder höher unterstützen. Intern nutzt es die nativen [iOS](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity) und [Android](https://github.com/stripe/stripe-android/tree/master/identity) SDKs.
Installieren Sie den SDK, indem Sie Folgendes ausführen:
#### Yarn
```bash
yarn add @stripe/stripe-identity-react-native
```
> Details zur aktuellen SDK-Version und vorigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-identity-react-native/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
Führen Sie für iOS `pod install` im Verzeichnis `ios` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Abhängigkeiten installiert haben. Für Android sind keine zusätzlichen Schritte erforderlich.
### Kamerazugriff für iOS einrichten (Client-side)
Das Stripe Identity iOS SDK erfordert Zugriff auf die Kamera des Geräts, um Ausweisdokumente zu erfassen. So aktivieren Sie Ihre App zum Anfordern von Kameraberechtigungen:
1. Öffnen Sie die Datei **Info.plist** Ihres Projekts in Xcode.
1. Fügen Sie den Schlüssel `NSCameraUsageDescription` hinzu.
1. Fügen Sie einen Zeichenfolgenwert hinzu, der Ihren Nutzern/Nutzerinnen den Grund für den erforderlichen Kamerazugriff erläutert. Beispiel:
> Diese App verwendet Ihre Kamera, um ein Foto von Ihren Identitätsnachweisen zu machen.
Weitere Informationen zum Anfordern des Kamerazugriffs finden Sie in der [Dokumentation von Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios).
### Material Theme für Android einrichten (Client-side)
Das Stripe Identity Android SDK erfordert, dass die Hosting-Aktivität das [Material Theme](https://material.io/develop/android/theming/dark) verwendet. So aktivieren Sie das Material Theme:
1. Öffnen Sie die Datei `app/src/main/AndroidManifest.xml` Ihres Projekts.
1. Stellen Sie sicher, dass das auf die `application` angewendete `android:theme` ein untergeordnetes Element eines der Material Themes ist (zum Beispiel `Theme.MaterialComponents.DayNight`).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Server-Endpoint hinzufügen [Serverseitig]
### VerificationSession erstellen
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll). Sie können das Feld [verifizierte Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) [erweitern](https://docs.stripe.com/api/expanding_objects.md), um Details zu den verifizierten Daten anzuzeigen.
Sie können Verifizierungsabläufe für die wiederverwendbare Konfiguration verwenden, die an den Parameter [verification_flow](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-verification_flow) übergeben wird. Weitere Informationen finden Sie im [Leitfaden für Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md).
Sie benötigen einen serverseitigen Endpoint zum [Erstellen der VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md). 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](https://docs.stripe.com/api/identity/verification_sessions.md). 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](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) und den temporären Geheimschlüssel an den Client, um das Formular zum Hochladen von Dokumenten anzuzeigen.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
> Der temporäre Geheimschlüssel ist an die `VerificationSession` gebunden und ermöglicht es Ihrer App, sensible Verifizierungsinformationen wie Dokumente und Selfie-Bilddateien zu erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie ihn nicht, protokollieren Sie ihn nicht und betten Sie ihn nicht in eine URL ein und machen Sie ihn nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS für alle Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den temporäre Geheimschlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder -ergebnisse preisgegeben werden.
Testen Sie Ihren Endpoint, indem Sie Ihren Webserver starten (z. B. `localhost:4242`) und mit curl eine POST-Anfrage zur Erstellung einer VerificationSession senden:
```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```
Die Antwort in Ihrem Terminal sieht folgendermaßen aus:
```bash
HTTP/1.1 200 OK
Content-Type: application/json
{ id: "vs_QdfQQ6xfGNJR7ogV6", ephemeral_key_secret: "ek_YWNjdF8xRm..." }
```
## Das Verifizierungsformular anzeigen [Clientseitig]
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 Schaltflächenkomponente:
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';
function VerifyScreen() {
return (
);
}
```
### Stripe Identity SDK importieren
Hook `useStripeIdentity` importieren:
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
function VerifyScreen() {
return (
);
}
```
### Ereignis-Handler zur Schaltfläche „Verifizieren“ hinzufügen
Da Sie nun eine Schaltfläche und einen Endpoint zum Erstellen einer VerificationSession haben, 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.
- Den Hook `useStripeIdentity` instanziieren, indem Sie `fetchOptions` mit Ihrem Markenlogo übergeben und dem/der Nutzer/in anzeigen.
- Den `status` verarbeiten, um zu ermitteln, ob der/die Nutzer/in den Verifizierungsablauf abgeschlossen hat.
```javascript
import React from 'react';
import {
View,
Button,Text,
Image
} from 'react-native';
import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
// A square logo for your brand
import logo from './assets/{{YOUR_BRAND_LOGO}}.png';
function VerifyScreen() {const fetchVerificationSessionParams = async () => {
try {
const data = await fetch(`${YOUR_SERVER_BASE_URL}/create-verification-session`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
});
const json = await data.json();
return json;
} catch (e) {
return {};
}
};
const fetchOptions = async () => {
const response = await fetchVerificationSessionParams();
return {
sessionId: response.id,
ephemeralKeySecret: response.ephemeral_key_secret,
brandLogo: Image.resolveAssetSource(logo),
};
};
const { status, present, loading } = useStripeIdentity(fetchOptions);
const handlePress = React.useCallback(() => {
present();
}, [present]);
return (
Status: {status}
);
}
```
### 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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
> Um Zugriff auf das Identity React Native SDK zu erhalten, gehen Sie zu den [Identitätseinstellungen](https://dashboard.stripe.com/settings/identity) und klicken auf **Aktivieren**.
Dieser Leitfaden zeigt, wie Sie eine Stripe Identity-Integration vom [Web Redirect](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) SDK zum nativen React Native SDK oder Ihrer mobilen App migrieren. In diesem Leitfaden erfahren Sie, wie Sie:
1. Stripe einrichten.
1. Aktualisieren Sie Ihren Server-Endpoint.
1. Das Verifizierungsformular anzeigen.
1. Verifizierungsereignisse verarbeiten.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
Die Schritte in dieser Anleitung sind vollständig in der [Beispiel-App](https://github.com/stripe/stripe-identity-react-native/tree/main/example) und dem [Beispiel-Backend-Server](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) implementiert.
## Einrichten [Serverseitig] [Clientseitig]
### SDK installieren (Client-side)
Das [React Native SDK](https://github.com/stripe/stripe-identity-react-native) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-identity-react-native) und mit Apps kompatibel, die iOS 13.0 oder Android 5.0 (API-Ebene 21) oder höher unterstützen. Intern nutzt es die nativen [iOS](https://github.com/stripe/stripe-ios/tree/master/StripeIdentity) und [Android](https://github.com/stripe/stripe-android/tree/master/identity) SDKs.
Installieren Sie den SDK, indem Sie Folgendes ausführen:
#### Yarn
```bash
yarn add @stripe/stripe-identity-react-native
```
> Details zur aktuellen SDK-Version und vorigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-identity-react-native/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository).
Führen Sie für iOS `pod install` im Verzeichnis `ios` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Abhängigkeiten installiert haben. Für Android sind keine zusätzlichen Schritte erforderlich.
### Kamerazugriff für iOS einrichten (Client-side)
Das Stripe Identity iOS SDK erfordert Zugriff auf die Kamera des Geräts, um Ausweisdokumente zu erfassen. So aktivieren Sie Ihre App zum Anfordern von Kameraberechtigungen:
1. Öffnen Sie die Datei **Info.plist** Ihres Projekts in Xcode.
1. Fügen Sie den Schlüssel `NSCameraUsageDescription` hinzu.
1. Fügen Sie einen Zeichenfolgenwert hinzu, der Ihren Nutzern/Nutzerinnen den Grund für den erforderlichen Kamerazugriff erläutert. Beispiel:
> Diese App verwendet Ihre Kamera, um ein Foto von Ihren Identitätsnachweisen zu machen.
Weitere Informationen zum Anfordern des Kamerazugriffs finden Sie in der [Dokumentation von Apple](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios).
### Material Theme für Android einrichten (Client-side)
Das Stripe Identity Android SDK erfordert, dass die Hosting-Aktivität das [Material Theme](https://material.io/develop/android/theming/dark) verwendet. So aktivieren Sie das Material Theme:
1. Öffnen Sie die Datei `app/src/main/AndroidManifest.xml` Ihres Projekts.
1. Stellen Sie sicher, dass das auf die `application` angewendete `android:theme` ein untergeordnetes Element eines der Material Themes ist (zum Beispiel `Theme.MaterialComponents.DayNight`).
### Stripe auf dem Server installieren (Server-side)
[Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto.
Installieren Sie dann die Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung:
#### Ruby
```bash
# Available as a gem
sudo gem install stripe
```
```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```
## Aktualisieren des Server-Endpoints [Serverseitig]
### Bestehende Webintegration
Wenn Sie eine [Modal](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=modal)-Integration haben, wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und `VerificationSession` [client_secret](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-client_secret) wurde an das Stripe-API-Objekt übergeben.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```
Bei einer Integration mit [Weiterleitung](https://docs.stripe.com/identity/verify-identity-documents.md?platform=web&type=redirect) wurde eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) erstellt und die [URL](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-url) der `VerificationSession` wurde an die mobile App des Kunden/der Kundin gesendet und in einem In-App-Browser geöffnet.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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}}',
},
});
// Return only the session URL to the frontend.
const url = verificationSession.url;
```
### Zur SDK-Integration migrieren
Um das native SDK zu verwenden, erstellen Sie dieselbe [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) und einen temporären Schlüssel.
#### Node.js
```javascript
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<>');
// 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: '2026-03-25.dahlia'}
);
// Return only the ID and ephemeral key secret to the frontend.
const verificationSessionId = verificationSession.id;
const ephemeralKeySecret = ephemeralKey.secret;
```
Nachdem Sie eine `VerificationSession` und einen temporären Schlüssel erfolgreich erstellt haben, senden Sie die [ID](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-id) der `VerificationSession` und den `ephemeral key secret` an die mobile App des Kunden/der Kundin.
> Eine laufende Implementierung dieses Endpoints finden Sie [hier](https://codesandbox.io/p/devbox/compassionate-violet-gshhgf) zum schnellen Testen.
> Mit dem Geheimschlüssel des temporären Schlüssels kann Ihre App sensible Verifizierungsinformationen erfassen. Es ist einmalig verwendbar und läuft nach 1 Stunde ab. Speichern Sie sie nicht, protokollieren Sie sie nicht, betten Sie sie in eine URL ein und machen Sie sie nicht für andere Personen als den/die Nutzer/in zugänglich. Stellen Sie sicher, dass Sie TLS auf allen Endpoints aktiviert haben, die den geheimen temporären Schlüssel zurückgeben. Senden Sie nur den geheimen temporären Schlüssel an Ihre App, um zu vermeiden, dass die Verifizierungskonfiguration oder die Ergebnisse offengelegt werden.
## Das Verifizierungsformular anzeigen [Clientseitig]
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 Schaltflächenkomponente:
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';
function VerifyScreen() {
return (
);
}
```
### Stripe Identity SDK importieren
Hook `useStripeIdentity` importieren:
```javascript
import React from 'react';
import {
View,
Button,
} from 'react-native';import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
function VerifyScreen() {
return (
);
}
```
### Ereignis-Handler zur Schaltfläche „Verifizieren“ hinzufügen
Da Sie nun eine Schaltfläche und einen Endpoint zum Erstellen einer VerificationSession haben, 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.
- Den Hook `useStripeIdentity` instanziieren, indem Sie `fetchOptions` mit Ihrem Markenlogo übergeben und dem/der Nutzer/in anzeigen.
- Den `status` verarbeiten, um zu ermitteln, ob der/die Nutzer/in den Verifizierungsablauf abgeschlossen hat.
```javascript
import React from 'react';
import {
View,
Button,Text,
Image
} from 'react-native';
import { useStripeIdentity } from "@stripe/stripe-identity-react-native";
// A square logo for your brand
import logo from './assets/{{YOUR_BRAND_LOGO}}.png';
function VerifyScreen() {const fetchVerificationSessionParams = async () => {
try {
const data = await fetch(`${YOUR_SERVER_BASE_URL}/create-verification-session`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
});
const json = await data.json();
return json;
} catch (e) {
return {};
}
};
const fetchOptions = async () => {
const response = await fetchVerificationSessionParams();
return {
sessionId: response.id,
ephemeralKeySecret: response.ephemeral_key_secret,
brandLogo: Image.resolveAssetSource(logo),
};
};
const { status, present, loading } = useStripeIdentity(fetchOptions);
const handlePress = React.useCallback(() => {
present();
}, [present]);
return (
Status: {status}
);
}
```
### 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.
1. Stellen Sie sicher, dass keine Netzwerkfehler vorhanden sind und dass der Endpoint eine `VerificationSession`-ID und einen temporären Geheimschlüssel zurückgibt.
## Verifizierungsereignisse verarbeiten
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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:
| Ereignisname | Beschreibung | Nächste Schritte |
| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| [identity.verification_session.verified](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.verified) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und alle waren erfolgreich. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus. |
| [identity.verification_session.requires_input](https://docs.stripe.com/api/events/types.md#event_types-identity.verification_session.requires_input) | Die Verarbeitung aller [Verifizierungsprüfungen](https://docs.stripe.com/identity/verification-checks.md) ist abgeschlossen, und mindestens eine dieser Prüfungen ist fehlgeschlagen. | Lösen Sie relevante Aktionen in Ihrer Anwendung aus und ermöglichen Sie Ihren Nutzer/innen, die Verifizierung zu wiederholen. |
Verwenden Sie einen [Webhook-Handler](https://docs.stripe.com/identity/handle-verification-outcomes.md), 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](https://dashboard.stripe.com/events?type=identity.%2A) 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](https://docs.stripe.com/identity/handle-verification-outcomes.md)
### 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](https://dashboard.stripe.com/test/identity/verification-sessions)
Am häufigsten werden einmalige Verifizierungen über das Stripe-Dashboard erstellt, aber Sie können diesen Prozess automatisieren, wenn Sie die API integrieren. Sie gehen wie folgt vor:
1. Erstellen Sie eine VerificationSession über das Dashboard.
1. Teilen Sie den Verifizierungslink mit Ihrem Nutzer/Ihrer Nutzerin.
1. Lassen Sie sich die Verifizierungsergebnisse im Dashboard anzeigen.
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
1. (Optional) Passen Sie Ihre Markeneinstellungen auf der Seite [Branding-Einstellungen](https://dashboard.stripe.com/settings/branding) an.
## VerificationSession erstellen [Dashboard]
Eine [VerificationSession](https://docs.stripe.com/api/identity/verification_sessions.md) ist die programmgesteuerte Darstellung der Verifizierung. Sie enthält Details zur Art der Verifizierung (z. B. welche [Prüfung](https://docs.stripe.com/identity/verification-checks.md) durchgeführt werden soll) und zeigt die [verifizierten Ergebnisse](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) an.
So erstellen Sie eine VerificationSession im Stripe-Dashboard:
1. Rufen Sie die Seite [Sitzung erstellen](https://dashboard.stripe.com/identity/verification-sessions/create) auf.
1. Wählen Sie **Dokumentprüfung** aus.
1. Klicken Sie auf **Erstellen**.
## Teilen Sie den Verifizierungslink mit Ihrem/Ihrer Nutzer/in. [Dashboard]
1. Klicken Sie auf **Verifizierungslink kopieren**.
1. Teilen Sie die kopierte URL mit Ihrem Nutzer/Ihrer Nutzerin.
Verifizierungslinks laufen nach 48 Stunden ab und können nur einmal verwendet werden. Teilen Sie den Link nur mit dem Nutzer/der Nutzerin, den/die Sie verifizieren möchten. Wir empfehlen, Verifizierungslinks nicht per E-Mail oder Textnachricht zu versenden.
## Verifizierungsergebnisse anzeigen [Dashboard]
[Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) 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`.
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](https://dashboard.stripe.com/test/identity/verification-sessions)
## Before you begin
1. [Aktivieren Sie Ihr Konto](https://dashboard.stripe.com/account/onboarding).
1. Füllen Sie Ihren [Antrag für Stripe Identity](https://dashboard.stripe.com/identity/application) aus.
1. (Optional) Passen Sie Ihre Markeneinstellungen auf der Seite [Branding-Einstellungen](https://dashboard.stripe.com/settings/branding) an.
## Verifizierungsablauf erstellen [Dashboard]
Ein [Ablauf](https://docs.stripe.com/identity/verification-flows.md) stellt eine wiederverwendbare Konfiguration für Verifizierungen dar, die Sie von Ihren Nutzern/Nutzerinnen anfordern.
So erstellen Sie einen Ablauf im Dashboard:
1. Navigieren Sie zur Seite [Verifizierungsabläufe](https://dashboard.stripe.com/identity/verification-flows?create=true) in Ihrem Dashboard.
1. Füllen Sie das Formular mit der gewünschten Konfiguration aus und klicken Sie auf **Speichern**. Sie können den Ablauf später nach Bedarf anpassen.
## Teilen Sie den statischen Link mit Ihren Nutzern/Nutzerinnen [Dashboard]
1. Klicken Sie auf der Seite mit den Ablaufdetails auf die URL, um sie in Ihre Zwischenablage zu kopieren.
1. Teilen Sie die kopierte URL mit Ihrem/Ihrer Nutzer/in.
Diese URL läuft nie ab und kann zur Verifizierung einer beliebigen Anzahl von Nutzer/innen verwendet werden, solange der Ablauf aktiviert ist. Sie können einen Ablauf auf der Seite mit den Ablaufdetails deaktivieren. Teilen Sie den Link nur mit Nutzern/Nutzerinnen, die Sie verifizieren möchten.
## Verifizierungsergebnisse anzeigen [Dashboard]
Wenn Ihre Nutzer/innen die Verifizierung abschließen, wird eine Verifizierungssitzung für die Ergebnisse erstellt, die in Ihrem Dashboard angezeigt wird. [Dokumentprüfungen](https://docs.stripe.com/identity/verification-checks.md#document-availability) erfolgen asynchron, d. h., die Ergebnisse der Prüfung sind nicht sofort verfügbar. Die Prüfung eines Identitätsnachweises dauert in der Regel 1 bis 3 Minuten. Sobald die Verarbeitung abgeschlossen ist, ändert sich der Status der VerificationSession von `processing` in `verified`.
Verwenden Sie das Dashboard, um alle Ihre Verifizierungen anzuzeigen, die erfassten Daten zu prüfen und fehlgeschlagene Verifizierungen nachvollziehen zu können.
## See also
- [Verifizierungsabläufe](https://docs.stripe.com/identity/verification-flows.md)