Filtre les portefeuilles et les hachages de transaction sur Ethereum, Solana, Base, Optimism, Arbitrum One et d'autres réseaux pris en charge. Évalue l'exposition aux sanctions et la source des fonds pour 0,15 $ par vérification.
Approuvé par plus de 3 000 organisations dans le monde entier.
$0.15 per check
Une seule API couvre 13 réseaux blockchain gérés, y compris Bitcoin, Ethereum, Solana, Polygon, BNB Smart Chain, Base, Optimism et Arbitrum One. Filtre les portefeuilles et les transactions sur leur réseau réel, ou utilise ton propre fournisseur de filtrage et exécute-le au sein de Didit.
Choisis les vérifications dont tu as besoin, ID, preuve de vie, correspondance faciale, sanctions, adresse, âge, téléphone, e-mail, questions personnalisées. Glisse-les dans un workflow sur le tableau de bord, ou publie le même workflow via notre API. Crée des branches conditionnelles, lance des tests A/B, aucun code requis.
$ curl -X POST https://verification.didit.me/v3/wallet-screening/ \
-H "x-api-key: $DIDIT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"wallet_address": "0xRecipient...",
"blockchain": "ETH",
"direction": "OUTBOUND"
}'{ "risk_score": 87, "severity": "CRITICAL" }// Your endpoint receives a signed wallet-screening result
const crypto = require("node:crypto"); // ESM: import crypto from "node:crypto"
// X-Signature-V2 = HMAC over the canonical JSON, never the raw bytes. Match the sender byte for
// byte: keys sorted by code point, integers digit for digit, floats in Python's repr.
class Num { constructor(src) { this.src = src; } } // a number as written on the wire, not a double
const num = (s) => { if (/^-?\d+$/.test(s)) return BigInt(s).toString(); const n = +s; // ints stay exact
if (Number.isInteger(n)) return BigInt(n).toString(); const [m, e] = n.toExponential().split("e"); // 27.0 -> 27
return +e >= -4 ? String(n) : `${m}e-${String(-e).padStart(2, "0")}`; }; // 1e-05, not 0.00001
const byCodePoint = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)); // UTF-8 order = Python's
const canon = (v) => Array.isArray(v) ? `[${v.map(canon)}]` : v instanceof Num ? num(v.src)
: v && typeof v === "object" ? `{${Object.keys(v).sort(byCodePoint).map((k) => `${JSON.stringify(k)}:${canon(v[k])}`)}}`
: JSON.stringify(v);
// Read the body as text: express.json() would round 1000000000000000129 to a double first.
// Register this route ABOVE any global app.use(express.json()): the first parser to run
// consumes the stream, and a body it already parsed has lost the digits the signature covers.
app.post("/webhooks/didit", express.text({ type: "application/json" }), (req, res) => {
const exact = JSON.parse(req.body, (k, v, c) => typeof v === "number" ? new Num(c.source) : v); // Node 21+
const body = JSON.parse(req.body);
const mac = crypto.createHmac("sha256", SECRET).update(canon(exact), "utf8").digest("hex");
const sig = Buffer.from(String(req.headers["x-signature-v2"] ?? ""));
// Freshness comes from the signed body timestamp; the header alone is unsigned and replayable.
const ts = body.timestamp, fresh = String(ts) === req.headers["x-timestamp"]
&& Math.abs(Date.now() / 1000 - ts) <= 300;
if (!fresh || sig.length !== mac.length
|| !crypto.timingSafeEqual(sig, Buffer.from(mac))) return res.sendStatus(401);
const { status, decision, txn_id } = body;
// status: APPROVED | IN_REVIEW | DECLINED | AWAITING_USER
res.sendStatus(200);
});{ webhook_type: "transaction.status.updated", status: "APPROVED" }# Didit Wallet Screening (KYT) — integrate in 5 minutes
You are integrating Didit's Wallet Screening / Know Your Transaction (KYT)
module into <my_stack>. Follow these steps exactly. Every URL, header,
and enum value below is canonical — do not paraphrase or "improve" them.
Wallet Screening produces a standardised risk payload regardless of
which underlying provider sits behind it:
- Risk score 0-100 + severity (LOW, MEDIUM, HIGH, CRITICAL)
- Source of funds breakdown across 14+ categories
- Exposure table (counterparty entities, direct vs indirect hops)
- Network graph metrics
- Sanctions / darknet / mixer flags as discrete signals
## 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/
## 2. Choose a screening source
- Wallet Screening runs at $0.15 per check on Didit's own on-chain
risk data — nothing to configure, it works out of the box.
- Or bring your own screening provider and run it inside Didit: open
Transactions > Settings > Provider Preferences in the Business
Console (https://business.didit.me) and paste your existing
provider API key. The screening result payload is identical
whichever source you use.
## 3. Two integration paths — pick one
### Path A — Workflow / Transactions API (recommended)
Best when you want Wallet Screening chained into the Transaction
Monitoring rules engine so flagged transactions automatically generate
review cases.
POST https://verification.didit.me/v3/transactions/
Headers:
x-api-key: <your-api-key>
Content-Type: application/json
Body (outbound pre-transfer screen, screens the destination wallet):
{
"transaction_id": "withdrawal-001",
"transaction_category": "finance",
"include_crypto_screening": true,
"transaction_details": {
"direction": "OUTBOUND",
"amount": "0.25",
"currency": "ETH",
"currency_kind": "crypto",
"crypto_params": { "crypto_chain": "ETH" },
"action_type": "withdrawal"
},
"subject": {
"entity_type": "individual",
"vendor_data": "user-123",
"full_name": "John Doe"
},
"counterparty": {
"entity_type": "unhosted_wallet",
"full_name": "John Doe",
"payment_method": {
"method_type": "crypto_wallet",
"account_id": "0xRecipientWallet..."
}
}
}
Direction rules — required:
- INBOUND pre-transfer -> screens counterparty.payment_method.account_id
- INBOUND post-transfer -> screens the tx hash scoped to subject.payment_method.account_id
- OUTBOUND pre-transfer -> screens counterparty.payment_method.account_id
- OUTBOUND post-transfer -> screens the tx hash scoped to counterparty.payment_method.account_id
For post-transfer screening, also include
transaction_details.payment_reference_id -> the blockchain tx hash
### Path B — Standalone wallet-screening API
Best when you want a one-off wallet-risk lookup without writing a full
transaction. Same screening source, same $0.15 per check price.
POST https://verification.didit.me/v3/wallet-screening/
Headers:
x-api-key: <your-api-key>
Content-Type: application/json
Body:
{
"wallet_address": "0xRecipientWallet...",
"blockchain": "ETH",
"direction": "OUTBOUND"
}
Synchronous JSON response — no webhook required for the standalone call.
Use Path A whenever the screening result needs to flow into the rules
engine, case management, or the auto-remediation loop.
### Select the actual network
Managed wallet and transaction screening accepts BTC, ETH, LTC, XRP, BCH,
DOGE, TRX, SOL, MATIC, BNB, BASE, OP and ARB.
BASE is Base, OP is Optimism and ARB is Arbitrum One.
Celo, Mode and Plume are not supported by the managed integration.
Connected providers have their own coverage; Lightning requires a supported connection.
For tokens, currency is the asset symbol and crypto_params.crypto_chain is
its network. Always set the chain explicitly, including for USDT and USDC.
The standalone USDT and USDC values are legacy Ethereum aliases.
Never send ETH as a substitute for another EVM network.
Custom-token transfer indexing must be verified with the token contract.
## 4. Webhooks
Register one webhook destination per workspace:
POST https://verification.didit.me/v3/webhook/destinations/
Body: { "url": "https://yourapp.com/didit/webhooks",
"events": ["transaction.status.updated"] }
Every delivery carries an X-Signature-V2 Hash-based Message Authentication
Code (HMAC) header. 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.Verify it before trusting the payload:
signature = hmac_sha256(secret, raw_body).hex()
if signature != request.headers["X-Signature-V2"]:
return 401
## 5. Reading the result
Every screening returns a standardised risk object:
- risk_score (0-100, higher = more exposure)
- severity ("LOW", "MEDIUM", "HIGH", "CRITICAL")
- source_of_funds (array of { category, percentage })
- exposure (array of { entity, hop_distance, received, sent, risk })
- flags (array including "sanctioned", "darknet_market", "mixer",
"ransomware", "child_exploitation", "scam", and others)
- network_graph (nodes, edges, centrality, depth)
Feed flagged transactions into the Transaction Monitoring rules engine
so high-risk hits automatically generate cases at the published
$0.02 per transaction inspection rate.
## 6. Travel Rule (FATF Recommendation 16)
For Virtual Asset Service Provider (VASP) to VASP transfers, include
the Travel Rule payload alongside the transaction body:
"travel_rule": {
"originator_vasp": {...},
"beneficiary_vasp": {...},
"originator": { "full_name", "date_of_birth", ... },
"beneficiary": { "full_name", "wallet_address" }
}
Didit handles the structured-message exchange with supported counterparty
VASPs. Reference: https://docs.didit.me/transaction-monitoring/travel-rule
## 7. Hard rules — do not change
- Base URL stays https://verification.didit.me (NOT apx.didit.me).
- Auth header stays x-api-key (lowercase, hyphenated).
- Webhook signature header stays X-Signature-V2 (NOT X-Signature).
- currency_kind is always "crypto" for wallet screening.
- direction is always UPPERCASE ("INBOUND" or "OUTBOUND").
- severity casing stays UPPERCASE: LOW, MEDIUM, HIGH, CRITICAL.
## 8. Pricing reference
- $0.15 per wallet screening on Didit's own on-chain risk data — or
bring your own screening provider and run it inside Didit.
- $0.02 per transaction inspected by the Transaction Monitoring rule
engine. AML on flagged transactions at $0.20 per check.
- 500 free verifications every month on every account, forever.
- No minimums, no contracts. Volume discounts above 100k screenings
per month — see https://didit.me/pricing.
## 9. Verify your integration
1. Create a sandbox API key at https://business.didit.me.
2. Post the example outbound transaction above against a known-flagged
tutorial wallet — the response should have severity "CRITICAL" and
carry a "sanctioned" flag.
3. Confirm the webhook fires with transaction.status.updated and the
X-Signature-V2 header verifies cleanly.
4. Open Case Management in the console — the transaction should land
in the queue with source PROVIDER and severity CRITICAL.
Done. Wallet Screening is live. Reach out to support@didit.me with the
workspace id if you hit a wall.
Pour le développement, les tests et tes premiers utilisateurs.
Plus de 25 modules, tarifs publics. Remises automatiques sur volume.
Pour les gros volumes et les programmes réglementés.
Les remises sur volume s'appliquent automatiquement à mesure que votre utilisation augmente — pas de négociation, pas d'appel commercial.
Didit est une infrastructure d'identité et de fraude, la plateforme que nous aurions aimé avoir lorsque nous développions nos propres produits : ouverte, flexible et pensée pour les développeurs, afin qu'elle s'intègre parfaitement à votre stack plutôt que d'être une boîte noire autour de laquelle vous devez construire.
Une seule API couvre la vérification des personnes (KYC, know your customer), la vérification des entreprises (KYB, know your business), le screening des portefeuilles crypto (KYT, know your transaction), et le monitoring des transactions en temps réel, sur une stack conçue pour être :
L'empreinte sous-jacente : plus de 14 000 types de documents dans plus de 48 langues, plus de 1 000 sources de données, et plus de 200 signaux de fraude sur chaque session. L'infrastructure Didit apprend dynamiquement de chaque session et s'améliore chaque jour.
Le filtrage de portefeuilles, également appelé Know Your Transaction (KYT), évalue le risque on-chain sur une adresse de portefeuille crypto ou un hash de transaction. Exposition aux sanctions, marchés noirs, portefeuilles de ransomwares, mixeurs, contreparties de fonds volés, portefeuilles d'arnaque, financement du terrorisme, tout est remonté sous forme de score de risque, de niveau de gravité, de répartition de la source des fonds, et de drapeaux discrets sur lesquels vous pouvez agir en temps réel.
$0.15 par vérification effectuée de bout en bout via Didit, ou utilisez votre propre fournisseur de filtrage et exécutez-le via Didit sur le même contrat d'Application Programming Interface (API) /v3/, avec une gestion de cas et un audit unifiés.
Référence complète : docs.didit.me/core-technology/wallet-screening/overview.
$0.15 par vérification effectuée de bout en bout via Didit, un prix public unique, pas de contrat d'analyse séparé à gérer.
Si vous avez déjà un fournisseur de filtrage que vous préférez, vous pouvez l'utiliser via Didit, collez votre clé de fournisseur dans la console d'administration, chaque filtrage envoyé par Didit utilisera votre clé, et le filtrage sera décompté de votre contrat fournisseur existant.
Pas de minimums, pas de contrat, pas de surprises de dépassement. Basculez entre les modes par espace de travail dans Transactions → Paramètres → Préférences du fournisseur.
Le filtrage géré de portefeuilles et de transactions prend en charge 13 réseaux : Bitcoin (BTC), Ethereum (ETH), Litecoin (LTC), XRP Ledger (XRP), Bitcoin Cash (BCH), Dogecoin (DOGE), Tron (TRX), Solana (SOL), Polygon (MATIC), BNB Smart Chain (BNB), Base (BASE), Optimism (OP) et Arbitrum One (ARB).
Choisis le réseau réel pour chaque recherche. La même adresse peut avoir une activité et un risque différents selon les chaînes. Celo, Mode et Plume ne sont pas actuellement pris en charge par l'intégration gérée. Les fournisseurs de filtrage connectés ont leur propre couverture, et Lightning nécessite un fournisseur connecté pris en charge.
Consulte les blockchains prises en charge et les valeurs API.
Une charge utile standardisée, quel que soit le fournisseur sous-jacent.
risk_score, 0–100, plus le score est élevé, plus l'exposition est grande.severity, LOW, MEDIUM, HIGH, CRITICAL.source_of_funds, répartition sur plus de 14 catégories (portefeuille sanctionné, financement du terrorisme, exploitation d'enfants, ransomware, fonds volés, marchés noirs, mixeurs, arnaques, échanges à haut risque, jeux de hasard, échanges réglementés, pair-à-pair, services non identifiés).exposure, entités contreparties avec distance de saut directe vs indirecte, plus montants reçus et envoyés.network_graph, métriques de centralité et de profondeur.flags, signaux discrets comme sanctioned, darknet_market, mixer, ransomware.La même structure se retrouve dans la réponse de Transaction Monitoring.
Oui, sur les réseaux pris en charge. Filtre le portefeuille sur la chaîne où l'activité a lieu. USDT et USDC sont des symboles de jetons, pas des réseaux blockchain uniques.
Pour une recherche de portefeuille autonome, envoie le réseau réel dans blockchain. Dans une transaction, garde le symbole du jeton dans transaction_details.currency et envoie le réseau dans transaction_details.crypto_params.crypto_chain, comme BASE, OP ou ARB. La couverture des transferts de jetons personnalisés dépend également de l'indexation du contrat du jeton.
Les valeurs autonomes USDT et USDC sont des alias Ethereum hérités, pas des recherches multichaînes. Suis le guide de sélection d'actifs et de réseaux.
Les données de production sont traitées et stockées par défaut dans l'Union Européenne, sur Amazon Web Services. Les contrats d'entreprise peuvent demander des régions alternatives pour les juridictions dont les régulateurs l'exigent.
Chiffrement partout. AES-256 au repos sur chaque base de données, stockage d'objets et sauvegarde. Transport Layer Security 1.3 en transit sur chaque appel API, webhook et session de la Business Console. Les données biométriques sont chiffrées sous une Customer Master Key distincte.
La rétention est sous votre contrôle. La rétention par défaut est indéfinie (illimitée), sauf si vous configurez une durée plus courte, entre 30 jours et 10 ans par application, et vous pouvez supprimer n'importe quelle session individuelle à tout moment depuis le tableau de bord ou l'API.
Certifications : SOC 2 Type 1 & Type 2, ISO/IEC 27001:2022, iBeta Level 1 Presentation Attack Detection (PAD), et une attestation publique du Tesoro / SEPBLAC / CNMV espagnol que la vérification d'identité à distance de Didit est plus sûre qu'une vérification en personne. Rapport complet sur /security-compliance.
Didit est conforme par défaut aux exigences des régulateurs qui comptent pour l'infrastructure d'identité :
Note détaillée, chaque certificat, chaque lettre de régulateur : /security-compliance.
Trois chemins d'intégration, choisissez celui qui correspond à votre stack :
Même tableau de bord, même facturation, même prix au succès pour les trois. Guide étape par étape sur docs.didit.me/integration/integration-prompt.
Une seule API pour le KYC, le KYB, la surveillance des transactions et le screening de portefeuilles. Intégration en 5 minutes.