Agent402: 500+ tools, metered models and finished reports for AI agents
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.
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@0.13.22, 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/, 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.
What Agent402 is
> 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-tollbooth puts 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/route is the neutral Smart Order Router: rank tools across every x402 seller crawled (auto-discovered from the Coinbase CDP Bazaar), health-aware, with include=external to exclude us. The response returns the top N and carries matched for how many scored.
> - Leaderboard - GET /api/leaderboard is 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; totalSellers carries the full count). Pipeline: Bazaar → eth_getLogs → per-call ceiling → aggregate by payTo. 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 pays per successful call on Agent402's own services
> (Authorization: Bearer a402_…; /credits says whether
> packs are 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-track Payment HTTP auth scheme co-authored by Tempo and
> Stripe): the same 402 carries both, an mppx
> client 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 (Stripe stripe/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.
Framework adapters (drop-in tools for the major agent stacks - auto-payment underneath):
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 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
Run it yourself in 30 seconds
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):```bash
npx -y agent402-mcp@0.13.22
# in Claude Code: claude mcp add agent402 -- npx -y agent402-mcp@0.13.22
3. Clone and host the whole thing (all 500+ tools as an HTTP API + MCP, free mode, no payments):```bash
git clone https://github.com/MikeyPetrillo/Agent402 && cd Agent402
npm install
FREE_MODE=true npm start # → http://localhost:3000 (HTTP API + /mcp)
``````bash
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.
## Pay per call from a wallet
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`:```js
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:```js
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.
## What's in the catalog (500+ tools)
> **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.
| | Examples |
|---|---|
| **Browser & web** | `render` (headless Chromium, executes JS), `screenshot`, `extract` (article→markdown), `meta` |
| **Live search & answers** | `search` (real web index), `search-lite` (a quick 5-result sample), `answer` (web answer with citations), `search-news`/`search-images`/`search-videos` variants, `search-suggest`, `multi-search` |
| **PDFs & media** | `pdf-to-markdown`, `pdf-merge`, `pdf-extract-pages`, `pdf-rotate`, `images-to-pdf`, `audio-convert`, `audio-normalize` (EBU R128, real ffmpeg) |
| **Images** | `image-resize`, `image-convert`, `image-thumbnail`, `barcode-decode` (jimp/zxing, pure-CPU) |
| **OCR** | `image-ocr` (text out of any image - pure-CPU, no model) |
| **Geo** | `geo-distance` (haversine, pure-CPU), `geocode`, `reverse-geocode`, `place-search`, `geo-lookup` |
| **Live data** | `fx-rate` (ECB), `barcode-lookup` (Open Food Facts), `gov-data` (data.gov), `weather-forecast`/`weather-alerts`, `earthquakes` (USGS) |
| **Finance & crypto** | `stock-quote`/`stock-history` (a licensed feed, multi-venue consolidation), `crypto-price`/`crypto-market`/`crypto-history`/`crypto-trending`/`crypto-global` (CoinGecko) |
| **Crypto derivatives & options** | `perp-markets`, `perp-funding`, `perp-funding-screener`, `perp-basis`, `perp-open-interest`, `perp-klines`, `perp-orderbook` (live perpetuals: mark/oracle price, funding, OI, candles, depth); `options-summary`, `crypto-options-chain`, `options-ticker`, `options-volume` (options book, IV and greeks, onchain options volume) - $0.001 to $0.005 a call, no exchange account |
| **DeFi & stablecoins** | `defi-yields` (screen pools by chain, project, TVL and stablecoin-only), `defi-yield-history`, `defi-protocols`, `defi-protocol`, `defi-chains`, `defi-chain-tvl-history`, `defi-fees`, `defi-dex-volume`, `stablecoins`, `stablecoin-supply-history` - $0.001 to $0.003 a call |
| **Solana token intel** | `sol-token-pairs`, `sol-token-search`, `sol-trending`, `sol-price`, `sol-swap-quote`, `sol-token-lookup` - markets, prices and routing for any mint |
| **Crypto market coverage** | `crypto-news`, `crypto-indicators` (RSI, MACD, moving averages, computed here), `crypto-market-pulse`, `coin-profile`, `coin-history`, `coin-ohlc`, `coin-market-chart-range`, `coin-categories`, `coin-price-by-contract` (price by token ADDRESS, no coin id needed), `global-defi`, `exchanges`, `exchange-tickers`, `exchange-rates`, `coin-search`, `coins-list` - plus tokenized real-world assets from the same CoinGecko key: `rwa-list`, `rwa-markets`, `rwa-asset`, `rwa-issuers`, `rwa-issuer` (tokenized stocks, ETFs and commodities with onchain market data and the issuers behind them) |
| **Indexed chain data** | `asset-transfers` (filtered transfer history), `token-balances`, `token-allowance`, `tx-receipt` (decoded transfers), `block-receipts`, `token-price-history` - indexed reads across the major EVM chains, no node and no key of your own |
| **Farcaster social** | `fc-cast-search`, `fc-channel-feed`, `fc-trending`, `fc-user-casts`, `fc-cast`, `fc-cast-replies`, `fc-channel`, `fc-user-search`, `fc-cast-metrics` - search, feeds and engagement metrics on the onchain social graph |
| **Site crawling** | `site-map` (enumerate a site's URLs) and `site-crawl` (breadth-first crawl to clean markdown, robots-respecting, hard page/depth/time budgets) - the deterministic pair behind any "read this whole site" task |
| **Macro (FRED + more)** | yield curve, treasury, fiscal, Fed funds, CPI, unemployment, Sahm rule, ECB FX, World Bank, FRED bulk release observations |
| **SEC EDGAR** | ticker→CIK, filing list, 10-K/10-Q text, XBRL frames, insider transactions, 13F holdings, IPO calendar, full-text search |
| **Finished reports (cited)** | `research`/`research-pro`/`research-max` (grounded deep research), `market-brief`, `dossier`/`dossier-max` (company due diligence), `fund-report`/`fund-report-max` (13F portfolio), `domain-audit`/`domain-audit-pro` (graded security + deliverability), `recall-report` (FDA), `insider-report` (Form 4 flow), `token-risk`/`token-risk-pro` (on-chain contract risk), `filing-report` (latest SEC filing), `token-brief` (Solana mint risk evidence, available while its data source answers), `ticker-pack` (dossier + insider flow + holders), `ipo-report` (S-1 + 424B4 digest, deterministic) - $0.05 to $2.00 per report over x402 / MPP, or $2 to $5 by card at /reports; see the `/v1` table below |
| **Network truth** | `dns`, `dns-lookup`, `tls-cert`, `whois`, `http-check`, `robots-check`, `email-validate`, `ip-info` |
| **Crypto & payments** | `usdc-balance`, `tx-status`, `gas-estimate`, `ens-resolve`, `x402-quote`, `x402-verify`, `transfer-authorization` - non-custodial, multi-chain (Base/Polygon/Arbitrum/Optimism/Ethereum) |
| **Agent memory** | wallet-keyed KV + TTL, atomic counters, cross-wallet grants, hash-chained audit log, similarity recall |
| **Stats & forecasting** | `stats-summary`, `correlation`, `linear-regression`, `moving-average`, `outliers`; `forecast-naive`, `forecast-ses`, `forecast-holt`, `forecast-holt-winters` + `forecast-eval` (MAPE/RMSE backtest) |
| **Finance math** | `black-scholes` (option pricing + greeks), `bond-price`/`bond-ytm`, `cagr`, `sharpe-ratio`, `annuity`, `npv`/`irr`, `compound-interest`, `loan-payment`/`amortization`, `break-even`, `effective-annual-rate` (pure-CPU, deterministic) |
| **Compression** | `gzip`/`gunzip`, `brotli-compress`/`brotli-decompress`, `compress-compare` (algorithm shootout, pure-CPU via node:zlib) |
| **HTML extraction** | `html-select` (CSS query), `html-table`, `html-strip`, `html-links`, `html-meta` - deterministic counterpart to `extract` |
| **Network ops** | `dns-lookup`, `dns-propagation`, `spf-check`/`dmarc-check`/`dkim-lookup`, `email-deliverability`; `cert-transparency`, `http-headers` (security audit), `tech-stack`, `asn-info` (IP geo) |
| **Chain reads** | `block-number`, `chain-info`, `block-info`, `contract-code`, `erc721-owner`, `event-logs` - keyless JSON-RPC reads with multi-endpoint failover on Ethereum/Base/Polygon/Arbitrum/Optimism, from $0.001 |
| **SQL policy** | `sql-guard` ($0.004 - pass/warn/block verdict with named risks on a SQL statement, plus an Ed25519-signed check result when a signing key is configured), `sql-cert-verify` ($0.001 - verifies that signed result against the exact statement) |
| **x402 seller intelligence** | Three rungs on the same question, cheapest first. `seller-trust` (`GET /api/x402/seller-trust`, $0.005) - the router's gate field by field: indexed, manifest parses, chains advertised, settled calls observed, would we spend buyer money there. `seller-dossier` (`POST /api/seller-dossier`, $0.05) - the assembled record: every price with its provenance, advertised wallets against the wallets actually paid, settlement evidence per source, the dispatch verdict per chain with its reason, and what happened the times our router paid it. `seller-payability` (`POST /api/seller-payability`, $0.10) - buys one real call right now and reports every leg, including whether the accept's EIP-712 domain matches the token it names. The first two are offline reads of what we already know; the third spends USDC to find out |
| **150+ pure-CPU utilities** | hashing, JWT, base58, JSON⇄CSV/YAML, `token-count`, `text-chunk`, `json-validate`, text stats, cron math, validators, unit conversions across 13 categories (one parametric tool) |
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=` 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.
## LLM gateway (`/v1`) - chat, embeddings, rerank, images, speech & finished reports, pay per call
Point 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
also works, see For humans):
Endpoint · Price · Serves
`POST /v1/nano/chat/completions` · $0.003 · nano models - priced for high-frequency agent loops
`POST /v1/auto/chat/completions` · $0.01 · **no model needed** - deterministic eval-ranked routing (code / reasoning / long / general), optional `quality: fast \ · balanced \ · best` at the same price, decision disclosed via `agent402_router`
`POST /v1/chat/completions` · $0.02 · budget/mid models (gpt-4o-mini, claude haiku, gemini flash, deepseek, llama…)
`POST /v1/pro/chat/completions` · $0.10 · mid-frontier (gpt-4o, gpt-4.1, gpt-6 sol, claude sonnet, gemini pro, grok)
`POST /v1/premium/chat/completions` · $0.50 · frontier (gpt-5 and gpt-6 astra, o3, claude opus and claude fable 5.1)
`POST /v1/grounded/chat/completions` · $0.03 · the auto router plus a live web search on every call - answers carry OpenAI-wire `url_citation` annotations; never cached
`POST /v1/{nano,auto,pro,premium}/messages`, `POST /v1/messages` · tier price · the **Anthropic Messages wire** on every tier (same allowlist, caps and failover as the chat route); `effort` (low to max) is the depth control on Claude 4.7+, older Claude takes `thinking.budget_tokens`
`POST /v1/{nano,auto,pro,premium}/responses`, `POST /v1/responses` · tier price · the **OpenAI Responses wire** on every tier (function tools only, no server state)
`POST /v1/embeddings` · $0.002 · OpenAI embeddings, batch up to 64 inputs - identical repeats are **free**: the repeat's payment is not charged, except a Tempo transfer sent before the call, which is final when sent (deterministic output, cache default-on)
`POST /v1/rerank` · $0.002 · Cohere-compatible rerank (`{query, documents[], top_n}`), up to 50 documents, cache default-on
`POST /v1/images/generations` · $0.08 · image generation (FLUX.2 Pro, 1024x1024 PNG) - OpenAI images wire, inline base64 out
`POST /v1/images/fast` · $0.02 · budget text-to-image, same OpenAI images wire, about two seconds a picture
`POST /v1/images/pro` · $0.05 · higher-fidelity text-to-image, one picture a call
`POST /v1/videos/generations` · $0.20 · text-to-video: one silent 4-second 720p clip, MP4 inline base64, 16:9 or 9:16
`POST /v1/audio/speech` · $0.06 · text-to-speech, OpenAI `audio.speech.create()` wire - up to 2,000 chars in, raw mp3 (default) or pcm bytes out, five-model failover chain
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):
| Endpoint | Price | Report |
|---|---|---|
| `POST /v1/research` · `/v1/research/pro` · `/v1/research/max` | $0.60 · $0.85 · $1.10 | deep research report (`{query}`) - grounded multi-search, rerank, cited synthesis |
| `POST /v1/research/market-brief` | $0.85 | market / competitor brief (`{query}`) |
| `POST /v1/dossier` · `/v1/dossier/max` | $0.85 · $1.10 | company due-diligence dossier (`{ticker}`) - filings, insider flow, web |
| `POST /v1/fund` · `/v1/fund/max` | $0.60 · $0.85 | fund portfolio report from the latest 13F (`{manager}`) - bought/sold last quarter |
| `POST /v1/domain-audit` · `/v1/domain-audit/pro` | $0.60 · $0.85 | graded domain security + deliverability audit (`{domain}`) |
| `POST /v1/recall-report` | $0.60 | FDA recall report, drug/food/device (`{query}`) |
| `POST /v1/insider-report` | $0.60 | insider flow report from parsed Form 4 filings (`{ticker}`) |
| `POST /v1/filing-report` | $0.85 | latest SEC filing read and summarized with the facts that moved (`{ticker}`) |
| `POST /v1/token-brief` | $0.60 | Solana token risk evidence from on-chain and market data (`{mint}`), available while its data source answers |
| `POST /v1/ticker-pack` | $2.00 | one ticker in one report: dossier, insider flow and holders |
| `POST /v1/token-risk` · `/v1/token-risk/pro` | $0.60 · $0.85 | token and contract risk report from on-chain evidence (`{address, chain}`) |
| `POST /v1/ipo-report` | $0.05 | IPO pipeline digest, S-1 + 424B4 from EDGAR full-text search (`{days, keyword}`), deterministic |
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.
## For humans: reports and monitors
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):
| Page | What you get |
|---|---|
| agent402.tools/reports | Buy any finished report from the table above by card (`POST /api/buy`) for $2 to $5 (the deepest tiers and the ticker pack sit at the top of that range; current prices on the page), delivered at `/r/` - no wallet, no account. The card price includes payment processing; an agent paying per call pays the lower tool price for the same report. A report is generated only against a Stripe-verified paid session, once; a failed generation is refunded automatically. |
| agent402.tools/monitors | $5/month subscriptions that re-run a report when something changes and email you (up to 4 full reports in any 30 days; a change past that arrives as an alert email): **domain security monitor** (free daily re-probe, full paid re-run on a security change, a certificate inside 14 days of expiry, or every 30 days), **SEC filing watch** (new filing), **Solana token risk watch** (changed risk facts, available while its data source answers), **fund 13F watch** (new filing), **FDA recall watch** (new recall number), **insider flow watch** (new Form 4), **IPO pipeline watch** (weekly digest). Reports land at `/m/`; manage or cancel through the Stripe Customer Portal at `/monitors/manage`. |
| agent402.tools/credits | Prepaid credits: a prepayment for Agent402's own services, for business and developer use (the page says whether packs are on sale). Send a key (`a402_…`) as `Authorization: Bearer a402_…` on a priced route and the call is paid from the key - **debited only on a successful response**, integer micro-dollars so sub-cent prices are exact; credits never expire and carry no fees, and are not transferable or redeemable for cash. `GET /api/credits/balance` (same header) reads the balance; a 402 with `{reason, balanceUsd, topup}` means insufficient. Identity-bound tools (`/api/memory*`, `my-usage`) refuse credits because the payment is the identity there; pay those over an x402 rail. Routes that buy from an outside seller with our wallet (the route-execute tiers, `seller-payability`, `/api/decide/execute` and the flight routes) take a wallet payment only (x402, or MPP on a chain). |
A credits key is understood by the SDKs: `agent402-mcp` reads
`AGENT402_CREDITS_KEY` and `agent402-client` takes `{ creditsKey }`.
## Decide - describe the job, get the plan
`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.```bash
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"}'
- Neutral ranking. One formula scores every candidate (fit, observed reliability, price,
schema quality, freshness) with no term for who sells the tool, and every step says whether
the tool is ours (firstParty). - The fee comes back. A decision paid with a wallet returns its fee as a 24-hour credit toward
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 on x402. Because it can
buy from outside sellers, execute is paid from a wallet (x402, or MPP on a chain). - On MCP the same pair is
decide.plananddecide.execute;decide.feedback(free) records
whether a step worked. Page: agent402.tools/decide.
Skill packs - 70+ multi-tool workflows
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.
| Featured pack | Chains | Use it for |
|---|---|---|
security-audit |
cert-transparency · dns-lookup · spf-check · dmarc-check · http-headers · tls-cert · tech-stack | Domain security posture |
trend-analysis |
stock-history · fred-series · stats-summary · moving-average · linear-regression · outliers · correlation · forecast-eval | Quant workup on any time series |
structured-scrape |
extract · render · html-select · html-table · html-strip · html-links · html-meta | Deterministic scraping decision tree |
decode-blob |
jwt-decode · gunzip · brotli-decompress · base64 · hex · json-format · hash | Identify and peel any opaque string |
forecasting-bake-off |
stock-history · fred-series · forecast-eval · forecast-naive · forecast-ses · forecast-holt · forecast-holt-winters | Rank 4 forecasters by RMSE, pick the winner |
document-intel |
pdf-info · pdf-to-markdown · pdf-extract-pages · image-ocr · barcode-decode · pdf-merge · images-to-pdf | PDF/OCR/barcode pipeline |
status-snapshot |
dns-lookup · http-check · http-headers · tls-cert · robots-check | One-shot service-health sweep |
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.
x402 Index - Find · Route · Leaderboard
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.
| Surface | What |
|---|---|
GET /api/find?q={task} |
Resolve a task to the best-matching tools (route, price, schema, ready example) |
POST /api/route |
Smart Order Router: { query, top, include } → ranked tools across sellers (match score, then health, then price; a judgment model then moves the listing that actually does the task to the top, cheapest among equally good ones, reported in judged). include=external excludes Agent402 itself |
…(正文过长,页面只展示前面部分,完整内容见仓库)
