A Prova de Morada da Didit com FastAPI e MongoDB (PT-PT)

Integração PerfeitaIntegre a API de Prova de Morada da Didit com FastAPI e MongoDB para criar um backend KYC robusto e escalável, otimizando os seus fluxos de trabalho de verificação.

Verificação AutomatizadaAproveite as capacidades nativas de IA da Didit para extração, validação e verificação de autenticidade automáticas de documentos de morada, reduzindo a revisão manual e melhorando a precisão.

Fluxos de Trabalho ConfiguráveisUtilize as configurações flexíveis da Didit para definir ações personalizadas para vários resultados de verificação, como, por exemplo, discrepâncias de nomes ou problemas de qualidade de documentos, garantindo a conformidade com diversos requisitos regulamentares.

Escalável e EconómicoA Didit oferece uma abordagem modular e "developer-first" com Free Core KYC e preços "pay-per-successful-check", tornando-a uma escolha ideal para empresas de todos os tamanhos que procuram uma verificação de identidade escalável.

O Desafio da Verificação de Prova de Morada em KYC

A verificação de Prova de Morada (PoA) é um componente crítico dos processos de Conheça o Seu Cliente (KYC) em várias indústrias, desde serviços financeiros a mercados online. É essencial para confirmar a residência física de um utilizador, ajudando a prevenir fraudes, a cumprir as regulamentações Anti-Branqueamento de Capitais (AML) e a estabelecer confiança. No entanto, a revisão manual de contas de serviços públicos, extratos bancários e documentos emitidos pelo governo é demorada, propensa a erros humanos e não é escalável. As empresas precisam de uma solução robusta, automatizada e segura para lidar com as complexidades da verificação de PoA, mantendo uma experiência de utilizador fluida.

As soluções tradicionais de PoA envolvem frequentemente integrações complexas, altos custos de configuração e fluxos de trabalho rígidos. É aqui que plataformas de identidade modernas, nativas de IA, como a Didit, se destacam, oferecendo uma abordagem "developer-first" que simplifica a integração e fornece capacidades de verificação poderosas e automatizadas. Ao combinar a API de Prova de Morada da Didit com um backend escalável como o FastAPI e uma base de dados NoSQL flexível como o MongoDB, as empresas podem construir sistemas KYC altamente eficientes e compatíveis.

Configurar o Seu Ambiente FastAPI e MongoDB

Para começar, vai precisar de uma aplicação FastAPI e de uma instância MongoDB. O FastAPI é escolhido pelo seu alto desempenho e facilidade de uso, enquanto o MongoDB oferece a flexibilidade para armazenar diversos tipos de documentos e relatórios de verificação. Aqui está uma configuração básica:

1. Configuração da Aplicação FastAPI

Primeiro, instale o FastAPI e o Uvicorn:

pip install fastapi uvicorn python-multipart motor

Crie um ficheiro 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. Conexão MongoDB

Certifique-se de que o MongoDB está a funcionar, seja localmente ou através de um serviço na nuvem. A biblioteca motor permite a interação assíncrona com o MongoDB, crucial para aplicações FastAPI de alto desempenho.

Integração da API de Prova de Morada da Didit

A API de Prova de Morada da Didit permite-lhe submeter imagens de documentos ou PDFs para verificação, extraindo e validando informações de morada, realizando verificações de autenticidade e devolvendo dados estruturados. Este processo foi concebido para ser altamente automatizado e preciso, graças à arquitetura nativa de IA da Didit.

1. Envio de Documentos para a Didit

Vai precisar de um "endpoint" na sua aplicação FastAPI para aceitar o carregamento de documentos e os encaminhar para a Didit. A API da Didit suporta vários tipos de documentos (PDF, JPEG, PNG, WebP, TIFF) e oferece parâmetros configuráveis para uma validação melhorada.

@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)}")

Este "endpoint" lida com o carregamento de ficheiros, constrói o pedido para a API da Didit e, em seguida, processa a resposta. Note o uso de httpx.AsyncClient para pedidos HTTP não bloqueantes, o que é crucial para o desempenho do FastAPI.

2. Compreender o Relatório de Prova de Morada da Didit

A Didit fornece um relatório JSON abrangente para cada verificação de PoA. Este relatório inclui:

• poa.status: O estado geral da verificação (Aprovado, Recusado, Em Revisão).
• poa.document_type: Tipo de documento automaticamente detetado (por exemplo, UTILITY_BILL, BANK_STATEMENT).
• poa.issuer, poa.issue_date, poa.expiration_date: Detalhes chave do documento.
• poa.name_on_document, poa.poa_address, poa.poa_formatted_address, poa.poa_parsed_address: Informações de morada extraídas e estruturadas.
• poa.warnings: Uma lista de quaisquer avisos ou problemas detetados, como POOR_DOCUMENT_QUALITY, NAME_MISMATCH_WITH_PROVIDED, ou SUSPECTED_DOCUMENT_MANIPULATION.

Estas informações detalhadas permitem uma tomada de decisão sofisticada e o tratamento automatizado de casos excecionais. As configurações de verificação configuráveis da Didit, como poa_name_mismatch_action ou poa_document_issues_action, permitem-lhe definir como o seu sistema reage a riscos específicos, garantindo a conformidade e reduzindo a intervenção manual.

Armazenar e Gerir Dados de Verificação com MongoDB

O MongoDB é uma excelente escolha para armazenar resultados de verificação de PoA devido ao seu modelo de documento flexível. Pode armazenar a resposta JSON completa da Didit diretamente, permitindo uma fácil consulta e análise sem esquemas predefinidos. Esta flexibilidade é vital à medida que os requisitos de verificação evoluem ou novos pontos de dados se tornam disponíveis.

1. Armazenar o Registo de Verificação

Conforme demonstrado no exemplo do FastAPI, a didit_response é armazenada diretamente numa coleção poa_verifications. Esta abordagem captura todos os dados ricos fornecidos pela Didit.

2. Consultar Registos de Verificação

Pode facilmente consultar a sua coleção MongoDB para recuperar estados de verificação, documentos que necessitam de revisão ou dados de utilizador específicos:

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

Estes "endpoints" permitem-lhe obter o histórico de PoA de um utilizador ou recuperar todas as verificações que exigem revisão manual, demonstrando o poder do MongoDB na gestão de dados de conformidade complexos.

Como a Didit Ajuda

A Didit oferece uma plataforma de identidade nativa de IA e "developer-first" que simplifica processos complexos de verificação de identidade, como a Prova de Morada. O nosso produto Prova de Morada oferece uma validação abrangente, extraindo e verificando informações chave de vários documentos. Deteta automaticamente tipos de documentos, analisa moradas em formatos estruturados e realiza verificações de autenticidade para identificar potenciais manipulações. Com a Didit, beneficia de:

• Arquitetura Modular: Integre facilmente a verificação de PoA como um serviço autónomo ou combine-o com outros produtos Didit, como Verificação de Identidade e Rastreio e Monitorização AML, para construir fluxos de trabalho KYC completos.
• Precisão Nativa de IA: Os nossos algoritmos avançados de IA e aprendizagem automática garantem alta precisão na extração de dados e deteção de fraudes, minimizando falsos positivos e negativos.
• Fluxos de Trabalho Configuráveis: Defina regras e ações personalizadas para diferentes cenários de risco, como discrepâncias de nomes, problemas de qualidade de documentos ou manipulação suspeita, diretamente através das nossas APIs ou da Consola de Negócios "no-code".
• Experiência "Developer-First": Com um "sandbox" instantâneo, documentação pública abrangente e APIs limpas, os programadores podem integrar a Didit de forma rápida e eficiente.
• Escalabilidade Económica: A Didit oferece Free Core KYC e um modelo de "pay-per-successful-check", eliminando taxas de configuração e garantindo que paga apenas pelo que usa, tornando-a ideal para operações escaláveis.

Ao aproveitar a Didit, as empresas podem automatizar a confiança, otimizar a conformidade e proporcionar uma experiência de integração de utilizadores superior, sem o fardo de infraestruturas complexas ou revisão manual.

Pronto para Começar?

Pronto para ver a Didit em ação? Obtenha uma demonstração gratuita hoje.

Comece a verificar identidades gratuitamente com o nível gratuito da Didit.