Server data from the Official MCP Registry
1000+ pay-per-call web tools for agents: search, browser, PDF, memory. x402 USDC or proof-of-work.
1000+ pay-per-call web tools for agents: search, browser, PDF, memory. x402 USDC or proof-of-work.
Remote endpoints: streamable-http: https://agent402.tools/mcp
Valid MCP server (3 strong, 4 medium validity signals). No known CVEs in dependencies. ⚠️ Package registry links to a different repository than scanned source. Imported from the Official MCP Registry. 1 finding(s) downgraded by scanner intelligence.
3 tools verified · Open access · 1 issue 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.
Set these up before or after installing:
Environment variable: AGENT_KEY
Environment variable: AGENT402_BUDGET
Environment variable: AGENT402_MAX_PER_CALL
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 live node in the machine-to-machine economy: 1000+ tools autonomous agents pay for per call in USDC via the x402 protocol — or with proof-of-work, no wallet.
🟢 Live at agent402.tools — USDC on Base mainnet. Built by Mikey Petrillo.
No humans, no signups, no API keys. One program calls an endpoint, gets an
HTTP 402 Payment Required quote, settles payment from its own wallet (or with a
few seconds of compute), and gets the result. The payment is the identity.
Every settled call lands on-chain — live counts and the receiving wallet are at
/api/stats.
Run the whole loop yourself — an autonomous buyer discovers the catalog, gets
quoted over HTTP 402, settles, and uses the result, with zero human involvement:
node scripts/demo-payment.js # pays with compute — no wallet, no funds
AGENT_KEY=0xYOUR_FUNDED_KEY node scripts/demo-payment.js # settles in real USDC on Base
mcp/ ships an MCP server that exposes the whole catalog to any MCP
client and settles payment underneath — USDC via x402 with AGENT_KEY set,
proof-of-work (free) on the pure-CPU tools without it:
claude mcp add agent402 -- npx -y agent402-mcp # after npm publish, or:
claude mcp add agent402 -- node /path/to/Agent402/mcp/index.js
High-value tools (extract, render, screenshot, pdf, memory-*, …) are
first-class MCP tools; the other ~1000 are reachable through search_tools +
call_tool so the model's context window stays small. Test: node mcp/test.js.
The headline count is real: ~970 of these are individually-discoverable unit
conversions (GET /api/convert/{from}-to-{to}), each a genuine endpoint backed
by one verified engine and covered by exact-value + round-trip tests
(scripts/test-convert.js). The curated tools below are the rest:
| Category | Tools | Highlights |
|---|---|---|
| Web & documents | 5 | render (headless Chromium, $0.02), screenshot, pdf, extract, meta |
| Agent memory & coordination | 10 | Wallet-keyed KV + TTL, atomic counters, shared namespaces (grants), tamper-evident audit log, similarity recall — the payment IS the identity |
| Network & domains | 6 | dns, http-check, tls-cert, whois (RDAP), robots-check, sitemap |
| Data conversion | 16 | JSON ⇄ CSV/YAML/XML, markdown ⇄ HTML, json-diff/query/flatten/merge, csv-to-md, querystring, base-convert, roman |
| Text processing | 16 | slugify, case, text-stats, keywords, regex, levenshtein, redact (PII), extract-entities, readability, truncate, count, sort-lines |
| Encoding & crypto | 14 | hash, hmac, base64/32/58, hex, jwt-decode/verify, totp, crc32, rot13, morse, html-entities |
| Math & finance | 7 | calc (safe evaluator), stats, unit-convert, percentage, number-format, cidr (subnets), finance (loans/interest) |
| Generators & IDs | 5 | uuid (v4/v7), ulid, password, random, qr (PNG) |
| Time & scheduling | 9 | time, time-convert, cron-next, duration, date-diff, business-days, age, relative-time, add-time |
| Validation & parsing | 13 | email-validate (MX), url-parse, ip-info, user-agent, color, semver, mime, iban/card/isbn-validate, password-strength, json-pointer, uuid-validate |
Every tool is covered by tests: scripts/test-kit2.js asserts exact outputs for
the pure-CPU tools, scripts/test-memory.js covers the coordination layer, and
the paid end-to-end test (scripts/agent-e2e.js) buys each endpoint with real
USDC and verifies the result.
Free discovery surfaces: /tools (per-tool docs
pages), /api/pricing (JSON catalog),
/openapi.json (OpenAPI 3.1),
/llms.txt (LLM-readable docs), /health.
A single, ephemeral, sandboxed agent cannot give itself durable state, a portable identity, a place other agents can reach, atomic coordination primitives, or tamper-evident history. Agent402's memory layer is exactly that — keyed to the paying wallet, no signup:
| Endpoint | What it does |
|---|---|
POST /api/memory | Write KV, optional ttlSeconds; owner to target a granted namespace |
GET /api/memory | Read a key or list keys (your namespace, or a granted owner) |
POST /api/memory/incr | Atomic counter/lock — coordinate across agents |
POST /api/memory/grant | Share your namespace with another wallet (read/readwrite) |
POST /api/memory/revoke · GET /api/memory/grants | Manage access |
GET /api/memory/log | Tamper-evident, hash-chained audit history of a namespace |
POST /api/memory/remember · recall · forget | Similarity recall — store text, retrieve by meaning |
Two different agents (two wallets) coordinate through one shared namespace: A
grants B readwrite, B atomically increments a shared job counter, and the
hash-chained log proves who did what. That rendezvous point is not vibe-codable —
it requires a persistent, neutral third party with portable identity. See it run:
node scripts/demo-coordination.js # two wallets: grant → recall → atomic handoff → verifiable audit
Similarity recall (/api/memory/remember + /recall) ships with a local
lexical embedder (no key, works out of the box). Point it at any
OpenAI-compatible embeddings endpoint for true semantic recall — no code change:
EMBEDDINGS_URL=https://api.openai.com/v1/embeddings
EMBEDDINGS_MODEL=text-embedding-3-small
EMBEDDINGS_API_KEY=sk-...
Agents that can't pay USDC can still use the 41 pure-CPU tools by spending CPU
instead — a built-in anti-abuse onramp that converts non-payers into integrated
users. The browser/network/storage tools (render, screenshot, pdf,
memory, extract, http-check, …) stay wallet-only.
import { createHash } from "node:crypto";
const lz = (b) => { let t = 0; for (const x of b) { if (!x) { t += 8; continue; } t += Math.clz32(x) - 24; break; } return t; };
const c = await (await fetch("https://agent402.tools/api/pow/challenge?slug=hash")).json();
let n = 0; // find a nonce with `difficulty` leading zero bits
while (lz(createHash("sha256").update(c.challenge + ":" + n).digest()) < c.difficulty) n++;
const res = await fetch("https://agent402.tools/api/hash", {
method: "POST",
headers: { "Content-Type": "application/json", "X-Pow-Solution": c.token + ":" + n },
body: JSON.stringify({ text: "hello world" }),
});
Each challenge is signed, single-use, and short-lived; difficulty is tunable via
POW_DIFFICULTY. See GET /api/pow for the machine-readable description.
Why agents pay for this instead of building it themselves:
render,
screenshot, and memory are infrastructure rented by the call.memory is keyed to the paying wallet —
persist findings today, read them next week from a different machine, zero
credentials to store or leak.Dockerfile and
railway.toml are picked up automatically.WALLET_ADDRESS — your Base USDC receiving address (0x…). This is where
the money goes.CDP_API_KEY_ID / CDP_API_KEY_SECRET — free keys from
portal.cdp.coinbase.com. This enables
real-money settlement on Base mainnet and lists your endpoints in the
x402 Bazaar so agents can
discover and pay you without you lifting a finger.BASE_URL — your public Railway URL (e.g. https://agent402.up.railway.app),
used in the docs examples on the landing page.To test without real money first, set NETWORK=base-sepolia and omit the CDP
keys (the default x402.org facilitator handles testnet).
npm install
FREE_MODE=true npm start # demo mode, no payments
# or, with payments:
cp .env.example .env # fill in WALLET_ADDRESS etc.
node --env-file=.env src/server.js
Any x402 v2 client works. Example with @x402/fetch:
import { wrapFetchWithPayment } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { registerExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";
const client = new x402Client();
registerExactEvmScheme(client, { signer: privateKeyToAccount(KEY) });
const payFetch = wrapFetchWithPayment(fetch, client);
const res = await payFetch("https://YOUR-URL/api/extract", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ url: "https://example.com/article" }),
});
src/server.js — Express app and the endpoint catalog (prices, descriptions,
discovery schemas).src/payments.js — x402 v2 wiring: ExactEvmScheme (USDC on Base),
facilitator selection (CDP / custom / testnet default), and Bazaar discovery
extensions so agents can find the service.src/tools/extract.js — Readability + Turndown for article → markdown; jsdom
for metadata parsing.src/tools/fetch-guard.js — outbound fetch with SSRF protection (private IP
blocking), 5 MB size cap, 15 s timeout.src/tools/dns.js — DNS resolution with input validation.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.