Skip to main content
Didit Yakusanya $7.5M Kujenga Miundombinu ya Utambulisho na Udanganyifu
Didit
Utambulisho kwa mawakala wa AI

Wakala wako wa AI anaweza kuendesha KYC. Kwa amri moja.

Sakinisha Ujuzi kumi na mbili wa Wakala wa chanzo huria wa Didit kwenye Cursor, Claude Code, Codex, au OpenCode kwa amri moja ya `npx`. Uliza wakala kwa Kiingereza rahisi. Inaandika code na kupiga API halisi.

Anza bureSoma nyaraka
Inaungwa mkono na
Y CombinatorRobinhood Ventures
Firecrawl
Slash
Crnogorski Telekom
UCSF Neuroscape
Bit2Me
Shiply

Inaaminika na mashirika 2,000+ duniani kote.

Mchoro wa sinema, giza, usioeleweka wa ujuzi wa utambulisho unaoweza kusakinishwa na wakala, paneli nne za kioo zinazoelea, zinazopitisha mwanga katika mtazamo wa 3D kwenye nyeusi safi, zikipitishwa na mstari mweupe wa Didit Blue, kila paneli ikiwa na ikoni ndogo nyeupe-nyepesi ya ujuzi (terminal prompt, scan, key, branching diff). Zimezungukwa na mabano manne ya skana yanayong'aa.

Kwa nini ujuzi, si nyaraka

Nyaraka ni za binadamu. Ujuzi ni wa mawakala.

Mpe Cursor kichupo cha nyaraka na inabuni endpoints na inabadilisha status enums kuwa herufi ndogo. Mpe ujuzi wa Didit na kila mstari unaelekeza kwenye API halisi, endpoint iliyofungwa, headers zilizofungwa, scaffold ya handler ya webhook iliyosainiwa. Amri moja ya `npx`.

Jinsi inavyofanya kazi

Kutoka npx install hadi mtumiaji aliyethibitishwa kwa hatua nne.

  1. Hatua 01

    Sakinisha ujuzi

    Endesha `npx skills add didit-protocol/skills` kwenye mradi wako. CLI inagundua Cursor, Claude Code, Codex, au OpenCode na kuweka kila ujuzi kwenye folda sahihi. Sakinisha moja tu na `--skill didit-face-match`.

  2. Hatua 02

    Pata API key

    Ama pata moja kwa sekunde 60 kwenye [business.didit.me](https://business.didit.me) na `export DIDIT_API_KEY=…`, au ruhusu wakala kujisajili yenyewe kwa programu, `POST /programmatic/register/` ikifuatiwa na `verify-email/`, na key inarudi kwenye jibu. Hakuna kivinjari kinachohitajika.

  3. Hatua 03

    Uliza kwa Kiingereza rahisi

    *“Ongeza Didit KYC kwenye mtiririko wangu wa kujisajili.”* *“Chunguza mtumiaji huyu dhidi ya orodha za AML.”* Wakala anasoma ujuzi husika, anaandika code, na kuunganisha handler ya webhook iliyosainiwa. Sahihi mara ya kwanza, hakuna kubadilisha tab ya nyaraka.

  4. Hatua 04

    Mtumiaji anathibitisha

    Didit inasimamia kamera, upigaji wa hati, selfie, uhamishaji wa simu. Chini ya sekunde 30 kwa mtumiaji. Uamuzi wa chini ya sekunde 2 kwenye webhook yako, iliyosainiwa na `X-Signature-V2` ili uweze kuamini.

Ujuzi unakupa nini

Ujuzi kumi na mbili. Hakuna "hallucinations" kabisa. Kila API ya Didit.

Kila ujuzi ni faili moja ya Markdown inayofunga endpoint, headers, umbo la body, na status enum. Chanzo huria. Imewekwa toleo na API.
Vinjari ujuzi wote 12Tazama kwenye GitHub
01 · Katalogi

Ujuzi kumi na mbili. Mmoja kwa kila uwezo wa Didit.

Ujuzi mkuu kwa akaunti, sessions, workflows, na bili (endpoints 45+) pamoja na ujuzi kumi na moja tofauti kwa ID, liveness, face match, face search, umri, AML, barua pepe, simu, uthibitisho wa anwani, na uthibitisho wa database.
Katalogi kamili kwenye docs.didit.me
02 · Sakinisha

Amri moja ya npx. Imekamilika.

`npx skills add didit-protocol/skills` inasakinisha zote kumi na mbili. Ongeza `--skill didit-face-match` kuchagua moja. Unapendelea Git? `git clone` na nakili unachohitaji. Hupendi zana? Weka `SKILL.md` moja kwenye folda ya ujuzi ya agent wako.
Moduli ya Uthibitishaji wa Mtumiaji
03 · Hosts

Cursor, Claude Code, Codex, OpenCode.

Ujuzi uleule wa Markdown kila mahali. CLI inatambua kiotomatiki runtime yako na kuandika kwenye `.cursor/skills/` au `.claude/skills/`. Imejengwa kwenye kiwango huru cha [agentskills.io](https://agentskills.io), hakuna SDK ya muuzaji.
Workflow Orchestrator
04 · Hakuna kubahatisha

Ujuzi ndio chanzo cha ukweli.

Inafunga endpoint halisi, headers halisi, status casing halisi, bei za moja kwa moja. Agent inaacha kubuni njia na kupunguza herufi za enums. Endpoints 51 hujaribiwa kila toleo.
Moduli ya Uchunguzi wa AML
05 · Sanidi

Env var moja. Au jisajili mwenyewe.

`export DIDIT_API_KEY=…` na ujuzi umeunganishwa. Au ruhusu agent kujisajili yenyewe kupitia `POST /programmatic/register/` na kuchukua key bila kuacha terminal.
Pata API key
06 · Open source

Leseni ya MIT. Yako ya ku-fork.

Kila ujuzi unapatikana [github.com/didit-protocol/skills](https://github.com/didit-protocol/skills). Kagua code, badilisha prompts, tuma PR. Ujuzi unatolewa siku ileile endpoint inapotolewa.
github.com/didit-protocol/skills
Unganisha

Sakinisha ujuzi. Uliza wakala. Tuma.

Kushoto: usakinishaji. Kulia: cURL ambayo wakala anaandika mara tu ujuzi unapowekwa.
npx skills addSakinisha
$ npx skills add didit-protocol/skills
✓ Ujuzi 12 umesakinishwa

# or just one
$ npx skills add didit-protocol/skills \
  --skill didit-face-match

# set the api key
$ export DIDIT_API_KEY="sk_live_..."
OKTayariCursor, Claude Code, Codex, OpenCode imetambuliwa kiotomatiki.
Au `git clone` repo kwa udhibiti kamili.repo →
POST /v3/session/Matokeo ya Agent
$ curl -X POST https://verification.didit.me/v3/session/ \
  -H "x-api-key: $DIDIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "$DIDIT_WORKFLOW_ID",
    "vendor_data": "user-42",
    "callback_url": "https://app/cb"
  }'
201Imeundwa{ "url": "verify.didit.me/..." }
Imetengenezwa na skill ya `didit-kyc-onboarding`.docs →
Ujumuishaji tayari kwa agent

Sakinisha Didit Agent Skills zote 12 kwa prompt moja.

Bandika kwenye Cursor, Claude Code, Codex, au OpenCode. Wakala husakinisha ujuzi, huweka mazingira, huunda kiolezo cha kuunda kipindi + kishughulikiaji cha webhook kilichotiwa saini, na hujaribu dhidi ya API hai.
didit-integration-prompt.md
You are installing the Didit Agent Skills into this project and wiring the first verification session against the live https://verification.didit.me/v3/ API. After this prompt, the project should pass identity verification — Know Your Customer (KYC), Anti-Money Laundering (AML) screening, document Optical Character Recognition (OCR) — through Didit.

Didit ships twelve open-source Agent Skills at https://github.com/didit-protocol/skills and follows the open standard at https://agentskills.io. The CLI auto-detects whether you are running inside Cursor, Claude Code, Codex, or OpenCode and drops the skills into the right folder.

PRE-REQUISITES
  - A Didit API key (DIDIT_API_KEY). Either issued from https://business.didit.me, or self-registered by the agent via POST /programmatic/register/ + POST /programmatic/verify-email/ (no browser needed).
  - A workflow_id from the Workflow Builder that bundles ID Verification + Passive Liveness + Face Match + IP Analysis + AML — or just use the didit-kyc-onboarding skill below to create one programmatically.
  - A webhook endpoint that verifies the X-Signature-V2 header with HMAC-SHA256 on the raw body bytes (do NOT re-serialise the parsed JSON; the signature will not match).

STEP 1 — Install the skills

Recommended:

  npx skills add didit-protocol/skills

This installs all twelve skills. To install only one:

  npx skills add didit-protocol/skills --skill didit-face-match

Or git clone the repo and copy what you need:

  git clone https://github.com/didit-protocol/skills.git
  cp -r skills/didit-kyc-onboarding .claude/skills/
  cp -r skills/didit-id-document-verification .claude/skills/

The twelve skills:
  - didit-verification-management   : the hub. Account, sessions, workflows, billing, blocklist, webhook config. 45+ endpoints
  - didit-kyc-onboarding            : full KYC recipe (ID + selfie + face match) in one call
  - didit-id-document-verification  : passports, ID cards, driver's licences. OCR, MRZ, NFC. 4,000+ documents, 220+ countries
  - didit-liveness-detection        : 99.9%-accurate liveness from a single selfie
  - didit-face-match                : compare two faces, get a 0–100 score
  - didit-face-search               : 1:N face search for deduplication and blocklists
  - didit-biometric-age-estimation  : estimate age from a selfie
  - didit-email-verification        : email OTP, detects breached / disposable / undeliverable
  - didit-phone-verification        : phone OTP via SMS, WhatsApp, or Telegram. Catches VoIP
  - didit-aml-screening             : 1,300+ sanctions, PEP, adverse-media lists. Dual-score risk
  - didit-proof-of-address          : utility bills, bank statements. OCR + geocoding
  - didit-database-validation       : government databases across 18 countries

STEP 2 — Set the environment

Every skill reads DIDIT_API_KEY. Session-based skills also expect DIDIT_WORKFLOW_ID. Signed-webhook handlers expect DIDIT_WEBHOOK_SECRET.

  export DIDIT_API_KEY="<your api key>"
  export DIDIT_WORKFLOW_ID="<your workflow id>"   # optional
  export DIDIT_WEBHOOK_SECRET="<your secret>"     # optional

Programmatic alternative (no browser):

  curl -X POST https://apx.didit.me/auth/v2/programmatic/register/ \
    -H "Content-Type: application/json" \
    -d '{"email": "dev@example.com", "password": "MyStr0ng!Pass"}'

  # check the email, get the 6-char code, then:
  curl -X POST https://apx.didit.me/auth/v2/programmatic/verify-email/ \
    -H "Content-Type: application/json" \
    -d '{"email": "dev@example.com", "code": "<code>"}'
  # response includes api_key — export it as DIDIT_API_KEY.

STEP 3 — Create a verification session

  POST https://verification.didit.me/v3/session/
  Headers:
    x-api-key: $DIDIT_API_KEY
    Content-Type: application/json
  Body:
    {
      "workflow_id": "$DIDIT_WORKFLOW_ID",
      "vendor_data": "<your user id, max 256 chars>",
      "callback_url": "https://<your-app>/kyc/callback",
      "metadata": { "source": "agent-skill" }
    }

  Response: 201 Created. The hosted session URL is on the `url` field. Redirect the user, or send them the link by email / SMS / WhatsApp. Sub-2-second p99 verdict on completion.

STEP 4 — Read the signed webhook

Didit POSTs to your callback. KYC session statuses are Title Case With Spaces.

  Body (excerpted):
    {
      "session_id": "<uuid>",
      "vendor_data": "<your user id>",
      "status": "Approved",
      "id_verification": { "status": "Approved" },
      "liveness": { "status": "Approved" },
      "face": { "status": "Approved", "similarity_score": 0.94 },
      "aml": { "status": "Approved", "hits": [] }
    }

  Full enum:
    Approved | Declined | In Review | In Progress | Not Started | Abandoned | Expired | Resubmitted | Awaiting User | Not Finished

  Verify X-Signature-V2 BEFORE parsing the body — HMAC-SHA256 of the raw bytes with your webhook secret. Re-serialising the parsed body changes whitespace and key order and the signature will not match.

STEP 5 — Read the decision on demand

  GET https://verification.didit.me/v3/session/{sessionId}/decision/
  Headers:
    x-api-key: $DIDIT_API_KEY

Returns the full decision payload — id_verification, liveness, face, ip_analysis, aml. Use this whenever the agent needs to confirm the user's status before allowing an action. Never trust client-supplied "I'm verified" flags.

STEP 6 — Branch on status

  Approved      → continue
  Declined      → block, surface decision_reason_code, allow resubmit of the failed step
  In Review     → wait for the analyst webhook; don't block forever
  Resubmitted   → user re-took a failed step; new verdict is coming
  Awaiting User → user hasn't completed the flow; nudge with a reminder
  Expired       → create a new session

Abandoned and Declined sessions are NOT billed.

STEP 7 — Optional: ongoing AML monitoring

If AML monitoring is enabled on the workflow ($0.07 per user per year), Didit fires status.updated whenever the user lands on a new sanctions / PEP / adverse-media list. No extra endpoint to call.

WEBHOOK EVENT NAMES
  - status.updated       : KYC or KYB session status changed
  - data.updated         : session data corrected after creation
  - user.status.updated  : User entity changed status (Active, Flagged, Blocked)
  - user.data.updated    : User entity counters, metadata, or aggregate fields changed
  - activity.created     : timeline activity recorded

Verify X-Signature-V2 on every payload. The webhook secret is per-environment — sandbox is separate from production.

CONSTRAINTS
  - KYC session statuses use Title Case With Spaces (Approved, In Review). Do NOT transform them to UPPER_SNAKE_CASE — that casing is for Know Your Business (KYB) sessions and Transaction Monitoring, not KYC.
  - HMAC verification runs against the RAW request body bytes. Never re-serialise the parsed JSON.
  - Bundle price is $0.30 (ID + Liveness + Face Match + IP Analysis). AML adds $0.20. 500 verifications free every month, forever.
  - Default record retention is unlimited unless you configure it shorter (30 days to 10 years per application).

Read the docs:
  - https://docs.didit.me/getting-started/agent-skills
  - https://docs.didit.me/sessions-api/create-session
  - https://docs.didit.me/sessions-api/retrieve-session
  - https://docs.didit.me/integration/webhooks

Skills repo:
  - https://github.com/didit-protocol/skills

Start free at https://business.didit.me — sandbox key in 60 seconds, 500 verifications free every month, no credit card.
Inatii kwa muundo

Fungua nchi mpya kwa kubofya mara moja. Tunafanya kazi ngumu.

Tunafungua kampuni tanzu za ndani, tunapata leseni, tunafanya majaribio ya kupenya, tunapata vyeti, na tunalingana na kila kanuni mpya. Ili kusafirisha uthibitishaji katika nchi mpya, geuza swichi. Nchi 220+ ziko hewani, zinakaguliwa na kupimwa kila robo mwaka, mtoa huduma pekee wa utambulisho ambaye serikali ya nchi mwanachama wa EU imemwita rasmi kuwa salama zaidi kuliko uthibitishaji wa ana kwa ana.
Soma faili ya usalama na utiifu
EU financial sandbox
Tesoro · SEPBLAC · BdE
ISO/IEC 27001
Usalama wa habari · 2026
SOC 2 · Type I
AICPA · 2026
iBeta Level 1 PAD
NIST / NIAP · 2026
GDPR
EU 2016/679
DORA
EU 2022/2554
MiCA
EU 2023/1114
AMLD6 · eIDAS 2.0
EU-aligned kwa muundo

Namba za uthibitisho

Namba za uthibitisho
  • 0
    Open-source Agent Skills. Moja kwa kila uwezo wa Didit.
  • 0
    API endpoints zimefunikwa. Zote hujaribiwa kila toleo.
  • <0s
    Uamuzi wa KYC wa mwisho hadi mwisho kwa kila session kwenye p99.
  • 0
    Uthibitishaji wa bure kila mwezi, kwenye kila akaunti.
Ngazi tatu, orodha moja ya bei

Anza bure. Lipa kulingana na matumizi. Panua hadi Enterprise.

Uthibitishaji 500 bila malipo kila mwezi, milele. Lipa kadri unavyotumia kwa uzalishaji. Mikataba maalum, uhifadhi wa data, na SLA (Service Level Agreements) kwenye Enterprise.
Bure

Bure

$0 / mwezi. Hakuna kadi ya mkopo inayohitajika.

  • Kifurushi cha bure cha KYC (Uthibitishaji wa Kitambulisho + Passive Liveness + Face Match + Uchambuzi wa Kifaa & IP), 500 / mwezi, kila mwezi
  • Watumiaji Waliozuiwa
  • Utambuzi wa Marudio
  • Ishara 200+ za udanganyifu kwenye kila session
  • KYC inayoweza kutumika tena kwenye mtandao wa Didit
  • Jukwaa la Usimamizi wa Kesi
  • Workflow Builder
  • Nyaraka za umma, sandbox, SDKs, server ya MCP (Model Context Protocol)
  • Usaidizi wa jamii
Anza bure
Maarufu zaidi
Lipa kulingana na matumizi

Kulingana na Matumizi

Lipa tu kwa unachotumia. Moduli 25+. Bei za umma kwa kila moduli, hakuna ada ya chini ya kila mwezi.

  • KYC kamili kwa $0.33 (Kitambulisho + Biometric + IP / Kifaa)
  • Data za AML 10,000+, vikwazo, PEPs, habari hasi
  • Vyanzo vya data vya serikali 1,000+ kwa Uthibitishaji wa Database
  • Ufuatiliaji wa Miamala kwa $0.02 kwa kila muamala
  • KYB ya moja kwa moja kwa $2.00 kwa kila biashara
  • Uchunguzi wa Wallet kwa $0.15 kwa kila ukaguzi
  • Mtiririko wa uthibitishaji wa Whitelabel, brand yako, miundombinu yetu
Tazama orodha kamili ya beiAnza bure
Biashara Kubwa

Biashara Kubwa

MSA & SLA maalum. Kwa idadi kubwa na programu zilizodhibitiwa.

  • Mikataba ya kila mwaka
  • MSA, DPA, na SLA maalum
  • Kituo maalum cha Slack na WhatsApp
  • Wakaguzi wa mikono wanapohitajika
  • Masharti ya muuzaji na white-label
  • Vipengele vya kipekee na ushirikiano wa washirika
  • CSM aliyetajwa, ukaguzi wa usalama, usaidizi wa kufuata
Wasiliana nasi

Anza bure → lipa tu wakati ukaguzi unafanyika → fungua Enterprise kwa mkataba maalum, SLA, au uhifadhi wa data.

FAQ

Maswali ya kawaida

What is Didit?

Didit is infrastructure for identity and fraud, the platform we wished existed when we were building products ourselves: open, flexible, and developer-friendly, so it works as a real part of your stack instead of a black box you integrate around.

One API covers verifying people (KYC, know your customer), verifying businesses (KYB, know your business), screening crypto wallets (KYT, know your transaction), and monitoring transactions in real time, on a stack built to be:

  • Fast, sub-2-second p99 on every session
  • Reliable, in production with 1,500+ companies across 220+ countries
  • Secure, SOC 2 Type 1, ISO 27001, GDPR-native, and formally attested by Spain's financial regulator as safer than verifying someone in person

The footprint underneath: 14,000+ document types in 48+ languages, 1,000+ data sources, and 200+ fraud signals on every session. The Didit infrastructure dynamically learns from every session and gets better every day.

What is an Agent Skill?

A small Markdown file that teaches your AI agent how to call one of Didit's APIs, endpoint, headers, body shape, error cases, with working code in TypeScript, Python, and cURL.

Install it once. The next time you ask Cursor or Claude Code “add KYC to my signup flow”, the agent reads the skill and writes the right code on the first try. No tab-switching to docs. No invented endpoints. No wrong status casing.

It's the Agent Skills open standard. Didit ships twelve of them, free and open-source at github.com/didit-protocol/skills.

What can the twelve skills do?

One skill per Didit capability, twelve in total, 51 endpoints tested end-to-end:

  • `didit-verification-management`, the hub. Account setup, workflows, sessions, billing, blocklist, webhooks (45+ endpoints)
  • `didit-kyc-onboarding`, full KYC recipe (ID scan + selfie + face match) in one go
  • `didit-id-document-verification`, passports, ID cards, driver's licences. OCR, MRZ, NFC. 4,000+ document types, 220+ countries
  • `didit-liveness-detection`, 99.9% accurate liveness from a single selfie
  • `didit-face-match`, compare two faces, get a 0–100 score
  • `didit-face-search`, 1:N face search for deduplication and blocklists
  • `didit-biometric-age-estimation`, estimate age from a selfie
  • `didit-email-verification`, OTP, detects breached and disposable addresses
  • `didit-phone-verification`, SMS, WhatsApp, or Telegram OTP. Catches VoIP
  • `didit-aml-screening`, 1,300+ sanctions, PEP, and adverse-media lists
  • `didit-proof-of-address`, utility bills, bank statements, OCR with geocoding
  • `didit-database-validation`, government databases across 18 countries

Install the lot in one command: npx skills add didit-protocol/skills. Install just one: npx skills add didit-protocol/skills --skill didit-face-match.

How fast is the verification for my end user?

The full flow normally takes under 30 seconds end-to-end, pick up the ID, snap the document, snap the selfie, done. That is the fastest in the market. Legacy KYC providers usually take more than 90 seconds for the same flow.

On the back end, Didit returns the result in under two seconds at p99, measured from the moment the user finishes the selfie to the moment your webhook fires. Mobile capture is tuned for slow phones and slow networks: progressive image compression, lazy software development kit load, and a one-tap hand-off from desktop to phone via QR code if the user starts on web.

Which agents work with the skills?

Cursor, Claude Code, Codex, and OpenCode, plus anything that follows the agentskills.io open standard.

The npx CLI detects your agent and drops the skill into the right place, .claude/skills/, .cursor/skills/, and so on. Same Markdown file everywhere, no host-specific SDK.

Under the hood every skill points at the same https://verification.didit.me/v3/* API with the same x-api-key header and the same signed webhook. The skill is just how the agent reads it.

What happens if a user fails, abandons, or expires?

Every session lands on one of seven clear statuses, so your code always knows what to do:

  • Approved, every check passed. Move the user forward.
  • Declined, one or more checks failed. You can allow the user to resubmit the specific failed step (for example, re-take the selfie) without re-running the whole flow.
  • In Review, flagged for compliance review. Open the case in the console, see every signal, decide approve or decline.
  • In Progress, user is mid-flow.
  • Not Started, link sent, user has not opened it yet. Send a reminder if it sits too long.
  • Abandoned, user opened the link but did not finish in time. Re-engage or expire.
  • Expired, the session link aged out. Create a new session.

A signed webhook fires on every status change, so your database always stays in sync. Abandoned and declined sessions are free.

Where does my customer data live and how is it protected?

Production data is processed and stored in the European Union by default, on Amazon Web Services. Enterprise contracts can request alternative regions for jurisdictions whose regulators require it.

Encryption everywhere. AES-256 at rest across every database, object store, and backup. Transport Layer Security 1.3 in transit on every API call, webhook, and Business Console session. Biometric data is encrypted under a separate Customer Master Key.

Retention is yours to control. Default retention is indefinite (unlimited) unless you configure shorter, between 30 days and 10 years per application, and you can delete any individual session at any time from the dashboard or the API.

Certifications: SOC 2 Type 1 (Type 2 audit in progress), ISO/IEC 27001:2022, iBeta Level 1 PAD, and a public attestation from Spain''s Tesoro / SEPBLAC / CNMV that Didit''s remote identity verification is safer than verifying someone in person. Full report at /security-compliance.

Is Didit compliant for my industry?

Didit ships compliant by default for the regulators that matter to identity infrastructure:

  • GDPR + UK GDPR, controller / processor split, full Data Processing Agreement published, lead supervisory authority named (Spain''s AEPD).
  • AMLD6 + EU AML Single Rulebook, 1,300+ sanctions, politically exposed person, and adverse-media lists screened in real time.
  • eIDAS 2.0, EU Digital Identity Wallet aligned; reusable-identity ready.
  • MiCA (Markets in Crypto-Assets), ready for crypto on-ramps, exchanges, and custodians.
  • DORA, Digital Operational Resilience Act, EU financial-services operational resilience.
  • BIPA, CUBI, Washington HB 1493, CCPA / CPRA, US biometric privacy (Illinois, Texas, Washington) and California consumer privacy.
  • UK Online Safety Act, age-gating and child-safety obligations.
  • FATF Travel Rule, originator and beneficiary data on crypto transfers, IVMS-101 interoperable.

Detailed memo, every certificate, every regulator letter: /security-compliance.

How fast can I integrate and start verifying users?
  • 60 seconds to a sandbox account at business.didit.me, no credit card.
  • 5 minutes to a working verification through Claude Code, Cursor, or any coding agent via our Model Context Protocol (MCP) server.
  • A weekend to a production-ready integration with signed-webhook verification, retries, and a remediation flow when a user is declined.

Three integration paths, pick whichever fits your stack:

  • Embed natively with our Web, iOS, Android, React Native, or Flutter SDK.
  • Redirect the user to the hosted verification page, zero SDK.
  • Send a link by email, SMS, WhatsApp, or any channel, zero front-end work.

Same dashboard, same billing, same pay-per-success price for all three. Step-by-step guide at docs.didit.me/integration/integration-prompt.

How does the install actually work?

One command:

``bash npx skills add didit-protocol/skills ``

The CLI detects whether you're in Cursor, Claude Code, Codex, or OpenCode and drops every skill into the right folder. Install just one with --skill didit-face-match.

Prefer Git? git clone https://github.com/didit-protocol/skills and copy what you want. Prefer no tooling? Open the repo and copy a single SKILL.md into your agent's skill directory, every skill is self-contained.

The only env var every skill needs is DIDIT_API_KEY. Get one in 60 seconds at business.didit.me, or let the agent register itself programmatically via POST /programmatic/register/.

What does a real prompt look like?

Plain English, no jargon, no boilerplate:

  • “Register a Didit account for me”
  • “Create a KYC workflow with ID scan and liveness”
  • “Create a verification session for this user”
  • “Screen John Smith against AML databases”
  • “Check my credit balance”

The agent reads the relevant skill and writes production-ready code in TypeScript, Python, or Bash. No guesswork, the skill ships the exact endpoint, header, body, and status enum.

Why use a skill, not just the docs?

Docs are written for humans. Agents trip on the same things over and over:

  • Invented endpoints, they make up POST /v3/wallet-screening/ when the real path lives inside /v3/transactions/
  • Wrong status casing, KYC is Approved, KYB is APPROVED, agents mix them up
  • Broken webhook signatures, they re-serialise the JSON before verifying the HMAC, which breaks the signature
  • Stale pricing, they quote old numbers from training data

Skills lock all of that. Versioned alongside the API: when Didit ships a new endpoint, the skill ships the same day. 51 endpoints tested, every release.

Related

Modules zinazohusiana + workflows

Miundombinu ya utambulisho na udanganyifu.

API moja kwa KYC, KYB, Ufuatiliaji wa Miamala, na Uchunguzi wa Wallet. Unganisha ndani ya dakika 5.

Anza bila malipoZungumza nasi
Uliza AI ifupishe ukurasa huu