proofsdocscomparepricinglog in

Documentation

Learn how to integrate proof.holdings

Core Primitives
The mental model in one page
API Reference
Complete API documentation
SDKs
Official client libraries
Smart Reuse
Skip re-verification with existing proofs
Multi-Profile System
Multiple public profiles per account
Message Templates
Custom branding and message templates per project
Comparison
vs SMS OTP, TOTP, WebAuthn
Pricing
Plans and pricing tiers
Security
Threat model and guarantees
MCP Server
176 tools for AI agents
Integrations
n8n, Zapier, Make, and custom integrations
Proof of Me
Anti-impersonation reverse verification via trusted Circle members
Proof of Delegation
A proven domain authorizing an artifact, and how to verify or withdraw it
Resources
GitHub Docs
API Status

MCP Server

176 tools for AI agents — verify assets, manage approvals, and automate trust workflows


What is MCP?

The Model Context Protocol (MCP) lets AI assistants call tools directly. The proof.holdings MCP server wraps our entire REST API into 176 structured tools that any MCP-compatible agent can use — Claude, LangChain, CrewAI, OpenAI Agents SDK, Cursor, Windsurf, and more.


Two ways to connect

There is a hosted server and a local one. They expose the same tools; what differs is what you have to install and how you authenticate.

Hosted (remote)Local (npm)
Installnothingnpx -y @proof-holdings/mcp-server
Credential to startnonenone (PROOF_API_KEY is optional)
How an account is reachedbrowser sign-in (OAuth) from the clientPROOF_API_KEY in the environment
TransportHTTPstdio

Start with the hosted server unless you need a local process — it needs no install, and signing in happens in the client rather than by pasting a key into a config file.

Hosted server

bash
claude mcp add --transport http proof https://api.proof.holdings/mcp

The connection succeeds immediately and anonymously. The first tool that needs an account answers with a 401 carrying an OAuth challenge, and the client offers to authenticate — in Claude Code that is /mcp → Authenticate. You sign in and approve the request in a browser; the client stores the result and sends it from then on.

Approving that request creates a scoped API key on your account, named after the client. Revoking access is deleting that key in the dashboard.

Local server

bash
npx -y @proof-holdings/mcp-server

It starts with no configuration. Supplying PROOF_API_KEY is what gives it an account from the first call.

VariableRequiredDefaultDescription
PROOF_API_KEYNo—Your API key (pk_live_* or pk_test_*). Without it the server still starts.
PROOF_BASE_URLNohttps://api.proof.holdingsAPI base URL

What works without an account

The server starts and lists all 176 tools whether or not it holds a credential — an agent can always see what is available. Ten tools then work with no account at all, in four groups:

  • Checking somebody else's proof — validate_proof verifies a signed token against our published keys, and list_revoked_proofs reads the revocation list.
  • Checking somebody else's delegation — verify_delegation answers whether one artifact is authorized by the domain it claims, and verify_delegations re-checks a set of them. This is the half an agent reaches for before installing something.
  • Signing in — start_login and wait_for_login run a browser or messenger sign-in and return a session.
  • Creating an account — create_account, send_account_email and wait_for_account_creation bootstrap a new account from inside the agent.

Plus render_auth_link, which formats a sign-in link locally and calls nothing.

The verification tools are open on purpose: the party checking a proof or a delegation is usually not our customer, and a check that required an account would not get run.

Everything else needs an account. Those tools do not fail obscurely: each says an account is needed and how to get one.

Signing in with start_login gives a session, and a session reaches 54 of the tools — the ones that act on your own account through the dashboard's own authentication. The remaining tools need an API key (or the hosted server's OAuth flow, which mints one).


Client setup

Claude Code CLI

bash
# hosted
claude mcp add --transport http proof https://api.proof.holdings/mcp

# local
claude mcp add proof-holdings -- npx -y @proof-holdings/mcp-server \
  --env PROOF_API_KEY=pk_live_YOUR_API_KEY

Claude Desktop, Cursor, Windsurf

Every client below takes the same two shapes. The hosted one needs no key:

json
{
  "mcpServers": {
    "proof": {
      "type": "http",
      "url": "https://api.proof.holdings/mcp"
    }
  }
}

The local one runs the package, and PROOF_API_KEY is optional — without it the server still starts and the keyless tools above work:

json
{
  "mcpServers": {
    "proof-holdings": {
      "command": "npx",
      "args": ["-y", "@proof-holdings/mcp-server"],
      "env": {
        "PROOF_API_KEY": "pk_live_YOUR_API_KEY"
      }
    }
  }
}

GET /api/v1/mcp/connect serves both fragments live, so an agent can read the current ones rather than copying from here.

Config file locations:

ClientConfig file
Claude Desktop (macOS)~/Library/Application Support/Claude/claude_desktop_config.json
Claude Desktop (Windows)%APPDATA%\Claude\claude_desktop_config.json
Cursor.cursor/mcp.json in your project
Windsurf~/.codeium/windsurf/mcp_config.json

Tool Overview (176 tools)

Group totals below are exact. The tables name the tools you are most likely to reach for rather than all 176 — an MCP client's own tools/list is the complete, current list, and it is the one the server answers from.

Verifications & requests (28 tools)

Asset control challenges, multi-channel phone verification, and the multi-asset B2B request flow.

ToolDescription
create_verificationCreate a new verification challenge
get_verificationGet verification status
submit_verification_codeSubmit a verification code
trigger_verificationTrigger a verification check
wait_for_verificationPoll until verification completes
create_multi_channel_verificationChallenge one phone across up to three channels, first completion wins
create_verification_requestCreate a multi-asset request
get_request_by_referenceGet a request by reference ID
share_request_emailEmail a request to its recipient

Domains & DNS (23 tools)

Domain control proofs, DNS provider credentials, and the email-based domain flow.

ToolDescription
add_domainAdd a domain to verify
verify_domainCheck the challenge record and mint the proof
connect_cloudflareConnect Cloudflare so records are written for you
verify_domain_with_credentialsProve control using stored provider credentials
setup_domain_emailSet up sending from the domain
list_dns_credentialsList stored DNS provider credentials

Account, settings & billing (37 tools)

Everything about your own account: usage, keys, contact identifiers, 2FA, and the agent account bootstrap.

ToolDescription
get_platform_summaryOne-call snapshot of the account
get_usageQuota and usage for the period
searchSearch across the account
create_accountBootstrap a new account from inside an agent
create_api_keyCreate a scoped API key
list_assetsList verified assets and their proof handles
start_2faBegin a 2FA step-up

HITL approvals & consent (22 tools)

Human-in-the-loop approvals, their end-to-end encrypted key material, and the consent layer underneath them.

ToolDescription
create_hitlCreate a human-approval configuration
create_confirmationSend an approval request to a person
wait_for_confirmationPoll until a person approves or denies
get_confirmation_approval_linkGet a fresh approval link
create_authorizationAsk a person to consent to being contacted
revoke_authorizationWithdraw a consent

Circles & Proof of Me (20 tools)

The people primitive: circles of trusted contacts, their channels, and cross-channel identity challenges.

ToolDescription
create_circleCreate a circle
add_circle_memberAdd a trusted contact
invite_circle_memberSend a single-use enrollment link
add_circle_member_channelAdd a channel to a member
create_identity_challengeRun a cross-channel identity check

Public profiles (16 tools)

Public verification pages, the proofs they display, and their templates.

ToolDescription
create_profileCreate a public profile
claim_usernameClaim a public username
update_public_proofsChoose which proofs a profile shows
preview_profile_templatePreview a profile template

Templates & webhooks (11 tools)

Message templates for outbound channels, and the webhook delivery log.

ToolDescription
list_templatesList message templates
update_templateChange a template
render_templateRender a template with variables
list_webhook_deliveriesList webhook deliveries
retry_webhook_deliveryRetry a failed delivery

Delegations & proofs (10 tools)

Proof of Delegation — a proven domain authorizing an artifact — plus the proof lifecycle and the public verifier surface.

ToolDescription
create_delegationAuthorize an artifact from a domain you have proven
list_delegationsList your delegations
revoke_delegationRevoke a delegation
verify_delegationCheck whether an artifact is authorized by the domain it claims
validate_proofVerify a signed proof token (no account needed)
get_proof_statusRead a proof's status by its public handle
list_revoked_proofsRead the revocation list (no account needed)

verify_delegation is the one to reach for when an agent is deciding whether to trust a server or package. It answers about an artifact identity you resolved independently — a package you are installing, an endpoint you are calling — never one read out of the artifact's own files.

Sign-in & sessions (9 tools)

Browser and messenger sign-in, and the sessions it produces.

ToolDescription
start_loginBegin a sign-in (no account needed)
wait_for_loginPoll until sign-in completes
get_current_userWho the current session belongs to
list_auth_sessionsList active sessions
render_auth_linkRender a sign-in link for the user to open

Example: Verify a phone number

text
Agent: I need to verify that +1-555-0123 belongs to this user.

→ create_verification({ type: "phone", identifier: "+15550123", channel: "sms" })
← { id: "ver_abc123", status: "pending", expires_at: "..." }

→ wait_for_verification({ id: "ver_abc123" })
← { status: "verified", proof_token: "eyJhbGc..." }

Example: Request human approval

text
Agent: This wire transfer needs a human to approve it.

→ create_confirmation({ hitl_id: "hitl_abc", message: "<ciphertext>" })
← { id: "conf_xyz", status: "pending", timeout_at: "..." }

→ wait_for_confirmation({ id: "conf_xyz" })
← { status: "resolved", response: { action: "approve" }, proof_token: "eyJhbGc..." }

Example: Check whether a server may act for a domain

text
Agent: This MCP server says it works on behalf of example.com. Is that true?

→ verify_delegation({ delegate: "pkg:npm/their-package", principal: "example.com" })
← { verified: true, scope: ["send-email"], expires_at: "..." }

Test mode

A pk_test_* key puts every tool in test mode: verifications complete without sending real messages, and test data is kept apart from production data. test_verify completes a test verification directly.


Resources

  • API Reference — the REST API these tools wrap
  • Proof of Delegation — the delegation module in full
  • SDKs — JavaScript, Python, Go and PHP clients
  • Core Primitives — the mental model in one page

Related

API ReferenceSDKsIntegrationsMCP Server Ownership
Last updated September 5, 2026
Proof Holdings

The verification API for humans and AI agents — every verification a signed proof you hold.

A service of LT Telecom (Uždaroji akcinė bendrovė "LT telekomunikacijos")

PrivacyTermsGitHubLinkedIn