Thibitisha watu kwa kitambulisho cha kielektroniki (eID) wanachotumia tayari. Kubali Smart-ID, Mobile-ID, Finnish Trust Network na MitID kupitia mtiririko mmoja wa kazi, na chelezo ya hati inapohitajika.
Inaaminika na mashirika 2,000+ duniani kote.
Moja kwa moja
Moja kwa moja
Hivi karibuniHivi karibuniHivi karibuni
Hivi karibuniHivi karibuni
Moja kwa moja
Hivi karibuniHivi karibuni
Hivi karibuni
Hivi karibuni
Hivi karibuniHivi karibuni
Moja kwa mojaMoja kwa moja
Hivi karibuniHivi karibuni
Hivi karibuni
Hivi karibuni
Hivi karibuni
Hivi karibuni
+26Hivi karibuniHali hutofautisha upatikanaji wa uzalishaji na upimaji wa ujumuishaji. Ufunikaji wa nchi unaelezea njia ya wallet iliyosanidiwa, si ukaguzi wa utambulisho wa moja kwa moja uliokamilika katika kila nchi. Hakuna tarehe ya uzinduzi iliyoahidiwa.
Hali ya ujumuishaji
Smart-ID, Mobile-ID, Finnish Trust Network na MitID zinapatikana. Chagua pochi zinazokubalika kulingana na nchi na waruhusu watumiaji kuthibitisha kwa kitambulisho kinachostahiki walichonacho tayari. Ujumuishaji mwingine ulioorodheshwa bado unakuja hivi karibuni.
Katika console, chagua wallet zinazopatikana kwa kila nchi katika mazingira yako. Chagua kama kuingia kulikoghairiwa au kushindwa kutaangukia kwenye kunasa hati au kukataa.
Moja kwa moja kutoka kwenye katalogi ya mbinu
Kwenye katalogi
Nchi zilizofunikwa
eIDAS high
Moja kwa MojaMoja kwa MojaHivi KaribuniHivi KaribuniHivi KaribuniHakuna udhibiti wa mpangilio popote
Kuteua ndio usanidi wote. Mtumiaji anachagua kutoka unachokubali, na mpangilio kwenye skrini hauna maana. Kila wallet inabaki na hali yake ya katalogi hadi ianze kutumika.
Mtiririko wa Smart-ID na Mobile-ID
MitID · Danish Agency for Digital Government
Zinaonekana kwa wasimamizi pekee
Watumiaji wa mwisho hawaoni lebo ya uhakikisho, jina la chanzo, au bei. Wakaguzi wako wanaona zote tatu.
Nchi zenye angalau wallet moja
Nchi
Inafunikwa na EUDI Wallet
Ufikiaji unafuata katalogi nchi kwa nchi. Bendera hapa inamaanisha wallet imeorodheshwa kwa nchi hiyo, si kwamba inatumika.
$ 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
Bei zilizo hapa chini ni USD kwa kila uthibitishaji wa pochi uliokamilika. Zinajumuisha bidhaa ya utambulisho iliyotajwa; ukaguzi mwingine wa mtiririko wa kazi na chelezo ya hati hulipwa kando. Ukaguzi 500 wa hati za bure za kila mwezi haujumuishi pochi. Bei iliyotangazwa haimaanishi kuwa pochi inapatikana: upatikanaji unaonyeshwa kando. Pochi zinazopatikana bila bei iliyochapishwa zinaonyesha Ombi; pochi zilizopangwa bila bei iliyochapishwa zinaonyesha Zinakuja hivi karibuni. Pochi za utambulisho huthibitisha watu; uchunguzi wa pochi za crypto ni bidhaa tofauti.
Inapatikana inamaanisha imewezeshwa katika uzalishaji. Inakuja hivi karibuni inamaanisha bado haijaweshwa katika uzalishaji, hata kama majaribio ya kuunganisha yameanza. Wallet zinazopatikana huonekana kwanza.
ConnectID (Australia) imeunganishwa kwa majaribio ya sandbox; upatikanaji wa uzalishaji bado unakuja hivi karibuni. Vitambulisho vya Estonia (Estonia) na eParaksts (Latvia) bado vimepangwa kuunganishwa. Wallets hizi hazina bei zilizochapishwa au tarehe za uzinduzi wa uzalishaji.
Soma nyaraka za kina| Pochi ya utambulisho | USD / uthibitishaji uliokamilika | Nchi / eneo | Upatikanaji wa uzalishaji |
|---|---|---|---|
| MitID personal | US$ 0.25 |
| Inapatikana |
| BankID Sweden | US$ 0.20 |
| Inapatikana |
| Finnish Trust Network | US$ 0.25 |
| Inapatikana |
| Smart-ID | US$ 0.20 |
| Inapatikana |
| Mobile-ID | US$ 0.20 |
| Inapatikana |
| BankID Norway High | US$ 0.35 |
| Inakuja hivi karibuni |
| Vipps Plus | US$ 0.25 |
| Inakuja hivi karibuni |
| Buypass ID | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| itsme | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| iDIN full identification | US$ 0.85 |
| Inakuja hivi karibuni |
| Personalausweis Profile 2 | US$ 0.45 |
| Inakuja hivi karibuni |
| Freja eID | US$ 0.25 |
| Inakuja hivi karibuni |
| UAE PASS | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| gov.br | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| OneID | US$ 2.50 |
| Inakuja hivi karibuni |
| GOV.UK Wallet | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| Bank iD | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| MojeID | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| Diia | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| FranceConnect | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| Auðkenni | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| ConnectID | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| EUDI Wallet | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| Estonian ID-card | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
| eParaksts | Inakuja hivi karibuni |
| Inakuja hivi karibuni |
Kwa ajili ya kuunda, kujaribu, na watumiaji wako wa kwanza.
Moduli 25+, bei wazi. Punguzo la kiotomatiki kwa wingi.
Kwa kiasi kikubwa na programu zilizodhibitiwa.
Punguzo la wingi hutumika kiotomatiki kadri matumizi yanavyoongezeka — hakuna mazungumzo, hakuna simu ya mauzo.
Didit ni miundombinu ya utambulisho na udanganyifu, jukwaa ambalo tulitamani lingekuwepo tulipokuwa tukijenga bidhaa sisi wenyewe: wazi, rahisi kubadilika, na rafiki kwa wasanidi, ili lifanye kazi kama sehemu halisi ya stack yako badala ya black box unayounganisha.
API moja inashughulikia kuthibitisha watu (KYC, know your customer), kuthibitisha biashara (KYB, know your business), kuchunguza crypto wallets (KYT, know your transaction), na kufuatilia miamala kwa wakati halisi, kwenye stack iliyojengwa kuwa:
Msingi wake: aina 14,000+ za hati katika lugha 48+, vyanzo vya data 1,000+, na ishara za udanganyifu 200+ kwenye kila session. Miundombinu ya Didit inajifunza kwa nguvu kutoka kila session na inaboresha kila siku.
Mtumiaji anathibitisha kwa kutumia kitambulisho cha kielektroniki (eID) kilichopo, na Didit huangalia ushahidi wa kitambulisho uliosainiwa kabla ya kuandika matokeo kwenye session. Mwingiliano unategemea wallet: Smart-ID huomba nambari ya kibinafsi, huku Mobile-ID pia ikiomba nambari ya simu. Zote hutumia msimbo wa kulinganisha na idhini kwenye kifaa cha mtumiaji.
Uthibitishaji wa wallet ni njia moja ndani ya ID Verification, pamoja na kunasa hati na utafutaji usio wa hati. Katika API ya workflow, kipengele hicho kinaitwa OCR. Wallet zinazopatikana hutegemea nchi na mazingira. Anza na nyaraka za wallet.
MitID, Smart-ID, Mobile-ID na Finnish Trust Network zinapatikana. Smart-ID inapatikana Estonia, Latvia, Lithuania na Ubelgiji; Mobile-ID inapatikana Estonia na Lithuania; Finnish Trust Network inapatikana Finland. MitID inahudumia Denmark. Pochi zingine zilizoorodheshwa, ikiwemo iDIN, BankID, Freja eID, ConnectID na EUDI Wallet, bado zinakuja hivi karibuni.
Chagua pochi zinazokubalika kwa kila nchi kwenye koni. API ya mtiririko wa kazi inatumia katalogi kwa mazingira na nchi yako. Tumia mwongozo wa ujumuishaji kusanidi chelezo ya hati.
Mtumiaji huchagua pochi inayokubalika, anaweka nambari yake ya kibinafsi, na anatoa nambari ya simu kwa Mobile-ID. Didit inaonyesha msimbo wa kulinganisha. Mtumiaji huangalia kuwa msimbo unalingana na ule ulio kwenye simu yake na kuidhinisha ombi la uthibitishaji hapo. PIN inaingizwa tu kwenye kifaa cha mtumiaji, kamwe si kwenye Didit.
Didit inasubiri jibu lililosainiwa, huangalia saini na hali ya cheti, na kurejesha sifa za utambulisho zilizothibitishwa kwenye kipindi. Muda wa kukamilisha unategemea mtumiaji na jibu la pochi. Fuata mwongozo wa Smart-ID na Mobile-ID.
Didit huangalia saini ya uthibitishaji dhidi ya changamoto kwa session hiyo, huthibitisha cheti dhidi ya watoaji wanaoaminika, na huangalia hali yake ya kufutwa. Utambulisho uliorejeshwa lazima ulingane na msimbo wa kibinafsi na nchi iliyotumika kwa ombi. Mtiririko uliopangishwa pia huthibitisha tokeni yake ya session na kukataa majaribio ya kukamilisha yanayorudiwa.
Ukaguzi huu huunganisha jibu lililosainiwa na mtumiaji anayetarajiwa na ombi. Hazibadilishi hitaji la mtumiaji kulinganisha misimbo na kulinda kifaa chake. Soma njia ya uthibitishaji, mtoa huduma wa wallet na sifa zilizosainiwa kwenye matokeo ya session, na thibitisha saini za webhook kabla ya kutumia matokeo katika programu yako. Tazama mwongozo wa kiufundi.
Swichi moja inashughulikia visa vyote vitatu: hana wallet, kaghairi, au kuingia kukashindikana. Inaweza kurudi kwenye kunasa hati au kukataa kipindi, na unaweka hii kwa kila nchi.
Matokeo hurekodi njia iliyorudiwa na sababu, hivyo kuingia kwa wallet iliyoachwa hakufichwi kamwe.
Smart-ID inapatikana kwa Estonia, Latvia, Lithuania na Ubelgiji. Mobile-ID inapatikana kwa Estonia na Lithuania. Mobile-ID haitumiki kwa Latvia. Watumiaji wanahitaji kitambulisho kinachostahiki kwa pochi yao iliyochaguliwa.
Wezesha kila pochi kwa nchi inayolingana katika mtiririko wako wa kazi. Soma mwongozo wa Smart-ID na Mobile-ID kwa hatua za uthibitishaji, sehemu za utambulisho zilizothibitishwa na chelezo ya hati.
Imesimbwa kwa njia fiche wakati wa usafirishaji na inapohifadhiwa, katika eneo unalochagua, chini ya SOC 2 Type 1 na Type 2, ISO 27001 na GDPR.
Wallet inashiriki tu sifa zinazoombwa, na unaweza kuondoa tiki kwenye sifa yoyote ya hiari ili isihifadhiwe kabisa. Sifa zinazohitajika huhifadhiwa kila wakati, pamoja na rejeleo la uthibitisho uliosainiwa ambalo mkaguzi anahitaji.
Maelezo kamili yanapatikana kwenye /security-compliance.
Didit inatumika na kampuni 2,000+ katika sekta zinazodhibitiwa — fintech, benki, iGaming, crypto, masoko, huduma za afya na serikali.
Kuingia kwa wallet kunafikia uhakikisho wa cryptographic, ushahidi wenye nguvu zaidi kati ya njia tatu, na kiwango cha uhakikisho kinarekodiwa kwenye kila kipindi. Pale ambapo mdhibiti anataja eID maalum ya kitaifa, kukubali wallet hiyo kwa kawaida ndiyo njia safi zaidi ya kuitimiza.
Memo kuhusu /security-compliance.
Dakika chache, kwa njia tatu.
Anza kwenye business.didit.me, au soma docs.didit.me/integration/integration-prompt.
API moja kwa KYC, KYB, Ufuatiliaji wa Miamala, na Uchunguzi wa Wallet. Unganisha ndani ya dakika 5.