# Verifizierungsprüfungen Erfahren Sie mehr über die verschiedenen von Stripe Identity unterstützten Prüfschritte zur Feststellung der Identität. Stripe Identity unterstützt derzeit fünf Arten von Verifizierungsprüfungen: Dokument, Selfie, ID-Nummer, Adresse und Telefon. Jede Verifizierungsprüfung erfordert andere Informationen von Ihren Nutzerinnen/Nutzern, unterliegt unterschiedlichen Deckungskonzepten und Verifizierungsabläufen. Nachdem Sie eine Prüfung integriert haben, können Sie eine weitere mit minimalen Änderungen an Ihrer Integration hinzufügen. # Dokument > This is a Dokument for when type is document. View the full page at https://docs.stripe.com/identity/verification-checks?type=document. Dokumentenprüfungen verifizieren die Echtheit von behördlich ausgestellten Ausweisdokumenten. Stripe verwendet eine Kombination aus KI-Modellen, automatisierter heuristischer Analyse und manuellen Prüfungen, um die Authentizität von Hunderten verschiedener Dokumenttypen zu verifizieren. KI-Modelle werden verwendet, um hochauflösende Bilder der Vorder- und Rückseite von Dokumenten zu erfassen. Die Dokumentaufnahmen werden in Echtzeit analysiert, um sie auf Lesbarkeit zu prüfen und den Nutzer/die Nutzerin zu warnen, wenn das Dokument abgelaufen oder eine Verifizierung unwahrscheinlich ist. Stripe vergleicht die Bilder mit betrügerischen Dokumentenvorlagen aus einer Datenbank. Diese Datenbank wird regelmäßig aktualisiert, sodass Stripe neue gefälschte Dokumentenvorlagen erkennen und automatisch blockieren kann. Soweit verfügbar, werden Strichcodes und andere maschinenlesbare Merkmale des Dokuments dekodiert und Übereinstimmungskontrollen durchgeführt, um sicherzustellen, dass die Textdokumentdaten mit den maschinenlesbaren Daten übereinstimmen. Um „Präsentationsangriffe“ zu verhindern, bei denen Betrüger/innen Bilder aus gestohlenen Dokumenten oder das Gesicht einer anderen Person verwenden, setzt Stripe Computervision- und KI-Algorithmen ein, um sicherzustellen, dass der/die Nutzer/in eine Aufnahme eines echten Dokuments gemacht hat. Unter [Verifizierung der Dokumente Ihrer Nutzer/innen](https://docs.stripe.com/identity/verify-identity-documents.md) erfahren Sie, wie Sie Dokumentenprüfungen in Ihre Anwendung integrieren können. Darüber hinaus können Dokumentenprüfungen auch mit der [Prüfung von ID-Nummern kombiniert werden](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-options-document-require_id_number). So wird die Echtheit des Dokuments gewährleistet und sichergestellt, dass die darin enthaltenen Informationen über Datenbanken von Drittanbietern hinweg miteinander verglichen werden können. ## Verfügbarkeit Dokumentenprüfungen sind für die meisten behördlich ausgestellten Dokumente (Personalausweise, Führerscheine und Reisepässe) aus den folgenden Ländern verfügbar: Akzeptierte Ausweisdokumente variieren je nach Land, Reisepässe werden jedoch weitgehend unterstützt. - AE - AL - AM - AR - AT - AU - AZ - BD - BE - BG - BH - BJ - BO - BR - BS - BY - CA - CH - CI - CL - CM - CN - CO - CR - CY - CZ - DE - DK - DO - DZ - EC - EE - EG - ES - FI - FR - GB - GE - GH - GR - GT - HK - HN - HR - HT - HU - ID - IE - IL - IN - IQ - IT - JE - JM - JO - JP - KE - KR - KW - KZ - LB - LI - LK - LT - LU - LV - MA - MD - MK - MM - MN - MT - MU - MX - MY - NG - NL - NO - NP - NZ - PA - PE - PH - PK - PL - PR - PS - PT - PY - RO - RS - RU - SA - SE - SG - SI - SK - SV - TH - TN - TR - TW - UA - UG - US - UY - UZ - VE - VN - ZA > Stripe unterstützt keine Extraktion von Dokumentfeldern in arabischer, chinesischer, griechischer, hebräischer, koreanischer, kyrillischer, tamilischer oder thailändischer Schrift. # Selfie > This is a Selfie for when type is selfie. View the full page at https://docs.stripe.com/identity/verification-checks?type=selfie. Dokumentenprüfungen bieten zwar Schutz vor der Verwendung betrügerischer Ausweisdokumente, doch Betrüger/innen können sich Zugang zu gestohlenen echten Dokumenten verschaffen. Um dies zu verhindern, kann Stripe Ihre Nutzer/innen Selfie-Prüfungen unterziehen. Bei Selfie-Prüfungen wird im amtlichen Lichtbildausweis und in einer Gesichtsaufnahme der Nutzerin oder des Nutzers nach charakteristischen biologischen Merkmalen, wie der Gesichtsgeometrie gesucht. Anschließend prüft Stripe mithilfe moderner Machine-Learning-Algorithmen, ob die Gesichtsaufnahmen zu derselben Person gehören. In some places, such as the EU, there are privacy laws that require you to justify your use of biometric technology or offer an alternative, non-biometric means of verification. We recommend you offer an alternative verification option or consult with your legal counsel. ### Verfügbarkeit Selfie-Prüfungen für behördlich ausgestellte Lichtbildausweise sind in den folgenden Ländern verfügbar: - AE - AL - AM - AR - AT - AU - AZ - BD - BE - BG - BH - BJ - BO - BR - BS - BY - CA - CH - CI - CL - CM - CN - CO - CR - CY - CZ - DE - DK - DO - DZ - EC - EE - EG - ES - FI - FR - GB - GE - GH - GR - GT - HK - HN - HR - HT - HU - ID - IE - IL - IN - IQ - IT - JE - JM - JO - JP - KE - KR - KW - KZ - LB - LI - LK - LT - LU - LV - MA - MD - MK - MM - MN - MT - MU - MX - MY - NG - NL - NO - NP - NZ - PA - PE - PH - PK - PL - PR - PS - PT - PY - RO - RS - RU - SA - SE - SG - SI - SK - SV - TH - TN - TR - TW - UA - UG - US - UY - UZ - VE - VN - ZA ## Selfie-Checks hinzufügen Befolgen Sie zunächst den Leitfaden zum [Erfassen und Verifizieren von Identitätsdokumenten](https://docs.stripe.com/identity/verify-identity-documents.md), um Selfie-Prüfungen in Ihre Anwendung aufzunehmen. ## Selfie-Prüfungen zu VerificationSessions hinzufügen Verwenden Sie beim [Erstellen einer VerificationSession](https://docs.stripe.com/api/identity/verification_sessions/create.md) den Parameter [options.document.require_matching_selfie](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-options-document-require_matching_selfie), um Selfie-Prüfungen zu ermöglichen. ```curl curl https://api.stripe.com/v1/identity/verification_sessions \ -u "<>:" \ -d type=document \ -d "options[document][require_matching_selfie]"=true ``` ```cli stripe identity verification_sessions create \ --type=document \ -d "options[document][require_matching_selfie]"=true ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") verification_session = client.v1.identity.verification_sessions.create({ type: 'document', options: {document: {require_matching_selfie: true}}, }) ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. verification_session = client.v1.identity.verification_sessions.create({ "type": "document", "options": {"document": {"require_matching_selfie": True}}, }) ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $verificationSession = $stripe->identity->verificationSessions->create([ 'type' => 'document', 'options' => ['document' => ['require_matching_selfie' => true]], ]); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); VerificationSessionCreateParams params = VerificationSessionCreateParams.builder() .setType(VerificationSessionCreateParams.Type.DOCUMENT) .setOptions( VerificationSessionCreateParams.Options.builder() .setDocument( VerificationSessionCreateParams.Options.Document.builder() .setRequireMatchingSelfie(true) .build() ) .build() ) .build(); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. VerificationSession verificationSession = client.v1().identity().verificationSessions().create(params); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const verificationSession = await stripe.identity.verificationSessions.create({ type: 'document', options: { document: { require_matching_selfie: true, }, }, }); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.IdentityVerificationSessionCreateParams{ Type: stripe.String(stripe.IdentityVerificationSessionTypeDocument), Options: &stripe.IdentityVerificationSessionCreateOptionsParams{ Document: &stripe.IdentityVerificationSessionCreateOptionsDocumentParams{ RequireMatchingSelfie: stripe.Bool(true), }, }, } result, err := sc.V1IdentityVerificationSessions.Create(context.TODO(), params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var options = new Stripe.Identity.VerificationSessionCreateOptions { Type = "document", Options = new Stripe.Identity.VerificationSessionOptionsOptions { Document = new Stripe.Identity.VerificationSessionOptionsDocumentOptions { RequireMatchingSelfie = true, }, }, }; var client = new StripeClient("<>"); var service = client.V1.Identity.VerificationSessions; Stripe.Identity.VerificationSession verificationSession = service.Create(options); ``` Hiermit wird der Verifizierungsvorgang so konfiguriert, dass ein amtlicher Lichtbildausweis und ein Selfie der Nutzerin oder des Nutzers erforderlich sind. ## Zugriff auf Ergebnisse der Selfie-Prüfung Nachdem sie übermittelt und verarbeitet wurde, ändert sich der Status der VerificationSession je nach Ergebnis der Prüfungen: - `verified` – Sowohl die Dokument- als auch die Selfie-Prüfung waren erfolgreich. Die Sitzung [verified_outputs](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-verified_outputs) enthält aus dem Dokument entnommene Informationen. - `requires_input` – Mindestens eine der Dokument- oder Selfie-Prüfungen ist fehlgeschlagen. Um auf die erfassten Selfie- und Dokumentaufnahmen zugreifen zu können, müssen Sie den verknüpften [VerificationReport](https://docs.stripe.com/api/identity/verification_reports.md) abrufen. Dies können Sie tun, indem Sie das Feld [last_verification_report](https://docs.stripe.com/api/identity/verification_sessions/object.md#identity_verification_session_object-last_verification_report) in der Sitzung [erweitern](https://docs.stripe.com/api/expanding_objects.md): #### Node.js ```javascript // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const verificationSession = await stripe.identity.verificationSessions.retrieve( '{{SESSION_ID}}', { expand: ['last_verification_report'], } ); const verificationReport = verificationSession.last_verification_report; ``` #### Ruby ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys Stripe.api_key = '<>' verification_session = Stripe::Identity::VerificationSession.retrieve({ id: '{{SESSION_ID}}', expand: ['last_verification_report'], }) verification_report = verification_session.last_verification_report ``` #### Python ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys stripe.api_key = '<>' verification_session = stripe.identity.VerificationSession.retrieve( '{{SESSION_ID}}', expand=['last_verification_report'], ) verification_report = verification_session.last_verification_report ``` #### PHP ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient(<>); $verification_session = $stripe->identity->verificationSessions->retrieve( '{{SESSION_ID}}', [ 'expand' => ['last_verification_report'], ] ); $verification_report = $verification_session->last_verification_report; ``` #### Java ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys Stripe.apiKey = "<>"; VerificationSessionRetrieveParams params = VerificationSessionRetrieveParams.builder() .addExpand("last_verification_report") .build(); VerificationSession verificationSession = VerificationSession.retrieve("{{SESSION_ID}}", params, null); VerificationReport verificationReport = verificationSession.getLastVerificationReportObject(); ``` #### Gehen Sie zu ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys stripe.Key = "<>" params := &stripe.IdentityVerificationSessionParams{} params.AddExpand("last_verification_report") vs, _ := verificationsession.Get("{{SESSION_ID}}", params) verification_report := vs.LastVerificationReport ``` #### .NET ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeConfiguration.ApiKey = "<>"; var options = new VerificationSessionGetOptions(); options.AddExpand("last_verification_report"); var service = new VerificationSessionService(); var verificationSession = service.Get("{{SESSION_ID}}", options); var verificationReport = verificationSession.LastVerificationReport; ``` Im VerificationReport finden Sie die Felder [Dokument](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-document) und [Selfie](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-selfie), die die Ergebnisse der Dokument- und Selfieprüfungen enthalten. Nachfolgend finden Sie ein Beispiel für einen VerificationReport mit erfolgreichen Dokumenten- und Selfie-Prüfungen. ```json { "id": "vr_orWziM4j7CiRL8J4vQmXgW2w", "object": "identity.verification_report", "type": "document", "verification_session": "vs_orWziM4j7CiRL8J4vQmXgW2w", "created": 1611776872, "livemode": true, "options": { "document": { "require_matching_selfie": true } }, "document": { "status": "verified", "error": null, "first_name": "Jenny", "last_name": "Rosen", "address": { "line1": "1234 Main St.", "city": "San Francisco", "state": "CA", "postal_code": "94111", "country": "US" }, "document_type": "id_card", "expiration_date": { "day": 17, "month": 7, "year": 2024 }, "files": ["file_orWziM4j7CiRL8J4vQmXgW2w", "file_orWziM4j7CiRL8J4vQmXgW2w"], "issued_date": { "day": 4, "month": 27, "year": 2021 }, "issuing_country": "US" }, "selfie": { "status": "verified", "error": null, "document": "file_orWziM4j7CiRL8J4vQmXgW2w", "selfie": "file_orWziM4j7CiRL8J4vQmXgW2w", } } ``` Um auf die erfassten Dokument- und Gesichtsaufnahmen zuzugreifen, lesen Sie bitte [Zugriff auf Verifizierungsergebnisse](https://docs.stripe.com/identity/access-verification-results.md). ## Informationen zu fehlgeschlagenen Selfie-Prüfungen Die VerificationReport-Felder [Dokument](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-document) und [Selfie](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-selfie) enthalten die erfassten Daten sowie die Felder `status` und `error`, die erläutern, ob eine Prüfung erfolgreich war oder nicht. Das `status`-Feld informiert Sie darüber, ob eine Prüfung erfolgreich war oder nicht. Folgende Werte sind möglich: - `verified` – Die Verifizierungsprüfung war erfolgreich und die erfassten Daten wurden verifiziert. - `unverified` – Die Verifizierungsprüfung ist fehlgeschlagen. Im `error`-Hash finden Sie weitere Informationen. Wenn die Verifizierungsprüfung fehlschlägt, enthält das `error`-Feld die Werte `code` und `reason`, die den Grund für das Fehlschlagen der Prüfung erläutern. Mit dem Feld `error.code` können Verifizierungsfehler programmatisch gehandhabt werden. Das Feld `reason` enthält eine beschreibende Nachricht, die den Grund für das Fehlschlagen erklärt und die Sie Ihrer Nutzerin oder Ihrem Nutzer vorlegen können. ### Fehlgeschlagene Dokumentprüfungen Fehlerdetails sind im Berichtsfeld [document.error](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-document-error) verfügbar. | Fehlercode | Beschreibung | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `document_expired` | Das eingereichte Identitätsdokument ist abgelaufen. | | `document_unverified_other` | Stripe konnte das eingereichte Identitätsdokument nicht verifizieren. [Prüfen Sie die Liste unterstützter Dokumententypen](https://docs.stripe.com/identity/verification-checks.md?type=document). | | `document_type_not_supported` | Das eingereichte Identitätsdokument gehört nicht zu den [erlaubten Dokumententypen](https://docs.stripe.com/api/identity/verification_sessions/create.md#create_identity_verification_session-options-document-allow_document_types) der Sitzung. | ### Fehlgeschlagene Selfie-Prüfungen Fehlerdetails sind im Berichtsfeld [selfie.error](https://docs.stripe.com/api/identity/verification_reports/object.md#identity_verification_report_object-selfie-error) verfügbar. | Fehlercode | Beschreibung | | ------------------------------- | ----------------------------------------------------------------------------- | | `selfie_document_missing_photo` | Das eingereichte Identitätsdokument enthält keine Aufnahme eines Gesichts. | | `selfie_face_mismatch` | Die Aufnahme des Gesichts stimmt nicht mit dem Gesicht im Dokument überein. | | `selfie_unverified_other` | Stripe konnte das eingereichte Selfie nicht verifizieren. | | `selfie_manipulated` | Die Gesichtsaufnahme wurde verfälscht oder in betrügerischer Weise verändert. | # ID-Nummer > This is a ID-Nummer for when type is id-number. View the full page at https://docs.stripe.com/identity/verification-checks?type=id-number. Anhand von Prüfungen von ID-Nummern können Name, Geburtsdatum und nationale Ausweisnummer eines/einer Nutzers/in verifiziert werden. Stripe verwendet eine Kombination aus Datenquellen von Drittanbietern, wie Kreditauskunfteien, Versorgungsunternehmen oder behördliche erstellte Datenbanken usw., um die angegebene ID-Nummer zu verifizieren. Um in Ihrer Anwendung Prüfungen von ID-Nummern durchzuführen, lesen Sie bitte [VerificationSession erstellen](https://docs.stripe.com/identity/verification-sessions.md#create). ### Verfügbarkeit Prüfungen von ID-Nummern sind in den folgenden Ländern verfügbar: - US # Telefon (nur auf Einladung) > This is a Telefon (nur auf Einladung) for when type is phone. View the full page at https://docs.stripe.com/identity/verification-checks?type=phone. Die Verifizierung der Telefonnummer ist eine unkomplizierte Verifizierungsmethode, mit der sich die Konversionszeit verkürzen und der Verifizierungsvorgang der Nutzer/innen verbessern lässt. Stripe fragt eine/n Nutzer/in im Identitätsablauf nach seiner/ihrer Telefonnummer und dem rechtsgültigen Namen. Wir senden einen Verifizierungscode per SMS an die angegebene Telefonnummer, den der/die Nutzer/in auf dem Bildschirm bestätigen muss. Gleichzeitig versuchen wir, die Inhaberschaft der Telefonnummer anhand unserer Aufzeichnungen und anderer Risikosignale im Stripe-Netzwerk zu verifizieren. Wenn wir die Eigentumsdaten verifizieren können, kann der/die Nutzer/in zu Ihrer Website zurückkehren. Wenn wir zu keinem Entschluss gelangen, kann der/die Nutzer/in nahtlos in einen Dokumentenverifizierungsablauf übergehen. ### Verfügbarkeit (Nur auf Einladung) [Kontaktieren uns](mailto:identity-phone-verification-beta@stripe.com), um Zugriff auf Telefonnummernprüfungen in den folgenden Ländern anzufordern: - US # Adresse (nur auf Einladung) > This is a Adresse (nur auf Einladung) for when type is address. View the full page at https://docs.stripe.com/identity/verification-checks?type=address. Anhand von Adressprüfungen können Name, Geburtsdatum und Adresse eines/einer Nutzers/in verifiziert werden. Stripe verwendet eine Kombination aus Datenquellen von Drittanbietern, wie Kreditauskunfteien, Versorgungsunternehmen oder behördlich erstellte Datenbanken etc., um die angegebene Adresse zu verifizieren. Um Ihre Anwendung um Adressprüfungen zu erweitern, lesen Sie bitte [VerificationSession erstellen](https://docs.stripe.com/identity/verification-sessions.md#create). ### Verfügbarkeit (Nur auf Einladung) [Kontaktieren Sie unser Support-Team](https://support.stripe.com/contact), um Zugriff auf Adressprüfungen in den folgenden Länder anzufordern: - AT - AU - BE - BR - CA - CH - CZ - DE - DK - ES - FI - FR - GB - HK - ID - IE - IT - MT - MX - MY - NL - NO - PL - PT - RO - SE - SG - SK - TH - US ## See also - [Identitätsnachweise Ihrer Nutzer/innen verifizieren](https://docs.stripe.com/identity/verify-identity-documents.md) - [Die Verification Sessions API](https://docs.stripe.com/identity/verification-sessions.md#create)