Tingkatkan Performa: Python Async untuk API & Webhook Didit (ID)

Optimalkan Interaksi APIManfaatkan asyncio Python untuk melakukan panggilan non-blocking ke API Didit, secara drastis meningkatkan throughput untuk verifikasi identitas dan mengurangi latensi untuk operasi bervolume tinggi.

Pemrosesan Webhook EfisienTerapkan handler webhook asinkron untuk memproses peristiwa Didit yang masuk tanpa blocking, memastikan aplikasi Anda tetap responsif dan dapat diskalakan untuk menangani banyak notifikasi konkuren.

Kuasai Manajemen Batas LajuPahami dan kelola batas laju API Didit secara efektif menggunakan teknik asinkron dan strategi backoff cerdas, mencegah gangguan layanan dan memastikan pertukaran data yang andal.

Keunggulan AI-Native DiditPlatform Didit dirancang untuk kinerja tinggi dan kemudahan pengembang, menawarkan registrasi terprogram dan API yang kuat yang sangat melengkapi pemrograman asinkron untuk solusi identitas yang skalabel dan didorong AI.

Kebutuhan akan Kecepatan: Mengapa Pemrograman Asinkron Penting untuk Identitas

Di dunia digital yang serba cepat saat ini, aplikasi menuntut respons instan. Baik Anda meng-onboarding pengguna baru, memproses transaksi, atau memverifikasi identitas, penundaan dapat menyebabkan hilangnya pelanggan dan pendapatan. Verifikasi identitas, khususnya, sering kali melibatkan beberapa panggilan API—untuk memeriksa dokumen, melakukan deteksi keaktifan, atau menyaring daftar pantauan. Panggilan API sinkron, di mana program Anda menunggu setiap permintaan selesai sebelum beralih ke yang berikutnya, dapat dengan cepat menjadi hambatan, terutama saat menangani volume tinggi.

Di sinilah pemrograman asinkron, khususnya asyncio Python, bersinar. Dengan memungkinkan aplikasi Anda untuk memulai beberapa tugas secara bersamaan tanpa memblokir thread eksekusi utama, asyncio memungkinkan throughput dan responsivitas yang jauh lebih tinggi. Untuk berintegrasi dengan platform identitas canggih seperti Didit, yang menawarkan API yang kuat untuk Verifikasi ID, Keaktifan Pasif & Aktif, Pencocokan Wajah 1:1, dan Penyaringan AML, memanfaatkan asyncio bukan hanya optimasi—ini adalah kebutuhan untuk membangun sistem yang skalabel dan berkinerja tinggi.

Bayangkan skenario di mana ribuan pengguna mencoba mendaftar secara bersamaan. Setiap pendaftaran membutuhkan beberapa pemeriksaan identitas. Dengan panggilan sinkron, server Anda akan memprosesnya satu per satu, menyebabkan antrean panjang dan pengguna yang frustrasi. Dengan asyncio, aplikasi Anda dapat memulai semua pemeriksaan ini hampir secara bersamaan, menunggu hasilnya kembali saat sudah siap, secara dramatis meningkatkan pengalaman pengguna dan kapasitas sistem secara keseluruhan.

Menerapkan Panggilan API Async ke Didit

Berintegrasi dengan API Didit secara asinkron melibatkan penggunaan klien HTTP yang mendukung asyncio, seperti httpx atau aiohttp. Pustaka ini memungkinkan Anda untuk mengirim permintaan tanpa blocking, menjadikannya ideal untuk skenario throughput tinggi.

Mari kita pertimbangkan kasus penggunaan umum: memulai beberapa sesi verifikasi identitas. API Didit dirancang untuk efisiensi, dan dengan asyncio, Anda dapat memaksimalkan ini. Misalnya, membuat sesi verifikasi melalui POST /v3/session/ dapat dilakukan secara bersamaan. Setiap sesi mungkin melibatkan Verifikasi ID Didit (OCR, MRZ, barcode) atau pemeriksaan Keaktifan Pasif & Aktif.

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()  # Raise an exception for bad status codes
        return response.json()

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

    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"Error creating session for user_{user_ids[i]}: {result}")
        else:
            print(f"Session created for user_{user_ids[i]}: {result['session_id']}")

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

Contoh ini menunjukkan cara membuat 100 sesi verifikasi secara bersamaan. Setiap panggilan ke create_didit_session adalah coroutine yang dapat ditunggu. asyncio.gather menjalankan semuanya secara paralel, secara signifikan mengurangi total waktu dibandingkan dengan eksekusi sekuensial.

Menangani Webhook Didit Secara Asinkron untuk Pembaruan Real-time

Webhook sangat penting untuk pembaruan real-time dari Didit, memberi tahu sistem Anda tentang penyelesaian Verifikasi ID, hasil Penyaringan AML, atau hasil pemeriksaan Bukti Alamat. Ketika Didit mengirim notifikasi webhook, aplikasi Anda perlu memprosesnya dengan cepat tanpa memblokir webhook masuk berikutnya. Handler webhook asinkron sangat penting untuk ini.

Kerangka kerja web Python asinkron yang khas seperti FastAPI atau Aiohttp sangat cocok untuk membangun penerima webhook asinkron. Ketika Didit mengirim webhook (misalnya, notifikasi penyelesaian sesi), handler Anda dapat mengurai payload, memverifikasi tanda tangan menggunakan secret_shared_key yang diperoleh dari konfigurasi webhook Didit, dan kemudian mengantrekan pemrosesan peristiwa ke tugas latar belakang atau antrean pesan tanpa menunda respons HTTP kembali ke Didit.

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

app = FastAPI()
WEBHOOK_SECRET = "whsec_a1b2c3d4e5f6g7h8i9j0..." # Get this from Didit webhook config

async def process_didit_event(event_data: dict):
    # Simulate asynchronous processing, e.g., updating database, notifying users
    print(f"Processing Didit event: {event_data['event_type']} for session {event_data['session_id']}")
    await asyncio.sleep(2) # Simulate I/O bound task
    print(f"Finished processing event for session {event_data['session_id']}")

@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="Missing X-Didit-Signature header")

    body = await request.body()
    
    # Verify webhook signature (important for security)
    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="Invalid webhook signature")

    event_data = await request.json()
    
    # Process event asynchronously in the background
    asyncio.create_task(process_didit_event(event_data))
    
    return {"status": "received", "message": "Event accepted for processing"}

Contoh FastAPI ini menunjukkan cara dengan cepat mengakui webhook dan kemudian memindahkan pemrosesan sebenarnya menggunakan asyncio.create_task. Ini memastikan bahwa endpoint webhook Anda tetap sangat tersedia dan responsif, bahkan jika memproses peristiwa individual membutuhkan waktu. Konfigurasi webhook Didit memungkinkan Anda untuk menentukan webhook_url dan webhook_version, sehingga mudah untuk mengatur pengiriman peristiwa yang aman dan andal.

Menavigasi Batas Laju dengan Strategi Async

Batas laju API adalah pertimbangan penting untuk setiap integrasi throughput tinggi. Didit, seperti penyedia API yang kuat lainnya, memberlakukan pembatasan laju untuk menjaga stabilitas. Memahami dan menangani batas-batas ini dengan baik sangat penting untuk menghindari kesalahan 429 Too Many Requests dan memastikan operasi berkelanjutan.

Didit menyediakan header batas laju yang jelas (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After) dalam responsnya. Dengan asyncio, Anda dapat menerapkan strategi pembatasan laju yang canggih, seperti backoff eksponensial dengan jitter dan algoritma token bucket, tanpa memblokir seluruh aplikasi Anda.

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)) # Exponential backoff
            print(f"Rate limit hit. Retrying in {retry_after} seconds...")
            await asyncio.sleep(retry_after)
        else:
            response.raise_for_status()
            return response.json()
    raise Exception("Max retries exceeded for rate-limited request.")

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): # Simulate exceeding a 300 rpm limit with 150 tasks
            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"Request {i} failed: {result}")
            else:
                print(f"Request {i} succeeded: {result.get('session_id')}")

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

Contoh ini menunjukkan strategi backoff eksponensial asinkron. Ketika 429 diterima, coroutine menunggu durasi Retry-After yang ditentukan (atau waktu yang meningkat secara eksponensial) sebelum mencoba lagi, semuanya tanpa memblokir tugas konkuren lainnya. Batas global Didit (300 permintaan per menit per aplikasi untuk endpoint GET/Write/Delete) dan batas spesifik endpoint (misalnya, 600 rpm untuk POST /v2/session/) didokumentasikan dengan jelas, memungkinkan Anda untuk merancang klien async Anda sesuai dengan itu.

Bagaimana Didit Membantu Membangun Solusi Identitas Throughput Tinggi

Arsitektur Didit secara inheren dirancang untuk mendukung operasi throughput tinggi, menjadikannya mitra ideal untuk integrasi asinkron. Platform kami menawarkan beberapa keuntungan utama:

• Developer-First & AI-Native: Didit menyediakan API yang bersih dan dokumentasi komprehensif, sehingga mudah untuk berintegrasi dengan asyncio Python. Pendekatan AI-native kami berarti tugas verifikasi identitas yang kompleks, mulai dari Verifikasi ID hingga Keaktifan Pasif & Aktif, diproses secara efisien di pihak kami, memungkinkan aplikasi Anda untuk hanya menunggu hasilnya.
• Primitive Identitas Modular: Desain modular Didit memungkinkan Anda untuk memilih pemeriksaan identitas yang Anda butuhkan. Baik itu Verifikasi ID (OCR, MRZ), Pencocokan Wajah 1:1, atau Bukti Alamat, setiap primitive dapat diakses melalui API berkinerja tinggi, sangat cocok untuk panggilan konkuren.
• Registrasi Terprogram: Tidak seperti banyak platform, Didit memungkinkan registrasi terprogram, bahkan untuk agen AI. Anda bisa mendapatkan kredensial API hanya dalam dua panggilan API, sepenuhnya tanpa kepala, tanpa pernah membuka browser. Ini meminimalkan gesekan penyiapan dan memungkinkan penyebaran infrastruktur identitas Anda secara otomatis dan berskala besar.
• Alur Kerja Terorkestrasi: Mesin tanpa kode Didit memungkinkan Anda untuk mengorkestrasi alur kerja KYC yang kompleks, mengurangi jumlah panggilan API individual yang perlu dikelola aplikasi Anda sambil tetap mendapatkan manfaat dari pemrosesan asinkron dari hasil sesi keseluruhan.
• KYC Inti Gratis & Harga Fleksibel: Didit menawarkan KYC Inti Gratis, memungkinkan Anda untuk memulai tanpa biaya di muka. Model bayar-per-pemeriksaan-berhasil kami dan tanpa biaya penyiapan berarti Anda hanya membayar untuk apa yang Anda gunakan, selaras sempurna dengan arsitektur skalabel berbasis penggunaan yang diaktifkan oleh pemrosesan asinkron.

Dengan menggabungkan kekuatan Python asyncio dengan API Didit yang kuat dan ramah pengembang, Anda dapat membangun sistem verifikasi identitas yang tidak hanya aman dan patuh tetapi juga sangat cepat dan skalabel, mampu menangani tuntutan bisnis digital modern.

Siap Memulai?

Siap melihat Didit beraksi? Dapatkan demo gratis hari ini.

Mulai verifikasi identitas secara gratis dengan tingkat gratis Didit.