Zum Hauptinhalt springen
Didit erhält 7,5 Mio. $ für die Infrastruktur für Identität und Betrug
Didit
Datenbankvalidierung

Überprüfe jede Identität.
Gegen die ausstellende Quelle.

Gleiche einen Namen, eine ID-Nummer oder Adresse mit der ausstellenden Quelle ab, über 1.000 Register, Auskunfteien und Telekommunikationsanbieter mit einem einzigen Aufruf. Ab $0.05 pro Prüfung, 500 kostenlos/Monat.

Unterstützt von
Y CombinatorRobinhood Ventures
Firecrawl
Slash
Crnogorski Telekom
UCSF Neuroscape
Bit2Me
Shiply

Über 2.000 Organisationen weltweit vertrauen uns.

Behördenregister

IDs gegen
aktuelle nationale Datenbanken prüfen.

Bestätige die Person und ihre ID anhand offizieller Aufzeichnungen, SSN, RFC, CPF, Aadhaar, NIN und über 60 weitere nationale Register. Preis pro Land veröffentlicht.

So funktioniert's

Vom Anmelden zum verifizierten Nutzer in vier Schritten.

  1. Schritt 01

    Workflow erstellen

    Wähle die gewünschten Prüfungen aus, ID, Liveness, Face Match, Sanktionen, Adresse, Alter, Telefon, E-Mail, benutzerdefinierte Fragen. Ziehe sie im Dashboard in einen Flow oder poste denselben Flow an unsere API. Verzweige nach Bedingungen, führe A/B-Tests durch, kein Code erforderlich.

  2. Schritt 02

    Integrieren

    Bette nativ mit unseren Web-, iOS-, Android-, React Native- oder Flutter-SDKs ein. Leite auf eine gehostete Seite weiter. Oder sende deinem Nutzer einfach einen Link, per E-Mail, SMS, WhatsApp, überall. Wähle, was zu deinem Stack passt.

  3. Schritt 03

    Nutzer durchläuft den Flow

    Didit hostet die Kamera, die Beleuchtungshinweise, die mobile Übergabe und die Barrierefreiheit. Während der Nutzer den Flow durchläuft, bewerten wir über 200 Betrugssignale in Echtzeit und verifizieren jedes Feld anhand autoritativer Datenquellen. Ergebnis in unter zwei Sekunden.

  4. Schritt 04

    Du erhältst die Ergebnisse

    Echtzeit-signierte Webhooks halten deine Datenbank synchron, sobald ein Nutzer genehmigt, abgelehnt oder zur Überprüfung gesendet wird. Frage die API bei Bedarf ab. Oder öffne die Konsole, um jede Session und jedes Signal zu prüfen und Fälle nach deinen Wünschen zu verwalten.

Für Entwickler gemacht · Gegen Betrug gebaut · Offen im Design

Sechs Funktionen. Ein Feature Flag. DATABASE_VALIDATION.

Jede der unten aufgeführten Funktionen ist ein Toggle im selben Modul. Keine Upsell-Stufen, keine separaten Pläne, keine zusätzlichen Anrufe, schalte die gewünschten Dienste pro Workflow ein.
01 · Quellenkatalog

Über 1.000 autoritative Quellen. Ein Aufruf.

Standesämter, Finanzbehörden, Wählerverzeichnisse, Kreditauskunfteien, Telekommunikationsanbieter, Gerichtsakten und Adressverifizierung, alles über einen Endpunkt erreichbar. Jeden Monat wird eine neue Quelle hinzugefügt und erscheint automatisch.
02 · Quellenkategorien

Register. Auskunfteien. Telkos. Gerichte. Adresse.

Wähle den Datenbereich, der zu der Art von Betrug passt, die du bekämpfst. Standesamtsprüfungen decken synthetische Identitäten auf. Kreditauskunfteien bestätigen die Historie. Telko-Prüfungen bestätigen eine aktive Leitung. Adressverifizierung beweist den Wohnsitz.
03 · Orchestrierung pro Quelle

Dienste parallel ausführen. Höchste Sicherheit gewinnt.

Aktiviere beliebig viele Dienste pro Land, und Didit feuert sie parallel ab. Eine bestätigende Quelle ist ein starkes Signal, zwei unabhängige, übereinstimmende Quellen liefern das stärkste Urteil, das wir zurückgeben können.
04 · Berichtsformat

Feldgenauer Abgleich. Quelldaten. Biometrischer Score.

Jede Quelle liefert ein feldspezifisches Urteil, einen Ergebniscode und einen bereinigten Registereintrag, vollständiger Name, Daten, Foto, Unterschrift und ein Face-Match-Score bei biometrischen Diensten wie Argentiniens RENAPER und Panamas Tribunal Electoral.
05 · Regionale Abdeckung

Lateinamerika, Spanien und über 45 Länder.

19 direkt integrierte Standesämter in Lateinamerika und Spanien. 156 Datensätze in 45 weiteren Ländern über das globale Identitätsnetzwerk. Eine neue Integration ist auf Anfrage typischerweise in zwei bis drei Wochen live.
06 · Variable Pay-per-Call

Ab $0.05 pro Prüfung. Keine Mindestmengen. 500 gratis.

Abrechnung nur bei erfolgreicher Abfrage. Günstigste Stufe $0.05 (Dominikanische Republik). Standard-Behördenregister-Stufe $0.20 (Argentinien, Brasilien, Mexiko, Spanien, Kolumbien, Peru, Chile und weitere). Übersprungene Dienste werden nie abgerechnet.
Integrieren

Zwei Endpunkte. Gleiches JSON. Gleicher Katalog.

Lass Didit die ID erfassen und die Felder automatisch ziehen, oder sende die Identitätsdaten direkt, falls du sie bereits hast. Dieselbe JSON-Struktur beim Export.
POST /v3/session/Gehostetes UI
$ curl -X POST https://verification.didit.me/v3/session/ \
  -H "x-api-key: $DIDIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "wf_db_validation",
    "vendor_data": "user-42"
  }'
201Erstellt{ "session_url": "verify.didit.me/..." }
Didit erfasst die ID, zieht die Felder automatisch und führt alle aktivierten Quellen aus.Doku →
POST /v3/database-validation/Server-zu-Server
$ curl -X POST https://verification.didit.me/v3/database-validation/ \
  -H "x-api-key: $DIDIT_API_KEY" \
  -F "issuing_state=BRA" \
  -F "services=bra_cpf" \
  -F "identification_number=12345678900"
200OK{ "match_type": "full_match", "validation_type": "1x1" }
Du besitzt die Identitätsdaten. Wir leiten sie an das richtige Register weiter und liefern das Ergebnis direkt zurück.Doku →
Agenten-fertige Integration

Datenbankvalidierung mit einem Prompt implementieren.

Füge den folgenden Block in Claude Code, Cursor, Codex, Devin, Aider oder Replit Agent ein. Gib deinen Stack an, Framework, Sprache, Anwendungsfall, und der Agent implementiert den Workflow, Webhook und Entscheidungscode Ende-zu-Ende.
didit-integration-prompt.md
# Didit Database Validation — integrate in 5 minutes

You are integrating Didit's Database Validation module into <my_stack>.
Database Validation cross-references each user's identity data against the
authoritative source for that country — the national civil registry, tax
authority, electoral roll, credit bureau, telco database, court record or
biometric service that issued the document. 1,000+ data sources reachable
through one endpoint. Follow these steps exactly. Every URL, header, and
enum value below is canonical — do not paraphrase or "improve" them.

## 1. Provision an account
- Sign up: https://business.didit.me (no credit card required).
- Or provision programmatically: POST https://apx.didit.me/auth/v2/programmatic/register/
  (returns an API key bound to the workspace + application).

## 2. Two integration paths — pick one

### Path A — Workflow Builder (hosted UI)
Best when you want Didit to capture the ID document, run Optical Character Recognition (OCR), derive the
required fields automatically, and trigger the right registry service per
issuing country.

1. Create a workflow that contains the DATABASE_VALIDATION feature:
   POST https://verification.didit.me/v3/workflows/
   Authorization header:  x-api-key: <your-api-key>
   Body: workflow_label, features array including
         { feature: "DATABASE_VALIDATION" }   (UPPERCASE — strict enum)
   Configure per-country service IDs (e.g. arg_renaper, bra_cpf,
   mex_curp, dom_cedula) plus partialMatchAction / noMatchAction.

2. Create a verification session for an end user:
   POST https://verification.didit.me/v3/session/
   Body: workflow_id (from step 1), vendor_data (your own user id).
   Response: session_url — redirect the user to it.

3. Listen for webhook callbacks (see "Webhooks" below).

### Path B — Standalone server-to-server API
Best when you already have the identity fields (mobile SDK capture,
existing onboarding pipeline, reseller flow). Single endpoint, every
country and every service routed through it.

POST https://verification.didit.me/v3/database-validation/
Content-Type: multipart/form-data
Body fields (all optional except issuing_state and at least one identifier):
  - issuing_state           (required, ISO 3166-1 alpha-3, e.g. ARG, BRA, MEX)
  - services                (optional, repeated, service IDs to run; omit
                             to run every configured service for that country)
  - identification_number   (e.g. DNI, CPF, CURP, cedula number)
  - first_name
  - last_name
  - date_of_birth           (YYYY-MM-DD)
  - selfie                  (file, required for biometric services such as
                             arg_renaper, pan_cedula_sib, pan_cedula_sib_plus)
  - address_element_1       (street + number)
  - address_element_2       (unit / building / floor)
  - address_element_3       (suburb / district)
  - address_element_4       (city / state / region)
  - address_element_5       (postal code; postal_code alias accepted)
  - consent                 (boolean — required when the selected service
                             has requires_consent=true in the catalog)
  - vendor_data             (optional string, your user id)

Response: JSON report with match_type, validation_type (1x1 or 2x2),
per-service validations, source_data, and any warnings.

## 3. Webhooks (Path A only — Path B returns synchronously)
- Register a webhook destination once via
  POST https://verification.didit.me/v3/webhook/destinations/
  Body: url, subscribed_events: ["session.verified", "session.review_started",
                                  "session.declined"]
- Response includes secret_shared_key — store it.
- Every webhook delivery carries an X-Signature-V2 header you MUST verify
  before trusting the payload.  HMAC-SHA256 verification MUST run against the raw body bytes (the raw payload as Didit sent it) BEFORE any JSON parsing — re-serialising the parsed body changes whitespace and key order, which invalidates the signature.Algorithm:
    1. sortKeys(payload) recursively
    2. shortenFloats (truncate trailing zeros after the decimal point)
    3. JSON.stringify the result
    4. HMAC-SHA256 with the secret_shared_key
    5. Hex-encode, compare to the X-Signature-V2 header.

## 4. Reading the report (both paths return the same shape)
The database_validation object includes:
- status: "Approved" | "Declined" | "In Review" | "Not Finished"
- match_type: "full_match" | "partial_match" | "no_match"
- issuing_state: ISO 3166-1 alpha-3 country code
- validation_type: "1x1" (single source full-match) or "2x2" (two
  independent sources corroborate the data)
- screened_data: the user fields submitted (identification_number,
  first_name, last_name, date_of_birth, selfie, address fields, ...)
- validations: array of per-service results. Each entry carries
  service_id (e.g. arg_renaper), service_name, outcome_code (MATCH,
  NO_MATCH, DOCUMENT_NOT_FOUND, BIOMETRIC_IMAGE_UNUSABLE,
  REGISTRY_UNAVAILABLE, ...), optional outcome_detail, a per-field
  validation block (full_match / partial_match / no_match), and a
  source_data block lifted from the registry record (photo, signature,
  full_name, gender, dates, face_match_score for biometric services).

Configurable risks (action per workflow — Decline, Review, or Approve):
- DATABASE_VALIDATION_PARTIAL_MATCH    (partialMatchAction)
- DATABASE_VALIDATION_NO_MATCH         (noMatchAction)

Warnings raised when a service cannot run:
- COULD_NOT_PERFORM_DATABASE_VALIDATION — required input field missing
  (e.g. CPF could not be OCR-extracted). You are NOT charged. Session
  auto-moves to In Review; saving the missing field in the Console
  retriggers the check.

## 5. Hard rules — do not change
- Base URL for /v3/* endpoints is verification.didit.me (NOT apx.didit.me).
- Feature enum is UPPERCASE: DATABASE_VALIDATION, ID_VERIFICATION,
  LIVENESS, FACE_MATCH, AML, IP_ANALYSIS.
- Country codes are ISO 3166-1 alpha-3 UPPERCASE: ARG, BRA, MEX, ESP, ...
- Service IDs are lowercase snake-case with a country prefix:
  arg_renaper, bra_cpf, mex_curp, dom_cedula, pan_cedula_sib_plus, ...
- Auth header is x-api-key (lowercase, hyphenated).
- Webhook signature header is X-Signature-V2 (NOT X-Signature).
- Status casing matches exactly: "Approved", "Declined", "In Review",
  "Not Finished" (title-cased, space-separated).
- match_type casing matches exactly: full_match, partial_match, no_match
  (lowercase snake-case).
- You are only billed when a service returns a result. Skipped services
  (missing input, unsupported issuing_state) are never billed.

## 6. Pricing reference (public, pay-per-call)
- Variable per source. Lowest tier: $0.05 per check (Dominican Republic,
  Junta Central Electoral).
- Standard government-registry tier: $0.20 per check (Argentina RENAPER,
  Brazil Receita Federal CPF, Mexico RENAPO CURP, Spain DGP, Colombia
  Registraduria, Peru RENIEC, Chile Registro Civil, Ecuador, Uruguay,
  El Salvador, Guatemala, Honduras, Bolivia, Paraguay, Venezuela, Costa
  Rica).
- Biometric premium tier: $0.75 (Panama SIB) up to $1.50 (Panama SIB
  Plus elevated tier with stronger biometric thresholds).
- Global identity network: 156 datasets across 45 countries (AU, NZ,
  UK, IE, FR, DE, IT, ES, PT, NL, BE, CH, AT, Nordics, Greece, Poland,
  Czechia, Hungary, Romania, Slovakia, India, Indonesia, Philippines,
  Thailand, Malaysia, Singapore, Hong Kong, China, Cambodia, Kenya,
  Nigeria, South Africa, Morocco, USA, Canada). Per-service pricing
  surfaced in the catalog and billing exports.
- 500 free checks every month, forever, on every account.

## 7. Verify your integration
- Sandbox starts on signup at https://business.didit.me — no separate flag.
- Test the full catalog of services with the per-country reference pages
  under https://docs.didit.me/api-reference/database-validation/.
- Switch to live: flip the application's environment toggle in console.

When in doubt: https://docs.didit.me/core-technology/database-validation/overview
Brauchst du mehr Kontext? Siehe die vollständige Moduldokumentation.docs.didit.me →
Abdeckung amtlicher Register

147 amtliche Register durchsuchbar.

Jeder Datenbank-Validierungsanbieter, den Didit abgleicht, mit der kanonischen Referenz-URL und der Verifizierungskategorie. Stammt aus demselben Mintlify-Dokumentenkatalog, aus dem die Business Console liest, suche nach Ländernamen, ISO 3166-1 Alpha-3-Code oder Service-ID. 147 Services · 53 Länder.

Kanonische Referenz: docs.didit.me/core-technology/database-validation/overview

Compliant by Design

Ein neues Land mit einem Klick erschließen. Wir machen die Arbeit.

Wir gründen lokale Tochtergesellschaften, sichern Lizenzen, führen Penetrationstests durch, erhalten Zertifizierungen und passen uns jeder neuen Regulierung an. Um Verifizierungen in einem neuen Land zu starten, legst du einfach einen Schalter um. Über 220 Länder live, vierteljährlich auditiert und Pen-getestet, der einzige Identitätsanbieter, den eine EU-Mitgliedsregierung offiziell als sicherer als die persönliche Verifizierung eingestuft hat.
Sicherheits- & Compliance-Dossier lesen
EU Financial Sandbox
Tesoro · SEPBLAC · BdE
ISO/IEC 27001
Informationssicherheit · 2026
SOC 2 · Type I
AICPA · 2026
iBeta Level 1 PAD
NIST / NIAP · 2026
GDPR
EU 2016/679
DORA
EU 2022/2554
MiCA
EU 2023/1114
AMLD6 · eIDAS 2.0
EU-konform by Design

Zahlen beweisen es

Zahlen beweisen es
  • 0+
    Autoritative Quellen, ein Aufruf.
  • 0
    Zivilregister in Lateinamerika und Spanien, direkt integriert.
  • Ab $0.05
    Pro Prüfung. Nur bei Ergebnis berechnet.
  • <0.0s
    End-to-End im Live-Betrieb.
Drei Stufen, eine Preisliste

Kostenlos starten. Nach Nutzung zahlen. Bis zum Enterprise-Level skalieren.

500 kostenlose Verifizierungen jeden Monat, für immer. Pay-as-you-go für die Produktion. Individuelle Verträge, Datenresidenz und SLAs (Service Level Agreements) für Enterprise.
Kostenlos

Kostenlos

$0 / Monat. Keine Kreditkarte erforderlich.

  • Kostenloses KYC-Paket (ID-Verifizierung + passive Lebenderkennung + Gesichtsabgleich + Geräte- & IP-Analyse), 500 / Monat, jeden Monat
  • Blockierte Nutzer
  • Duplikaterkennung
  • Über 200 Betrugssignale pro Session
  • Wiederverwendbares KYC im Didit-Netzwerk
  • Case Management Plattform
  • Workflow Builder
  • Öffentliche Docs, Sandbox, SDKs, MCP (Model Context Protocol) Server
  • Community Support
Am beliebtesten
Zahlung nach Nutzung

Nutzungsbasiert

Zahle nur, was du nutzt. Über 25 Module. Öffentliche Preise pro Modul, keine monatliche Mindestgebühr.

  • Full KYC für $0.33 (ID + Biometrie + IP / Gerät)
  • Über 10.000 AML-Datensätze, Sanktionen, PEPs, Adverse Media
  • Über 1.000 staatliche Datenquellen für Datenbankvalidierung
  • Transaktionsüberwachung für $0.02 pro Transaktion
  • Live KYB für $2.00 pro Unternehmen
  • Wallet Screening für $0.15 pro Prüfung
  • Whitelabel-Verifizierungsflow, deine Marke, unsere Infrastruktur
Enterprise

Enterprise

Individuelle MSA & SLA. Für große Volumina und regulierte Programme.

  • Jahresverträge
  • Individuelle MSA, DPA und SLA
  • Dedizierter Slack- und WhatsApp-Kanal
  • Manuelle Prüfer auf Abruf
  • Reseller- und White-Label-Konditionen
  • Exklusive Features und Partnerintegrationen
  • Benannter CSM, Sicherheitsprüfung, Compliance-Support

Kostenlos starten → nur zahlen, wenn eine Prüfung läuft → Enterprise für einen individuellen Vertrag, SLA oder Datenresidenz freischalten.

FAQ

Häufige Fragen

Was ist Didit?

Didit ist die Infrastruktur für Identität und Betrugsprävention, die Plattform, die wir uns selbst gewünscht hätten, als wir unsere eigenen Produkte entwickelten: offen, flexibel und entwicklerfreundlich, damit sie sich nahtlos in deinen Stack integriert, anstatt eine Blackbox zu sein, um die herum du integrieren musst.

Eine API deckt die Verifizierung von Personen (KYC, Know Your Customer), die Verifizierung von Unternehmen (KYB, Know Your Business), das Screening von Krypto-Wallets (KYT, Know Your Transaction) und die Echtzeit-Transaktionsüberwachung ab, auf einem Stack, der gebaut wurde, um:

  • Schnell zu sein, unter 2 Sekunden p99 bei jeder Session
  • Zuverlässig zu sein, im Einsatz bei über 1.500 Unternehmen in über 220 Ländern
  • Sicher zu sein, SOC 2 Typ 1, ISO 27001, GDPR-nativ und von der spanischen Finanzaufsichtsbehörde formell als sicherer als die persönliche Verifizierung attestiert

Die zugrunde liegende Basis: über 14.000 Dokumenttypen in über 48 Sprachen, über 1.000 Datenquellen und über 200 Betrugssignale bei jeder Session. Die Didit-Infrastruktur lernt dynamisch aus jeder Session und wird jeden Tag besser.

Was ist Datenbankvalidierung?

Die Datenbankvalidierung gleicht die Identitätsdaten eines Nutzers, Name, Geburtsdatum, Identifikationsnummer, Adresse, mit über 1.000 autoritativen Quellen ab, die über einen einzigen Endpunkt erreichbar sind. Dazu gehören staatliche Personenstandsregister, Steuerbehörden, Wählerverzeichnisse, Kreditauskunfteien, Telekommunikationsdatenbanken, Gerichtsakten und Adressverifizierungen.

Sie bekämpft synthetische Identitäten (ein gefälschter DNI oder brasilianischer Cadastro de Pessoas Físicas (CPF) wird nicht im offiziellen Register zu finden sein), bestätigt den Wohnsitz für das Onboarding gemäß der Anti-Geldwäsche-Richtlinie 6 (AMLD6) und leitet automatisch nach issuing_state weiter, sodass du keine länderspezifischen Anbieter fest codieren musst.

Vollständige Referenz: docs.didit.me/core-technology/database-validation/overview.

Was kostet die Datenbankvalidierung?

Variabel pro Anbieter, nur bei Ergebnisberechnung. Keine Mindestmengen, keine Plattformgebühren, keine Kosten für übersprungene Dienste.

  • Günstigste Stufe $0.05 pro Prüfung (Dominikanische Republik über Junta Central Electoral).
  • Standard-Stufe für staatliche Register $0.20 (Argentinien, Brasilien, Mexiko, Spanien, Kolumbien, Peru, Chile und weitere).
  • Biometrisches Premium $0.75–$1.50 (Panama Servicio de Identificación Biométrica (SIB) und SIB Plus).

Gebündelt in einem vollständigen Know Your Customer (KYC)-Workflow zusammen mit Ausweisdokumentenprüfung + Liveness + Face Match: $0.33 pro Session.

Wie schnell ist die Verifizierung für meine Endnutzer?

Der gesamte Ablauf dauert normalerweise unter 30 Sekunden von Anfang bis Ende, Ausweis nehmen, Dokument fotografieren, Selfie machen, fertig. Das ist der schnellste Wert auf dem Markt. Herkömmliche KYC-Anbieter benötigen für denselben Ablauf in der Regel mehr als 90 Sekunden.

Im Backend liefert Didit das Ergebnis in unter zwei Sekunden bei p99, gemessen vom Zeitpunkt, an dem der Nutzer das Selfie beendet, bis zum Auslösen deines Webhooks. Die mobile Erfassung ist für langsame Telefone und langsame Netzwerke optimiert: progressive Bildkomprimierung, verzögertes Laden des Software Development Kits (SDK) und eine One-Tap-Übergabe vom Desktop zum Telefon per QR-Code, wenn der Nutzer im Web beginnt.

Wie sieht die Antwortstruktur aus?

Das database_validation-Objekt gibt zurück:

  • status, Approved, Declined, In Review.
  • match_type, full_match, partial_match, no_match.
  • validation_type, 1x1 (ein Register bestätigt) oder 2x2 (zwei unabhängige Register bestätigen, die höchste Vertrauensstufe, die wir ausdrücken können).
  • validations[], Zeilen pro Dienst mit service_id, Ergebnis pro Feld, einem outcome_code (MATCH, NO_MATCH, DOCUMENT_NOT_FOUND, BIOMETRIC_IMAGE_UNUSABLE, REGISTRY_UNAVAILABLE) und den source_data, die aus dem Registereintrag entnommen wurden, vollständiger Name, Daten, Foto Uniform Resource Locator (URL), Unterschrift, plus face_match_score für biometrische Dienste.

Dieselbe Struktur bei der eigenständigen Application Programming Interface (API) und im Session-Flow.

Was passiert, wenn ein Nutzer scheitert, abbricht oder die Session abläuft?

Jede Session landet in einem von sieben klaren Status, sodass dein Code immer weiß, was zu tun ist:

  • Approved, alle Prüfungen bestanden. Den Nutzer weiterleiten.
  • Declined, eine oder mehrere Prüfungen fehlgeschlagen. Du kannst dem Nutzer erlauben, den spezifischen fehlgeschlagenen Schritt (z. B. das Selfie erneut aufnehmen) erneut einzureichen, ohne den gesamten Ablauf erneut durchzuführen.
  • In Review, zur Compliance-Prüfung markiert. Den Fall in der Konsole öffnen, alle Signale einsehen, Genehmigung oder Ablehnung entscheiden.
  • In Progress, Nutzer befindet sich mitten im Ablauf.
  • Not Started, Link gesendet, Nutzer hat ihn noch nicht geöffnet. Eine Erinnerung senden, wenn er zu lange unbeachtet bleibt.
  • Abandoned, Nutzer hat den Link geöffnet, aber nicht rechtzeitig abgeschlossen. Erneut ansprechen oder ablaufen lassen.
  • Expired, der Session-Link ist abgelaufen. Eine neue Session erstellen.

Ein signierter Webhook wird bei jeder Statusänderung ausgelöst, sodass deine Datenbank immer synchron bleibt. Abgebrochene und abgelehnte Sessions sind kostenlos.

Wo werden meine Kundendaten gespeichert und wie werden sie geschützt?

Produktionsdaten werden standardmäßig in der Europäischen Union verarbeitet und gespeichert, auf Amazon Web Services. Unternehmenskunden können alternative Regionen für Jurisdiktionen anfordern, deren Regulierungsbehörden dies verlangen.

Verschlüsselung überall. AES-256 im Ruhezustand über jede Datenbank, jeden Objektspeicher und jedes Backup. Transport Layer Security 1.3 während der Übertragung bei jedem API-Aufruf, Webhook und jeder Business Console-Session. Biometrische Daten werden unter einem separaten Customer Master Key verschlüsselt.

Die Aufbewahrung liegt in deiner Kontrolle. Die Standardaufbewahrungsfrist ist unbegrenzt, es sei denn, du konfigurierst eine kürzere, zwischen 30 Tagen und 10 Jahren pro Anwendung, und du kannst jede einzelne Session jederzeit über das Dashboard oder die API löschen.

Zertifizierungen: SOC 2 Typ 1 (Typ 2 Audit läuft), ISO/IEC 27001:2022, iBeta Level 1 PAD und eine öffentliche Bestätigung des spanischen Tesoro / SEPBLAC / CNMV, dass Didits Fernidentitätsprüfung sicherer ist als die persönliche Verifizierung. Vollständiger Bericht unter /security-compliance.

Ist Didit für meine Branche konform?

Didit ist standardmäßig konform mit den für die Identitätsinfrastruktur relevanten Regulierungsbehörden:

  • GDPR + UK GDPR, Aufteilung in Verantwortlichen und Auftragsverarbeiter, vollständige Veröffentlichung des Datenverarbeitungsvertrags, benannte federführende Aufsichtsbehörde (spanische AEPD).
  • AMLD6 + EU AML Single Rulebook, Über 1.300 Sanktions-, PEP- (politisch exponierte Person) und Adverse-Media-Listen werden in Echtzeit überprüft.
  • eIDAS 2.0, Ausgerichtet auf die EU Digital Identity Wallet; bereit für wiederverwendbare Identitäten.
  • MiCA (Markets in Crypto-Assets), Bereit für Krypto-On-Ramps, Börsen und Verwahrstellen.
  • DORA, Digital Operational Resilience Act, EU-weite operationelle Resilienz für Finanzdienstleistungen.
  • BIPA, CUBI, Washington HB 1493, CCPA / CPRA, US-Biometriedatenschutz (Illinois, Texas, Washington) und kalifornischer Verbraucherdatenschutz.
  • UK Online Safety Act, Altersverifikation und Kinderschutzpflichten.
  • FATF Travel Rule, Ursprungs- und Empfängerdaten bei Krypto-Transfers, IVMS-101-kompatibel.

Ausführliches Memo, alle Zertifikate, alle Schreiben der Regulierungsbehörden: /security-compliance.

Wie schnell kann ich Didit integrieren und Nutzer verifizieren?
  • 60 Sekunden bis zu einem Sandbox-Konto auf business.didit.me, keine Kreditkarte erforderlich.
  • 5 Minuten bis zu einer funktionierenden Verifizierung über Claude Code, Cursor oder jeden Coding Agent via unserem Model Context Protocol (MCP) Server.
  • Ein Wochenende bis zu einer produktionsreifen Integration mit signierter Webhook-Verifizierung, Wiederholungsversuchen und einem Korrektur-Workflow, falls ein Nutzer abgelehnt wird.

Drei Integrationswege, wähle den, der am besten zu deinem Stack passt:

  • Nativ einbetten mit unserem Web-, iOS-, Android-, React Native- oder Flutter-SDK.
  • Den Nutzer auf die gehostete Verifizierungsseite weiterleiten, kein SDK erforderlich.
  • Einen Link senden per E-Mail, SMS, WhatsApp oder über jeden anderen Kanal, keine Frontend-Arbeit.

Das gleiche Dashboard, die gleiche Abrechnung, der gleiche Pay-per-Success-Preis für alle drei Optionen. Eine Schritt-für-Schritt-Anleitung findest du unter docs.didit.me/integration/integration-prompt.

Infrastruktur für Identität und Betrugsprävention.

Eine API für KYC, KYB, Transaktionsüberwachung und Wallet-Screening. In 5 Minuten integriert.

Lass dir diese Seite von einer KI zusammenfassen