MCP for KYC: Run Identity Verification in Natural Language

Know Your Customer (KYC) checks have always meant wiring an SDK, handling webhooks, and polling a decision endpoint. Didit's official Model Context Protocol (MCP) server collapses that work into a conversation. Point an AI agent — Claude Desktop, Claude Code, Cursor, or any MCP-capable client — at https://mcp.didit.me/mcp, and it can create a verification session, return the link your user opens, and poll the final decision, all from a natural-language prompt. Under the hood it runs the same document check, liveness, and face match that power onboarding for 1,500+ companies in production, at $0.33 for a full KYC verification. This post walks through what the MCP layer does, how an agent runs a KYC flow end to end, and how to connect it in a couple of minutes.

Key takeaways

• Didit's MCP server exposes 130+ tools across 11 categories over Streamable HTTP at https://mcp.didit.me/mcp — hosted or self-hosted.
• Authentication is OAuth 2.1 + Proof Key for Code Exchange (PKCE) — "Log in with Didit" via business.didit.me, with no API key for the hosted server. Access is user-scoped and respects your console role.
• An agent can create a KYC session, surface the verification link, and poll the decision without you writing polling or webhook code.
• A full KYC verification (ID document + passive liveness + face match) costs $0.33, with 500 free verifications every month and sub-2-second inference.
• Setup in Claude Code is one command: claude mcp add --transport http didit https://mcp.didit.me/mcp, then /mcp to log in.
• The MCP layer itself is free — you only pay per successful verification.

What the Didit MCP server is

The Model Context Protocol is an open standard that lets AI agents call external tools through a consistent interface. Didit's implementation is the official MCP server for the identity and fraud platform, published under the MIT license at github.com/didit-protocol/mcp. It speaks Streamable HTTP at the production endpoint https://mcp.didit.me/mcp, and you can run it hosted or self-host it in your own environment.

It ships 130+ tools across 11 categories: Discovery, Sessions (KYC and KYB), Workflows & Questionnaires, Standalone Verification, Transaction Monitoring & Anti-Money Laundering (AML), Vendor Users & Businesses, Lists (blocklist and allowlist), Cases, Reports/Audit/Alerts, Webhooks, and Workspace/Billing. For a KYC flow you'll mostly touch Discovery (to find your workflows) and Sessions.

Authentication without an API key

The hosted server uses OAuth 2.1 with PKCE — the "Log in with Didit" flow through business.didit.me. There is no API key to paste into a config file for the hosted setup. When your agent first connects, it opens a browser, you approve access, and the token is scoped to your user. That means the agent can only do what your console role already permits, across two scopes: didit:management and didit:verification. If you're a read-only member, the agent inherits read-only access. This user-scoped model keeps automation inside the same permission boundaries as the console UI.

Running a KYC session in natural language

A KYC session in Didit bundles the core identity checks: an ID document verification, passive liveness to confirm a real person is present, and a 1:1 face match between the selfie and the document portrait. Once the MCP server is connected, you don't call these individually — you describe the outcome you want and let the agent orchestrate the tools.

A realistic prompt looks like this:

"Create a KYC verification session for our standard onboarding workflow, give me the link to send to the applicant, then check back and tell me the decision once they've finished."

The agent calls the session-creation tool, which returns a hosted verification URL. You forward that link to your applicant (or drop it into your onboarding email). When they complete the flow — snapping their ID and a selfie — the agent uses the session-retrieval tools to poll status and report the verdict: approved, declined, or in review, with the extracted document fields and match score. No webhook endpoint, no cron job, no manual polling loop on your side.

For higher-volume work, you can ask the agent to batch: "Create ten KYC sessions for these applicants and give me a table of links." Because the tools are composable, the agent handles the fan-out and collates the results.

Connecting your MCP client

Claude Code connects with a single command:

claude mcp add --transport http didit https://mcp.didit.me/mcp

Then run /mcp inside Claude Code to trigger the "Log in with Didit" OAuth flow. Once authenticated, the Didit tools appear in your session.

For Claude Desktop, Cursor, VS Code, Windsurf, and Zed, add a JSON entry pointing at the same Streamable HTTP URL:

{
  "mcpServers": {
    "didit": {
      "type": "http",
      "url": "https://mcp.didit.me/mcp"
    }
  }
}

ChatGPT Developer Mode support is available through OpenAI's beta connector flow; because that surface is still in beta, expect the connection steps to shift as OpenAI iterates. The full client matrix and the latest configuration snippets live in the MCP overview docs.

What KYC actually checks

When you run ID Verification through a KYC session, the platform reads the document against 14,000+ supported document types across 220+ countries and territories, in 48+ languages. Passive liveness confirms the selfie is a live capture rather than a photo of a photo or a screen replay. Face match scores the selfie against the document portrait. The combined result is a single decision your agent reports back, backed by 200+ fraud signals and sub-2-second inference.

Because it's the same engine used in production onboarding, the MCP path isn't a sandbox toy — the decision an agent returns is the decision you'd act on. You can also route sessions through a custom workflow so the agent triggers additional modules (proof of address, AML screening, database validation) when your risk logic calls for them.

Pricing and where the MCP layer fits

A full KYC verification — ID document, passive liveness, and face match — is $0.33. Every account gets 500 free verifications per month, and the MCP server itself adds no cost: you pay only for successful verifications, whether they're triggered from the console, the API, an SDK, or an agent. That makes MCP an easy way to prototype an identity flow. You can wire it into an agent, run a handful of real sessions inside your free tier, and confirm the decisions before you touch a line of integration code.

Didit is Y Combinator W26, has raised $7.5M, is profitable, and runs across 220+ countries with 14,000+ document types and 48+ languages — so the same MCP endpoint that helps you prototype scales to production volume without a replatform.

Start free

Spin up an AI agent, point it at https://mcp.didit.me/mcp, and run your first KYC session in natural language today. Create your workspace and start free — you get 500 verifications every month at no cost, no card required. Read the MCP overview, browse the server source, or explore the developer hub to see every tool your agent can reach.