Docs

Build with
Wafermap.

Every Wafermap resource is an HTTP endpoint that charges per call with x402 v2. There are no accounts and no API keys: the payment is the authentication.

  • Base URL: https://wafermap.xyz
  • Catalog: GET /v1/resources (free, JSON)
  • Call: POST /v1/<resource-id> with a JSON body
  • Pay: USDG on Robinhood Chain (eip155:4663), or USDC on Solana, Base (eip155:8453), Arbitrum (eip155:42161), Polygon (eip155:137), Arc (eip155:5042) or Soneium (eip155:1868)

Quickstart

New here? Make your first paid call in four terminal steps. The shortest path in code is the SDK or the CLI. Below is the whole protocol by hand: Node 18+ or any modern runtime, with viem. Use a fresh wallet that holds only what your agent should spend.

// npm i viem
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.AGENT_KEY);
const CHAIN_ID = { "eip155:4663": 4663, "eip155:8453": 8453, "eip155:42161": 42161, "eip155:137": 137 };

async function call(id, body, network = "eip155:4663") {
  const url = `https://wafermap.xyz/v1/${id}`;
  const init = { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) };
  let res = await fetch(url, init);
  if (res.status !== 402) return res.json();

  const quote = await res.json();
  const req = quote.accepts.find((r) => r.network === network);
  const nonce = "0x" + crypto.getRandomValues(new Uint8Array(32)).reduce((s, b) => s + b.toString(16).padStart(2, "0"), "");
  const validBefore = BigInt(Math.floor(Date.now() / 1000) + 120);
  const signature = await account.signTypedData({
    domain: { name: req.extra.name, version: req.extra.version, chainId: CHAIN_ID[network], verifyingContract: req.asset },
    types: { TransferWithAuthorization: [
      { name: "from", type: "address" }, { name: "to", type: "address" },
      { name: "value", type: "uint256" }, { name: "validAfter", type: "uint256" },
      { name: "validBefore", type: "uint256" }, { name: "nonce", type: "bytes32" } ] },
    primaryType: "TransferWithAuthorization",
    message: { from: account.address, to: req.payTo, value: BigInt(req.amount), validAfter: 0n, validBefore, nonce },
  });
  const payment = { x402Version: 2, resource: quote.resource, accepted: req, payload: { signature,
    authorization: { from: account.address, to: req.payTo, value: req.amount, validAfter: "0", validBefore: String(validBefore), nonce } } };
  init.headers["PAYMENT-SIGNATURE"] = btoa(JSON.stringify(payment));
  res = await fetch(url, init);
  return res.json(); // { resource, result, receipt: { amountUsd, tx, network } }
}

const out = await call("market-brief", { network: "robinhood" });
console.log(out.result.brief, out.receipt.tx);

How x402 works

  1. Request. POST /v1/<id> with your JSON input. Input is validated first, so a bad request costs nothing.
  2. 402 quote. The response is 402 Payment Required. The body (and the base64 PAYMENT-REQUIRED header) lists accepts: one quote per network with amount (6 decimals), asset, payTo and the token's EIP-712 domain in extra.
  3. Sign. Sign an EIP-3009 transferWithAuthorization for exactly amount to payTo. Signing costs no gas. Send it base64-encoded in PAYMENT-SIGNATURE (the legacy X-PAYMENT header also works).
  4. Deliver. The facilitator verifies the signature, the resource runs, and only then the transfer settles on-chain. The response carries the result, a receipt and a base64 PAYMENT-RESPONSE header with the transaction hash.

Networks & assets

NetworkCAIP-2AssetContractEIP-712 domain
Robinhood Chaineip155:4663USDG0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168"Global Dollar", "1"
Solanasolana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpUSDCEPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1vextra.feePayer
Baseeip155:8453USDC0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"USD Coin", "2"
Arbitrum Oneeip155:42161USDC0xaf88d065e77c8cC2239327C5EDb3A432268e5831"USD Coin", "2"
Polygon PoSeip155:137USDC0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"USD Coin", "2"
Arceip155:5042USDC0x3600000000000000000000000000000000000000"USDC", "2"
Soneiumeip155:1868USDC.e0xbA9986D2381edf1DA03B0B9c1f8b00dc4AacC369"Bridged USDC (Soneium)", "2"

Every asset uses 6 decimals, so a $0.005 call is amount: "5000" on any network. Payments are gasless for you on all of them: the facilitator pays the gas (Coinbase CDP on Solana, Base, Arbitrum, Polygon, Arc and Soneium; Elsa on Robinhood Chain, Arc and Soneium). On Arc, USDC is also the gas token; its ERC-20 face at 0x3600…0000 uses 6 decimals like every other asset here. On Solana the payload is { transaction }: a v0 transaction with SetComputeUnitLimit, SetComputeUnitPrice, a USDC TransferChecked and a Memo, signed by you, with the quote's extra.feePayer as fee payer and its signature left empty. The 402 lists every network a resource can be paid on right now; if you name no network in your payment, Robinhood Chain is assumed.

Endpoints

GET /v1/resourcesFull catalog: id, price, input fields, returns, networks, then live marketplace listings (provider community, id m/<name>). ?provider=wafermap for Wafermap's own only. Free.
GET /v1/resources/:idOne resource. Free.
POST /v1/:idRun a resource. Answers 402 until paid.
POST /v1/m/:nameRun a marketplace listing; paid to its seller. See Calling a listing.
GET /v1/payments?payer=0x…Settled payments for one payer (public on-chain data). Free.
GET /api/discover?q=…Search third-party x402 services in the open x402 Bazaar index. Payable ones (USDG on Robinhood Chain, USDC on Solana, Base, Arbitrum, Polygon, Arc or Soneium) first, each with its price per network. Free.
GET /api/tokens?network=…Swappable tokens: ETH, WETH, the stablecoin and, on Robinhood Chain, every stock token. Free.
GET /api/statsLive totals: resources, paid calls, volume. Free.

Streaming

Every LLM resource can stream its answer. Pay as usual and add Accept: text/event-stream to the paid request: the answer arrives as server-sent events while the model writes. The price and the payment are the same. The payment settles only after the model finished with a non-empty answer: if it cannot start, stops halfway or says nothing, you get an error event and nothing is charged. If you disconnect early, the call still settles once the model finishes.

delta{ text }, the next piece of the answer.
receiptThe settled payment, same shape as the JSON receipt (network, amountUsd, payer, tx, ms). Streams carry no PAYMENT-RESPONSE header, because headers go out before the payment settles.
done{ resource, model, text, usage }, the whole answer once more.
error{ code, message }: stream_broken, empty_answer or settle_failed. Nothing was charged.
const { res } = await x402fetch("https://wafermap.xyz/v1/gemma-4", {
  method: "POST",
  headers: { "content-type": "application/json", accept: "text/event-stream" },
  body: JSON.stringify({ prompt: "Explain x402 in two sentences." }),
}, { signer });
// read res.body as server-sent events: delta, receipt, done (or error)

Paying in $WAFERMAP and free holder calls answer in plain JSON for now.

Metered LLM calls

Every LLM resource can also be paid by the token. Next to the flat price, its 402 quote offers the x402 scheme upto: the agent signs one ceiling, and after the model finishes Wafermap settles only the tokens it used. A short answer costs less than the flat price; a long one never costs more than the ceiling.

RatesOutput tokens cost the resource's flat price per 1,000; input tokens a quarter of that. Holder wallets get the holder rates. The quote carries them in metered (inputPer1kTokensUsd, outputPer1kTokensUsd).
CeilingThe prompt (estimated from its length) plus max_tokens of output, 1,024 by default. At the default it is about the flat price. Lower max_tokens to sign less.
ChargeThe input and output tokens the model reported, at least $0.001 and at most the ceiling. If a model reports no usage, the tokens are estimated from the text and the receipt says so.
NetworksUSDC on Base, Arbitrum and Polygon, settled through Coinbase's facilitator. Not in $WAFERMAP.
SignatureA Permit2 transfer of at most the ceiling. Only the x402 upto proxy (0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002) can spend it, only to Wafermap's address in the quote, only through the facilitator the quote names, and for at most 5 minutes. A wallet that never approved Permit2 for USDC adds an EIP-2612 permit (extension eip2612GasSponsoring), so no gas is needed.
CapsWallet caps and team budgets count the full ceiling, because that is what was signed.
wafermap call llama-4-scout prompt="Say hi in five words." --metered --network base
# ✓ Paid $0.001 USDC for 16 in + 8 out tokens, signed up to $0.006167

The receipt adds metered: { inputTokens, outputTokens, estimated, ceilingUsd, chargedUsd }, and amountUsd is what was charged. It works with streaming too. SDK: wm.call(id, input, { metered: true }). MCP: wafermap_call with metered: true. In the App, tick Pay per token on an LLM resource. CLI 0.4.12 or later.

Errors & refunds

Errors look like {"error":{"code","message"}}. Wafermap settles a payment only after the resource succeeded, so there is nothing to refund: if the model, the chain or the page you asked for fails, the signed authorization is released and never executed.

400 missing_field / invalid_*Your input. Not charged.
402 verify_invalidSignature, amount, balance or network did not check out.
402 nonce_usedThat authorization was already used. Sign a new one.
422 fetch_failedThe link you gave could not be read. Not charged.
422 content_filteredThe image model's safety filter rejected the prompt, after one automatic retry. Rephrase or pick another image model. Not charged.
429 model_busyModel at capacity. Retry. Not charged.
502 *_failed / *_unavailableUpstream failure. Not charged.

Agent wallet

The Wafermap Wallet generates a key in your browser and stores it in local storage. The app signs payments with it inside your per-payment and daily caps, and swaps inside a per-swap cap. Wafermap's servers never receive the key. Export it to use the same wallet from code, and keep only a small balance on it.

CLI

The wafermap command keeps the agent key on your own machine, encrypted with your password (scrypt + AES-256-GCM in ~/.wafermap/keystore.json), and enforces the same caps before it signs anything. Source (MIT): github.com/wafermap/wafermap-cli.

# Node 20+
npm i -g @wafermapxyz/cli                       # or: npm i -g https://wafermap.xyz/cli/wafermap.tgz
wafermap init                                  # new encrypted wallet; prints the EVM and Solana addresses to fund
wafermap limits --per-payment 0.1 --per-day 1 --per-swap 25
wafermap balance

wafermap call prediction-markets query="fed rates"
wafermap call stock-signal symbol=TSLA
wafermap call flux-2-dev prompt="a glossy silicon wafer" --out wafer.png
wafermap discover weather                      # third-party x402 services
wafermap pay https://x402.agentindex.world/weather city=Jakarta
wafermap swap 0.01 ETH USDG                    # KyberSwap route, needs a little ETH for gas
wafermap history

Every payment and swap asks for confirmation unless you add --yes; the caps apply either way. --network base, arbitrum, polygon or solana pays in USDC on that network (swaps run on robinhood or base). Set WAFERMAP_PASSWORD for scripts.

Solana. Every Wafermap wallet (web and CLI) also has a Solana address, derived from the same key, so one backup covers both. It pays x402 services that accept USDC on Solana: it signs a USDC transfer whose network fee the service's facilitator pays, so the wallet needs no SOL. wafermap export-key --solana (or Reveal Solana key in Wallet) gives the key in the form Phantom and Solflare import.

MCP server

Remote: https://wafermap.xyz/mcp (Streamable HTTP, no install). Browse the catalog, read resource schemas, discover third-party x402 services and list swappable tokens for free; wafermap_call runs a paid resource when params._meta["x402/payment"] carries a signed x402 payment, and otherwise returns the payment requirements. Listed in the official MCP Registry as xyz.wafermap/wafermap.

Local, with a wallet: wafermap mcp runs the same tools plus automatic payments and swaps from your encrypted local wallet, inside your caps, for Claude Desktop, Claude Code, Cursor and other MCP clients. Its source is in the wafermap-cli repo. To approve every payment yourself, run wafermap limits --mcp-confirm on (see Where the limits live).

Put the wallet password in your operating system's keychain once with wafermap keychain on (Windows DPAPI, macOS Keychain or the Linux Secret Service, CLI 0.4.0+), so the client config holds no secret. WAFERMAP_PASSWORD in the client's env still works, but then the password sits in plain text in that file.

{
  "mcpServers": {
    "wafermap": {
      "command": "wafermap",
      "args": ["mcp"]
    }
  }
}
wafermap_walletAddress, balances on both chains, caps, today's spend.
wafermap_resourcesThe Wafermap catalog with prices and input fields.
wafermap_callRun a resource and pay it, within the caps.
wafermap_discoverSearch third-party x402 services.
wafermap_payCall any x402 URL and pay it, within the caps.
wafermap_swap_quoteBest KyberSwap route for a trade.
wafermap_swapExecute a swap. Off until you run wafermap limits --mcp-swaps on; then capped per swap.
wafermap_historyRecent payments and swaps.

Where the limits live

Spending limits sit with the key, not with Wafermap. There are two layers, and the first one is the hard one.

  1. The wallet: hard caps. The key and the caps live together, in your browser (Wafermap Wallet) or on your machine (the CLI and the local MCP server, ~/.wafermap/config.json). Before it signs anything, the wallet reads the 402 quote and refuses when the price is above the per-payment cap, or when it would take today's spend past the daily cap. Refused means nothing is signed, so nothing can be charged. Defaults: $0.10 per payment, $1 per day, $25 per swap; MCP swaps stay off until you turn them on.
  2. You: per-payment approval. Clients such as Claude Desktop stop at every tool call and show the resource, the network and the input before you allow it once. To have the wallet itself ask, whatever the client, run wafermap limits --mcp-confirm on and restart the MCP server: every payment and swap then waits for your approval, showing the amount, asset, recipient, network and resource, before anything is signed. A client that cannot show the prompt gets a refusal, never a silent payment.

The daily cap counts what you signed, not what a server reports. Every payment is recorded at its full signed amount the moment it is signed, before it is sent, and stays counted whatever the server answers: an error, a receipt saying $0, or no answer at all. If another process or tab used the budget in the meantime, the signed payment is dropped before it is sent. (CLI 0.3.3; earlier versions counted from the server's receipt. Changelog.)

What Wafermap's server does: it quotes the price, verifies your signature, runs the resource and settles only if it worked. It never holds your key or your caps, and it cannot take more than you signed: an x402 authorization is for one exact amount to one address, and it expires.

What no wallet can enforce: a signed x402 payment can be executed by whoever receives it until it expires, so "a failed call costs $0" is the server's promise. Wafermap wallets keep that window short: EVM payments are signed for at most 90 seconds (the web wallet, and the CLI from 0.4.0), and the CLI gives up on any request after 60 seconds. You can check it without trusting anyone: wafermap history --verify asks each token contract (authorizationState) whether every signed EVM payment was executed, and lists the ones that expired unused. From 0.4.6 a payment counts as executed only once the contract's AuthorizationUsed event for it is found, so a nonce cancelled with cancelAuthorization shows as cancelled, not paid. From 0.4.7 Solana payments are checked too, on the public Solana RPC: the CLI logs its own signature and the payment's blockhash, anchors it to that block on-chain, and shows a payment as unused only once the blockhash has expired and the wallet's history has no transaction with that signature.

A budget in a prompt is an instruction, not a limit. To make it one, set the cap in the wallet:

wafermap limits --per-payment 0.02 --per-day 0.5
wafermap limits                                # shows the current caps

Over a cap, the CLI and MCP tools answer over_payment_cap or over_daily_cap; a payment you decline answers declined, and confirm_unavailable means confirmation is on but the client cannot ask. The remote MCP server (/mcp) never pays on its own: it returns the payment requirements and your client signs.

SDK

// npm i @wafermapxyz/cli
import { Wafermap } from "@wafermapxyz/cli";

const wm = new Wafermap({ privateKey: process.env.AGENT_KEY, limits: { perPayment: 0.05, perDay: 2 } });

const { result, receipt } = await wm.call("stock-signal", { symbol: "TSLA" });
const [svc] = await wm.discover("token price");
const paid = await wm.pay(svc.url, { method: svc.method, input: svc.input, network: "base" });
const quote = await wm.swapQuote("ETH", "USDG", "0.01");
await wm.swap(quote);

Pass approve: (a) => boolean to confirm each payment or swap, and ledger to persist spending for the daily cap. x402fetch(url, init, { signer }) pays any x402 v1 or v2 endpoint directly.

Discovery

Beyond its own catalog, Wafermap searches the open x402 Bazaar index (run by Coinbase CDP, tens of thousands of services) and pays any service that accepts the exact scheme in USDG on Robinhood Chain or USDC on Solana, Base, Arbitrum, Polygon, Arc or Soneium. The Wafermap App does this on its own when no Wafermap resource fits: it finds a service, fills its input, and shows you the price before paying.

Third-party services are run by their owners, not by Wafermap. Their answers, prices and refund rules are theirs. A seller can charge a different price on each chain, so every result carries prices (one entry per network Wafermap can pay, cheapest first) next to priceUsd, the lowest of them; the quote you approve is always the seller's own price on the network you pay with. In the browser, calls go through a narrow relay (POST /api/relay) that only forwards to services returned by discovery and never sees your key; the CLI, SDK and MCP server call them directly.

Swaps

Swaps route through the KyberSwap aggregator on Robinhood Chain and Base. The quote and the transaction are built on your device and sent from your wallet: an exact-amount approval when needed, then the swap with 1% maximum slippage by default. Swaps need a little ETH for gas, always ask before sending in the app, and are capped per swap. Wafermap takes no fee on swaps.

$WAFERMAP holder tiers

Held on Robinhood ChainUnlocks
100,000 $WAFERMAPHolder: 50% off Wafermap's own resources on EVM networks, x402 Tracker Pro (movers, the full export and alerts), and a higher chat limit in the App (200 messages an hour instead of 40).
1,000,000 $WAFERMAPPro: all of the above, plus 10 free calls a day to resources listed at $0.01 or less, and Featured marketplace listings for sellers.

Holder price

A wallet that holds at least 100,000 $WAFERMAP on Robinhood Chain (0xfda080f64d84c989cfc50ff18253542cfe502db3) pays 50% less for Wafermap's own resources, down to the $0.001 minimum, when it pays on an EVM network (Robinhood Chain, Base, Arbitrum, Polygon, Arc or Soneium).

  • Quote: send X-Wafermap-Payer: 0xYourWallet with the first request. If that wallet holds enough, the 402 quote's EVM options carry the holder price and the body includes "discount": {"kind": "holder", "percent": 50}. The Wafermap wallet, CLI (0.4.2+), SDK and local MCP server send it for you, and only to Wafermap.
  • Pay: the discount goes to the wallet that signs the payment. Wafermap reads that wallet's balance again (cached for a minute), so naming someone else's wallet gets you nothing. A holder can still pay the regular price.
  • A spot check, not a snapshot: the balance is read when you pay (cached for a minute), so moving one bag between wallets can discount each of them in turn. At half a cent or so per call, that costs more in gas than it saves.
  • Not discounted: Solana payments (the holding is an EVM wallet) and marketplace listings (their price is the seller's).
  • Check a wallet: GET /api/holder?address=0x… (free): balance, tier (none, holder, pro) and free calls left today.

Pay in $WAFERMAP

Wafermap's own resources can also be paid in $WAFERMAP, at 50% off the list price, and the tokens are burned (sent to the dead address). It does not stack with the holder price. Marketplace listings are paid to their sellers in USDG or USDC only.

  • How: $WAFERMAP has no EIP-3009, so it uses Uniswap's Permit2 (0x000000000022D473030F116dDEE9F6B43aC78BA3 on Robinhood Chain). The 402 quote carries one more option, scheme wafermap-permit2: a token amount from the market price, payTo the dead address, and Wafermap's relayer as the spender. You sign a Permit2 transfer of exactly that amount, valid for two minutes. Wafermap checks it, runs the resource, and only if it succeeded the relayer sends the tokens to the dead address. A failed call moves nothing.
  • Once per wallet: approve Permit2 to move your $WAFERMAP (one Robinhood Chain transaction, paid in ETH): wafermap approve-wafermap, or the button on a resource page.
  • CLI: wafermap call <id> --pay wafermap. MCP: wafermap_call with payIn: "wafermap". The Wafermap clients sign a Permit2 transfer only for Wafermap's own resources, never for a third-party service, because a Permit2 spender chooses where the tokens go. Check whether it is on: GET /api/token-pay.

Holder pass

Free calls and Tracker Pro need proof that you hold the wallet, not only its address. A holder pass is a message the wallet signs (personal_sign: no transaction, no cost), valid for up to 24 hours, sent as X-Wafermap-Pass. The Wafermap wallet and the CLI (0.4.4+) sign and send it for you, only to Wafermap; wafermap pass prints one for your own scripts. Format: base64url JSON {"v":1,"address","iat","exp","sig"}, where sig signs exactly:

wafermap.xyz holder pass

Wallet: 0xYourWallet
Issued: 2026-11-02T08:00:00.000Z
Expires: 2026-11-03T08:00:00.000Z

Proves you hold this wallet, so Wafermap can apply what your $WAFERMAP unlocks. It costs nothing and moves no funds.

Free calls (Pro)

  • How: call a resource listed at $0.01 or less with X-Wafermap-Pass and no payment. If the wallet holds 1,000,000 $WAFERMAP and has calls left, the answer comes straight back with "receipt": null and "free": {"left": 9, "perDay": 10}. Otherwise you get the usual 402 quote, and its body says why in free.code (free_used_up, not_pro, free_not_eligible, pass_expired…).
  • Ten a day per wallet, reset at 00:00 UTC. A call that fails gives its free call back. There is also a ceiling on free calls a day over all wallets; past it, paid calls work as usual.
  • Free calls are not payments: they never show in paid-call numbers anywhere on this site.

x402 Tracker Pro (Holder)

On /x402, unlock with a pass to see which services crossed 25 distinct payers, which gained the most payers or calls, and which are new with 10+ payers, over 24 hours or 7 days, and download every ranked service as CSV or JSON. API, with the pass in X-Wafermap-Pass: GET /api/x402/pro/movers?window=24h|7d and GET /api/x402/pro/export?format=csv|json.

Tracker alerts (Holder)

Up to 5 rules per wallet, checked after every full pass over the index (about hourly). Each hit lands in the inbox on /x402 and, if the rule has a webhook, is posted to it.

  • Rules: crossed (any service reaches 25 distinct payers), newcomer (a service missing from the two passes before, already paid by minPayers wallets, default 10), watch (one host whose payers move by minPayers, default 5, or whose 30-day calls move by minCallsPct percent, default 25; also once when it drops out of the ranked list).
  • Webhooks: Discord and Slack webhook URLs get a plain message. Any other https:// URL gets JSON (alert, pass, permalink, hits, more, text) signed like marketplace calls: x-wafermap-signature: sha256=HMAC-SHA256(secret, "${x-wafermap-timestamp}.${body}"), with the secret shown once when the rule is made. A webhook that fails 10 passes in a row is no longer called until a test message gets through.
  • Holding: the wallet's balance is read on-chain at every pass. Below 100,000 $WAFERMAP the rule is skipped (marked paused), not deleted.
  • API, with the pass in X-Wafermap-Pass: GET /api/x402/pro/alerts (rules and the last 50 hits, kept 30 days), POST /api/x402/pro/alerts with {"kind","host","minPayers","minCallsPct","webhook"}, DELETE /api/x402/pro/alerts/:id, POST /api/x402/pro/alerts/:id/test.

Higher chat limit (Holder)

The App's free agent answers 40 messages an hour per visitor, under a daily ceiling for all visitors. When the paying wallet holds 100,000 $WAFERMAP, the App sends its holder pass and the limit becomes 200 messages an hour for that wallet, outside the shared ceiling. Paid calls are not affected: your wallet's own per-payment and daily caps stay exactly as you set them.

Buyback & burn (rule bb-1)

Part of the $WAFERMAP creator fees goes back into the token every week, by a fixed rule published before the first buy. Every step is an on-chain transaction from one wallet, listed on Proof.

Outside wallets that paid through Wafermap in the last 30 daysShare of the week's creator fees
From the start25%
25 wallets35%
100 wallets50%
  • What counts as outside. Wallets counted on Proof with Wafermap's own wallets excluded: test payers, the treasury, the team's CLI and browser wallets, and Founding Sellers buys. The live count is in /api/buyback.
  • The share only rises. Once a step is reached it is kept, even if the count falls later.
  • When. Every Monday (UTC), for the creator fees claimed since the previous run. bb-1 covers creator fees that were not yet claimed when it was published on 10 Nov 2026; fees claimed before that are not included. Run 0 started on 10 Nov 2026 with the 0.3617 ETH claimed that day, and the weekly schedule starts on Monday 16 Nov 2026.
  • How. From the fee wallet 0xCBf636c3a28FD95Dde80E7cD888Df344E6C5296F: the share is spent in ETH on the token's own Uniswap v4 pool (ETH / $WAFERMAP), in at least four buys spread over 24 hours. Then every token bought is sent in one transaction to the dead address 0x000000000000000000000000000000000000dEaD, where no one can move it.
  • Small weeks. If a week's share is under 0.002 ETH, it carries over to the next week so gas does not eat it.
  • No discretion. No buys outside this schedule, no price targets, and the share changes only through the steps above. A change to the rule gets a new version (bb-2), announced at least 7 days before it applies.

Proof lists each week's fee claims, every buy with the ETH it spent and the tokens it received, and the burn transaction. The amounts are read from Robinhood Chain before a week is published. Tokens paid for resources in $WAFERMAP are burned too; Proof counts those apart.

Sell on Wafermap

Anyone can list a model or API on the Wafermap Marketplace and set a price per call. Agents call it at POST /v1/m/<name>; the x402 quote names your wallet as payTo, so every payment goes straight to you in USDG on Robinhood Chain or USDC on Base, Arbitrum or Polygon. Wafermap takes no fee and never holds the money.

Solana payouts (optional). On /sell, add a Solana address and sign a message with that Solana wallet (Phantom, Solflare, or your Wafermap wallet's Solana side). The signature proves the address is yours, so a typo can never receive your sales. Once that address holds a USDC account (receive any USDC there once), your listings are also quoted in USDC on Solana, paid straight to it.

  1. Sign in on /sell with the wallet that should be paid (a signed message, no transaction).
  2. Register the endpoint: an HTTPS URL that answers POST with JSON. Pick JSON API (you define up to 10 input fields) or OpenAI-style model (a chat-completions endpoint).
  3. Set the price: $0.001 to $5 per call. You get a signing secret once.
  4. Prove the domain: serve https://<your host>/.well-known/wafermap-seller.json containing {"sellers": ["0xYourWallet"]}, as JSON, without a redirect. List several wallets if several people sell from one host.
  5. Pass a test call (free, sent exactly like a paid one), then publish. A listing goes live only when the proof and the test were made against its current endpoint.

Founding sellers. The first five outside sellers to go live get their first 100 paid calls bought by Wafermap at full price, up to $0.05 a call (at most $5 per seller), paid to the seller's wallet over the following days with real inputs. The rules: a real, useful API (we may decline a listing); one slot per seller or domain; Wafermap's own projects are excluded. The calls come from Wafermap's labelled CLI wallet, so they show as team on Proof and are not counted in the listing's paid calls or paying wallets. Program listings carry a Founding seller tag. To claim a slot, go live and email hello@wafermap.xyz or DM @wafermap.

Working example. The code behind our demo listing is open (MIT): wafermap-seller-demo, one Cloudflare Worker with the domain proof, signature check and a JSON and a model route. Deploy it on your own domain and follow the steps above.

Requests Wafermap sends you

POST <your URL>JSON body. JSON API: the agent's input, already checked against your fields (unknown fields dropped, strings trimmed, numbers passed as sent). OpenAI-style: {model, messages, stream: false, max_tokens?} with your model name.
X-Wafermap-ListingThe listing's name (slug).
X-Wafermap-TimestampUnix seconds when the request was signed.
X-Wafermap-Signaturesha256= + hex HMAC-SHA256 of <timestamp>.<raw body>, keyed with your listing's secret (the whole whsec_… string).
User-AgentStarts with Wafermap-Marketplace/1. Do not rely on it: check the signature.

Your answer. Status 2xx, content-type JSON, a non-empty object or array, within 25 seconds and under 2 MB. Redirects are not followed. OpenAI-style answers need a non-empty choices list whose message has text content or tool calls. Anything else counts as a failed call: the agent is not charged and you are not paid.

Answer checks (optional, JSON listings). Declare what every answer must contain, and a paid call settles only if it does. Up to 10 paths, each with a type (string, number, boolean, array, object or any): the value must be there and not empty (null, "", [] and {} fail). Paths use dots, and numbers index lists: data.items.0.price. Add a freshness check to promise recent data: a path to a timestamp in your answer (Unix seconds, milliseconds or an ISO date) and a maximum age from 10 seconds to 30 days. An answer that fails a check is a failed call (schema_mismatch or stale_answer): the agent is not charged, and it counts against your success rate and health checks like any other failure. Agents see your checks on the listing page and in the catalog (responseChecks). Set them when you create the listing, or change them later on /sell; new checks need a passing test call before the listing is live again.

Verify requests

Refuse calls without a valid signature, or anyone could call your API directly without paying. Check it on the raw body, before parsing, and reject timestamps more than five minutes off.

// Node
import crypto from "node:crypto";

function fromWafermap(headers, rawBody, secret) {
  const ts = headers["x-wafermap-timestamp"] ?? "";
  const sig = headers["x-wafermap-signature"] ?? "";
  if (!/^\d+$/.test(ts) || Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  const want = "sha256=" + crypto.createHmac("sha256", secret).update(ts + "." + rawBody).digest("hex");
  const a = Buffer.from(sig), b = Buffer.from(want);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}
# Python. headers: a case-insensitive mapping (Flask, Starlette/FastAPI and Django request.headers)
import hmac, hashlib, time

def from_wafermap(headers, raw_body: bytes, secret: str) -> bool:
    ts = headers.get("x-wafermap-timestamp", "")
    sig = headers.get("x-wafermap-signature", "")
    if not (ts.isascii() and ts.isdigit()) or abs(time.time() - int(ts)) > 300:
        return False
    want = "sha256=" + hmac.new(secret.encode(), ts.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(sig.encode(), want.encode())
// Cloudflare Workers / Deno / Bun (Web Crypto)
async function fromWafermap(req, rawBody, secret) {
  const ts = req.headers.get("x-wafermap-timestamp") ?? "";
  const sig = (req.headers.get("x-wafermap-signature") ?? "").replace(/^sha256=/, "");
  if (!/^\d+$/.test(ts) || !/^[0-9a-f]{64}$/.test(sig) || Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
  const bytes = Uint8Array.from(sig.match(/../g), (h) => parseInt(h, 16));
  return crypto.subtle.verify("HMAC", key, bytes, new TextEncoder().encode(ts + "." + rawBody));
}

Lost the secret, or it leaked? Rotate it from the listing's page on /sell. Wafermap signs with the new secret at once, with no grace period, so deploy it right away: until you do, your check refuses our calls and they fail unpaid.

When you get paid

Wafermap checks the agent's input, verifies the signed payment with the facilitator (Coinbase CDP), forwards the call to you, and settles the transfer to your wallet only after you answered with a result that passes your answer checks. If your API fails, times out, answers empty or fails a check, the authorization is released: the agent pays nothing and you receive nothing. Each paying wallet can have one unsettled call per listing at a time, and payment authorizations must stay valid for at least 60 seconds, so you are not asked to work for a payment that can no longer settle.

Health checks, metrics and reports

  • Health checks. Every live listing gets one free, signed call about every 30 minutes, with the header X-Wafermap-Check: health and the example input (or a neutral value for each required field; models get a short prompt). Three failures in a row take the listing off the marketplace (status failing); the next passing check brings it back. Failed paid calls never count towards hiding a listing, so nobody can hide one by sending it bad input.
  • Metrics. Each listing shows paid calls and paying wallets over 30 days, the share of paid calls that got an answer, the median time to answer, and health-check uptime over 7 days, refreshed every 10 minutes. All measured, never estimated; a seller paying its own listing is not counted, and neither are Wafermap's own wallets (tests). In the answer rate, only the seller's own failures count (time-outs, errors 5xx, no JSON, an empty answer; not a 4xx refusal of the caller's input), at most once per paying wallet per day. They are in metrics on GET /api/market and GET /v1/m/:name.
  • Reports. Anyone can report a listing from its page on wafermap.xyz. Reports are reviewed by Wafermap; they never hide a listing by themselves.
  • Discovery. Live listings appear in GET /v1/resources (provider community, id m/<name>), in the MCP tools wafermap_resources and wafermap_call, and in the CLI (wafermap call m/<name>). Their 402 quotes carry x402 Bazaar discovery metadata.

Networks and prices per listing

By default a listing is paid on every network the marketplace offers (USDG on Robinhood Chain, USDC on Base, Arbitrum and Polygon, and USDC on Solana once the seller has a Solana payout address), at one price. On /sell → Manage → Networks & prices, a seller can turn networks off and give any network its own price, for example $0.005 on Base and $0.01 on Robinhood Chain. Changes apply to the next quote and keep the listing live; no new test is needed.

  • Quotes: the 402 lists only the networks the listing accepts, each with its own amount. A payment must match the amount of the network it is signed for.
  • Catalogs: GET /api/market and GET /v1/resources give price (the lowest) and prices ([{network, price}]). The marketplace shows "from" when prices differ.
  • API: PATCH /api/market/mine/:name with {"networks": ["base", "robinhood"], "prices": {"base": "0.005"}}. networks: null accepts every network again; a price of null or "" falls back to the listing's price.

While a seller's wallet holds at least 1,000,000 $WAFERMAP on Robinhood Chain, its live listings are Featured: they carry a badge and are listed first on the marketplace, whatever the sort. The balance is read every 10 minutes; nothing is locked, staked or spent, and Featured ends when the balance drops below the line. Featured never changes the checks: a Featured listing that fails its health checks is hidden like any other. featured is in GET /api/market.

Staked listings

A seller can sign a promise to keep at least 250,000 $WAFERMAP in its wallet on Robinhood Chain for 30, 90 or 180 days. While the promise holds, its listings carry a Staked badge with the amount and the end date. Nothing is transferred and no contract holds the tokens: they stay in the seller's wallet the whole time.

  • Checked: the balance is read about every 10 minutes. If it drops below the promised amount before the date, the stake is broken: the badge becomes Stake broken for 30 days, and no new stake is taken from that wallet until then. Tokens moved out and back between two reads are not seen.
  • Ending: a stake that reaches its date is kept and the badge goes. Ending early counts as breaking it while the seller has listings up; with none up, it is released.
  • Checkable: the signed text and signature are kept, so anyone can check the promise against the seller's address. The text: wafermap.xyz marketplace stake, the amount, the date, the seller wallet and the time it was issued.
  • Featured is separate: it needs 1,000,000 $WAFERMAP held, with no promise. A wallet can have both. stake and stakeBrokenAt are in GET /api/market.

Rules

  • Up to 5 listings per wallet. Price $0.001 to $5 per call.
  • Endpoints: https:// on port 443, a public hostname (no IP addresses, no internal names), not on wafermap.xyz.
  • Changing a live listing's endpoint takes it off the marketplace until the domain proof and a new test pass; changing its model or input fields, until a new test passes (through the API, PATCH /api/market/mine/:name; on /sell, create a new listing instead). Name, summary, category and price can change any time and the listing stays live.
  • You are responsible for what your API returns. No illegal content, malware, deception or other people's APIs. Listings that break this are removed.

Calling a listing

GET /api/marketEvery live listing: price, seller wallet, host, input fields, networks. Free.
GET /v1/m/:nameOne listing. Free.
POST /v1/m/:nameRun it. Answers 402 with a quote payable to the seller, exactly like a Wafermap resource. wafermap pay (CLI), wm.pay() (SDK) and wafermap_pay (MCP) take this URL.

Workflows

A workflow is several resources in one call: one quote, one payment, one answer. It is paid like any other resource (POST /v1/<id>, the same 402 and the same networks), and the payment settles only after every step worked. If any step fails, the call fails with that step's name in the error, and nothing is charged. Every answer lists its steps with how long each took. A workflow costs less than calling its steps one by one, and $WAFERMAP holders get the same 50% off.

  • Token Due Diligence (token-due-diligence, $0.02): the token and its market, who controls the contract (owner, proxy, whether supply or code can still change) and, on Robinhood Chain, the builder record from HEY Research Lab; then one verdict (looks normal, caution, high risk or insufficient data) with what was checked.
  • Stock Token Brief (stock-brief, $0.02): one tokenized stock's Chainlink reference and on-chain DEX price, the Polymarket markets about the company, and one brief that ties them together.
  • Launch Scan (launch-scan, $0.03): the newest token launches on Robinhood Chain or Base, each contract checked, ranked into what to look at closely and what looks cleanest. A risk screen, not a buy list.
wafermap call token-due-diligence address=0x… network=robinhood
wafermap call stock-brief symbol=TSLA
wafermap call launch-scan network=base limit=5

How the due diligence level is decided

The level is computed by a fixed rule (dd-1), not by the AI, so you can recompute it from the answer alone. The contract reads are pinned to one block (block in the answer, replayable on an archive RPC); market data is as of asOf. The answer's rule holds the level, why it fired, and every input it used. The AI only writes the summary, the checks and the risks.

  • high risk: the address is not a contract, or an owner is set or the code is upgradeable, together with liquidity under $10,000 or a main pool under 7 days old.
  • caution: any one of those: an owner is set, the code is upgradeable, liquidity is under $10,000, or the main pool is under 7 days old.
  • looks normal: none of them.
  • insufficient data: there is no market data to read liquidity from.

Inputs: contract.isContract, contract.owner (a zero-address owner counts as none), contract.proxy, snapshot.market.liquidityUsd, and the age at asOf of the deepest pool in snapshot.pools (a pool with no creation date is not counted as new). The builder record is shown but does not change the level. Market data comes from DexScreener, or GeckoTerminal when DexScreener cannot be read; snapshot.source says which.

Team budgets

A team gives several agent wallets one daily budget in USD. Before a paid call runs, Wafermap adds up what the team's active wallets settled since 00:00 UTC; a call that would take the team over its budget is refused with 402 team_budget_exceeded before any work starts, so nothing is charged. The owner can also pause a team, which refuses every paid call from its wallets (402 team_paused). Each wallet keeps its own funds and its own caps.

  • Set up at /teams: sign in with a wallet, create a team (a name and a daily budget up to $1,000), invite wallets by address.
  • Consent. An invited wallet counts only after it signs in at /teams and accepts. The owner's own wallet joins at once. A wallet is active in one team at a time and can leave whenever it wants.
  • What counts: USDG, USDC and $WAFERMAP payments through Wafermap from EVM wallets, on Wafermap's resources and marketplace listings. Not counted: Solana payments, free holder calls, third-party services paid through discovery, and anything paid outside Wafermap.
  • Timing. Each call is checked against what had settled when it started, so calls that start at the same moment can together go over by at most their own prices.

Limits: 3 teams per owner, 25 wallets per team. API for the signed-in wallet (cookie session from /api/auth/*, same origin): GET /api/teams, POST /api/teams, PATCH /api/teams/:id, DELETE /api/teams/:id, POST /api/teams/:id/members, DELETE /api/teams/:id/members/:address, POST /api/teams/:id/accept, GET /api/teams/:id/statement?month=YYYY-MM (owner, see spend reports).

Spend reports

A monthly statement lists every payment a wallet made to Wafermap and to marketplace sellers in one calendar month (UTC): the date, the resource, the network, the price in USD, and the on-chain transfer that settled it (token contract, from, to, amount in the token's own units, transaction). It comes as CSV for accounting or JSON you can check against the chains yourself.

  • A wallet: on the Wallet page under the spending summary, or GET /api/statement?wallet=0x…[,SolanaAddress]&month=2026-11[&format=csv]. Up to 10 addresses at once, so an agent wallet's EVM and Solana sides make one statement. Settlements are public on Proof already, so this needs no sign-in.
  • A team: on /teams, owner only: every payment each wallet made while it was an active member that month, including wallets that have left since.
  • CLI (0.4.11+): wafermap statement --month 2026-11 --out statement.json (or --csv) for the wallet on that machine.
  • Check it: wafermap statement --verify statement.json reads every transaction from its chain: an EVM line passes only if the receipt holds a Transfer of exactly that amount of that token from the payer to the recipient; a Solana line, only if the transaction succeeded and moved exactly that amount between those two owners. It also checks that the totals add up to the lines. It uses public RPCs unless you set WAFERMAP_RPC_<NETWORK>; nothing goes through Wafermap.
  • What is in it: USDG, USDC and $WAFERMAP payments (burns: the recipient is the dead address). Not in it: free holder calls (not payments), third-party services paid directly through discovery (only your machine knows them: wafermap history), and swaps.

Resource catalog

ResourceEndpointPrice