🪙 Tollbooth

agenttoll.dev is a marketplace of receipt-backed paid work products exposed through the Model Context Protocol. Any MCP-compatible agent — Claude, Cursor, custom builds — can discover a task, inspect the price and seller metadata, cap the spend, call the tool, and receive structured JSON with a receipt envelope. Payment happens through the x402 protocol: the agent attaches a USDC micropayment to the request, the server verifies it on-chain, and returns the finished work. Pennies per task. No signup, no billing dashboard, no API key management.

One-line pitch: checkout infrastructure for agent-bought work, except the checkout is a 402 response with a payment challenge instead of a credit card form.

Point any MCP-compatible client at the endpoint:

{
  "mcpServers": {
    "tollbooth": {
      "url": "https://agenttoll.dev/mcp"
    }
  }
}

That's it. The server advertises all 100 tools with their schemas and prices. Your agent picks the ones it needs.

Send a few dollars of USDC (Base mainnet) to a wallet your agent controls. That's the only balance you need. One cent covers 10–100 tool calls depending on the tool.

Your MCP client handles the payment flow automatically. When you call a paid tool, the server responds with HTTP 402 and a payment challenge. Your client signs the payment, re-sends the request, and gets the data back. You don't write any payment code.

Base MCP gives assistants a user-approved Base Account wallet path for x402 payments. AgentToll ships an Agent Skill that helps an MCP assistant inspect route metadata, verify the Base USDC seller address, cap the payment, explain the purchase, and refuse unsafe calls before asking the user to approve a spend.

npx skills add huwhitememes/tollbooth --skill agenttoll-base-mcp-buyer

• Skill source: skills/agenttoll-base-mcp-buyer/SKILL.md
• Web copy: agenttoll.dev/agenttoll-base-mcp-skill.md
• Builder article: Base MCP Turns AI Agents Into x402 Buyers

  Agent                    Tollbooth                 Base Mainnet
    │                          │                          │
    │── tool call ────────────▶│                          │
    │                          │                          │
    │◀── 402 Payment Required ─│                          │
    │    (price, scheme,       │                          │
    │     accept tokens)       │                          │
    │                          │                          │
    │── signed USDC payment ──▶│                          │
    │    (x402 exact scheme)   │                          │
    │                          │── verify on-chain ──────▶│
    │                          │◀── ✓ valid ──────────────│
    │                          │                          │
    │◀── 200 OK + tool result ─│                          │
    │                          │                          │

What the agent sees: A normal MCP tool call that costs money. The 402 → payment → retry cycle is handled by the x402 client library. No manual signing, no transaction monitoring.

What the developer sees: A single endpoint. No auth headers, no API keys to rotate, no rate limit tiers to manage. The price is in the tool schema — your agent can decide whether a call is worth it before paying.

Total: 100 tools. Browse all of them at agenttoll.dev/tools.

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { exactEvmClientExtension } from "@x402/evm/exact/client";

// 1. Create an MCP client with x402 payment support
const client = new Client({
  name: "my-agent",
  version: "1.0.0",
});

const transport = new StreamableHTTPClientTransport(
  new URL("https://agenttoll.dev/mcp"),
  {
    // x402 exact payment extension — handles 402 → sign → retry
    extensions: [
      exactEvmClientExtension({
        walletClient: yourBaseWalletClient, // viem wallet on Base
      }),
    ],
  }
);

await client.connect(transport);

// 2. List available tools (free — no payment needed for discovery)
const { tools } = await client.listTools();

// Each tool's price is in the schema:
// tools[0].annotations.price_usd → "0.03"
// tools[0].annotations.x402_price → { scheme: "exact", ... }

// 3. Call a paid tool — payment happens automatically
const result = await client.callTool({
  name: "cross_platform_arb_scan",
  arguments: {
    query: "bitcoin",
    min_net_edge: "0.015",
  },
});

// result.content[0].text → JSON with cross-platform arbitrage opportunities
// Your wallet was debited $0.10 in USDC on Base. That's it.
console.log(result.content[0].text);

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "tollbooth": {
      "url": "https://agenttoll.dev/mcp"
    }
  }
}

Claude will discover all 100 tools automatically. (Note: Claude Desktop needs an x402-compatible payment wallet to complete paid calls — the discovery and schema listing are free.)

                    ┌─────────────────────────────────┐
                    │      agenttoll.dev (edge)        │
                    │    Cloudflare Worker (Hono)      │
                    │                                  │
  MCP Request ─────▶│  ┌─────────────┐  ┌──────────┐  │
  (JSON-RPC over    │  │  MCP Server  │  │ x402     │  │
   HTTP/SSE)        │  │  (Durable    │  │ Payment  │  │
                    │  │   Object)    │  │ Middleware│  │
                    │  └──────┬───────┘  └────┬─────┘  │
                    │         │               │        │
                    │  ┌──────▼───────────────▼─────┐  │
                    │  │    Tool Implementations     │  │
                    │  │  (scrapers, API wrappers,   │  │
                    │  │   data feeds, analyzers)    │  │
                    │  └──────────────┬──────────────┘  │
                    │         ┌───────┴────────┐        │
                    │    ┌────▼────┐    ┌──────▼─────┐  │
                    │    │ KV Cache │    │ Public     │  │
                    │    │ (15min   │    │ APIs       │  │
                    │    │  TTL)    │    │ (no keys)  │  │
                    │    └─────────┘    └────────────┘  │
                    └─────────────────────────────────┘
                                     │
                    ┌────────────────▼────────────────┐
                    │   x402 Facilitator               │
                    │   facilitator.payai.network      │
                    │   Verifies USDC payment on Base  │
                    └─────────────────────────────────┘

Stack: TypeScript · Hono · Cloudflare Workers · Durable Objects · KV · @modelcontextprotocol/sdk · @x402/core · @x402/hono

Many current tools use free, keyless public sources — USAspending.gov, SEC EDGAR, CourtListener, PubMed, NASA FIRMS, NOAA, USGS, Polymarket, Kalshi, Reddit, GitHub, and others. That is the supply layer, not the product. agenttoll.dev packages sources into agent-buyable work: task-shaped outputs, buyer metadata, spend caps, structured results, and receipts. You pay for the finished work and payment-safe packaging, not for raw public data.

agenttoll.dev publishes a machine-readable manifest at the standard location:

https://agenttoll.dev/.well-known/agent.json

This follows the emerging agent discovery spec — identity, endpoint, payment config, and full tool catalog with prices. Agents can discover agenttoll.dev the same way crawlers discover robots.txt.

{
  "schema_version": "0.1",
  "name": "agenttoll.dev",
  "description": "Paid MCP and HTTP tools for prediction market intelligence...",
  "homepage": "https://agenttoll.dev",
  "mcp": "https://agenttoll.dev/mcp",
  "contact": { "name": "Hu White", "email": "memerhuwhite@gmail.com" },
  "payments": {
    "protocol": "x402",
    "scheme": "exact",
    "network": "eip155:8453",
    "network_name": "Base mainnet",
    "asset": "USDC",
    "asset_contract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "facilitator": "https://facilitator.payai.network",
    "seller": "0x62a0D3d9DF0dE8804983009949c714EaeAFd87F1"
  },
  "tools": [ ... 100 tools with name, price_usd, description, input schema ... ]
}

agenttoll.dev is live and functional, but it's not pretending to be something it isn't:

• No uptime SLA. This runs on a Cloudflare Worker. It's reliable for a solo project, but there's no redundancy beyond what Cloudflare provides. Don't build life-critical infrastructure on it.
• Data is as fresh as the upstream APIs. Most tools cache responses for 10–15 minutes in KV. If a source API is down, the tool is down. Polymarket, SEC EDGAR, and CourtListener have all had outages in 2026.
• Prices may change. Current pricing ($0.01–$0.10) reflects what a solo operator can sustain. If upstream APIs start rate-limiting or adding their own costs, prices go up. The agent.json always reflects current pricing — your agent reads it dynamically.
• No data guarantees. These are wrappers around public APIs. If the FDA reports bad data, agenttoll.dev returns bad data. Verify before making decisions with real money.
• x402 is early. The protocol works (payments settle on Base mainnet), but the client ecosystem is still maturing. If your MCP client doesn't support x402 payment extensions yet, paid calls will fail with a 402 you can't resolve. Discovery and schema listing work for any MCP client.
• No rate limiting beyond politeness. Tools self-throttle to respect upstream API limits (e.g., 9 req/sec for SEC, 2 req/sec for FRED). There's no per-customer rate limiting — if you hammer the endpoint, you'll get errors from upstream APIs, not from agenttoll.dev.

The agenttoll.dev service is free to use (you only pay per call). Source code in this repo is provided for reference and self-hosting. See LICENSE if present.

The underlying data tools aggregate from public APIs under their respective terms of service (USAspending.gov public domain, SEC EDGAR public domain, NOAA/USGS public domain, etc.).