Проверяйте людей через электронную идентификацию (eID), которой они уже пользуются. Принимайте MitID, BankID Швеция, Finnish Trust Network, Smart-ID и Mobile-ID в одном процессе, с проверкой документа как резервным вариантом.
Нам доверяют более 3000 организаций по всему миру.
Доступно
Доступно
СкороСкороСкоро
СкороСкоро
Доступно
СкороСкоро
Скоро
Скоро
СкороСкоро
ДоступноДоступно
СкороСкоро
Скоро
Скоро
Скоро
Скоро
+26СкороСтатусы различают доступность в продакшене и тестирование интеграции. Покрытие по странам описывает настроенный маршрут кошелька, а не завершённую проверку личности в каждой стране. Дата запуска не гарантируется.
Статус интеграции
MitID, BankID Швеция, Finnish Trust Network, Smart-ID и Mobile-ID уже доступны. Выберите принимаемые кошельки по странам, и пользователи пройдут аутентификацию с помощью уже имеющейся подходящей идентификации. Остальные интеграции из списка появятся скоро.
В консоли выберите кошельки, доступные для каждой страны в вашей среде. Определите, будет ли отменённый или неудачный вход переключаться на сканирование документов или отклоняться.
Прямо из каталога методов
В каталоге
Охвачено стран
eIDAS высокий
ДоступноДоступноСкороСкороСкороНикаких настроек порядка
Вся конфигурация — это галочки. Пользователь выбирает из того, что вы разрешаете, и порядок на экране не имеет значения. Каждый кошелек сохраняет свой статус в каталоге до момента запуска.
Флоу Smart-ID и Mobile-ID
MitID · Danish Agency for Digital Government
Только для админ-панелей
Конечные пользователи никогда не видят уровень гарантии, название источника или цену. Ваши ревьюеры видят все три.
Страны с хотя бы одним кошельком
Страны
Покрывается кошельком EUDI
Покрытие следует за каталогом по странам. Флаг здесь означает, что кошелек указан для этой страны, а не то, что он уже запущен.
$ curl -X POST https://verification.didit.me/v3/session/ \
-H "x-api-key: <your-api-key>" \
-H "Content-Type: application/json" \
-d '{
"workflow_id": "<your-workflow-uuid>",
"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.
Read the catalog one of these ways:
- Business Console: your application -> Workflows -> the ID Verification
step -> Countries -> "Wallets accepted". Coming-soon wallets are listed
but cannot be switched on. https://docs.didit.me/console/id-verification-methods
- Didit MCP server (https://mcp.didit.me/mcp), tool
didit_workflow_get_id_verification_methods_catalog; pass country as ISO
3166-1 alpha-3 to narrow it. The MCP server signs in with "Log in with
Didit" (OAuth). It does not accept the x-api-key.
https://docs.didit.me/integration/mcp/tools
- Public coverage table (no sign-in, read-only):
https://docs.didit.me/core-technology/id-verification/digital-id-wallets#supported-wallets
If your code holds only an API key, it cannot read the catalog itself: use the
wallet ids listed in this prompt, and treat the answer of the workflow save as
the check. A live application answers 400 for a wallet that is not available
in that country ("<wallet> is not offered in <ISO3>", "unknown wallet").
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. When this prompt was generated it marked these
available:
- MitID: wallet id mitid, country keys DNK
- BankID: wallet id bankid_se, country keys SWE
- Finnish Trust Network: wallet id ftn, country keys FIN
- Smart-ID: wallet id smart_id, country keys EST, LVA, LTU, BEL
- Mobile-ID: wallet id mobile_id, country keys EST, LTU
Finnish Trust Network has its own 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. Check 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: 201. The workflow id is uuid (workflow_id carries the same value);
the workflow is published straight away. Create it once and keep the id:
every call to this endpoint makes a new workflow.
is_desktop_allowed defaults to false: on a desktop browser the hosted flow
then shows a QR code to continue on a phone. Add "is_desktop_allowed": true
next to workflow_label to let people finish on desktop.
Use that id as workflow_id in step 4. The ID Verification node id of a
workflow made by this call is "ocr".
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. A sandbox
application accepts coming-soon wallets, so this only shows on live
- 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 session_id, session_token, url and status "Not Started".
Redirect the user to url (hosted flow) or open it in the Web, iOS, Android,
React Native or Flutter SDK. The field is named url on this response.
One unfinished session exists per workflow_id and vendor_data pair: calling
create again with the same pair answers 201 again with that same session.
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 in the console (API & Webhooks), or over the API:
POST https://verification.didit.me/v3/webhook/destinations/
-H "x-api-key: <your-api-key>"
-H "Content-Type: application/json"
-d '{
"label": "Verification webhooks",
"url": "https://<your-public-host>/webhooks/didit",
"webhook_version": "v3",
"subscribed_events": ["status.updated", "data.updated"]
}'
label, url and subscribed_events are required. url must be a public HTTPS
address: Didit does not deliver to localhost or private addresses. Response:
201 with uuid and secret_shared_key. Store secret_shared_key as the webhook
secret (DIDIT_WEBHOOK_SECRET); it is unique to this destination. Remove a
destination with DELETE /v3/webhook/destinations/{uuid}/ (204).
What arrives:
- webhook_type is "status.updated" (the session changed status) or
"data.updated" (verification data was corrected after the fact)
- a destination receives the events of every session of the application,
so filter on workflow_id or vendor_data when several flows share it
- creating a session already sends status.updated with status
"Not Started". The decision key is present only when status is Approved,
Declined, In Review or Abandoned.
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.
Idempotency: event_id is the same on every retry of one event, so store it
and skip a delivery you already processed. One session can
still send the same status under two event ids, and the
console's Try Webhook test deliveries carry no event_id, so
also make the handler safe to run twice for one
(session_id, status, webhook_type).
Compare: constant-time (crypto.timingSafeEqual)
Reference handler (Express). Keep the verification lines as written.
The handler is a fragment. Put this above it and app.listen(process.env.PORT)
below it. It needs Express and Node 21 or newer (an older Node rejects
every delivery). It expects a JSON body: answer 400 yourself if you accept
anything else on this route, and refuse to start without the secret.
const express = require("express");
const app = express();
const SECRET = process.env.DIDIT_WEBHOOK_SECRET; // secret_shared_key of the destination
// 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: event_id, session_id, status, webhook_type,
workflow_id, vendor_data, timestamp, decision.
Status values (exact strings): Not Started, In Progress, Approved, Declined,
In Review, Resubmitted, Expired, Abandoned, Kyc Expired. Awaiting User only
appears on business verification sessions.
## 6. Reading the result
The same V3 decision reaches you two ways:
- webhook body: body.decision.id_verifications[]
- GET https://verification.didit.me/v3/session/{session_id}/decision/
-H "x-api-key: <your-api-key>"
This response IS the decision object. Read id_verifications at the top
level: there is no decision wrapper here.
Until the user finishes the ID step, status is "Not Started" or "In Progress"
and id_verifications is null, not an empty array. Guard for it.
The decision is the V3 shape: every feature result is a plural array with one
entry per workflow node. ID Verification results live in
id_verifications[]: there is no singular kyc (that is the V2 shape) and no
id_verification. The decision's features list names the step
ID_VERIFICATION, while the workflow body takes OCR. 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 wallet sign-in failed
and on_failure declined the session; otherwise
null. After a document fallback that succeeds the
entry reads verification_method "document" with
fallback_from null
A wallet entry that succeeds is assurance cryptographic: an identity provider
authenticated the person and signed the attributes. The normalised full_name
and date_of_birth sit on the entry itself; attributes holds the wallet's own
claims. On a live application, 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: $0.55; production availability: Coming soon
- eParaksts mobile: $0.55; 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[] in the webhook body and
id_verifications[] on the GET decision response, never kyc
## 9. Verify your integration
Sandbox (an application in sandbox mode: nothing is billed and no real eID is
called). https://docs.didit.me/integration/sandbox-testing
- a sandbox application can enable every wallet in the catalog, the
coming-soon ones included. A workflow that saves in sandbox can still be
refused on a live application, so only use wallets marked available.
- open the session url, pick the wallet and confirm: the default approve
scenario simulates the sign-in. The entry then has verification_method
"wallet", assurance "cryptographic" and wallet_provider set, and the
normalised full_name and date_of_birth are filled. But
wallet_verification.signature_valid and level_of_assurance are null and
attributes is { "sandbox": true }: no real credential was checked.
Assert signature_valid === true and the level of assurance only against
a live application.
- to exercise on_failure, create the session with
"sandbox_scenario": "wallet_cancelled" (also wallet_timeout and
wallet_provider_error). The wallet sign-in then fails and the flow moves
to document capture or declines, as on_failure says. A fallback that
ends in an approved document reads verification_method "document".
- POST /v3/session/{session_id}/simulate/ forces a final status but writes
no id_verifications entry, so it cannot stand in for a sign-in.
Checks:
- create the workflow, create a session, and read its decision: expect 201,
201 with url, and 200 with status "Not Started"
- run one session per accepted wallet in sandbox through the hosted flow
- assert the id_verifications[] entry for your node has verification_method
wallet and wallet_provider set to the wallet you picked
- run one session with sandbox_scenario "wallet_cancelled" and assert your
on_failure setting actually fires
- on a live application, assert wallet_verification.signature_valid is true
- 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
Цены указаны в долларах США за одну успешно пройденную верификацию через цифровой кошелёк. Они включают только заявленный продукт для подтверждения личности; другие проверки в рамках рабочего процесса и резервные методы верификации документов оплачиваются отдельно. 500 бесплатных ежемесячных проверок документов не распространяются на цифровые кошельки. Объявленная цена не означает, что кошелёк уже доступен: статус доступности указан отдельно. Для доступных кошельков без опубликованной цены указано «По запросу»; для планируемых кошельков без опубликованной цены — «Скоро». Цифровые кошельки подтверждают личность; проверка криптокошельков — это отдельный продукт.
«Доступно» означает, что функция включена в продакшене. «Скоро» означает, что функция ещё не включена в продакшене, даже если началось интеграционное тестирование. Доступные кошельки отображаются первыми.
ConnectID (Австралия), Estonian ID-card (Эстония) и eParaksts mobile (Латвия) интегрированы для тестирования в песочнице. Актуальные цены и доступность в продакшене для каждого кошелька смотрите в таблице.
Подробная документация| Цифровой кошелек | USD / успешно пройденную верификацию | Страна / регион | Доступность в продакшене |
|---|---|---|---|
| MitID personal | 0,25 $ |
| Доступно |
| BankID Sweden | 0,20 $ |
| Доступно |
| Finnish Trust Network | 0,25 $ |
| Доступно |
| Smart-ID | 0,20 $ |
| Доступно |
| Mobile-ID | 0,20 $ |
| Доступно |
| BankID Norway High | 0,35 $ |
| Скоро |
| Vipps Plus | 0,25 $ |
| Скоро |
| Buypass ID | Скоро |
| Скоро |
| itsme | Скоро |
| Скоро |
| iDIN full identification | 0,85 $ |
| Скоро |
| Personalausweis Profile 2 | 0,45 $ |
| Скоро |
| Freja eID | 0,25 $ |
| Скоро |
| UAE PASS | Скоро |
| Скоро |
| gov.br | Скоро |
| Скоро |
| OneID | 2,50 $ |
| Скоро |
| GOV.UK Wallet | Скоро |
| Скоро |
| Bank iD | Скоро |
| Скоро |
| MojeID | Скоро |
| Скоро |
| Diia | Скоро |
| Скоро |
| FranceConnect | Скоро |
| Скоро |
| Auðkenni | Скоро |
| Скоро |
| ConnectID | Скоро |
| Скоро |
| EUDI Wallet | Скоро |
| Скоро |
| Estonian ID-card | 0,55 $ |
| Скоро |
| eParaksts mobile | 0,55 $ |
| Скоро |
Для разработки, тестирования и первых пользователей.
Более 25 модулей с открытыми ценами. Автоматические скидки за объём.
Для больших объёмов и регулируемых программ.
Скидки за объём применяются автоматически по мере роста использования — никаких переговоров, никаких звонков от продаж.
Didit — это инфраструктура для идентификации и борьбы с мошенничеством, платформа, которую мы сами хотели бы иметь, когда создавали свои продукты: открытая, гибкая и удобная для разработчиков. Она становится полноценной частью вашего стека, а не черным ящиком, вокруг которого приходится выстраивать интеграцию.
Единый API охватывает верификацию людей (KYC, know your customer), верификацию компаний (KYB, know your business), проверку криптокошельков (KYT, know your transaction) и мониторинг транзакций в реальном времени. Наш стек создан, чтобы быть:
В основе: более 14 000 типов документов на 48+ языках, более 1000 источников данных и более 200 сигналов мошенничества для каждой сессии. Инфраструктура Didit динамически обучается на каждой сессии и становится лучше с каждым днем.
Пользователь проходит аутентификацию с помощью существующего электронного удостоверения личности (eID), а Didit проверяет подписанные данные перед записью результата в сессию. Взаимодействие зависит от кошелька: Smart-ID запрашивает персональный код, а Mobile-ID — ещё и номер телефона. Оба используют код сравнения и подтверждение на устройстве пользователя.
Аутентификация через кошелёк — это один из методов верификации личности, наряду со сканированием документов и поиском по не-документальным источникам. В API рабочего процесса эта функция называется OCR. Доступные кошельки зависят от страны и среды. Начните с документации по кошелькам.
MitID, BankID Швеция, Finnish Trust Network, Smart-ID и Mobile-ID уже доступны. MitID работает в Дании, BankID в Швеции, Finnish Trust Network в Финляндии; Smart-ID охватывает Эстонию, Латвию, Литву и Бельгию; Mobile-ID охватывает Эстонию и Литву. Остальные кошельки из списка, включая iDIN, BankID Норвегия, Freja eID, ConnectID и EUDI Wallet, появятся скоро.
Выберите принимаемые кошельки для каждой страны в консоли. API рабочего процесса использует каталог для вашей среды и страны. Используйте руководство по интеграции для настройки резервного метода верификации документов.
Пользователь выбирает подходящий кошелёк, вводит свой персональный код и указывает номер телефона для Mobile-ID. Didit отображает код для сравнения. Пользователь проверяет, совпадает ли код с тем, что на его телефоне, и подтверждает запрос на аутентификацию. PIN-код вводится только на устройстве пользователя, никогда не в Didit.
Didit ожидает подписанный ответ, проверяет подпись и статус сертификата, а затем возвращает проверенные атрибуты личности в сессию. Время завершения зависит от пользователя и ответа кошелька. Следуйте руководству по Smart-ID и Mobile-ID.
Didit проверяет подпись аутентификации на соответствие запросу для данной сессии, верифицирует сертификат по доверенным эмитентам и проверяет его статус отзыва. Возвращённые данные должны совпадать с персональным кодом и страной, использованными для запроса. Хостируемый флоу также валидирует свой токен сессии и отклоняет повторные попытки завершения.
Эти проверки связывают подписанный ответ с ожидаемым пользователем и запросом. Они не отменяют необходимости для пользователя сравнивать коды и защищать своё устройство. Прочитайте метод верификации, провайдера кошелька и подписанные атрибуты в результате сессии, а также верифицируйте подписи вебхуков, прежде чем использовать результат в своём приложении. См. техническое руководство.
Один переключатель решает все три проблемы: нет кошелька, отмена или ошибка входа. Система либо переключается на захват документов, либо отклоняет сессию. Вы настраиваете это для каждой страны.
Результат записывает метод, на который произошел откат, и причину, так что незавершенный вход через кошелек никогда не останется незамеченным.
Smart-ID доступен для Эстонии, Латвии, Литвы и Бельгии. Mobile-ID доступен для Эстонии и Литвы. Mobile-ID не поддерживается в Латвии. Пользователям необходимы соответствующие учётные данные для выбранного кошелька.
Включите каждый кошелёк для соответствующей страны в своём рабочем процессе. Прочитайте руководство по Smart-ID и Mobile-ID для получения информации о шагах аутентификации, проверяемых полях личности и резервном методе верификации документов.
Данные зашифрованы при передаче и хранении, в выбранном вами регионе, в соответствии со стандартами SOC 2 Type 1 и Type 2, ISO 27001 и GDPR.
Кошелек передает только те атрибуты, которые запрашиваются, и вы можете снять отметку с любого необязательного атрибута, чтобы он вообще не хранился. Обязательные атрибуты всегда хранятся вместе со ссылкой на подписанное подтверждение, необходимое для аудита.
Подробности на /security-compliance.
Didit используется в работе более чем 3000 компаний в регулируемых отраслях — финтех, банкинг, iGaming, криптоиндустрия, маркетплейсы, здравоохранение и государственные учреждения.
Вход через кошелек обеспечивает криптографическую надежность, что является самым сильным доказательством из трех методов, и уровень надежности записывается в каждой сессии. Если регулятор указывает конкретный национальный eID, принятие этого кошелька обычно является самым простым способом удовлетворить его требования.
Меморандумы на /security-compliance.
За считанные минуты, тремя способами.
Начните на business.didit.me или прочитайте docs.didit.me/integration/integration-prompt.
Единый API для KYC, KYB, мониторинга транзакций и проверки кошельков. Интеграция за 5 минут.
Estonian ID-card
eParaksts mobile