Any AI Agent With an EIP-3009 Wallet Can Pay For Your MCP Tools#
Founding Member rate ends June 10, 2026. Activate x402 pricing on any server before June 10 to lock in the 85% Founding Member revenue share forever. Servers activated after June 10 get the standard 80% share, same number as Stripe.
TL;DR: MCPize just shipped x402 to production. Servers can charge agents USDC per tool call. The agent signs an EIP-3009 authorization, the facilitator broadcasts on Base, the server returns the result. Four seconds end-to-end. No subscription, no API key, no checkout page. First $0.01 already settled on Base mainnet. Founding Member rate (85% to publisher) is permanent for anyone who activates before June 10.
A wallet I created five minutes ago just paid my server $0.01#
There's a Coinbase Wallet on my desktop that says $0.01.
The USDC arrived from a wallet I generated with viem.generatePrivateKey() five minutes earlier. The wallet paid my own MCPize server $0.01 to call a tool named echo. The tool returned a JSON timestamp. The whole loop took four seconds.
Proof: 0xfba0c6e...a771 on Base mainnet.
This is the first real-money x402 payment MCPize has ever processed.
HTTP 402 was reserved in 1997. Nobody used it for 30 years.#
The HTTP status code 402 has existed in the spec since RFC 7231. The official description is one line: "reserved for future use." Browsers ignored it. Servers never returned it. The whole web ran on subscriptions, API keys, and OAuth instead.
Then Coinbase shipped a facilitator in April 2026 and the protocol finally has working infrastructure. The flow is short:
- Agent calls
tools/call - Server responds
402 Payment Requiredwith a JSON body that says "send 0.01 USDC on Base, here's the recipient, here's the EIP-712 domain" - Agent signs an EIP-3009
TransferWithAuthorization(off-chain, gasless for the agent) - Server forwards the signed authorization to the CDP facilitator
- Facilitator broadcasts the transfer on Base
- Server returns the tool result
No accounts. No invoices. No reconciliation. The agent has a wallet. The server has a price. Settlement happens on Base in roughly four seconds.
Why this matters specifically for MCP#
AI agents are already calling tools. They don't have credit cards. They can't fill out a Stripe checkout form. Try asking Claude to subscribe to your API and you'll see the failure mode in real time.
What they can do is sign an EIP-3009 message in 50 milliseconds.
x402 is the missing payment rail for software that buys from software. MCP is the first major catalog of tools agents call. Combining the two means agents can pay for tools as easily as they pay for tokens.
Six weeks and 15 spec fixes#
The happy path I described is what the documentation promises. Building the production version was different.
Phase 0 through 3 took five weeks: schema migration, Zod validators, CLI manifest support, gateway middleware, Payments tab in the dashboard, marketplace badges, docs pages. Mostly straightforward work.
Then I deployed to production and the first live request returned 401.
The auth layer was rejecting anonymous requests before the x402 middleware could see them. Unit tests with mocked auth never caught it. Fix: a pass-through when the server has a pricing block configured.
The next request returned 400 from the facilitator. The schema validator wanted a mimeType field that the canonical x402 spec marks optional. Our facilitator request body had drifted out of sync with the 402 challenge body. Unified the builders.
Then signature recovery started failing on Sepolia. I ran cast call against Circle's USDC contract and discovered the testnet contract publishes name() = "USDC", not "USD Coin" like mainnet. Every test signature was failing EIP-712 verification with a misleading "invalid signature" error.
At that point I dispatched a background agent to audit the entire stack against the canonical x402 spec at github.com/coinbase/x402. It found five critical gaps and ten minor ones. We fixed all 15.
The most subtle ones:
PaymentHeaderSchema.signatureregex was fixed at 65 bytes. EIP-1271 contract-wallet signatures (Coinbase Smart Wallet, Safe) are variable length. We were silently rejecting every smart-wallet payment with a "wrong signature length" error.X-PAYMENT-RESPONSEwas missingsuccess: true. The canonical SettlementResponse schema requires it. The reference clientx402-fetchrejects the header without it.- 402 error body had no
accepts: [requirement]field. Without it, clients can't re-sign and retry on a transient facilitator failure. - Hardcoded
x402Version: 1in the facilitator body. Should mirror the payload's version. Doesn't bite today, would break the day we add v2.
Each one is a paper cut. Together they decide whether a developer trying your server says "this works" or "this is broken."
What it looks like for publishers#
If you publish an MCP server on MCPize, the setup is point-and-click in the dashboard:
- Open your server's Payments tab
- Toggle "Accept x402 payments"
- Paste your wallet address (the input validates EIP-55 checksum and suggests a fix if you paste a lowercased one)
- Set a price per tool ($0.01 to $100 per call, six decimals of precision)
- Save
The marketplace immediately shows a "Pay-per-call" chip on your server card. Your mcpize.yaml manifest can also carry the same pricing block, with the dashboard reflecting any divergence.
Real-time tracking lives in the same tab: a payments ledger with BaseScan deep-links per settlement, lifetime revenue counter, last 7-day total with delta vs the prior week, and a 7-day sparkline. Each settlement records the developer's revenue_share_pct at the moment of payment, so a Founding Member rate stays locked even if platform rates change later.
100% of the USDC settles directly to your wallet. We don't escrow, we don't hold a payout schedule, we don't take a cut of revenue you generate via the direct endpoint. The 15% platform fee on x402 payments covers Stripe processing, tax compliance, hosting, support, fraud prevention, and platform promotion.
Full walkthrough at /docs/monetization.
What it looks like for agent builders#
If you call tools from an agent, install x402-fetch:
npm install x402-fetch viemIt wraps fetch and handles the 402 retry:
import { privateKeyToAccount } from "viem/accounts";
import { createWalletClient, http } from "viem";
import { base } from "viem/chains";
import { wrapFetchWithPayment } from "x402-fetch";
const account = privateKeyToAccount(process.env.WALLET_PK as `0x${string}`);
const wallet = createWalletClient({
account,
chain: base,
transport: http(),
});
// Max $0.10 per call. Wrapper rejects anything above this.
const fetchWithPay = wrapFetchWithPayment(fetch, wallet, 100_000n);
const res = await fetchWithPay("https://your-server.mcpize.run/mcp", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "tools/call",
params: { name: "echo", arguments: { text: "hello" } },
}),
});That's the whole client. A full smoke-test script lives in the MCPize repo at scripts/x402-smoke-test.ts.
Founding Member rate ends June 10#
Until June 10, any server that activates x402 pricing locks in 85% revenue share permanently. The same number applies to Stripe subscriptions, so the rate table is unified across payment channels.
After June 10 the standard rate is 80%. New servers from that point onward pay the standard fee. Existing Founding Members keep 85% forever. No expiration, no renewal logic, no re-application.
Configure pricing today at mcpize.com/developer.
The agent economy runs on HTTP. The payment rail is x402. MCPize is the first MCP marketplace to ship it to production.
What's the smallest payment you'd accept for a useful API call?
