接入你的智能体
发布者自己的命令。不是 PlugMCP 端点。
用我们的密钥与日志托管一份副本。
npx -y [email protected]Claude Code 没有针对本地命令的安装链接。复制下方命令并在终端中运行。
claude mcp add agent402-mcp -- npx -y agent402-mcp@0.13.32在终端中运行。
{ "mcpServers": { "agent402-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
远程 URL 还是本机命令？ 两种安装方式的区别
来自发布者
Live at agent402.tools.
The paid door for AI agents: 500+ tools, metered models and finished reports, paid per call in USDC over x402 and MPP, or by card. The applied layer of Agentic Finance. Open source, self-hostable, MCP-native.
Agent402 MCP server. Agent402 is a catalog of 500+ tools that AI agents find, pay for per request over x402 or MPP, and call with no account or API key. The applied layer of Agentic Finance: skill packs too, USDC or USDG on 14 chains, or free via proof-of
Operated by Havok Holdings LLC · Live · Why pay here · Receipts · Status · Security · Company
Try it in 30 seconds: claude mcp add agent402 -- npx -y agent402-mcp, or paste https://agent402.tools/mcp into any MCP client. The free tier needs no wallet. Verified setup blocks for Cursor, VS Code, Windsurf, Cline, Roo Code, Codex CLI, Gemini CLI, Continue, ElizaOS and AgentCore: agent402.tools/guides/agent-hosts (shortlinks agent402.sh/<host>, e.g. agent402.sh/cursor).
Who pays: agents pay per call (from $0.001; models metered under a quoted ceiling and settled at actual usage); people buy finished reports ($2 to $5) and monitors ($5 a month) by card; sites charge crawlers with the tollbooth.
Agentic Finance is software agents paying and getting paid on their own: discovering a service, paying per request from a wallet over open protocols (x402, MPP), receiving a verifiable receipt, and earning per request in return. Agent402 is its applied layer - explainer: agent402.tools/agentic-finance · glossary.
Selling an x402 API? List it on the index for free at
/sell(POST /api/index/register: self-serve, no signup, 0% take). The router sends buyers to a seller once its routes show settled payments from several independent buyers; calls priced at $0.01 or less can be tried before that, marked unproven on the buyer's receipt. Charging crawlers on your own site instead?agent402-tollboothputs a 402 gate in front of it.What makes it different: Agent402 is open-source and self-hostable - and a single integration gives a buyer three free primitives over the whole x402 ecosystem:
- Find -
/api/find?q={task}resolves a task description to the best-matching tools (route, price, schema, ready example).- Route -
POST /api/routeis the neutral Smart Order Router: rank tools across every x402 seller crawled (auto-discovered from the Coinbase CDP Bazaar), health-aware, withinclude=externalto exclude us. The response returns the top N and carriesmatchedfor how many scored.- Leaderboard -
GET /api/leaderboardis the public on-chain ranking of x402 sellers by Base USDC settled volume - calls served, totalUsd, unique buyers per seller. It returns the top N, never the whole board (25 by default, 50 the ceiling;totalSellerscarries the full count). Pipeline: Bazaar →eth_getLogs→ per-call ceiling → aggregate bypayTo. Hourly snapshot.Plus the catalog - 500+ strong: search/answer as the MCP front door, then 500+ tools and curated skill packs (multi-tool workflows callable as MCP prompts) - all runnable yourself, plus
agent402-tollbooth- an open pay-per-crawl gate for the other side of x402.Two doors, two price lists. Agents pay per call in USDC (x402 / MPP) or free via proof-of-work, and a finished report costs $0.60 to $2.00 that way. People pay by card: the same reports at agent402.tools/reports (company dossier, 13F fund report, insider flow, market brief, deep research, FDA recall, domain audit) are $2 to $5, monitors that re-run on change at /monitors are $5 a month, and a prepaid credits key already issued keeps paying per successful call (
Authorization: Bearer a402_…; new credits are not on sale). The card price includes payment processing. An agent paying per call pays the lower tool price for the same report.Two payment wires, one URL. Every paid endpoint accepts x402 (
PAYMENT-SIGNATURE, USDC on 12 chains or USDG on Robinhood Chain) and MPP (Machine Payments Protocol, the IETF-trackPaymentHTTP auth scheme co-authored by Tempo and Stripe): the same 402 carries both, anmppxclient pays out of the box, and MPP settles on Base and Celo (USDC), natively on Tempo (USDC.e or PathUSD via Tempo's relay), or by card over MPP (Stripestripe/charge, offered on routes priced $0.50 and up when the operator configures it). The MPP marketplace lists every MPP seller we can verify live. Details: What is MPP · live MPP settlements.
500+ strong - live web search and cited answers as the MCP front door, then ready-to-use web tools and multi-tool skill packs for your AI agent, from one server. Every one priced per call and settled on-chain. Browser
rendering, web search, PDFs, images, OCR, live financial/crypto/macro data, SEC EDGAR, deterministic stats, forecasting, and options/bond pricing (Black-Scholes, YTM), compression, and 150+ pure-CPU utilities. Run it yourself for free in 30 seconds (MCP or
plain HTTP, no API keys, no signup - the free tier and x402/MPP payments never
need a key; only a prepaid credits key already issued is a bearer key), connect
it to Claude/ChatGPT/any MCP client, and add your own tools in a few lines.
No language model writes a utility tool's answer, and every tool CI can run
without a third-party key is re-tested against its own example before every release. The model-backed
surfaces are explicit and priced as such: the /v1 gateway (metered under a
quoted ceiling, or flat tiers) and the finished report products (/v1/research, /v1/dossier, ... below).
Optionally, the same server can charge per call over the x402 protocol (USDC on Base, Solana, Polygon, Arbitrum, Monad, Celo, Avalanche, Sei, Optimism, Arc, Stellar & Algorand, plus USDG on Robinhood Chain - 13 chains) - so the instance you self-host for free can also be a hosted, monetized one. Free mode is one setting (
FREE_MODE=true); a paid instance needs a payout wallet.
🟢 Hosted demo: agent402.tools · 📖 Wiki · 📦 npm · 🔌 MCP Registry · 🧩 Smithery
Pick whichever fits. They are all free and need no wallet:
1. Zero install - add the hosted connector to Claude (claude.ai → Settings → Connectors → Add custom connector):
https://agent402.tools/mcp
2. One command - run the MCP server locally (the pure-CPU tools work with no key; it pays the tiny proof-of-work for you):
npx -y agent402-mcp
# in Claude Code: claude mcp add agent402 -- npx -y agent402-mcp
3. Clone and host the whole thing (all 500+ tools as an HTTP API + MCP, free mode, no payments):
git clone https://github.com/MikeyPetrillo/Agent402 && cd Agent402
npm install
FREE_MODE=true npm start # → http://localhost:3000 (HTTP API + /mcp)
# try a tool over HTTP - no auth in free mode
curl -s -X POST localhost:3000/api/hash -H 'content-type: application/json' \
-d '{"text":"hello world","algo":"sha256"}'
4. One-click deploy to Railway (full self-hosted instance - adds optional Postgres + Redis plugins for analytics + response caching):
Boots straight from the repo's Dockerfile. Optional plugins are auto-detected via env: add Redis → REDIS_URL enables the upstream response cache (X-Cache: hit|miss), add Postgres → DATABASE_URL enables the public /api/analytics dashboard. No env vars required to boot in free mode.
Every paid route answers 402 with both an x402 offer and MPP challenges, so either client pays it. No API key, no signup: the wallet is the account.
MPP (USDC.e or PathUSD on Tempo, listed first in the 402, or USDC on Base or Celo) with mppx:
import { Mppx, tempo, evm } from "mppx/client";
const account = (await import("viem/accounts")).privateKeyToAccount(process.env.AGENT_KEY);
const res = await Mppx.create({ methods: [tempo.charge({ account }), evm.charge({ account })] }).fetch("https://agent402.tools/api/uuid");
x402 (USDC on Base and other chains) with @x402/fetch:
import { wrapFetchWithPayment } from "@x402/fetch"; import { x402Client } from "@x402/core/client"; import { registerExactEvmScheme } from "@x402/evm/exact/client";
const client = new x402Client(); registerExactEvmScheme(client, { signer: (await import("viem/accounts")).privateKeyToAccount(process.env.AGENT_KEY) });
const res = await wrapFetchWithPayment(fetch, client)("https://agent402.tools/api/uuid");
More: Paying with MPP · Paying with x402.
Every tool earns its place: priced to market and settled on-chain, and every tool CI can run without a third-party key is tested against its own example on every CI run. CI holds a 400-entry catalog floor and verifies the “500+” claim against the running catalog (
scripts/sync-count.js --check). The catalog grows only when a tool is worth calling.
Full schemas live in /openapi.json; a
machine-readable catalog is at /api/pricing
and /llms.txt. Don't know which tool you need?
/api/find?q=<task> resolves
a task description to the right tool - route, price, schema, and a ready example -
so an agent skips the token-heavy "search around to find a tool" step.
/v1) - chat, embeddings, rerank, images, speech & finished reports, pay per callPoint any OpenAI SDK at base_url = https://agent402.tools/v1 and pay per call in
USDC over x402 or MPP - no API key, no signup, no account (a prepaid credits key
already issued also works, see For humans):
Streaming (stream: true), full tools/function-calling passthrough, an opt-in
prompt cache on the chat tiers (cache: true → byte-identical repeats free for
10 minutes; the repeat's payment is not charged, except a Tempo transfer sent before
the call, which is final when sent), upstream failover chains that end in a canary-proven model, and a
free GET /v1/models listing every model with
its tier and caps. A real-money canary buys the core surfaces daily (the chat
tiers, the messages and responses wires, embeddings, rerank, image generation
and speech) - streaming, routing disclosure, and both cache behaviors included.
Finished report products live on the same /v1 prefix: one paid call returns
a complete, cited report (JSON, with a sources appendix) rather than a raw model
turn. Every report is grounded in primary data the server fetches itself (EDGAR
filings, openFDA, DNS/TLS probes, on-chain reads, a live web search) before
synthesis; ipo-report is fully deterministic (no model at all):
Reports are wallet-only (x402 / MPP / prepaid credits, never proof-of-work) and take a few minutes to generate. The same reports are sold to people by card at agent402.tools/reports for $2 to $5 depending on depth. The card price includes payment processing; an agent paying per call over x402 or MPP pays the lower tool price for the same report.
Two companion tools close the loop: POST /api/route/execute ($0.01, with
execute-plus $0.05, execute-max $0.55 and execute-pro $3.30 tiers for pricier tools) resolves a task description to the
best tool and runs it in one paid call, including, with include:"external",
tools sold by other x402 sellers (it routes on proven on-chain settled
volume, with one exception - a Base or Solana seller with no history yet is
tried only after every proven candidate, under a small per-call ceiling, and
flagged unproven on the receipt - buys the result from them on the chain you paid
on - Base, Solana, Algorand or Tempo - and sells it to you; see the
Smart Order Router guide), and
POST /api/my-usage ($0.005) returns the paying wallet's own purchase
history - no wallet parameter; the x402 payment is the identity, so nobody can
read another wallet's profile.
The same catalog has a card-paying front door (Stripe Checkout; the operator
enables it with STRIPE_SECRET_KEY, otherwise these pages simply do not mount):
An issued credits key is understood by the SDKs: agent402-mcp reads
AGENT402_CREDITS_KEY and agent402-client takes { creditsKey }.
POST /api/decide turns a plain-language task into a call-ready plan: which tools, from this
catalog and from outside x402 sellers whose 402 was verified in the last week, in what order, with
fallbacks, inputs that validate against each tool's schema, and cost and latency estimates.
Priced by depth: quick (one best tool), plan (steps and fallbacks) and full (plus a compiled
prompt), from $0.005 per decision over x402 or MPP.
curl -X POST https://agent402.tools/api/decide \
-H "Content-Type: application/json" \
-d '{"task":"Check whether wallet 0xd8dA...6045 is on a sanctions list, then list its recent token transfers on Base","depth":"plan"}'
firstParty).POST /api/decide/execute, which runs the plan: our tools directly, outside steps bought from the
seller and resold at the seller's price plus a disclosed 5% markup. Spend stops at the budget,
fallbacks are tried in order, and a run where no step succeeds is not charged.decide.plan and decide.execute; decide.feedback (free) records
whether a step worked. Page: agent402.tools/decide.For jobs that span several tools - "audit a domain", "diagnose deliverability",
"work up a time-series", "peel an opaque blob" - Agent402 ships curated
skill packs: ordered, typed sequences of tool calls with a Claude-ready
prompt template. Callable as MCP prompts (prompts/list → prompts/get { name, arguments })
or plain HTTP at GET /api/skill-packs/{slug}/prompt (every slug is listed in the
free JSON index at /api/skill-packs.json).
A task-shaped query to catalog.search (the hosted connector's search tool; the older search_tools name still works as an alias) returns the matching pack alongside individual tools.
All 80+ packs at /skills · JSON index at /api/skill-packs.json ·
on MCP the packs appear under prompts/list so any MCP-aware client picks them up automatically.
Agent402 is also the open routing + ranking layer for the whole x402
ecosystem: it crawls public x402 sellers (the local catalog + an
auto-discovered set from the Coinbase CDP Bazaar,
refreshed hourly) and exposes them through three free surfaces - same logic as
/api/find: discovery primitives shouldn't cost money.
# "I need an OCR tool - find me the cheapest healthy one anywhere on x402"
curl -X POST https://agent402.tools/api/route \
-H 'content-type: application/json' \
-d '{"query":"ocr image to text","top":5}'
# "Who are the most-used x402 sellers right now? (on-chain proof, not self-reports)"
curl 'https://agent402.tools/api/leaderboard?top=25&include=external'
Dispatch is labelled, never implied: every /api/route row and /api/index
seller carries routerDispatchEligible and routerDispatchReason (crawl_failed,
network_unknown, settlement_required, settlement_checked_at_pay_time,
eligible, ...); executeVia appears only on a row the router will pay right
now (executeViaCallableNow: true), otherwise the tier moves to
executeViaWhenEligible. routable is crawl readiness, never a promise to pay.
A manifest-priced route is also read live once and then weekly, so the chains
its 402 actually offers reach the row even when the seller's manifest lags.
Health-aware: sellers whose last few crawls errored are excluded from the router (a buyer routed to a dead seller wastes money). Healthier sellers also break ties at equal match score and price, so flaky-but-cheap sellers lose to reliable ones. Brand-new sellers (no history yet) get the benefit of the doubt.
Judged fit: the lexical score rewards a listing whose name repeats the task's words, so one seller's twenty narrow routes could out-rank a general tool that does the job. A judgment model now reads a shortlist - at most two rows per seller, plus the best matches from the local catalog - and moves the listing that actually does the task to the top; when several do it equally well, the cheapest wins. It never adds a seller the settlement gate did not admit, it can say "none of these" (route-execute then refuses before anything is paid), and it fails open to the lexical order. The tools themselves still run no model; this is only how the router chooses.
Operators get 3-rail attribution on the dashboard (/api/stats,
/__operator, token-gated - it answers 404 without the operator token): USDC vs. proof-of-work vs.
heartbeat-probe traffic are counted separately - and the heartbeat rail is gated
on a POW_SECRET-signed token (not a spoofable User-Agent), so the operator
view reflects real external demand.
For API sellers: /sell is the front door -
list an existing x402-speaking API on the index for free with
POST /api/index/register (health-routed, 0%
take, self-serve, no signup), or install agent402-tollbooth to
put a pay-per-crawl gate in front of a site that isn't x402-native yet.
From code, the agent402-client npm package wraps all of this -
find() a tool, then call() it, paying automatically (a built-in proof-of-work
for free tools, your x402 wallet for paid ones), with caching and idempotent
retries:
npm install agent402-client
import { Agent402 } from "agent402-client";
const a = new Agent402(); // free tier (proof-of-work)
const out = await a.call("hash", { text: "hello world", algo: "sha256" });
// a prepaid credits key already issued pays wallet-only tools (new credits are not on sale)
const b = new Agent402({ creditsKey: "a402_..." });
services/live)A separate, read-only service that draws x402 payments on Base and MPP payments on Tempo as they settle. It reads public chain RPCs and public discovery listings, holds the last hour in memory, and fans out to browsers over one server-sent event stream; it shares no process, database or key with the API. Hosted at https://live.agent402.tools.
Run it locally (Node 22+, no dependencies):
cd services/live
PORT=8090 node server.js # then open http://localhost:8090
node test.js # offline tests
Optional settings: LIVE_BASE_RPCS and LIVE_TEMPO_RPCS (comma-separated RPC URLs), LIVE_INCLUDE_UNLISTED=1 (also count Base payments to wallets no discovery listing names), LIVE_INTERNAL_PAYERS (payer wallets to label as test traffic), LIVE_MAX_PAYMENT_USD (default 50).
If you're already on one of the stacks below - OpenAI, Anthropic, the Vercel AI SDK, LangChain (JS or Python), LlamaIndex, Strands, Google ADK, or the OpenAI Agents SDK - skip the wiring: there's a drop-in package that turns the Agent402 catalog into native tool objects for your framework, with payment handled underneath (proof-of-work for free tools, x402+USDC when you pass an @x402/fetch):
// e.g. OpenAI - every adapter has the same surface.
import OpenAI from "openai";
import { agent402Tools } from "agent402-openai-tools";
const openai = new OpenAI();
const { tools, execute } = await agent402Tools({ slugs: ["extract", "hash", "render"] });
const res = await openai.chat.completions.create({ model: "gpt-4o-mini", tools, messages: [...] });
// when the model returns a tool call: await execute(call.function.name, JSON.parse(call.function.arguments));
Already a Claude/MCP user? agent402-mcp is still the better path - paste https://agent402.tools/mcp into your client. The adapters are for direct API integrations where MCP isn't available. Sources: adapters/.
OpenClaw agents: drop in skills/openclaw/agent402/SKILL.md - teaches an OpenClaw agent to find, pay (x402 USDC on Base, eleven other chains accepted, or free proof-of-work), and call any of the 500+ tools and packs.
A tool is just an object in a kit array. Drop this into any file in
src/tools/ (e.g. append to AGENT_TOOLS in src/tools/agent-kit.js)
and it's live - routed, schema-published, MCP-exposed, and covered by the
"every tool answers its own example" CI check:
{
route: "POST /api/reverse",
name: "Reverse text",
slug: "reverse",
category: "text",
price: "$0.001", // free via proof-of-work for pure-CPU tools
description: "Reverse a string. Example: {\"text\":\"abc\"} → {\"reversed\":\"cba\"}",
discovery: {
inputSchema: { properties: { text: { type: "string" } }, required: ["text"] },
example: { text: "abc" }, // CI calls this and checks it works
},
handler: (input) => {
if (typeof input.text !== "string") { const e = new Error('"text" required'); e.statusCode = 400; throw e; }
return { reversed: [...input.text].reverse().join("") };
},
}
That's the whole contract: handler(input) returns a JSON-serializable object
(or throws an Error with .statusCode for a 4xx). Pure-CPU tools are
automatically free-via-proof-of-work; tools that hit the network or disk stay
wallet-only. See CONTRIBUTING.md for the full walkthrough.
The same server can require payment per call - useful if you host a public
instance. Payments are the default posture: a bare npm start fails closed,
exiting unless WALLET_ADDRESS is set - running without payments is the
explicit opt-in (FREE_MODE=true npm start). To charge, set WALLET_ADDRESS
PAYMENT_NETWORKS=…,robinhood +
ROBINHOOD_FACILITATOR_URL) via standard x402 clients:Every 402 is valid under @x402/core's own schemas (at most five tags, CI-checked
on all routes) and carries a typed output schema twice: in the bazaar discovery
extension and as accepts[0].outputSchema on the first accept, so a client that
reads the spec's field sees the response shape before paying.
Optional: GATEWAY_NANOPAYMENTS=on adds a Circle Gateway batched accept on Arc
and Base beside the plain one (same price, same payTo; buyers who deposited
USDC into Gateway sign per call with no gas, and Gateway settles off chain into
your Gateway balance, withdrawn with scripts/gateway-withdraw.js). Off by
default; see the wiki's Self-Hosting page.
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://agent402.tools/api/extract", {
method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ url: "https://agent402.tools/guides/x402-in-5-minutes" }),
});
MPP dual-stack. The paywall also speaks MPP (Machine Payments Protocol -
the IETF-track Payment HTTP auth scheme from tempoxyz/mpp):
the same 402 carries a WWW-Authenticate: Payment challenge, Authorization: Payment credentials settle, and settled responses return a Payment-Receipt.
MPP has two methods here: evm settles identically to x402 (EIP-3009 USDC,
same facilitator, same price); tempo settles natively via
Tempo's own relay (TIP-1034/TIP-20, no x402 facilitator
involved) - a genuinely separate settlement path, set TEMPO_API_KEY to
enable it. An mppx client works out
of the box for either method; set MPP_SECRET_KEY to enable the shim on your
own instance. Same URL either way - the buyer's client picks the dialect.
Agents without a wallet still use every pure-CPU tool by solving a single-use sha256 proof-of-work (a fraction of a second on a laptop; the MCP servers do it automatically). Details: wiki: Paying with x402 · Paying with MPP · Paying with Compute.
Every claim links to the surface that proves it (the live version, a section of the home page: agent402.tools/#why).
POST /v1/metered/chat/completions) quotes each 402 from the request's own body; a wallet paying upto settles actual usage under that ceiling, provider discounts such as prompt-cache reads pass through, and every settled x402 or MPP response carries a receipt; a JSON answer bought with an EVM wallet can be attested on Base by that wallet (POST /api/attest).success:false, moved no money; a retry carrying the same Idempotency-Key and the same payment credential replays the paid answer instead of paying again, and a request re-sent with the same signed EVM payment is answered from its first answer even without a key (X-Replayed-Answer: 1); the one residual case (a settled receipt on an error response) is detected by our own alarm and recorded as a debt in a refund ledger, never written off silently.POST /api/route/execute resolves a task to the best seller across the ecosystem, buys the result from that seller with our wallet and sells it to you under one receipt. Sellers are routable on proven on-chain settlement, with one bounded exception for a zero-history Base or Solana seller under a small per-call ceiling./status), a real-money canary through every on-chain rail daily, transactions published by rail and wire (/revenue), open source and self-hostable. The deterministic tools run no model; the ones that do are named (the /v1 tiers, the report products, the image, speech, transcription, embedding and AI-answer tools, the Decide planner, and the judgment model that can pick among the router's shortlisted candidates). The operator is identified on-chain: Agent402 is agent 94639 in the ERC-8004 Identity Registry on Base, resolving to /.well-known/agent-registration.json, with an A2A agent card at /.well-known/agent-card.json./status - where a day with no observation
reads "no data", never uptime, because an outage is exactly when a probe
cannot report.agent402.base.eth
(a Base name resolving to the public receiving wallet); every other chain's
receiving address is in the live 402 and at /.well-known/x402,
so anyone can verify on chain; live counts at /api/stats.x402 is an open payment protocol built on HTTP 402 Payment Required for machine-to-machine, pay-per-call payments in stablecoins (USDC).
Most projects in the space are the protocol + SDKs,
a starter template, or a payment facilitator. Agent402 is the applied layer -
a ready-to-run x402 server that already speaks the protocol and ships 500+
working tools, so you don't have to build the catalog yourself.
Listed in the official MCP Registry and discoverable in the Coinbase x402 Bazaar.
Works with AWS Bedrock AgentCore Payments out of the box - AgentCore orchestrates x402, which is the protocol Agent402 already speaks. Point the AgentCore Gateway at https://agent402.tools/mcp for all 500+ tools, or use agent402-strands for a curated subset inside a Strands agent. Five-minute recipe: wiki: AWS Bedrock AgentCore.
Charge AI crawlers that hit your site. Humans browse free; known bots get
402 Payment Required and can pay in USDC over x402 - or solve a free
proof-of-work. The open, crypto-native answer to Cloudflare's closed
pay-per-crawl: no CDN lock-in, no Stripe, no merchant-of-record, no signup.
npm i agent402-tollbooth · tollbooth/ · tollbooth/README.mdRuns as Express middleware, a Next.js / Vercel Edge middleware, a Cloudflare
Worker, a reverse proxy, or a WordPress plugin (beta). Drop-in templates in
tollbooth/deploy/. One Web-Crypto core powers all of them.
Since 0.9.x the gate also speaks MPP natively: hand it your @x402/express
middleware (createTollbooth({ x402 })) and it mints WWW-Authenticate: Payment
evm challenges from the same 402, or give it a Tempo relay key
(createTollbooth({ tempo: { apiKey, recipient, currency, splits } })) and it
settles MPP tempo/charge credentials on Tempo with optional split payments,
with no x402 middleware at all.
Since 0.10.0 the edge build speaks MPP too: with secret, payTo and your
verifyX402 callback set, every 402 carries a WWW-Authenticate: Payment
challenge beside the x402 quote, and an Authorization: Payment credential
(HMAC-bound to that challenge, unexpired, minted for that exact resource) is
translated to PAYMENT-SIGNATURE and handed to the same verifier.
/v1 chat, embeddings, images, speech) is additionally subject to the
upstream model providers' usage policies. Wallets used for prohibited content are blocked
before settlement (WALLET_BLOCKLIST).agent402-mcp (mcp/), agent402-client (client/), agent402-tollbooth (tollbooth/), agent402-openclaw (openclaw/), agent402-agentkit (adapters/agentkit/), elizaos-plugin-agent402 (adapters/eliza/) and the facilitator (facilitator/). GitHub's repository-level license badge reports the server's AGPL; a package's license field and its directory's LICENSE are what apply to that package. Provided as-is, without warranty (see LICENSE and NOTICE). "Agent402" and the logo are trademarks of Havok Holdings LLC - the license covers the code, not the name; forks must rename (see TRADEMARKS.md).
If you self-host, you are the operator: your deployment, your terms, your compliance -
Havok Holdings LLC operates only the hosted instance and is not responsible for third-party
deployments.PRs that add useful tools, fix bugs, or improve docs are very welcome - see CONTRIBUTING.md. Server AGPL-3.0, every published package MIT (see Legal above). Maintained by Havok Holdings LLC.
Agent402 MCP server. Agent402 is a catalog of 500+ tools that AI agents find, pay for per request over x402 or MPP, and call with no account or API key. The applied layer of Agentic Finance: skill pac
{ "mcpServers": { "agent402-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}概览
Agent402 MCP server. Agent402 is a catalog of 500+ tools that AI agents find, pay for per request over x402 or MPP, and call with no account or API key. The applied layer of Agentic Finance: skill packs too, USDC or USDG on 14 chains, or free via proof-of
工具
暂无工具列表。远程服务器在首次健康检查后会获得工具列表。
常见问题
在本页复制适用于 Cursor、Claude Desktop、Claude Code 或 VS Code 的 stdio 配置。它使用发布者的安装方式，而不是 PlugMCP 代理。
此记录未列出必需的环境变量。
Agent402 通过 stdio 在本地运行。
上次检查时间：2026-11-15。 Agent402 MCP server. Agent402 is a catalog of 500+ tools that AI agents find, pay for per request over x402 or MPP, and call with no account or API key. The applied layer of Agentic Finance: skill packs too, USDC or USDG on 14 chains, or free via proof-of