Three interfaces.
Clear responsibilities.
Inspect & verify
Public MCP for proposed-payment inspection and public receipt retrieval/verification. No wallet authorization or payment execution.
https://mcp.onchaindiligence.com/public/mcpClaude setup below →Paid · x402Evidence providers
The separate paid MCP surface provides evidence services using x402. It is not exposed through the free Plugin.
https://mcp.onchaindiligence.com/mcpPaid MCP documentation →Application integrationCommerce SDK
Connect your executor to preflight, observation, recovery and Action Receipts. Your wallet keeps control of spending.
TypeScript quickstart →ChatGPT Developer Mode host-loop passed. Plugin submitted, review pending. Claude Custom Connector validated. These statuses do not imply directory approval.
Evaluate, execute,
observe, verify.
A separate @onchaindiligence/sdk/commerce export orchestrates an agent’s merchant payment lifecycle. OCD evaluates. Your executor authorizes. Your executor submits. OCD observes.
import { createCommerceClient, MockCommerceExecutor, apiPurchasePolicy } from '@onchaindiligence/sdk/commerce' import { NodeFileRecoveryStore } from '@onchaindiligence/sdk/commerce/node' const ocd = createCommerceClient({ recovery: new NodeFileRecoveryStore('./ocd-recovery') }) const { policy } = apiPurchasePolicy({ maxAmount: '1.00', allowedNetwork: 'eip155:8453', allowedAsset: BASE_USDC }) const op = await ocd.open({ action: proposedPayment, policy }) const evaluation = await op.preflight() // OCD evaluates against your policy if (evaluation.kind === 'blocked' || evaluation.kind === 'approval-required') return handleThat(evaluation) const execution = await op.execute({ executor: myExecutor }) // your executor authorizes + submits, e.g. X402BaseUsdcExecutor const result = await op.observeAndFinalize() // OCD observes what actually happened -- safe to retry while pending result.receipt.receipt.execution.status // read the fact, never infer "success" from existence
npm install @onchaindiligence/sdk ·
Package on npm → ·
See the complete, runnable quickstart.ts → (mocked executor, no wallet needed, costs nothing).
The commerce client, an MCP connection, and free receipt retrieval/verification are the practical sequence below — the schema catalog and deeper protocol construction remain fully documented further down this page.
ChatGPT, Claude, Gemini,
or ordinary TypeScript.
OCD exposes the same application/MCP interfaces from ChatGPT-style MCP/app environments, Claude MCP, Gemini or custom-tool/MCP environments, and ordinary TypeScript applications — one integration, not three. The application-level commerce hook above (not the model remembering to call a tool) is the real enforcement mechanism.
Retrieve and verify
a receipt, at no cost.
Use OnChainDiligence
with Claude.
A free, read-only MCP connector lets Claude inspect a proposed payment and retrieve/verify OCD receipts directly in a conversation. It cannot send payments, custody funds, authorize a wallet, reach private operations, or call the paid x402 MCP surface — it only inspects and verifies.
- In Claude, go to Settings/Customize → Connectors → Add custom connector.
- Paste the server URL:
https://mcp.onchaindiligence.com/public/mcp - Name it OnChainDiligence. Authentication: None. Transport: Streamable HTTP.
- Click Add — no account, credentials, or setup required.
Try it against a real example receipt: OCD-RCP-NB51-QG4S-VCAN-Y57F →
"Inspect a $0.001 USDC payment on Base against a $1 maximum." "Retrieve OCD receipt OCD-RCP-NB51-QG4S-VCAN-Y57F." "Verify that receipt and tell me what it does and doesn't prove."
npm and PyPI.
Use OnChainDiligence
from an agent.
The MCP service is a separate callable interface from the Technocore signing DID. It exposes public-data diligence tools over Streamable HTTP and charges only after an agent approves a server-supplied x402 requirement.
- Connect an MCP client to
https://mcp.onchaindiligence.com/mcp. - Call
tools/listand choose a tool, such asscreen_wallet. - Call it once without payment. The response returns the exact x402 requirement in
structuredContent.accepts[0]. - Have the agent apply its own policy, then authorize the returned USDC requirement from its own wallet and retry with
_meta["x402/payment"]. - Read the signed result. The service is non-custodial: it never receives a wallet private key.
// Configure your MCP client with this public endpoint. const client = await connectMcp('https://mcp.onchaindiligence.com/mcp') const { tools } = await client.listTools() const unpaid = await client.callTool({ name: 'screen_wallet', arguments: { address: '0x0000000000000000000000000000000000000000' } }) const requirement = unpaid.structuredContent.accepts[0] // amount, asset, Base, recipient // Only after your agent's policy approves the server-supplied requirement: const payment = await createPaymentHeader(agentWallet, 1, requirement) const result = await client.callTool({ name: 'screen_wallet', arguments: { address }, _meta: { 'x402/payment': payment } })
The live service returned 10000 atomic USDC units ($0.01) for screen_wallet during validation on 2026-09-03. Do not hard-code that value: always use the requirement returned by the live server. Full runnable consumer example →
Make your agent
independently verifiable.
ArcFX is the working example of this pattern, not a requirement for using it. Full spec: AGENT_EVIDENCE_INTEROP.md →
- Install
@onchaindiligence/agent-evidence - Construct Mandate / Evidence / Policy / Decision / Execution records
- Seal a bundle with
sealBundle - Publish signer lifecycle metadata at
/.well-known/agent-evidence-keys - Hand the bundle to an independent verifier — browser handoff or any transport
- Verifier resolves trust via
trustPolicyFromKeyRegistryor its own policy - Receive
VALID / INVALID / UNVERIFIABLE
import { trustPolicyFromKeyRegistry, verifyBundle } from '@onchaindiligence/agent-evidence' // Fetching is the caller's job -- the SDK stays offline-usable. const registry = await fetch('https://issuer.example/.well-known/agent-evidence-keys').then(r => r.json()) const policy = trustPolicyFromKeyRegistry(registry, { expectedIssuer: 'issuer', expectedEnvironment: 'production' }) const report = verifyBundle(bundle, policy) report.state // VALID | INVALID | UNVERIFIABLE
The contract, implementation
and tools are inspectable.
Start with the format and shared conformance corpus, construct or verify bundles in Python, then connect the existing API, SDK, CLI and MCP evidence sources.
Agent Evidence v0
Normative format, trust model and verification algorithm.
Read specification → SchemasPublic catalog
Stable Draft 2020-12 schema URLs for every v0 artifact.
Open catalog → PythonReference package
Deterministic builders, DSSE sealing and offline tri-state verification.
View package → TypeScriptAgent Evidence package
Public Node.js package for deterministic bundles, DSSE sealing and offline verification.
Install from npm → Production proofP1.8 reference bundle
Real Chainalysis and SEC evidence, policy-bound decision and withheld execution.
Inspect bundle → InteropConformance corpus
Language-neutral valid, invalid and unverifiable vectors.
Inspect vectors → TypeScriptSDK
Typed API client and offline attestation verification.
View SDK → CLICommand line
Call production checks and verify signed attestations offline.
View CLI → Agent toolsMCP server
Production compliance tools for agents over MCP.
View MCP → BrowserAttestation verifier
Verify current API attestations against an explicit key record.
Open verifier →