Didit MCP server
Commit 15. Nov. 2026Ermöglicht es KI-Agenten, KYC-, KYB-, AML-Screening, Transaktionsmonitoring und Fraud-Workflows durch integrierte Verification-Tools durchzuführen.
Auch bekannt als didit-protocol/mcp, mcp
- Stars
- 1
- Tools
- 9
- Downloads, 30 Tage
- —
- Neueste Version
- 5.0.1
- Letzter Commit
- 15. Nov. 2026
- Lizenz
- MIT
Was ist Didit MCP?
Ermöglicht es KI-Agenten, KYC-, KYB-, AML-Screening, Transaktionsmonitoring und Fraud-Workflows durch integrierte Verification-Tools durchzuführen. Er stellt 9 Tools bereit, etwa npx, amount_in_dollars, confirm.
Zusammenfassung generiert aus dem README des Projekts
Über Didit MCP server
Der Didit MCP server gibt KI-Agenten die Möglichkeit, Identity- und Compliance-Workflows zu verwalten. Er integriert über 160 Tools für KYC, KYB, AML-Screening, Transaktionsmonitoring und biometrische Verifizierung. Entwickler können diesen Server mit Clients wie Claude, Cursor, VS Code, Windsurf und Zed nutzen, um komplexe Verifizierungsprozesse zu automatisieren.
Nutzer können sich über eine gehostete URL via OAuth 2.1 für den Zugriff auf persönliche Accounts verbinden oder einen Application API Key für Headless-Agenten in CI/CD-Umgebungen bereitstellen. Um den Token-Verbrauch zu steuern, bietet der Server ein Core-Toolset mit etwa 30 Tools an, während der vollständige Katalog weiterhin über ein Search-Tool zugänglich bleibt. Für sicherheitskritische Umgebungen steht ein Read-only-Modus zur Verfügung, um jegliche Statusänderungen während der Agenten-Interaktionen zu verhindern.
Was du damit machen kannst
- 1Identity-Verification-Workflows automatisierenEin KI-Agent kann Verifizierungssessions innerhalb einer Sandbox-Umgebung erstellen und verwalten, um die Compliance-Logik zu testen.
- 2Token-Verbrauch optimierenDu kannst die Anzahl der in den KI-Kontext geladenen Tools einschränken, um die Token-Kosten während einer Session zu reduzieren.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du Didit MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenDidit MCP in Claude Code installieren
$ claude mcp add --transport http mcp https://mcp.didit.me/mcpDidit MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"mcp": {
"url": "https://mcp.didit.me/mcp"
}
}
}Didit MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"mcp": {
"type": "http",
"url": "https://mcp.didit.me/mcp"
}
}
}Didit MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"mcp","type":"http","url":"https://mcp.didit.me/mcp"}'Didit MCP in Codex installieren
$ codex mcp add mcp --url https://mcp.didit.me/mcpDidit MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.mcp] url = "https://mcp.didit.me/mcp"
Didit MCP in Gemini CLI installieren
$ gemini mcp add -s user --transport http mcp https://mcp.didit.me/mcpDidit MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"mcp": {
"url": "https://mcp.didit.me/mcp",
"type": "http"
}
}
}Didit MCP tools 9
Erkannt aus dem READMEnpxamount_in_dollarsconfirmpayment_methodidempotency_keyagent_top_up_not_enabledauthentication_requiredpayment_method_requiredcard_declined
| npx | — | |
| amount_in_dollars | — | |
| confirm | — | |
| payment_method | — | |
| idempotency_key | — | |
| agent_top_up_not_enabled | — | |
| authentication_required | — | |
| payment_method_required | — | |
| card_declined | — |
Konfiguration
DIDIT_ACCESS_TOKEN
| Name | Beschreibung | Typ |
|---|---|---|
| DIDIT_ACCESS_TOKEN | — |
Automatisierte Checks
Geluften am 13. Nov. 2026Vollständiger Bericht →Noch nicht verifiziert. Ein Server benötigt einen Score von 80, keine kritischen Befunde und genug Daten für unsere Prüfung. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbardidit-protocol/mcp is public and reachablegithub.com/didit-protocol/mcp ↗Bestanden
- Paket nennt dieses Repository als QuelleNicht geprüft
- Build-Provenienz (Sigstore-Attestierung)Nicht geprüft
- Open Source Lizenz (OSI)MITspdx.org/licenses/MIT.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit or release 2026-11-11github.com/didit-protocol/mcp ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
- Keine versteckten Anweisungen an das Modell9 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertNo tool named like delete, drop or execBestanden
- Remote-Endpoint beantwortet den MCP-HandshakeHTTPS endpoint answered 401 (sign-in required)Bestanden
README
Auf GitHub ansehenDidit MCP Server
The official Model Context Protocol server for Didit — bring KYC, KYB, AML screening, transaction monitoring, biometrics, and full workspace operations to Claude, Cursor, VS Code, Windsurf, Zed, and any MCP client.
- 160+ tools across sessions, workflows, vendor users/businesses, transactions, the standalone verification APIs, lists, cases, reports, webhooks, and billing.
- Load only what you need. Add
?toolsets=corefor a short catalog of about 30 tools, about a tenth of the tokens the full list costs; the rest stays one step away throughdidit_tool_search. See Toolsets. - Read-only mode for connections that must never change anything: add
?read_only=true. - Two ways to connect. "Log in with Didit" (OAuth 2.1 + PKCE): the MCP acts as the signed-in user with their role's permissions. Or an application API key, for agents that run with no person present (CI, scheduled jobs, backend agents): the connection is that one application. See Authentication.
- Tools call Didit REST endpoints. Session PDF generation returns a temporary download URL for the original PDF.
Full documentation: https://docs.didit.me/integration/mcp/overview
Session PDF downloads
didit_session_generate_pdf returns download_url, expires_at (UTC), and
expires_in (300 seconds). Fetch the URL without an Authorization header to save
the original Didit PDF. The server checks PDF access before issuing the link and
fetches the original report again at download time using the same user and organization.
It does not reconstruct the report from session data. If the session changes between
issuance and download, the download reflects the current report. Revoked or expired
user access can invalidate a link before its five-minute expiry.
Deployments must set MCP_PDF_DOWNLOAD_KEY to 32 cryptographically random bytes
encoded as 64 hexadecimal characters, shared across all replicas, and set
MCP_RESOURCE_URI to the public HTTPS MCP endpoint. Route
/downloads/session-report.pdf to this HTTP server. The authenticated-encryption
key protects the credentials embedded in the session-scoped link; rotating it
invalidates outstanding links. Treat links as secrets and redact the token query
parameter in proxy/access logs. Responses use Cache-Control: no-store.
E-signature files
didit_session_get_signature_evidence, didit_session_get_signed_document and
didit_session_get_signature_field_image return the same kind of link (plus content_type)
for a signer's evidence PDF, the signed PDF of one document and the PNG of a signature field.
They use the same MCP_PDF_DOWNLOAD_KEY and MCP_RESOURCE_URI; route
/downloads/session-signature to this HTTP server as well. The file is checked against its
recorded SHA-256 at issuance and again at download. didit_session_validate_signatures
re-validates the signed documents and returns the result as JSON.
Stdio deployments need a reachable HTTP deployment with the same key, API base URL,
and MCP_RESOURCE_URI; stdio alone cannot serve download links. Missing key
configuration produces an actionable tool error instead of inline PDF data.
Quick start
Hosted (recommended)
No install, no API key — point your client at the hosted URL and sign in via the browser:
https://mcp.didit.me/mcp
| Client | Install |
|---|---|
| Claude (web, Desktop) | Add Didit to Claude |
| Claude Code | claude mcp add --transport http didit https://mcp.didit.me/mcp |
| Cursor | Add Didit to Cursor |
| VS Code (GitHub Copilot) | Add Didit to VS Code |
| OpenAI Codex | codex mcp add didit --url https://mcp.didit.me/mcp |
Cursor (~/.cursor/mcp.json), by hand
{ "mcpServers": { "didit": { "url": "https://mcp.didit.me/mcp" } } }
Windsurf / Zed (via the mcp-remote bridge)
{ "mcpServers": { "didit": { "command": "npx", "args": ["-y", "mcp-remote@latest", "https://mcp.didit.me/mcp"] } } }
See per-client setup for every client, with screenshots and troubleshooting.
Once connected, ask for "my Didit context" (the model calls didit_context_get), or start from one of the server's prompts: integrate_didit, review_queue, explain_session, build_workflow, verification_report.
Sign in without a browser (device code)
For the local (stdio) server on a remote machine, in a container or in CI, where no browser can open, sign in with an OAuth device code. It also works for accounts that use a passkey or SSO and have no password.
npx -y @didit-protocol/mcp-server login
The terminal prints a short code and a link:
To connect this machine to your Didit account, open https://business.didit.me/device and enter the code WDJB-MJHT
Or open: https://business.didit.me/device?user_code=WDJB-MJHT
Approve only if the code on the page matches this one.
Open the link on any device with a browser, sign in to Didit, check that the code matches and approve. The command then saves your credentials and prints the scopes that were granted (never the token). Approve only a code you started yourself.
- Credentials live in
~/.config/didit/mcp-credentials.json(override withDIDIT_MCP_CREDENTIALS_FILE), readable by you only, one entry per Didit environment. - The local server uses them automatically when
DIDIT_ACCESS_TOKENis not set, and refreshes them before they expire. npx -y @didit-protocol/mcp-server logoutrevokes the grant and deletes the stored credentials.- Set
DIDIT_DEVICE_NAMEto change the name shown on the approval page (default: the machine's hostname). - In CI, run
loginonce on a trusted machine and mount the credentials file as a secret, or setDIDIT_ACCESS_TOKENas before. Do not share one credentials file between jobs that run at the same time, because refresh tokens rotate. - No shell? Ask the agent to call
didit_account_device_login_start, show you the link and code, thendidit_account_device_login_pollonce you approve. Both tools exist only on the local server.
Sign in with the account tools
On the local server an agent can also sign in by itself, with an email address and a password: didit_account_login for an existing account (then didit_account_verify_2fa when the account has an authenticator app), or didit_account_register and didit_account_verify_email for a new one.
The local server keeps that sign-in, so the tools that follow are authenticated with nothing passed between them.
- It is kept in the same credentials file as a device-code sign-in (
~/.config/didit/mcp-credentials.json, readable by you only) and refreshed before it expires. A server started later picks it up. - The answer of these tools carries no refresh token: the server holds it, because a refresh token works once.
- When the file cannot be written (a read-only home directory in a container), the sign-in is kept in memory until the server stops.
- If you signed in both ways, the server uses the more recent sign-in.
DIDIT_ACCESS_TOKEN, when set, still takes precedence over both. npx -y @didit-protocol/mcp-server logoutremoves it from the machine.- An account that signs in with a passkey or SSO has no password: use the device code above.
These tools exist only on the local server. The hosted server never takes a password.
Connect with an API key (headless agents and CI)
An agent that runs with no person present has no browser to sign in with.
It connects to the hosted server with the application API key it already sends to the Didit API, in the x-api-key header:
Claude Code
claude mcp add --transport http didit https://mcp.didit.me/mcp --header "x-api-key: $DIDIT_API_KEY"
Cursor (~/.cursor/mcp.json)
{ "mcpServers": { "didit": { "url": "https://mcp.didit.me/mcp", "headers": { "x-api-key": "${env:DIDIT_API_KEY}" } } } }
Any other client or your own agent: send x-api-key: <key> on every request to https://mcp.didit.me/mcp.
Authorization: Bearer <key> works too, for clients that only let you set a bearer token.
What an API key connection is:
- One application.
The connection acts on the application the key belongs to, so there are no ids to pass.
didit_context_getnames it, says whether it isliveorsandbox, and reportsconnection.type: "api_key". A call that names another organization or application is refused. - The key's own access. The key is forwarded to the Didit API exactly as on a direct API call, and the API decides what it may do. A full-access key reaches everything of its application; a restricted key only the resources it was given. Give an agent a restricted key with an expiry, created in the Didit console under the application's API keys.
- Sandbox first. Connect with the sandbox application's key to build and test: every check is simulated and nothing is billed.
- Combines with toolsets and read-only:
https://mcp.didit.me/mcp?toolsets=core&read_only=true(see Toolsets). - Revoked like any key. Revoke or rotate the key in the console and the connection stops within a minute. Every tool call is logged with the key's id, never the key.
What needs a person, and is therefore neither listed nor run on an API key connection:
- members, roles and API key management;
- the organization's plan, cards, receipts and billing details;
- the audit log, and
didit_workflow_build_graph(usedidit_workflow_create, or the graph toolsdidit_workflow_create_draft,didit_workflow_validate_graphanddidit_workflow_set_graph); - download links for session PDFs and e-signature files (request the file from the Didit API with the same key).
A person does those in the Didit console, or through a connection that signs in with OAuth.
Two limits to know:
- A key limited to specific IP addresses is refused, because the Didit API would see this server's address and not yours.
/mcpand/mcp/paymentstake a key. From nothing to a first verification, with no browser. The account tools of the local server create the account:didit_account_register, thendidit_account_verify_emailwith the code sent to the email address. The answer carries the new organization with its live and its sandbox application, each with its API key. The local server is signed in from that moment (see Sign in with the account tools), so the same conversation goes on to create a workflow (didit_workflow_create) and a session (didit_session_create) in the sandbox application. For an agent that runs elsewhere, store the keys in your secret store and connect it to the hosted server with the sandbox key; switch to the live key to go live.didit_org_get_balancereads the credit balance; when credit is needed, see Agent payments.
GET /healthz lists api_key under features on a server that accepts keys.
Authentication
The MCP is an OAuth 2.1 resource server; the Didit console (business.didit.me) is the authorization server. On first connect your client opens a browser, you Log in with Didit and approve the scopes, and the MCP then acts as you — across every organization you belong to, with your role's permissions. Tokens are short-lived and refreshed automatically.
Scopes: didit:management (workspace operations), didit:verification (running checks) and didit:staff (Didit staff accounts only; the authorization server never issues it to anyone else). Your console role is enforced server-side on every call.
The hosted server also takes an application API key in place of a sign-in, for agents that run with no person present. Such a connection is one application with the key's own access, not a user with a role: see Connect with an API key.
The phone code pair,
didit_verify_phone_sendanddidit_verify_phone_check, always calls the public phone API with the application's API key, because the console has no route for them. On a sign-in the MCP reads that key with your sign-in (a role withcreate:sessionsand thedidit:managementscope, or an organization owner or admin for a localdidit_account_logintoken); on an API key connection it uses the connection's own key. The key is never returned, stored or logged.
See Authentication.
Toolsets
By default a connection lists every tool your role may use, as it always has. Tool definitions are sent to the model with every request, so the whole catalog costs tens of thousands of tokens each time: roughly 50,000 to 115,000, depending on the model's tokenizer. Some clients also cap how many tools they accept. The short catalog trades that cost for one more step, a search for the tool: measured on a set of everyday requests, the strongest models reached the right tool a little more often with the full list, at about ten times the tokens. When the cost matters (a coding agent with a context budget, a client that caps the number of tools), name the toolsets you want on the server URL:
https://mcp.didit.me/mcp?toolsets=core
https://mcp.didit.me/mcp?toolsets=core,workflows
https://mcp.didit.me/mcp?toolsets=core,transactions,cases&read_only=true
core is the short catalog: about 30 tools and about a tenth of the tokens.
It covers your organizations and applications, sessions (create, find, decide, explain, simulate in the sandbox, webhook deliveries), finding workflows, analytics and balance, the application's API key and webhooks, finding cases, users, businesses and transactions, and the documentation search.
| Toolset | What it holds |
|---|---|
core |
The short list above. |
account |
Organizations, applications, API keys, members and roles. |
billing |
Plan, credit balance, payment methods, receipts and billing details. |
sessions |
Verification sessions: create, find, decide, review, share, import, PDFs and webhook deliveries. |
workflows |
Verification workflows and questionnaires: build, edit, validate and publish. |
lists |
Custom lists, the blocklist and the allowlist. |
vendors |
The people and companies you verify: vendor users and vendor businesses. |
transactions |
Transaction monitoring: transactions, wallet screening and rules with backtesting. |
cases |
Case management: create, assign, escalate and resolve cases. |
investigator |
The AI Investigator: its review queue, reports, decisions, policy questions and performance. |
webhooks |
Webhook destinations and alerts. |
reports |
Analytics, exports and the audit log. |
branding |
White-label branding of the verification flow. |
verification |
Standalone verification APIs: ID document, face, AML, proof of address, phone, email, database and business checks. |
docs |
Search the Didit documentation. |
all |
Every tool your role may use. The default. |
How it behaves:
- Toolsets are opt-in. A URL with no
toolsetslists everything, so an existing connection sees no difference. - Naming toolsets lists exactly those.
?toolsets=caseslists the case tools (anddidit_context_get); addcoreto get the short list too. - A toolset decides what is listed, not what you may run. A tool outside the selection still runs when called by name, with the same permission checks as always. Nothing is lost by loading less.
- The rest stays one step away. When a connection lists only part of the catalog it also gets four discovery tools:
didit_tool_search(find a tool by what you want to do, or list a toolset),didit_tool_describe(its full schema),didit_tool_call_readanddidit_tool_call_write(run it). A call through them is checked exactly like a direct call. read_only=trueis a safety boundary. Only tools that read are listed or discoverable, and every call that would change data is refused, whatever the client lists or remembers. It works with or withouttoolsets.- An unknown toolset is ignored, never an error, and the server's instructions name it back with the valid ids.
- Clients that cannot edit the URL send the
X-MCP-ToolsetsandX-MCP-Readonlyheaders instead. - The local (stdio) server takes
--toolsets=core,workflowsand--read-only, or theDIDIT_TOOLSETSandDIDIT_READ_ONLYenvironment variables. - A self-hosted server can change what a connection gets when it names nothing with
MCP_DEFAULT_TOOLSETS(for examplecore). GET /healthzlists what the server supports ("features": ["toolsets", "read_only", ...]), for a client that wants to check before it relies on one.
The server also sends instructions on connect (where to start, how organization and application ids resolve, what this connection loaded) and offers prompts (integrate_didit, review_queue, explain_session, build_workflow, verification_report).
didit_docs_search searches the live documentation at docs.didit.me, so questions about how Didit works are answered from the current pages; set DIDIT_DOCS_MCP_URL to an empty string to switch it off.
Tools
160+ tools, grouped by toolset. The full catalogue with read/write/destructive markers is in docs/TOOLS.md and at docs.didit.me. Highlights:
- Discovery & cross-app:
didit_context_get,didit_session_search,didit_transaction_search,didit_vendor_user_search,didit_analytics— aggregate across every org/app in one call. - Sessions: create, list, get decision, update status, reviews, bulk import, webhook delivery log + resend (
didit_session_webhookswaits for a sandbox session's webhook so an integration can be verified end to end), Precise Location evidence (didit_session_get_location_evidence: every attempt and the same person's earlier checks behind a Location verdict). - Verification APIs:
didit_verify_id,didit_verify_aml,didit_verify_face_match,didit_verify_kyb_search, … - Workflows (incl. branching graphs):
didit_workflow_search,didit_workflow_get_graph,didit_workflow_edit_graph— build conditional/branching workflows (fuzzy-match conditions, Document-AI steps) by sending small ops; large feature configs are kept server-side, never resent.didit_workflow_get_id_verification_methods_cataloganddidit_workflow_get_kyb_registry_cataloganswer the server-driven questions a config write depends on (which countries offer non-doc lookup / wallets, which KYB data tiers and monitoring a country's registries sell). - Investigator (AI case reviewer):
didit_investigator_queue_list,didit_investigator_report_get(recommendation, basis, evidence, precedents),didit_investigator_record_get(the review of one verification or transaction, open or decided),didit_investigator_add_note(a fact the user adds, as a team note the next review reads), questions, the free backtest (didit_investigator_backtest_start), performance, dashboard and Activity. Its decisions (didit_investigator_accept,_override,_batch_accept), policy answers (_question_answer,_question_dismiss) and the re-review that replaces the open report (_rereview, optionally with a note) are annotated destructive and refused withoutconfirm: true, which a client sends only after the user approves that exact action. Every Investigator call sendsX-Didit-Actor-Via: mcp(orcopilotwhen the console assistant marks its request so), so the Investigator Activity shows where the user acted from. - Compliance: transaction monitoring, custom and preset rule management with backtesting, lists/blocklist/allowlist, cases, reports, audit logs, alerts.
- Workspace: questionnaires, webhooks, members, billing, branding.
- API key for your integration:
didit_org_create_api_keycreates ONE key per connected app and application, scoped to what the signed-in person can do (never full access or key management), rate-limited and audit-logged. The secret is returned once; the person sees the key with the connected app in the console and can revoke it there. - Billing:
didit_org_get_balance,didit_billing_get_plan,didit_billing_quote_plan,didit_billing_list_payment_methods,didit_billing_list_receipts,didit_billing_get_detailsanddidit_billing_update_details. No tool charges a card: when credit or a plan change is needed, the tools return console links (next_steps.top_up_urlopens the top-up dialog with the amount filled in) and the person pays there. The local stdio server and the unlisted/mcp/paymentsendpoint (below) also offerdidit_org_top_up.
Didit MCP Fragen
Wie füge ich Didit MCP zu Claude Code hinzu?
Führe claude mcp add --transport http mcp https://mcp.didit.me/mcp in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich Didit MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet Didit MCP?
Er stellt 9 Tools bereit, darunter npx, amount_in_dollars, confirm, payment_method, idempotency_key.
Kann ich die Anzahl der geladenen Tools einschränken, um Tokens zu sparen?
Ja, du kannst '?toolsets=core' an deine Connection-URL anhängen, um einen kleineren Katalog mit etwa 30 essenziellen Tools zu laden.
Gibt es eine Möglichkeit sicherzustellen, dass der Agent keine Daten ändern kann?
Ja, du kannst den Read-only-Modus nutzen, indem du '?read_only=true' an die Connection-URL anhängst.
Wie gehe ich bei PDF-Downloads in einer lokalen Deployment-Umgebung vor?
Lokale Deployments erfordern das Setzen von MCP_PDF_DOWNLOAD_KEY und MCP_RESOURCE_URI sowie das Routing spezifischer Pfade an einen HTTP-Server, um die Dateien bereitzustellen.