Server data from the Official MCP Registry
Pay-per-call JSON repair + JSON Schema validation for AI agents (USDC on Base, x402).
Pay-per-call JSON repair + JSON Schema validation for AI agents (USDC on Base, x402).
Remote endpoints: streamable-http: https://x402.agentfund.net/mcp
This is a well-architected pay-per-call MCP server with solid security fundamentals. Authentication via x402 payments is properly implemented, credentials are handled safely (public address only, no private keys stored), and the core tool logic is deterministic with no dangerous operations. Minor code quality issues (broad exception handling, some input validation gaps) prevent a higher score, but permissions align appropriately with the server's purpose (JSON repair + payment settlement). Supply chain analysis found 10 known vulnerabilities in dependencies (2 critical, 2 high severity).
6 files analyzed · 16 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Available as Local & Remote
This plugin can run on your machine or connect to a hosted endpoint. during install.
From the project's GitHub README.
A small, autonomous, pay-per-call MCP server that AI agents discover and pay for per call, with revenue landing directly in a USDC wallet on Base via the x402 payment protocol.
structured_json_repair — deterministic JSON repair + JSON Schema validation/coercion. No model or paid API on the hot path, so each call costs ~nothing to serve (~100% margin).structured_json_repair takes a messy/invalid JSON-ish string (the kind LLMs and tools frequently emit) plus an optional JSON Schema, and returns clean, valid, schema-conformant JSON — with structured diagnostics when it can't fully fix it.
Fixes: trailing commas, single-quoted strings, unquoted keys, Python literals (None/True/False), NaN/Infinity, Markdown ``` code-fence wrappers, and truncated/garbled tails. With a schema, it validates (JSON Schema draft 2020-12) and optionally coerces primitives ("36" → 36, "true" → true).
Input (tools/call arguments):
| field | type | required | default | description |
|---|---|---|---|---|
input | string | ✅ | — | The raw/malformed JSON text. |
schema | object | — | — | JSON Schema (draft 2020-12) to validate/coerce against. |
coerce | boolean | — | true | Coerce primitive types to satisfy the schema. |
Output (structuredContent):
{
"ok": true, // valid JSON (and schema-valid when a schema was given)
"data": { "...": "..." }, // the repaired/validated value; null if unfixable
"changed": true, // true if any repair or coercion modified the input
"errors": [], // actionable messages when ok is false
"repairs": ["Removed trailing comma(s) before a closing } or ]."]
}
Annotations: readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false.
| Tool | Price | Network | Asset |
|---|---|---|---|
structured_json_repair | $0.01 / call | Base (mainnet) / Base Sepolia (sandbox) | USDC |
Discovery is free: initialize, tools/list, and ping are never charged — only a tools/call to a paid tool is.
agent (x402-enabled MCP client)
│ POST /mcp (JSON-RPC: tools/call structured_json_repair)
▼
┌─────────────────────────── Hono app (Workers / Node) ───────────────────────────┐
│ PaymentGate.evaluate() │
│ • initialize / tools/list / ping / free tools ─────────────► run MCP, return │
│ • paid tools/call: │
│ no/invalid payment ─► HTTP 402 + x402 "payment-required" envelope │
│ valid payment ─► run MCP tool ─► settle ─► result + receipt header │
└──────────────────────────────────────────────────────────────────────────────────┘
Because every MCP call hits a single /mcp endpoint, the gate inspects the JSON-RPC method/tool name and maps each paid tool to a synthetic x402 route (POST /x402/<tool>). The official x402 engine (@x402/core + @x402/evm) then handles price→atomic conversion, USDC asset resolution, the 402 envelope, facilitator verification, and on-chain settlement. Payment lives entirely at the HTTP layer and is transparent to JSON-RPC.
A real unpaid call returns (verified against the public testnet facilitator):
HTTP/1.1 402 Payment Required
payment-required: <base64 x402 v2 envelope>
// decoded envelope
{ "x402Version": 2,
"resource": { "url": ".../x402/structured_json_repair", ... },
"accepts": [{ "scheme": "exact", "network": "eip155:84532",
"amount": "10000", "asset": "0x036CbD…CF7e" /* USDC on Base Sepolia */,
"payTo": "0x…", "maxTimeoutSeconds": 300,
"extra": { "name": "USDC", "version": "2" } }] }
npm install
cp .dev.vars.example .dev.vars # then set PAYOUT_WALLET_ADDRESS (a PUBLIC 0x address)
npm run build
PAYOUT_WALLET_ADDRESS=0xYourPublicAddress npm start # Node server on :8787
# or: npm run dev (Cloudflare Workers dev server via wrangler)
Exercise it (no payment needed for discovery; the paid call returns 402):
# tools/list — free
curl -s -X POST http://localhost:8787/mcp \
-H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
# paid tool, unpaid — returns HTTP 402 with the x402 envelope in the `payment-required` header
curl -i -s -X POST http://localhost:8787/mcp \
-H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/call",
"params":{"name":"structured_json_repair","arguments":{"input":"{a:1,}"}}}'
Inspect interactively with the MCP Inspector:
npm run inspector # then connect to Streamable HTTP at http://localhost:8787/mcp
An x402-enabled MCP client pays automatically: it calls the tool, receives the 402, signs a USDC payment from its own wallet, and retries with the payment header — all transparently. With the x402 SDK (@x402/* + a wallet), wrap the HTTP transport so 402s are auto-paid, then use the standard MCP client against https://<host>/mcp. See the x402 client docs: https://docs.x402.org.
src/
index.ts # Hono app: routes, x402 gate wiring, Workers entry (default export)
node.ts # Node/VPS entry (npm start / bin)
config.ts # env loading + validation (address-only; refuses private keys)
mcp/
server.ts # MCP server factory; registers tools (tool-agnostic core)
transport.ts # stateless Streamable HTTP via @hono/mcp
tools/
structuredJsonRepair.ts # pure tool logic + Zod input/output schemas + registration
index.ts # tool registry — add new tools here
types.ts # ToolModule contract
payments/
x402.ts # paywall: per-tool routes, facilitator, verify/settle, JSON-RPC gating
test/
structuredJsonRepair.test.ts
paywall.test.ts
server.json # Official MCP Registry metadata
wrangler.toml # Cloudflare Workers config (sandbox + production envs)
.dev.vars.example # example env (placeholders only — no secrets)
src/tools/myTool.ts exporting a ToolModule (name, title, description, price, register). Set price: null for a free tool or "$0.05" for a paid one.src/tools/index.ts. That's the only change — the MCP, payment, and deploy layers pick it up automatically (the gate prices every tool whose price !== null).All config comes from environment variables (Workers [vars] / wrangler secret, or the process env on Node).
| Variable | Required | Default | Notes |
|---|---|---|---|
PAYOUT_WALLET_ADDRESS | ✅ | — | Public USDC payout address (0x + 40 hex). Never a private key. |
X402_MODE | — | sandbox | sandbox (testnet) or production (mainnet). |
X402_NETWORK | — | by mode | eip155:84532 (Base Sepolia) or eip155:8453 (Base). |
X402_FACILITATOR_URL | — | https://x402.org/facilitator | Public facilitator (works for testnet). |
X402_USE_CDP_FACILITATOR | — | false | true for the Coinbase CDP facilitator (mainnet). |
CDP_API_KEY_ID / CDP_API_KEY_SECRET | prod only | — | CDP facilitator credentials (set as secrets). |
PRICE_STRUCTURED_JSON_REPAIR | — | $0.01 | Per-tool price override (USD). |
See OPERATOR_CHECKLIST.md for the exact human-only steps (wallet, accounts, secrets, deploy, publish). In short:
# Sandbox (Base Sepolia, public facilitator)
wrangler secret put PAYOUT_WALLET_ADDRESS
wrangler deploy # → https://x402-json-repair-mcp.<subdomain>.workers.dev/mcp
# Production (Base mainnet, Coinbase CDP facilitator)
wrangler secret put PAYOUT_WALLET_ADDRESS --env production
wrangler secret put CDP_API_KEY_ID --env production
wrangler secret put CDP_API_KEY_SECRET --env production
wrangler deploy --env production
Node / VPS fallback: npm run build && PAYOUT_WALLET_ADDRESS=0x… npm start (serves /mcp on :8787; put it behind TLS).
server.json (set your OWNER namespace and the deployed URL), then publish with the registry mcp-publisher CLI. The registry feeds Smithery, PulseMCP, etc.GET /.well-known/x402 (capability + pricing per tool). Submit per current x402 docs.npm publish (the package is runnable via npx x402-json-repair-mcp for self-hosting).Operator-run commands are in OPERATOR_CHECKLIST.md.
PAYOUT_WALLET_ADDRESS to tell payers where to send USDC; it never signs or moves funds. config.ts actively refuses anything shaped like a private key (64 hex) or seed phrase..dev.vars locally (gitignored) and wrangler secret in production. Only .dev.vars.example (placeholders) is committed.@x402/core / @x402/evm packages (the v1 x402/x402-hono packages are deprecated). The 402 envelope is delivered in the payment-required response header (v2), which the agent's x402 client reads and pays.@cfworker/json-schema, not Ajv. Ajv compiles validators at runtime via the Function constructor, which Cloudflare Workers forbid (no eval). Since the schema is a runtime input, it can't be precompiled — so we use the eval-free, Workers-native @cfworker/json-schema (already an MCP SDK peer) plus a small schema-driven coercion pass.ToolModule with no changes to the MCP/payment/deploy core.MIT
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
by mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.