Using MCP Server

If you're building a product that needs to verify something about your users — that they own a GitHub account with 1,000+ followers, that their bank balance is above a threshold, that they have an order in their purchase history, or something else — you need a verification for it. In reclaim, we call such verifications "providers". Each provider has a unique providerId.

Once you have that providerId, your users can run the verification, generate a cryptographic proof, and share that proof with you — without ever handing you their password or a fakeable screenshot. You're the consumer: you consume the proofs your users produce.

The Reclaim MCP Server helps you find that right providerId which fits all your needs! It plugs into the AI agent you already use (Claude, Cursor, and others) and lets you, in plain English:

• Find a verification that already exists,
• Build a new one if it doesn't, and
• Fix one that isn't working.

This guide walks you through the whole thing.

How it fits together

  You (developer / consumer)
        │
        │  use your AI agent + Reclaim MCP server to…
        ▼
  ┌─────────────────────────────┐
  │  Find / Build / Fix a       │   ← this guide
  │  verification → providerId  │
  └─────────────────────────────┘
        │
        │  hand the providerId to your app
        ▼
  Your users run the verification → generate a proof → share it with you ✅

This guide covers the top box: getting a working providerId. Wiring it into your app so users can verify is a separate integration step — once you have a providerId, you're ready for it.

What you'll need

• We recommend installing Node.js 22.18 or newer (check with node -v; get it from nodejs.org if needed).
• A supported AI agent (Claude Code, Cursor, etc. — see below).

On the very first run, the agent downloads some helper files it needs to verify proofs. This takes a moment — just let it finish.

Step 1 — Connect Reclaim to your AI agent

Reclaim provides an MCP server: a small helper that gives your agent the Reclaim abilities. You set this up once. Pick your tool:

Claude Code

claude mcp add reclaim -s user -- npx -y --package=@reclaimprotocol/agent reclaim-mcp-server

Cursor

Add to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{
  "mcpServers": {
    "reclaim": {
      "command": "npx",
      "args": ["-y", "--package=@reclaimprotocol/agent", "reclaim-mcp-server"]
    }
  }
}

opencode

Add to ~/.config/opencode/opencode.json (global) or opencode.json (project):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "reclaim": {
      "type": "local",
      "command": ["npx", "-y", "--package=@reclaimprotocol/agent", "reclaim-mcp-server"],
      "enabled": true
    }
  }
}

Codex

codex mcp add reclaim -- npx -y --package=@reclaimprotocol/agent reclaim-mcp-server

Windsurf, VS Code, Cline, Antigravity & other MCP apps

They all use the same standard format. Open your app's MCP settings (or its config file) and add:

{
  "mcpServers": {
    "reclaim": {
      "command": "npx",
      "args": ["-y", "--package=@reclaimprotocol/agent", "reclaim-mcp-server"]
    }
  }
}

No API keys to set up in advance — the defaults work out of the box. The first time you do anything, a browser window opens the Reclaim dashboard and asks you to sign in once; your assistant captures that automatically and remembers it.

Make your assistant smarter at this (optional, recommended)

Reclaim ships a companion skill — expert instructions that make your assistant noticeably better at finding, building, and fixing verifications. Optional, but worth it.

For Claude Code:

# macOS / Linux
npm i -g @reclaimprotocol/agent
mkdir -p ~/.claude/skills/reclaim-provider
cp "$(npm root -g)/@reclaimprotocol/agent/skill/SKILL.md" ~/.claude/skills/reclaim-provider/SKILL.md

# Windows (PowerShell)
npm i -g @reclaimprotocol/agent
New-Item -ItemType Directory -Force $env:USERPROFILE\.claude\skills\reclaim-provider | Out-Null
Copy-Item "$(npm root -g)\@reclaimprotocol\agent\skill\SKILL.md" $env:USERPROFILE\.claude\skills\reclaim-provider\SKILL.md

Claude Code picks it up automatically next launch. On other tools, paste the contents of SKILL.md into the tool's custom instructions for the same depth (the server already includes built-in guidance, so this is optional).

Step 2 — Find an existing verification

Before building anything, check whether a verification already exists. Just ask:

List my Reclaim verifications.

or, to narrow it down:

Do I already have a verification for GitHub follower count?

Your assistant will look through the verifications on your account and show you what's there, including each one's providerId. If you find the one you need, you're done — grab the providerId and skip to Step 5.

Step 3 — Build a new verification

If nothing exists yet, just describe what you want to verify in plain language:

Build a Reclaim verification that proves a user's GitHub follower count.

or simply:

I want to verify GitHub follower count.

Here's what your assistant does behind the scenes — you don't manage any of it:

1. Signs in. A browser opens the Reclaim dashboard; you sign in once (or it reuses your saved session).
2. Opens the target site. It opens the website (e.g. github.com) and waits while you log in there.
3. Finds the data. It quietly records the page's network activity and locates the exact value you want to verify.
4. Drafts the verification. It builds a reusable recipe, keeping any private details safe.
5. Tests and publishes it. It runs a real cryptographic check to confirm the recipe works, then publishes it.

When it's done, you get a providerId — the handle you'll use everywhere else.

Your only manual steps are signing in when a browser window opens and confirming the exact value you want to verify. Everything else is automatic.

Step 4 — Fix a verification that isn't working

Websites change, and a verification that worked last month might stop. When that happens, you don't start over — you ask your assistant to fix it:

My GitHub follower-count verification stopped working — can you fix it?

It'll re-run the site, figure out what changed, repair the recipe, and publish an updated version under the same providerId. Your users keep using the same providerId as before — they just get the fixed version automatically.

This is also how you improve a verification (for example, tightening exactly what gets proven) without disrupting anything that already depends on it.

Step 5 — Put the providerId to work

The providerId from Steps 2–4 is what connects everything.

To let your users run verifications, you just need to hand this providerId in your app that integrates Reclaim — using the SDKs we provide. See Guides → JS SDK, Guides → Using JS SDK.

After integrating reclaim in your application, there your users can:

1. Start the verification for that providerId.
2. Log in to the site themselves and generate a proof — privately.
3. Share the finished proof with you.

Because each proof is cryptographic, you can trust it's genuine — your users never sent you their credentials, and the proof can't be faked or reused by someone else.

Common ways people use this

• Gate access or perks. Verify a user has a follower count, account age, or membership tier above some bar before unlocking a feature — without seeing the rest of their account.
• Prove eligibility. Confirm a user meets a threshold ("balance over X", "more than 1,000 followers") while keeping the underlying number private.
• Confirm ownership. Verify a user genuinely controls an account or has a specific order/transaction in their history.
• Reuse across users. One verification (one providerId) works for every user who needs that same proof — build it once, collect proofs forever.
• Keep verifications healthy. When a site changes, fix the verification in minutes and every integration stays on the same providerId.

Tips & troubleshooting

• First run feels slow? It's downloading the proof helper files one time. Later runs are fast.
• Asked to sign in again? Reclaim caches your dashboard login, but it expires periodically. Just sign in again when prompted.
• Prefer a permanent install over npx? Run npm i -g @reclaimprotocol/agent, then use reclaim-mcp-server directly as the command in your config (drop the npx wrapper).
• Stuck on a build? The companion skill above makes your assistant much better at the trickier sites — install it and try again.

In short

1. Connect Reclaim to your AI assistant (one command or one config block).
2. Find an existing verification, build a new one if it's missing, or fix one that broke.
3. Take the resulting providerId and wire it into your app.
4. Your users verify, generate proofs, and share them with you — passwords and screenshots never enter the picture. 🔒