Verifica personas con una identidad electrónica (eID) que ya usan. Acepta Smart-ID, Mobile-ID, Finnish Trust Network y MitID a través de un único flujo de trabajo, con opción de documento de respaldo cuando sea necesario.
Con la confianza de más de 2.000 organizaciones en todo el mundo.
Activo
Activo
PróximamentePróximamentePróximamente
PróximamentePróximamente
Activo
PróximamentePróximamente
Próximamente
Próximamente
PróximamentePróximamente
ActivoActivo
PróximamentePróximamente
Próximamente
Próximamente
Próximamente
Próximamente
+26PróximamenteLos estados distinguen la disponibilidad en producción de las pruebas de integración. La cobertura por país describe la ruta del monedero configurada, no una comprobación de identidad en vivo completada en todos los países. No se promete ninguna fecha de lanzamiento.
Estado de la integración
Smart-ID, Mobile-ID, Finnish Trust Network y MitID están disponibles. Elige las carteras aceptadas por país y permite que los usuarios se autentiquen con una identidad elegible que ya poseen. Otras integraciones listadas estarán disponibles próximamente.
En la consola, selecciona los monederos disponibles para cada país en tu entorno. Elige si un inicio de sesión cancelado o fallido recurre a la captura de documentos o se rechaza.
Directo del catálogo de métodos
En el catálogo
Países cubiertos
eIDAS alto
En vivoEn vivoPróximamentePróximamentePróximamenteSin controles de ordenación en ningún sitio
Marcar es toda la configuración. El usuario elige entre lo que aceptas, y el orden en pantalla no tiene significado. Cada wallet mantiene su estado de catálogo hasta que se activa.
Flujo de Smart-ID y Mobile-ID
MitID · Danish Agency for Digital Government
Solo para administradores
Los usuarios finales nunca ven una etiqueta de garantía, un nombre de fuente o un precio. Tus revisores ven los tres.
Países con al menos una wallet
Países
Cubierto por la EUDI Wallet
La cobertura sigue el catálogo país por país. Una bandera aquí significa que hay una wallet listada para ese país, no que esté activa.
$ curl -X POST https://verification.didit.me/v3/session/ \
-H "x-api-key: <your-api-key>" \
-H "Content-Type: application/json" \
-d '{
"workflow_id": "wf_wallets",
"vendor_data": "user_42"
}'{ "url": "https://verify.didit.me/..." }// Your endpoint receives a signed payload
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 } = body;
// One entry per ID Verification node; pick yours by node_id when you run several.
const [idv] = decision?.id_verifications ?? [];
// idv.verification_method: "document" | "id_lookup" | "wallet"
res.sendStatus(200);
});{ "verification_method": "wallet", "assurance": "cryptographic" }# Didit digital ID wallets — integrate in 5 minutes
You are adding digital ID wallet sign-in to my_stack. The user signs in with a
government or bank digital identity and the wallet returns signed attributes.
Every URL, header, and enum value below is canonical — do not paraphrase or
"improve" them.
## 1. Provision an account
- Sign up: https://business.didit.me (no credit card required).
- Grab the API key for your application from the console.
## 2. Read the methods catalog first
Wallet availability is server-driven per country. Never hard-code a wallet list.
The catalog is not a public REST endpoint. Read it one of two ways:
- Business Console (signed in): your application -> ID Verification ->
Countries tab. https://docs.didit.me/console/id-verification-methods
- Didit MCP server tool didit_workflow_get_id_verification_methods_catalog,
authenticated with the same x-api-key; pass country (ISO 3166-1 alpha-3)
to narrow it to one country. https://docs.didit.me/integration/mcp/tools
- Public mirror of the coverage table (no auth, read-only):
https://docs.didit.me/core-technology/id-verification/verification-methods#coverage
The catalog gives you, per wallet id: the display name, the countries it
covers, the issuing authority, the level of assurance, the availability state,
and the attributes it returns. MitID, Smart-ID, Mobile-ID and Finnish Trust
Network are available. Read the Finnish Trust Network integration guide:
https://docs.didit.me/core-technology/id-verification/finnish-trust-network
iDIN and other wallets remain coming soon until the catalog in
your environment marks them available. Re-read it; do not hard-code a date.
## 3. Create a workflow with the ID Verification (OCR) feature
POST https://verification.didit.me/v3/workflows/
-H "x-api-key: <your-api-key>"
-H "Content-Type: application/json"
The ID Verification feature's enum value is OCR (UPPERCASE — strict enum;
there is no ID_VERIFICATION alias and the API rejects it). Wallets are its
wallet method, accepted per country under config.methods on that same
feature entry, in the same request. Keys are ISO 3166-1 alpha-3.
{
"workflow_label": "Wallet onboarding",
"features": [
{
"feature": "OCR",
"config": {
"methods": {
"DNK": {
"document": { "enabled": true },
"wallet": {
"enabled": true,
"providers": ["mitid"],
"on_failure": "fallback_to_document"
}
},
"FIN": {
"document": { "enabled": true },
"wallet": {
"enabled": true,
"providers": ["ftn"],
"on_failure": "fallback_to_document"
}
}
}
}
}
]
}
Response: the workflow uuid — use it as workflow_id in step 4.
Rules that the API enforces:
- providers is an accept-list, not a ranking. Order carries no meaning and
the end user picks
- on_failure is either fallback_to_document or decline. It covers all three
cases: no wallet, cancelled, sign-in failed
- a wallet id the catalog does not mark available for that country is
rejected, and the rejection fails the whole save — including any lookup
configuration next to it. For unavailable wallets, keep wallet.enabled
false (or omit the wallet block) so the save succeeds
- unknown wallet ids already saved on a workflow are preserved untouched, so
a config written by a newer console version is never silently dropped
- a country with no method enabled is rejected at publish time
## 4. Create a session
POST https://verification.didit.me/v3/session/
-H "x-api-key: <your-api-key>"
-H "Content-Type: application/json"
-d '{ "workflow_id": "<id from step 3>", "vendor_data": "<your user id>" }'
Response: 201 with url (the hosted verification link), session_token and
session_id. Redirect the user to url, or open it in the SDK. The field is
named url — there is no session_url and no verification_url. Didit
shows the accepted wallets for the user's country with their brand marks,
hands off to the wallet, and waits for the signed assertion to come back.
## 5. Webhooks
Register a destination (console -> API & Webhooks, or
POST https://verification.didit.me/v3/webhook/destinations/ with
webhook_version "v3" and subscribed_events ["status.updated"]) and store the
secret_shared_key it returns. Verify every delivery:
Header: X-Signature-V2 (NOT X-Signature, NOT X-Signature-Simple)
Algorithm: HMAC-SHA256, hex digest, over the CANONICAL JSON of the payload
— the sender's Python json.dumps(sort_keys=True,
separators=(",", ":"), ensure_ascii=False) after whole-valued
floats become ints. Reproduce those bytes EXACTLY; do NOT
"parse, sort keys, JSON.stringify", which fails in four ways:
numbers come from the wire TEXT, never from parsed doubles
(read the body with express.text, not express.json(),
registered ABOVE any global app.use(express.json()), and
re-emit integers through BigInt(source) — JSON.parse rounds
1000000000000000129); floats use Python's repr (1e-05, not
0.00001; 27.0 becomes 27); keys sort by Unicode CODE POINT as
strings ("10" before "2", U+FF21 before U+1F642, which
JavaScript's default .sort() reverses); and the bytes come
straight from the sorted entries, never from a rebuilt object.
Do NOT hash the raw request bytes — that is the v1
X-Signature algorithm and fails for V2 whenever whitespace or
key order differs from the canonical form.
Freshness: the signed body field timestamp is the dispatch time (Unix
seconds, refreshed on every retry). Reject when
abs(now - timestamp) > 300 seconds, and reject when the
X-Timestamp header does not equal it. The header is not
covered by the signature, so it must never be the only replay
check: a captured delivery replays with just that header
refreshed.
Compare: constant-time (crypto.timingSafeEqual)
Reference handler (Express) — use it as written:
// Your endpoint receives a signed payload
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 } = body;
// One entry per ID Verification node; pick yours by node_id when you run several.
const [idv] = decision?.id_verifications ?? [];
// idv.verification_method: "document" | "id_lookup" | "wallet"
res.sendStatus(200);
});
Body fields you will use: session_id, status, webhook_type, workflow_id,
vendor_data, decision.
Status values: Approved, Declined, In Review, In Progress, Not Started,
Abandoned.
## 6. Reading the result
The decision is the V3 shape: every feature result is a plural array with one
entry per workflow node. ID Verification results live in
decision.id_verifications[] — there is no singular decision.kyc (that is the
V2 shape) and no decision.id_verification. Select your entry by node_id (the
id of your ID Verification node in the workflow graph); with a single ID step,
take index 0. Each entry carries, next to the document fields:
verification_method "document" | "id_lookup" | "wallet"
assurance "documentary" | "data_match" | "cryptographic"
wallet_provider the catalog wallet id the user signed in with; null
on document and id_lookup entries
wallet_verification provider, provider_name, issuing_authority,
issuing_country, credential_type, level_of_assurance
(low | substantial | high), verified_at,
signature_valid, attributes (what the wallet shared),
portrait when the wallet shares one; null otherwise
fallback_from { method, reason, action } when the session fell
back to document capture or was declined; else null
A wallet entry that succeeds is assurance cryptographic — the highest of the
three. Check wallet_verification.signature_valid before you trust attributes.
Field-by-field reference: https://docs.didit.me/reference/data-models#id-verification
## 7. Billing
- published customer prices in USD per completed wallet verification:
- MitID personal: $0.25; production availability: Available
- BankID Sweden: $0.20; production availability: Available
- Finnish Trust Network: $0.25; production availability: Available
- Smart-ID: $0.20; production availability: Available
- Mobile-ID: $0.20; production availability: Available
- BankID Norway High: $0.35; production availability: Coming soon
- Vipps Plus: $0.25; production availability: Coming soon
- Buypass ID: Coming soon; production availability: Coming soon
- itsme: Coming soon; production availability: Coming soon
- iDIN full identification: $0.85; production availability: Coming soon
- Personalausweis Profile 2: $0.45; production availability: Coming soon
- Freja eID: $0.25; production availability: Coming soon
- UAE PASS: Coming soon; production availability: Coming soon
- gov.br: Coming soon; production availability: Coming soon
- OneID: $2.50; production availability: Coming soon
- GOV.UK Wallet: Coming soon; production availability: Coming soon
- Bank iD: Coming soon; production availability: Coming soon
- MojeID: Coming soon; production availability: Coming soon
- Diia: Coming soon; production availability: Coming soon
- FranceConnect: Coming soon; production availability: Coming soon
- Auðkenni: Coming soon; production availability: Coming soon
- ConnectID: Coming soon; production availability: Coming soon
- EUDI Wallet: Coming soon; production availability: Coming soon
- Estonian ID-card: Coming soon; production availability: Coming soon
- eParaksts: Coming soon; production availability: Coming soon
- an announced price does not enable a wallet; check the live workflow catalog
- wallet checks are outside the document free tier; other checks are billed separately
- full pricing: https://docs.didit.me/core-technology/id-verification/digital-id-wallets#pricing
- document capture bills its own price when the user falls back
## 8. Hard rules — do not change
- base URL for v3 endpoints: verification.didit.me
- auth header: x-api-key (lowercase, hyphenated)
- webhook headers: X-Signature-V2 plus X-Timestamp; canonical JSON, never
raw bytes; freshness from the signed body timestamp
- feature enum: OCR (uppercase) — the ID Verification feature; per-country
methods go under its config.methods
- method keys: document, id_lookup, wallet (lowercase, snake_case)
- wallet ids come from the catalog verbatim, lowercase, snake_case
- country keys: ISO 3166-1 alpha-3, uppercase
- result path: decision.id_verifications[] (array), never decision.kyc
## 9. Verify your integration
- run one session per accepted wallet in sandbox
- assert the id_verifications[] entry for your node has verification_method
wallet and wallet_verification.signature_valid true
- cancel a wallet sign-in and assert your on_failure setting actually fires
- assert your webhook accepts a correctly signed payload with reordered
keys, whitespace and integer-like metadata keys ("10" before "2"), and
rejects a wrong X-Signature-V2, a payload whose signed timestamp is older
than 300 seconds, and that same stale payload with only the X-Timestamp
header refreshed
Docs: https://docs.didit.me/integration/integration-prompt
Los precios a continuación son en USD por verificación de cartera completada. Cubren el producto de identidad nombrado; otras comprobaciones de flujo de trabajo y la opción de documento de respaldo se facturan por separado. Las 500 comprobaciones de documentos mensuales gratuitas no cubren las carteras. Un precio anunciado no significa que una cartera esté activa: la disponibilidad se muestra por separado. Las carteras disponibles sin una tarifa publicada muestran "Bajo petición"; las carteras planificadas sin una tarifa publicada muestran "Próximamente". Las carteras de identidad verifican personas; la detección de carteras de criptomonedas es un producto aparte.
«Disponible» significa que está habilitado en producción. «Próximamente» significa que aún no está habilitado en producción, incluso si ya se han iniciado las pruebas de integración. Las carteras disponibles aparecen primero.
ConnectID (Australia) está integrado para pruebas en sandbox; el acceso a producción estará disponible próximamente. La tarjeta de identificación estonia (Estonia) y eParaksts (Letonia) siguen siendo integraciones planificadas. Estas wallets no tienen precios publicados ni fechas de lanzamiento en producción.
Lee la documentación detallada| Monedero de identidad | USD / verificación completada | País / región | Disponibilidad en producción |
|---|---|---|---|
| MitID personal | 0,25 US$ |
| Disponible |
| BankID Sweden | 0,20 US$ |
| Disponible |
| Finnish Trust Network | 0,25 US$ |
| Disponible |
| Smart-ID | 0,20 US$ |
| Disponible |
| Mobile-ID | 0,20 US$ |
| Disponible |
| BankID Norway High | 0,35 US$ |
| Próximamente |
| Vipps Plus | 0,25 US$ |
| Próximamente |
| Buypass ID | Próximamente |
| Próximamente |
| itsme | Próximamente |
| Próximamente |
| iDIN full identification | 0,85 US$ |
| Próximamente |
| Personalausweis Profile 2 | 0,45 US$ |
| Próximamente |
| Freja eID | 0,25 US$ |
| Próximamente |
| UAE PASS | Próximamente |
| Próximamente |
| gov.br | Próximamente |
| Próximamente |
| OneID | 2,50 US$ |
| Próximamente |
| GOV.UK Wallet | Próximamente |
| Próximamente |
| Bank iD | Próximamente |
| Próximamente |
| MojeID | Próximamente |
| Próximamente |
| Diia | Próximamente |
| Próximamente |
| FranceConnect | Próximamente |
| Próximamente |
| Auðkenni | Próximamente |
| Próximamente |
| ConnectID | Próximamente |
| Próximamente |
| EUDI Wallet | Próximamente |
| Próximamente |
| Estonian ID-card | Próximamente |
| Próximamente |
| eParaksts | Próximamente |
| Próximamente |
Para construir, probar y tus primeros usuarios.
Más de 25 módulos con precios públicos. Descuentos automáticos por volumen.
Para grandes volúmenes y programas regulados.
Los descuentos por volumen se aplican automáticamente a medida que aumenta el uso, sin negociaciones ni llamadas de ventas.
Didit es la infraestructura para identidad y fraude, la plataforma que nos hubiera gustado tener cuando construíamos nuestros propios productos: abierta, flexible y amigable para desarrolladores, para que funcione como una parte real de tu stack en lugar de una caja negra que integras a su alrededor.
Una API cubre la verificación de personas (KYC, know your customer), la verificación de empresas (KYB, know your business), el screening de carteras de criptomonedas (KYT, know your transaction) y el monitoreo de transacciones en tiempo real, en un stack diseñado para ser:
La base subyacente: más de 14.000 tipos de documentos en más de 48 idiomas, más de 1.000 fuentes de datos y más de 200 señales de fraude en cada sesión. La infraestructura de Didit aprende dinámicamente de cada sesión y mejora cada día.
El usuario se autentica con una identidad electrónica (eID) que ya tiene, y Didit comprueba la evidencia de identidad firmada antes de registrar el resultado en la sesión. La interacción depende del monedero: Smart-ID pide un código personal, mientras que Mobile-ID también pide un número de teléfono. Ambos usan un código de comparación y la aprobación en el dispositivo del usuario.
La autenticación con monedero es un método dentro de la Verificación de Identidad, junto con la captura de documentos y la búsqueda sin documentos. En la API de flujos de trabajo, esta funcionalidad se llama OCR. Los monederos disponibles dependen del país y del entorno. Empieza con la documentación de monederos.
MitID, Smart-ID, Mobile-ID y Finnish Trust Network están disponibles. Smart-ID cubre Estonia, Letonia, Lituania y Bélgica; Mobile-ID cubre Estonia y Lituania; Finnish Trust Network cubre Finlandia. MitID da servicio a Dinamarca. Otras carteras listadas, incluyendo iDIN, BankID, Freja eID, ConnectID y la EUDI Wallet, estarán disponibles próximamente.
Elige las carteras aceptadas para cada país en la consola. La API de flujo de trabajo utiliza el catálogo para tu entorno y país. Usa la guía de integración para configurar la opción de documento de respaldo.
El usuario elige una cartera aceptada, introduce su código personal y proporciona un número de teléfono para Mobile-ID. Didit muestra un código de comparación. El usuario comprueba que el código coincide con el de su teléfono y aprueba la solicitud de autenticación allí. El PIN se introduce solo en el dispositivo del usuario, nunca en Didit.
Didit espera la respuesta firmada, comprueba la firma y el estado del certificado, y devuelve los atributos de identidad verificados a la sesión. El tiempo de finalización depende del usuario y de la respuesta de la cartera. Sigue la guía de Smart-ID y Mobile-ID.
Didit comprueba la firma de autenticación contra el desafío de esa sesión, verifica el certificado contra emisores de confianza y comprueba su estado de revocación. La identidad devuelta debe coincidir con el código personal y el país utilizados para la solicitud. El flujo alojado también valida su token de sesión y rechaza los intentos repetidos de finalización.
Estas comprobaciones conectan la respuesta firmada con el usuario y la solicitud esperados. No sustituyen la necesidad de que el usuario compare códigos y proteja su dispositivo. Lee el método de verificación, el proveedor del monedero y los atributos firmados en el resultado de la sesión, y verifica las firmas de los webhooks antes de usar un resultado en tu aplicación. Consulta la guía técnica.
Un solo interruptor cubre los tres casos: sin monedero, cancelado o inicio de sesión fallido. Puede recurrir a la captura de documentos o rechazar la sesión, y lo configuras por país.
El resultado registra el método de respaldo y el motivo, para que un inicio de sesión de monedero abandonado nunca pase desapercibido.
Smart-ID está disponible para Estonia, Letonia, Lituania y Bélgica. Mobile-ID está disponible para Estonia y Lituania. Mobile-ID no es compatible con Letonia. Los usuarios necesitan una credencial elegible para la cartera seleccionada.
Habilita cada cartera para el país correspondiente en tu flujo de trabajo. Lee la guía de Smart-ID y Mobile-ID para conocer los pasos de autenticación, los campos de identidad verificados y la opción de documento de respaldo.
Cifrados en tránsito y en reposo, en la región que elijas, bajo SOC 2 Tipo 1 y Tipo 2, ISO 27001 y GDPR.
Un monedero solo comparte los atributos que solicita la petición, y puedes desmarcar cualquier atributo opcional para que no se almacene en absoluto. Los atributos obligatorios siempre se almacenan, junto con la referencia de aserción firmada que necesita un auditor.
Detalles completos en /security-compliance.
Didit está en producción con más de 2.000 empresas en sectores regulados: fintech, banca, iGaming, cripto, marketplaces, sanidad y gobierno.
El inicio de sesión con monedero alcanza una garantía criptográfica, la prueba más sólida de los tres métodos, y el nivel de garantía se registra en cada sesión. Cuando un regulador nombra un eID nacional específico, aceptar ese monedero suele ser la forma más limpia de satisfacerlo.
Notas en /security-compliance.
Minutos, de tres maneras.
Empieza en business.didit.me, o lee docs.didit.me/integration/integration-prompt.
Una API para KYC, KYB, Monitoreo de Transacciones y Detección de Fraude en Wallets. Intégrala en 5 minutos.