Get paid by AI agents.In USDC and Pix.
Agents do not fill forms and they do not wait. Your API, your MCP server, or a simple link answers 402; they pay in USDC, or Pix on links; every settlement seals a receipt you can prove.
the card on the right is live: curl gw.codespar.dev/e2e-live answers 402 and settles a real cent on Base
every payment seals a hash-chained receipt · rcpt_ILLNDmWV
One gateway, both directions.
Money moves both ways and the plumbing is the same: a signed authority, a settlement, a receipt. Pick the side you came for.
You get paid.
Put a price on what you already serve. Agents pay before your backend does the work.
You send agents out to spend.
Give an agent an allowance instead of an API key. It pays, inside the cap you signed.
Three ways to get paid by an agent.
All three pay you in USDC over x402, Pix on links, into the same wallet, with the same verifiable receipt. Pick the one that fits how you sell.
No checkout page, no invoice run, no card acquirer. The 402 is the invoice; the receipt is your ledger.
Gate
Livex402 paywalls for what you already serve. Your API charges per call and your MCP server charges per tool, before the request ever reaches your backend. You publish a price; agents pay it.
agent → gw.codespar.dev/you → your API
agent → gw.codespar.dev/mcp/you → tools/call
live on Base mainnet
Meter
BetaFor work you can only price after it runs. The agent signs a cap up front, you meter what it actually used, the difference goes back on-chain, and the receipt is re-sealed with the real number.
signed cap → meter → refund → re-seal
beta, behind a flag
Collect
Early accessOne link any agent can pay in USDC, and any Brazilian can pay in Pix. You fulfill only after it is verified.
agent → gw.codespar.dev/pay/you → USDC
human → same link → Pix
early access
A fixed price per call. Set it once, publish, done.
LivePrice by paid-call volume. The price per call drops as an agent keeps buying.
LivePrice set at request time by your own endpoint, so cost can follow the payload.
LivePrice by tokens processed, metered against the signed cap.
BetaPrice by compute time, metered against the signed cap.
BetaPrice per unit returned, metered against the signed cap.
BetaEach MCP tool carries its own price, charged before that tool runs.
LiveOne link. USDC from any agent today, Pix when the Brazilian rail lands.
Early accessFive minutes, no card acquirer.
Five-minute setupPoint the gateway at a URL you already serve, choose flat, tiered, dynamic or per-tool, and publish. No merchant account, no underwriting, no settlement window: the first agent that pays settles straight into your wallet.
Gate is proven on Base mainnet with real USDC, per call and per tool. Meter is in beta behind a flag while we settle the refund math in public. Collect is in early access; the Pix leg lands with our Brazilian production rail.
Usage-based, without trusting anyone's meter.
Fair prices are easy; fair caps are hard. The agent pre-authorizes a signed ceiling, you charge what was measured, the difference goes back on chain.
Settlements, not screenshots.
Every row below is real and live on Base mainnet right now, including our own Agent-Ready Check, which is itself a paywalled x402 endpoint. Curl any of them and a 402 comes back; open the hash and check the settlement yourself, with no API key and no call to us.
every row seals a hash-chained receipt, verify it offline · rcpt_ILLNDmWV · earlier mainnet settlements: a stranger's API 0x739d2d12… · our own seller wallet 0xd92e0aa8…
Deliberately small day-one amounts, hard-capped at $1 per payment while the lane is young. The point is the loop, not the volume.
Six things agents are paying for today.
A stranger's API
$0.001 · proven on mainnet
An agent finds a paid endpoint through discovery, pays it, and gets the data. No account, no key, no prior relationship. We proved this one on mainnet.
Reports that render
from $0.01 per render
A report, an image, a video: charge only when the artifact renders, at the price of that render.
Tools by the call
each tool, its own price
An MCP server where each tool carries its own price, charged before the tool runs.
A cart that closes in Pix
USDC or Pix · one link
A checkout link that takes USDC from a global agent or Pix from a Brazilian one. Same link, verified before fulfillment.
Also settles in Pix.
Subagent payroll
$0.10 · proven wallet to wallet
A parent agent settles its helpers wallet to wallet when the task lands: three subagents, three receipts, and the orchestrator can prove where every fraction went.
Also settles in Pix.
Credit packs
one-time · closes after first payment
Sell a bundle of calls once; the one-time link closes after the first payment.
Also settles in Pix.
Sign the purpose. The agent runs.
The scariest demo in agent payments is a retry loop with a wallet. Every payment on this page ran under a signed mandate, not a blank check, and the cap is cryptographic: it lives in the signature, not in a proxy setting someone can edit.
The agent drafts the intent
Budget and purpose, in plain terms: what it wants to spend, on what, and up to how much.
The owner signs once
A single signature authorizes the mandate: scope, cap, expiry. No re-approval per transaction.
Every spend is checked
Off-mission spend is refused at the wallet, before anything touches the chain.
Do not make your agent stop and wait for you. Let it run inside the intent you signed.
We tried paying $2 against a $1 cap. Refused before anything touched the chain (422 x402_mainnet_cap_exceeded).
Every settlement closes with a hash-chained receipt, the same audit primitive that backs every payment CodeSpar routes. Selling is the top half of this page; this is how you send your own agents out to buy, with an allowance instead of an API key.
One wallet per agent. One mandate over it.
An agent that can earn and an agent that can spend need somewhere to keep the money. Each one gets its own wallet, non-custodial, with a slot per rail: dollars stay dollars and reais stay reais, no synthetic FX in between.
The same signed mandate governs both slots. What the agent may spend, and where, is decided before the money moves, not after.
Illustrative balances from a sandbox agent. What matters: the wallet belongs to the agent, the mandate belongs to you, and neither one is us holding your money.
One governed call, any rail.
Your agent calls pay once. The runtime checks the mandate, picks USDC over x402 or Pix in Brazil, and seals the receipt. USDC/x402 is one slot of that wallet; the Pix lane is the same runtime, already proven in production in Brazil.
The x402 web is already selling.
Real endpoints charging agents per call today, ours among them. An agent discovers them through Coinbase's Bazaar or x402scan, pays, and gets the resource.
e2e-live
gw.codespar.dev/e2e-live
Our permanent $0.01 paywall on Base mainnet. Pay it right now; this is the pipeline every shape above runs on.
Superhighway
superhighway.walls.sh
Web search for agents, five tools at $0.001 per query.
tx402.ai
tx402.ai
LLM inference gateway across 20+ models, paid per call.
Arch Tools
archtools.dev
58 API tools: web scraping, crypto data, OCR.
x402 Video
x402-video.com
AI video generation, paid per render.
2s.io
2s.io
35 JSON endpoints, sub-cent to $0.03.
Directories: Coinbase Bazaar · x402scan · Awesome Agentic Commerce LATAM (the LATAM index, maintained by us)
From zero to a settled payment in five minutes.
Checkout was designed for humans; agents get a status code. Curl the live demo and read the 402 with your own eyes, then create a mandate and let your agent pay it.
Every step assumes a person is watching a screen. An agent has no screen, no phone and no patience, so it gives up or it hardcodes your card.
One round trip over plain HTTP. The cap was signed before the call, and the receipt is sealed the moment it settles.
HTTP/1.1 402 Payment Required Content-Type: application/json { "x402Version": 2, "error": "payment required", "resource": { "url": "https://gw.codespar.dev/agent-ready", "mimeType": "application/json", "description": "Agent-Ready Check" }, "accepts": [ { "scheme": "exact", "network": "eip155:8453", "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "amount": "40000", "payTo": "0x158E0638D971adB1f814A7F9f7ae891d4e1eF792", "maxTimeoutSeconds": 120 } ] }
What gw.codespar.dev/agent-ready returns before payment: our own check, priced at $0.04 a call. A real HTTP 402 shaped by the x402 spec, not a screenshot. Amounts are USDC minor units, so 40000 is $0.04.
Short answers to the obvious questions
Day one of production called for a short cap. The pipeline (mandate, hold, settlement, receipt) is the same for $100. The ceiling is an env var, not architecture.
It is machine payment. USDC over x402 is the global micropayment rail between agents. The same wallet also carries BRL/Pix slots. No synthetic FX; each currency stays on its own rail.
You can. Every transaction links to Basescan, the public block explorer for Base. No API key and no call to CodeSpar required to check it.
The URL leg is gasless for the payer; the facilitator's relayer covers gas. A direct wallet-to-wallet transfer costs about $0.001 in gas on Base.
A signed authorization: cap, scope (which payees), and expiry. The agent can only spend inside it. Spend outside the mandate is refused at the wallet, before anything settles.
Gate is live on Base mainnet. Meter is merged and in final validation behind a flag. Collect links are in early access; the Pix leg lands with our Brazilian production rail.
Take your first $0.01 from an agent.
The permanent $0.01 demo is live right now, and the Monetize hub creates yours in minutes. Your backend keeps speaking plain REST; the gateway does the money.
gate: live · meter: beta · collect: early access