Didits Adressnachweis mit FastAPI und MongoDB integrieren (DE)

Nahtlose IntegrationIntegrieren Sie Didits Proof of Address API mit FastAPI und MongoDB, um ein robustes und skalierbares KYC-Backend zu schaffen und Ihre Verifizierungsabläufe zu optimieren.

Automatisierte VerifizierungNutzen Sie Didits KI-native Fähigkeiten zur automatischen Extraktion, Validierung und Authentizitätsprüfung von Adressdokumenten, wodurch manuelle Überprüfungen reduziert und die Genauigkeit verbessert werden.

Konfigurierbare WorkflowsNutzen Sie Didits flexible Einstellungen, um benutzerdefinierte Aktionen für verschiedene Verifizierungsergebnisse zu definieren, wie z.B. Namensungleichheiten oder Probleme mit der Dokumentenqualität, um die Einhaltung verschiedener regulatorischer Anforderungen zu gewährleisten.

Skalierbar & KostengünstigDidit bietet einen modularen, entwicklerfreundlichen Ansatz mit Free Core KYC und einer Pay-per-Successful-Check-Preisgestaltung, was es zu einer idealen Wahl für Unternehmen jeder Größe macht, die eine skalierbare Identitätsprüfung suchen.

Die Herausforderung der Adressnachweis-Verifizierung im KYC

Die Verifizierung des Adressnachweises (Proof of Address, PoA) ist eine kritische Komponente der Know-Your-Customer (KYC)-Prozesse in verschiedenen Branchen, von Finanzdienstleistungen bis hin zu Online-Marktplätzen. Sie ist unerlässlich, um den physischen Wohnsitz eines Benutzers zu bestätigen, Betrug vorzubeugen, Anti-Geldwäsche (AML)-Vorschriften einzuhalten und Vertrauen aufzubauen. Die manuelle Überprüfung von Stromrechnungen, Kontoauszügen und behördlich ausgestellten Dokumenten ist jedoch zeitaufwändig, fehleranfällig und nicht skalierbar. Unternehmen benötigen eine robuste, automatisierte und sichere Lösung, um die Komplexität der PoA-Verifizierung zu bewältigen und gleichzeitig ein reibungsloses Benutzererlebnis zu gewährleisten.

Traditionelle PoA-Lösungen beinhalten oft komplexe Integrationen, hohe Einrichtungskosten und starre Workflows. Hier kommen moderne, KI-native Identitätsplattformen wie Didit ins Spiel, die einen entwicklerfreundlichen Ansatz bieten, der die Integration vereinfacht und leistungsstarke, automatisierte Verifizierungsfunktionen bereitstellt. Durch die Kombination von Didits Proof of Address API mit einem skalierbaren Backend wie FastAPI und einer flexiblen NoSQL-Datenbank wie MongoDB können Unternehmen hocheffiziente und konforme KYC-Systeme aufbauen.

Einrichtung Ihrer FastAPI- und MongoDB-Umgebung

Zunächst benötigen Sie eine FastAPI-Anwendung und eine MongoDB-Instanz. FastAPI wird aufgrund seiner hohen Leistung und Benutzerfreundlichkeit gewählt, während MongoDB die Flexibilität bietet, verschiedene Dokumententypen und Verifizierungsberichte zu speichern. Hier ist eine grundlegende Einrichtung:

1. FastAPI-Anwendungs-Setup

Installieren Sie zuerst FastAPI und Uvicorn:

pip install fastapi uvicorn python-multipart motor

Erstellen Sie eine Datei main.py:

from fastapi import FastAPI, UploadFile, File, Form, HTTPException
from motor.motor_asyncio import AsyncIOMotorClient
from typing import Optional
import httpx
import os

app = FastAPI()

# MongoDB setup
MONGO_DETAILS = os.getenv("MONGO_DETAILS", "mongodb://localhost:27017")
client = AsyncIOMotorClient(MONGO_DETAILS)
database = client.didit_kyc

# Didit API Key
DIDIT_API_KEY = os.getenv("DIDIT_API_KEY")
if not DIDIT_API_KEY:
    raise ValueError("DIDIT_API_KEY environment variable not set")

@app.on_event("startup")
async def startup_db_client():
    app.mongodb_client = client
    app.mongodb = database

@app.on_event("shutdown")
async def shutdown_db_client():
    app.mongodb_client.close()

@app.get("/health")
async def health_check():
    return {"status": "ok", "message": "FastAPI is running"}

2. MongoDB-Verbindung

Stellen Sie sicher, dass MongoDB läuft, entweder lokal oder über einen Cloud-Dienst. Die motor-Bibliothek ermöglicht eine asynchrone Interaktion mit MongoDB, was für hochleistungsfähige FastAPI-Anwendungen entscheidend ist.

Integration von Didits Proof of Address API

Didits Proof of Address API ermöglicht es Ihnen, Dokumentenbilder oder PDFs zur Verifizierung einzureichen, Adressinformationen zu extrahieren und zu validieren, Authentizitätsprüfungen durchzuführen und strukturierte Daten zurückzugeben. Dieser Prozess ist dank Didits KI-nativer Architektur hochgradig automatisiert und präzise.

1. Dokumente an Didit senden

Sie benötigen einen Endpunkt in Ihrer FastAPI-Anwendung, um Dokumentenuploads zu akzeptieren und an Didit weiterzuleiten. Didits API unterstützt verschiedene Dokumententypen (PDF, JPEG, PNG, WebP, TIFF) und bietet konfigurierbare Parameter für eine verbesserte Validierung.

@app.post("/verify-poa/")
async def verify_proof_of_address(
    document: UploadFile = File(...),
    expected_first_name: Optional[str] = Form(None),
    expected_last_name: Optional[str] = Form(None),
    expected_address: Optional[str] = Form(None),
    expected_country: Optional[str] = Form(None),
    poa_name_mismatch_action: str = Form("DECLINE"),
    poa_document_issues_action: str = Form("DECLINE"),
    poa_document_authenticity_action: str = Form("DECLINE"),
):
    if not document.content_type.startswith(('image/', 'application/pdf')):
        raise HTTPException(status_code=400, detail="Invalid document format. Only images and PDFs are allowed.")

    DIDIT_POA_ENDPOINT = "https://verification.didit.me/v3/poa/"
    headers = {"x-api-key": DIDIT_API_KEY}

    # Prepare form data for Didit API
    files = {'document': (document.filename, document.file.read(), document.content_type)}
    data = {
        "poa_name_mismatch_action": poa_name_mismatch_action,
        "poa_document_issues_action": poa_document_issues_action,
        "poa_document_authenticity_action": poa_document_authenticity_action,
    }
    if expected_first_name: data["expected_first_name"] = expected_first_name
    if expected_last_name: data["expected_last_name"] = expected_last_name
    if expected_address: data["expected_address"] = expected_address
    if expected_country: data["expected_country"] = expected_country

    async with httpx.AsyncClient() as client:
        try:
            didit_response = await client.post(DIDIT_POA_ENDPOINT, headers=headers, files=files, data=data, timeout=30.0)
            didit_response.raise_for_status()
            poa_result = didit_response.json()

            # Store the result in MongoDB
            verification_record = {
                "filename": document.filename,
                "user_id": "some_user_id", # Replace with actual user ID from your system
                "timestamp": datetime.utcnow(),
                "didit_response": poa_result,
                "status": poa_result['poa']['status']
            }
            await app.mongodb["poa_verifications"].insert_one(verification_record)

            return {"message": "POA verification initiated and result stored.", "result": poa_result}
        except httpx.HTTPStatusError as e:
            raise HTTPException(status_code=e.response.status_code, detail=f"Didit API error: {e.response.text}")
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")

Dieser Endpunkt verarbeitet den Dateiupload, erstellt die Anfrage für Didits API und verarbeitet dann die Antwort. Beachten Sie die Verwendung von httpx.AsyncClient für nicht-blockierende HTTP-Anfragen, was für die Leistung von FastAPI entscheidend ist.

2. Didits Proof of Address Bericht verstehen

Didit liefert einen umfassenden JSON-Bericht für jede PoA-Verifizierung. Dieser Bericht enthält:

• poa.status: Der allgemeine Verifizierungsstatus (Approved, Declined, In Review).
• poa.document_type: Automatisch erkannter Dokumententyp (z.B. UTILITY_BILL, BANK_STATEMENT).
• poa.issuer, poa.issue_date, poa.expiration_date: Wichtige Dokumentendetails.
• poa.name_on_document, poa.poa_address, poa.poa_formatted_address, poa.poa_parsed_address: Extrahierte und strukturierte Adressinformationen.
• poa.warnings: Eine Liste aller erkannten Warnungen oder Probleme, wie z.B. POOR_DOCUMENT_QUALITY, NAME_MISMATCH_WITH_PROVIDED oder SUSPECTED_DOCUMENT_MANIPULATION.

Diese detaillierten Einblicke ermöglichen eine ausgeklügelte Entscheidungsfindung und die automatisierte Handhabung von Grenzbereichen. Didits konfigurierbare Verifizierungseinstellungen, wie z.B. poa_name_mismatch_action oder poa_document_issues_action, ermöglichen es Ihnen, zu definieren, wie Ihr System auf spezifische Risiken reagiert, um die Compliance zu gewährleisten und manuelle Eingriffe zu reduzieren.

Speichern und Verwalten von Verifizierungsdaten mit MongoDB

MongoDB ist aufgrund seines flexiblen Dokumentenmodells eine ausgezeichnete Wahl zum Speichern von PoA-Verifizierungsergebnissen. Sie können die gesamte JSON-Antwort von Didit direkt speichern, was eine einfache Abfrage und Analyse ohne vordefinierte Schemata ermöglicht. Diese Flexibilität ist entscheidend, wenn sich Verifizierungsanforderungen ändern oder neue Datenpunkte verfügbar werden.

1. Speichern des Verifizierungsdatensatzes

Wie im FastAPI-Beispiel gezeigt, wird die didit_response direkt in einer poa_verifications-Sammlung gespeichert. Dieser Ansatz erfasst alle von Didit bereitgestellten umfangreichen Daten.

2. Abfragen von Verifizierungsdatensätzen

Sie können Ihre MongoDB-Sammlung einfach abfragen, um Verifizierungsstatus, zu überprüfende Dokumente oder spezifische Benutzerdaten abzurufen:

from datetime import datetime

@app.get("/poa-verifications/{user_id}")
async def get_poa_history(user_id: str):
    records = await app.mongodb["poa_verifications"].find({"user_id": user_id}).to_list(100)
    if not records:
        raise HTTPException(status_code=404, detail="No POA records found for this user.")
    # MongoDB _id is an ObjectId, convert to string for JSON serialization
    for record in records:
        record["_id"] = str(record["_id"])
    return records

@app.get("/poa-needs-review/")
async def get_poa_needs_review():
    records = await app.mongodb["poa_verifications"].find({"status": "In Review"}).to_list(100)
    for record in records:
        record["_id"] = str(record["_id"])
    return records

Diese Endpunkte ermöglichen es Ihnen, den PoA-Verlauf eines Benutzers abzurufen oder alle Verifizierungen abzurufen, die einer manuellen Überprüfung bedürfen, was die Leistungsfähigkeit von MongoDB beim Verwalten komplexer Compliance-Daten demonstriert.

Wie Didit hilft

Didit bietet eine KI-native, entwicklerfreundliche Identitätsplattform, die komplexe Identitätsverifizierungsprozesse wie den Adressnachweis vereinfacht. Unser Proof of Address-Produkt bietet eine umfassende Validierung durch Extraktion und Verifizierung wichtiger Informationen aus verschiedenen Dokumenten. Es erkennt automatisch Dokumententypen, analysiert Adressen in strukturierte Formate und führt Authentizitätsprüfungen durch, um potenzielle Manipulationen zu identifizieren. Mit Didit profitieren Sie von:

• Modularer Architektur: Integrieren Sie die PoA-Verifizierung einfach als eigenständigen Dienst oder kombinieren Sie sie mit anderen Didit-Produkten wie der ID-Verifizierung und dem AML-Screening & Monitoring, um vollständige KYC-Workflows zu erstellen.
• KI-nativer Genauigkeit: Unsere fortschrittlichen KI- und maschinellen Lernalgorithmen gewährleisten eine hohe Genauigkeit bei der Datenextraktion und Betrugserkennung, wodurch Fehlalarme und Fehlklassifizierungen minimiert werden.
• Konfigurierbaren Workflows: Definieren Sie benutzerdefinierte Regeln und Aktionen für verschiedene Risikoszenarien, wie z.B. Namensungleichheiten, Probleme mit der Dokumentenqualität oder vermutete Manipulation, direkt über unsere APIs oder die No-Code Business Console.
• Entwicklerfreundliche Erfahrung: Mit einer sofortigen Sandbox, umfassender öffentlicher Dokumentation und sauberen APIs können Entwickler Didit schnell und effizient integrieren.
• Kostengünstiger Skalierung: Didit bietet Free Core KYC und ein Pay-per-Successful-Check-Modell, wodurch Einrichtungsgebühren entfallen und Sie nur für das bezahlen, was Sie nutzen, was es ideal für skalierbare Operationen macht.

Durch die Nutzung von Didit können Unternehmen Vertrauen automatisieren, die Compliance optimieren und ein überlegenes Benutzer-Onboarding-Erlebnis bieten, ohne die Last einer komplexen Infrastruktur oder manuellen Überprüfung.

Bereit zum Start?

Möchten Sie Didit in Aktion sehen? Holen Sie sich noch heute eine kostenlose Demo.

Beginnen Sie kostenlos mit der Überprüfung von Identitäten mit Didits kostenlosem Tarif.