Acelere o Desempenho: Python Assíncrono para a API e Webhooks Didit (PT-PT)

Otimizar Interações com a APIAproveite o asyncio do Python para fazer chamadas não bloqueantes à API da Didit, melhorando drasticamente o rendimento para a verificação de identidade e reduzindo a latência para operações de alto volume.

Processamento Eficiente de WebhooksImplemente manipuladores de webhook assíncronos para processar eventos Didit recebidos sem bloquear, garantindo que a sua aplicação permanece responsiva e pode escalar para lidar com inúmeras notificações concorrentes.

Dominar a Gestão de Limites de TaxaCompreenda e gira eficazmente os limites de taxa da API da Didit usando técnicas assíncronas e estratégias de recuo inteligente, prevenindo interrupções de serviço e garantindo uma troca de dados fiável.

A Vantagem AI-Nativa da DiditA plataforma da Didit foi concebida para alto desempenho e facilidade de utilização para programadores, oferecendo registo programático e APIs robustas que complementam perfeitamente a programação assíncrona para soluções de identidade escaláveis e impulsionadas por IA.

A Necessidade de Velocidade: Porque a Programação Assíncrona é Importante para a Identidade

No mundo digital acelerado de hoje, as aplicações exigem respostas instantâneas. Quer esteja a integrar novos utilizadores, a processar transações ou a verificar identidades, atrasos podem levar à perda de clientes e receita. A verificação de identidade, em particular, envolve frequentemente várias chamadas à API — para verificar documentos, realizar deteção de vivacidade ou rastrear listas de vigilância. As chamadas síncronas à API, onde o seu programa espera que cada pedido seja concluído antes de passar para o próximo, podem rapidamente tornar-se um gargalo, especialmente ao lidar com grandes volumes.

É aqui que a programação assíncrona, especificamente o asyncio do Python, brilha. Ao permitir que a sua aplicação inicie múltiplas tarefas concorrentemente sem bloquear o thread de execução principal, o asyncio permite um rendimento e uma capacidade de resposta significativamente maiores. Para integrar com plataformas de identidade poderosas como a Didit, que oferecem APIs robustas para Verificação de ID, Vivacidade Passiva e Ativa, Correspondência Facial 1:1 e Rastreio AML, aproveitar o asyncio não é apenas uma otimização — é uma necessidade para construir sistemas escaláveis e de alto desempenho.

Imagine um cenário onde milhares de utilizadores estão a tentar registar-se simultaneamente. Cada registo requer várias verificações de identidade. Com chamadas síncronas, o seu servidor processaria estas uma a uma, levando a longas filas e utilizadores frustrados. Com o asyncio, a sua aplicação pode iniciar todas estas verificações quase simultaneamente, esperando que os resultados cheguem à medida que estão prontos, melhorando drasticamente a experiência do utilizador e a capacidade geral do sistema.

Implementar Chamadas Assíncronas à API da Didit

A integração assíncrona com a API da Didit envolve o uso de um cliente HTTP que suporte asyncio, como o httpx ou o aiohttp. Estas bibliotecas permitem-lhe enviar pedidos sem bloquear, tornando-as ideais para cenários de alto rendimento.

Consideremos um caso de uso comum: iniciar múltiplas sessões de verificação de identidade. A API da Didit foi concebida para eficiência, e com o asyncio, pode maximizar isso. Por exemplo, a criação de sessões de verificação via POST /v3/session/ pode ser feita concorrentemente. Cada sessão pode envolver a Verificação de ID da Didit (OCR, MRZ, códigos de barras) ou verificações de Vivacidade Passiva e Ativa.

import asyncio
import httpx

async def create_didit_session(api_key: str, user_id: str):
    url = "https://apx.didit.me/v3/sessions/"
    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
    payload = {"external_id": user_id, "flow_id": "your_flow_id"}
    
    async with httpx.AsyncClient() as client:
        response = await client.post(url, headers=headers, json=payload)
        response.raise_for_status()  # Levanta uma exceção para códigos de estado de erro
        return response.json()

async def main():
    didit_api_key = "YOUR_DIDIT_API_KEY"
    user_ids = [f"user_{i}" for i in range(100)] # Simula 100 utilizadores

    tasks = [create_didit_session(didit_api_key, user_id) for user_id in user_ids]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Erro ao criar sessão para user_{user_ids[i]}: {result}")
        else:
            print(f"Sessão criada para user_{user_ids[i]}: {result['session_id']}")

if __name__ == "__main__":
    asyncio.run(main())

Este exemplo demonstra como criar 100 sessões de verificação concorrentemente. Cada chamada para create_didit_session é uma corrotina aguardável. O asyncio.gather executa-as todas em paralelo, reduzindo significativamente o tempo total em comparação com a execução sequencial.

Lidar com Webhooks da Didit Assincronamente para Atualizações em Tempo Real

Os webhooks são cruciais para atualizações em tempo real da Didit, informando o seu sistema sobre a conclusão da Verificação de ID, o resultado de um Rastreio AML ou o resultado de uma verificação de Prova de Morada. Quando a Didit envia uma notificação de webhook, a sua aplicação precisa de processá-la rapidamente sem bloquear os webhooks subsequentes. Um manipulador de webhook assíncrono é essencial para isso.

Um framework web assíncrono típico do Python, como o FastAPI ou o Aiohttp, é perfeito para construir um recetor de webhook assíncrono. Quando a Didit envia um webhook (por exemplo, uma notificação de conclusão de sessão), o seu manipulador pode analisar o payload, verificar a assinatura usando a secret_shared_key obtida da configuração de webhook da Didit, e então enfileirar o processamento do evento para uma tarefa em segundo plano ou fila de mensagens sem atrasar a resposta HTTP de volta para a Didit.

from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib
import asyncio

app = FastAPI()
WEBHOOK_SECRET = "whsec_a1b2c3d4e5f6g7h8i9j0..." # Obtenha isto da configuração de webhook da Didit

async def process_didit_event(event_data: dict):
    # Simula o processamento assíncrono, por exemplo, atualização da base de dados, notificação de utilizadores
    print(f"A processar evento Didit: {event_data['event_type']} para a sessão {event_data['session_id']}")
    await asyncio.sleep(2) # Simula tarefa ligada a I/O
    print(f"Processamento do evento para a sessão {event_data['session_id']} concluído")

@app.post("/didit-webhook")
async def didit_webhook(request: Request):
    signature = request.headers.get("X-Didit-Signature")
    if not signature:
        raise HTTPException(status_code=400, detail="Cabeçalho X-Didit-Signature em falta")

    body = await request.body()
    
    # Verifica a assinatura do webhook (importante para segurança)
    expected_signature = hmac.new(WEBHOOK_SECRET.encode('utf-8'), body, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(signature, expected_signature):
        raise HTTPException(status_code=403, detail="Assinatura de webhook inválida")

    event_data = await request.json()
    
    # Processa o evento assincronamente em segundo plano
    asyncio.create_task(process_didit_event(event_data))
    
    return {"status": "received", "message": "Evento aceite para processamento"}

Este exemplo do FastAPI mostra como reconhecer rapidamente o webhook e depois descarregar o processamento real usando asyncio.create_task. Isso garante que o seu endpoint de webhook permanece altamente disponível e responsivo, mesmo que o processamento de eventos individuais demore algum tempo. A configuração de webhook da Didit permite especificar uma webhook_url e webhook_version, facilitando a configuração de entrega de eventos segura e fiável.

Navegar nos Limites de Taxa com Estratégias Assíncronas

Os limites de taxa da API são uma consideração crítica para qualquer integração de alto rendimento. A Didit, como qualquer fornecedor de API robusto, impõe limitação de taxa para manter a estabilidade. Compreender e lidar graciosamente com esses limites é fundamental para evitar erros 429 Too Many Requests e garantir a operação contínua.

A Didit fornece cabeçalhos de limite de taxa claros (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After) nas suas respostas. Com o asyncio, pode implementar estratégias sofisticadas de limitação de taxa, como recuo exponencial com jitter e algoritmos de balde de tokens, sem bloquear toda a sua aplicação.

import asyncio
import httpx
import time

async def make_rate_limited_request(client: httpx.AsyncClient, url: str, headers: dict, payload: dict, retries: int = 5):
    for attempt in range(retries):
        response = await client.post(url, headers=headers, json=payload)
        if response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 2 ** attempt)) # Recuo exponencial
            print(f"Limite de taxa atingido. A tentar novamente em {retry_after} segundos...")
            await asyncio.sleep(retry_after)
        else:
            response.raise_for_status()
            return response.json()
    raise Exception("Número máximo de tentativas excedido para pedido com limite de taxa.")

async def main_rate_limited():
    didit_api_key = "YOUR_DIDIT_API_KEY"
    url = "https://apx.didit.me/v3/sessions/"
    headers = {"x-api-key": didit_api_key, "Content-Type": "application/json"}
    
    async with httpx.AsyncClient() as client:
        tasks = []
        for i in range(150): # Simula a ultrapassagem de um limite de 300 rpm com 150 tarefas
            payload = {"external_id": f"user_{i}", "flow_id": "your_flow_id"}
            tasks.append(make_rate_limited_request(client, url, headers, payload))
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                print(f"Pedido {i} falhou: {result}")
            else:
                print(f"Pedido {i} bem-sucedido: {result.get('session_id')}")

if __name__ == "__main__":
    asyncio.run(main_rate_limited())

Este exemplo mostra uma estratégia assíncrona de recuo exponencial. Quando um 429 é recebido, a corrotina espera pela duração especificada em Retry-After (ou um tempo exponencialmente crescente) antes de tentar novamente, tudo sem bloquear outras tarefas concorrentes. Os limites globais da Didit (300 pedidos por minuto por aplicação para endpoints GET/Write/Delete) e os limites específicos do endpoint (por exemplo, 600 rpm para POST /v2/session/) estão claramente documentados, permitindo-lhe projetar os seus clientes assíncronos em conformidade.

Como a Didit Ajuda a Construir Soluções de Identidade de Alto Rendimento

A arquitetura da Didit é inerentemente projetada para suportar operações de alto rendimento, tornando-a um parceiro ideal para integrações assíncronas. A nossa plataforma oferece várias vantagens chave:

• Developer-First & AI-Nativa: A Didit fornece APIs limpas e documentação abrangente, tornando fácil a integração com o asyncio do Python. A nossa abordagem AI-nativa significa que tarefas complexas de verificação de identidade, desde a Verificação de ID à Vivacidade Passiva e Ativa, são processadas eficientemente do nosso lado, permitindo que a sua aplicação simplesmente aguarde os resultados.
• Primitivas de Identidade Modulares: O design modular da Didit permite-lhe escolher os controlos de identidade exatos de que precisa. Quer seja Verificação de ID (OCR, MRZ), Correspondência Facial 1:1, ou Prova de Morada, cada primitiva é acessível via uma API de alto desempenho, perfeitamente adequada para chamadas concorrentes.
• Registo Programático: Ao contrário de muitas plataformas, a Didit permite o registo programático, mesmo para agentes de IA. Pode obter credenciais de API em apenas duas chamadas de API, totalmente headless, sem nunca abrir um navegador. Isso minimiza o atrito de configuração e permite a implantação automatizada e em larga escala da sua infraestrutura de identidade.
• Fluxos de Trabalho Orquestrados: O motor sem código da Didit permite-lhe orquestrar fluxos de trabalho KYC complexos, reduzindo o número de chamadas individuais à API que a sua aplicação precisa de gerir, enquanto ainda beneficia do processamento assíncrono do resultado geral da sessão.
• KYC Básico Gratuito e Preços Flexíveis: A Didit oferece KYC Básico Gratuito, permitindo-lhe começar sem custos iniciais. O nosso modelo de pagamento por verificação bem-sucedida e sem taxas de configuração significa que só paga pelo que usa, alinhando-se perfeitamente com arquiteturas escaláveis e baseadas no uso, habilitadas pelo processamento assíncrono.

Ao combinar o poder do asyncio do Python com a API robusta e amigável para programadores da Didit, pode construir sistemas de verificação de identidade que são não só seguros e conformes, mas também incrivelmente rápidos e escaláveis, capazes de lidar com as exigências das empresas digitais modernas.

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.