Verifique pessoas com uma identidade eletrónica (eID) que já utilizam. Aceite Smart-ID, Mobile-ID, Finnish Trust Network e MitID através de um único fluxo de trabalho, com fallback de documentos quando necessário.
Confiado por mais de 2.000 organizações em todo o mundo.
Ativo
Ativo
Em breveEm breveEm breve
Em breveEm breve
Ativo
Em breveEm breve
Em breve
Em breve
Em breveEm breve
AtivoAtivo
Em breveEm breve
Em breve
Em breve
Em breve
Em breve
+26Em breveOs estados distinguem a disponibilidade em produção dos testes de integração. A cobertura por país descreve a rota da carteira configurada, não uma verificação de identidade ao vivo concluída em todos os países. Nenhuma data de lançamento é prometida.
Estado da integração
Smart-ID, Mobile-ID, Finnish Trust Network e MitID estão disponíveis. Escolha as carteiras aceites por país e permita que os utilizadores se autentiquem com uma identidade elegível que já possuem. Outras integrações listadas estarão disponíveis em breve.
Na consola, selecione as carteiras disponíveis para cada país no seu ambiente. Escolha se um início de sessão cancelado ou falhado reverte para a captura de documentos ou é recusado.
Diretamente do catálogo de métodos
No catálogo
Países abrangidos
eIDAS alto
Em diretoEm diretoEm breveEm breveEm breveSem controlos de ordenação em lado nenhum
Marcar é toda a configuração. O utilizador escolhe entre o que aceita, e a ordem no ecrã não tem significado. Cada carteira mantém o seu estado de catálogo até ficar ativa.
Fluxo Smart-ID e Mobile-ID
MitID · Danish Agency for Digital Government
Apenas para interfaces de administração
Os utilizadores finais nunca veem um rótulo de garantia, um nome de origem ou um preço. Os seus revisores veem os três.
Países com pelo menos uma carteira
Países
Abrangido pela Carteira EUDI
A cobertura segue o catálogo país a país. Uma bandeira aqui significa que uma carteira está listada para esse país, não que esteja ativa.
$ 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
Os preços abaixo são em USD por verificação de carteira concluída. Cobrem o produto de identidade nomeado; outras verificações de fluxo de trabalho e fallback de documentos são faturados separadamente. As 500 verificações de documentos mensais gratuitas não cobrem carteiras. Um preço anunciado não significa que uma carteira esteja ativa: a disponibilidade é mostrada separadamente. Carteiras disponíveis sem uma taxa publicada mostram "Sob consulta"; carteiras planeadas sem uma taxa publicada mostram "Em breve". As carteiras de identidade verificam pessoas; a análise de carteiras de criptomoedas é um produto separado.
Disponível significa ativado em produção. Em breve significa que ainda não está ativado em produção, mesmo que os testes de integração já tenham começado. As carteiras disponíveis aparecem primeiro.
O ConnectID (Austrália) está integrado para testes em sandbox; o acesso em produção estará disponível em breve. O Cartão de Identidade da Estónia (Estónia) e o eParaksts (Letónia) continuam a ser integrações planeadas. Estas carteiras não têm preços publicados nem datas de lançamento em produção.
Leia a documentação detalhada| Carteira de identidade | USD / verificação concluída | País / região | Disponibilidade em produção |
|---|---|---|---|
| MitID personal | 0,25 US$ |
| Disponível |
| BankID Sweden | 0,20 US$ |
| Disponível |
| Finnish Trust Network | 0,25 US$ |
| Disponível |
| Smart-ID | 0,20 US$ |
| Disponível |
| Mobile-ID | 0,20 US$ |
| Disponível |
| BankID Norway High | 0,35 US$ |
| Brevemente |
| Vipps Plus | 0,25 US$ |
| Brevemente |
| Buypass ID | Brevemente |
| Brevemente |
| itsme | Brevemente |
| Brevemente |
| iDIN full identification | 0,85 US$ |
| Brevemente |
| Personalausweis Profile 2 | 0,45 US$ |
| Brevemente |
| Freja eID | 0,25 US$ |
| Brevemente |
| UAE PASS | Brevemente |
| Brevemente |
| gov.br | Brevemente |
| Brevemente |
| OneID | 2,50 US$ |
| Brevemente |
| GOV.UK Wallet | Brevemente |
| Brevemente |
| Bank iD | Brevemente |
| Brevemente |
| MojeID | Brevemente |
| Brevemente |
| Diia | Brevemente |
| Brevemente |
| FranceConnect | Brevemente |
| Brevemente |
| Auðkenni | Brevemente |
| Brevemente |
| ConnectID | Brevemente |
| Brevemente |
| EUDI Wallet | Brevemente |
| Brevemente |
| Estonian ID-card | Brevemente |
| Brevemente |
| eParaksts | Brevemente |
| Brevemente |
Para construir, testar e para os seus primeiros utilizadores.
Mais de 25 módulos, preços públicos. Descontos automáticos por volume.
Para grandes volumes e programas regulados.
Os descontos por volume são aplicados automaticamente à medida que o uso aumenta — sem negociações, sem chamadas de vendas.
O Didit é a infraestrutura para identidade e fraude, a plataforma que gostaríamos que existisse quando estávamos a construir os nossos próprios produtos: aberta, flexível e amigável para programadores, para que funcione como uma parte real da sua stack em vez de uma caixa preta que integra à volta.
Uma API abrange a verificação de pessoas (KYC, know your customer), a verificação de empresas (KYB, know your business), a triagem de carteiras de criptomoedas (KYT, know your transaction), e a monitorização de transações em tempo real, numa stack construída para ser:
A base subjacente: mais de 14.000 tipos de documentos em mais de 48 idiomas, mais de 1.000 fontes de dados e mais de 200 sinais de fraude em cada sessão. A infraestrutura Didit aprende dinamicamente de cada sessão e melhora a cada dia.
O utilizador autentica-se com uma identidade eletrónica (eID) existente, e a Didit verifica a evidência de identidade assinada antes de registar o resultado na sessão. A interação depende da carteira: a Smart-ID pede um código pessoal, enquanto a Mobile-ID também pede um número de telefone. Ambas usam um código de comparação e aprovação no dispositivo do utilizador.
A autenticação por carteira é um método dentro da Verificação de Identidade, juntamente com a captura de documentos e a pesquisa sem documentos. Na API de workflow, essa funcionalidade é designada por OCR. As carteiras disponíveis dependem do país e do ambiente. Comece com a documentação das carteiras.
MitID, Smart-ID, Mobile-ID e Finnish Trust Network estão disponíveis. O Smart-ID abrange a Estónia, Letónia, Lituânia e Bélgica; o Mobile-ID abrange a Estónia e a Lituânia; o Finnish Trust Network abrange a Finlândia. O MitID serve a Dinamarca. Outras carteiras listadas, incluindo iDIN, BankID, Freja eID, ConnectID e a Carteira EUDI, estarão disponíveis em breve.
Escolha as carteiras aceites para cada país na consola. A API de fluxo de trabalho utiliza o catálogo para o seu ambiente e país. Utilize o guia de integração para configurar o fallback de documentos.
O utilizador escolhe uma carteira aceite, introduz o seu código pessoal e fornece um número de telefone para o Mobile-ID. A Didit exibe um código de comparação. O utilizador verifica se o código corresponde ao do seu telemóvel e aprova o pedido de autenticação lá. O PIN é introduzido apenas no dispositivo do utilizador, nunca na Didit.
Didit aguarda a resposta assinada, verifica a assinatura e o estado do certificado, e devolve os atributos de identidade verificados à sessão. O tempo de conclusão depende do utilizador e da resposta da carteira. Siga o guia Smart-ID e Mobile-ID.
A Didit verifica a assinatura de autenticação em relação ao desafio para essa sessão, verifica o certificado em relação a emissores fidedignos e verifica o seu estado de revogação. A identidade devolvida deve corresponder ao código pessoal e ao país usados para o pedido. O fluxo alojado também valida o seu token de sessão e rejeita tentativas repetidas de conclusão.
Estas verificações ligam a resposta assinada ao utilizador e pedido esperados. Não substituem a necessidade de o utilizador comparar códigos e proteger o seu dispositivo. Leia o método de verificação, o fornecedor da carteira e os atributos assinados no resultado da sessão, e verifique as assinaturas de webhook antes de usar um resultado na sua aplicação. Consulte o guia técnico.
Um único controlo abrange os três casos: sem carteira, cancelado ou início de sessão falhou. Ou recorre à captura de documentos ou recusa a sessão, e pode definir isso por país.
O resultado regista o método de fallback e a razão, para que um início de sessão abandonado na carteira nunca passe despercebido.
O Smart-ID está disponível para a Estónia, Letónia, Lituânia e Bélgica. O Mobile-ID está disponível para a Estónia e Lituânia. O Mobile-ID não é suportado para a Letónia. Os utilizadores precisam de uma credencial elegível para a carteira selecionada.
Ative cada carteira para o país correspondente no seu fluxo de trabalho. Leia o guia Smart-ID e Mobile-ID para os passos de autenticação, campos de identidade verificados e fallback de documentos.
Criptografados em trânsito e em repouso, na região que escolher, sob SOC 2 Type 1 e Type 2, ISO 27001 e GDPR.
Uma carteira partilha apenas os atributos solicitados, e pode desmarcar qualquer atributo opcional para que nunca seja armazenado. Os atributos obrigatórios são sempre armazenados, juntamente com a referência da asserção assinada de que um auditor necessita.
Detalhes completos em /security-compliance.
A Didit está em produção com mais de 2.000 empresas em indústrias reguladas — fintech, banca, iGaming, cripto, marketplaces, saúde e governo.
O início de sessão com carteira atinge a garantia criptográfica, a prova mais forte dos três métodos, e o nível de garantia é registado em cada sessão. Quando um regulador nomeia um eID nacional específico, aceitar essa carteira é geralmente a forma mais simples de o satisfazer.
Memos em /security-compliance.
Em minutos, de três formas.
Comece em business.didit.me, ou leia docs.didit.me/integration/integration-prompt.
Uma API para KYC, KYB, Monitorização de Transações e Rastreio de Carteiras. Integre em 5 minutos.