For agents
Toll for agents
The Toll check, the deployer history and the newest coins, as paid API calls an agent can make on its own. The check reads coins on Robinhood Chain. Pay per call in USDG on Robinhood Chain, over x402.
On this page
Free to start: new coins every day at no cost, coins already read are always free, agent checks free. Past that: 0.005 USDG per check over x402, charged only for a whole answer.
Endpoints
| Endpoint | What you get | Price |
|---|---|---|
| EndpointGET /api/x402/check/{token} | What you get The full check of any token: snipers in the first 3 seconds, bundles, who funded the dev, the dev’s past launches, holders, liquidity and red flags. The same JSON as /check. Reads Robinhood Chain: add ?chain= with rh (Robinhood Chain); paste a Robinhood Chain (0x…) token address. | Price$0.005 USDG |
| EndpointGET /api/x402/dev/{wallet} | What you get Every launch by one deployer, how many graduated, and how they ended. The same JSON as a deployer page on Toll (see the dev wall). | Price$0.005 USDG |
| EndpointGET /api/x402/larp/{token} | What you get The LARP check of a coin: is there a real product behind it. What it says in its own words, each claim checked against the chain, and the working parts of theirs that answered. Robinhood Chain: add ?chain=rh or ?chain=sol. A coin not read yet answers 402 with pending while we read it (nothing charged); a coin whose words we could not read is answered free. | Price$0.005 USDG |
| EndpointGET /api/x402/fresh?limit=10&chain=rh | What you get The newest coins on Robinhood Chain, newest first, with the live engine’s short notes on each (the dev, the first buyers, wallets that moved together, the liquidity): the list behind the terminal. limit 1 to 20 (default 10); add &format=text for plain text. Robinhood Chain only for now. A feed that is not updating, or an empty list, is answered free. | Price$0.01 USDG |
| EndpointPOST /api/x402/tx | What you get The pre-sign check: POST the transaction, EIP-712 signature or x402 payment an agent is about to sign and get ALLOW, WARN or BLOCK with the reasons, as an ERC-8265 RiskAssessment. Robinhood Chain only. No daily limit; free at POST /api/tx/check within the free coins a day. | Price$0.005 USDG |
| EndpointGET /api/x402/hook/{hook} | What you get One Uniswap v4 hook on Robinhood Chain: its name, what its permission bits let it do, whether its code can be changed, how many pools use it, the measured buy and sell cut on a test trade (or sells fail), and how its latest coins ended. The holder view of /api/hook/{hook}. | Price$0.005 USDG |
| EndpointGET /api/x402/pulse | What you get Robinhood Chain right now: launches in the last 5 minutes and hour, graduations, launches by launchpad, new pools, trades a minute and volume, from the live engine. Figures the engine did not send are left out, never shown as zero. | Price$0.01 USDG |
| EndpointGET /api/x402/stock/{id} | What you get One Robinhood Stock Token by ticker or contract: Chainlink’s reference price, the deepest pool’s price and the difference, supply in shares, corporate actions and the company’s SEC facts, every number with its source and time. The rest of Toll Markets (fundamentals, insider trades, 13F holders, guidance, macro) is listed at /.well-known/x402. | Price$0.02 USDG |
Network eip155:4663 (Robinhood Chain). Asset USDG 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168, 6 decimals, so $0.005 is 5000.
Or pay the same price in USDC on Base: network eip155:8453, asset 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, 6 decimals. Every 402 lists both options; sign the one you hold.
Payments settle through the Priors facilitator (Robinhood Chain) or a Base facilitator (Base); the money goes to Toll’s wallet. Paying is in USDG on Robinhood Chain or USDC on Base, whichever chain the coin you check is on.
Pre-sign check
Before an agent signs, it sends what it is about to sign. Toll answers ALLOW, WARN or BLOCK with the reasons, in the RiskAssessment shape of ERC-8265 (Prepared Transaction Envelope): action, warnings (each a code, a severity and a message) and scanners, with Toll named as ERC-8004 agent #20030 on chain 4663. Our own facts are under x-toll keys. The action is the worst warning: critical is BLOCK, high or medium is WARN, low or none is ALLOW.
- Approvals (approve, permit, Permit2, setApprovalForAll): unlimited to a plain wallet is BLOCK; to a contract we have no record of, or any amount to a plain wallet, is WARN; to Uniswap’s or Toll’s routers is ALLOW, with a note when unlimited.
- Transfers: to a burn address, the token itself, a router, a wallet the coin’s own check names, or a contract we have no record of is WARN.
- Swaps: the coin bought gets Toll’s coin check. BLOCK only for a finding whose coins rugged at 40% or more within 24 hours in our 2026-10-29 calibration (the dev sold 5% or more, the ten biggest wallets hold 70% or more, one wallet can pull the liquidity, ...); any other finding against is WARN. A coin not read yet is WARN with the seconds to wait, never ALLOW.
- x402 payments: payTo must be the seller’s registered ERC-8004 agentWallet (found by the agentId you pass, or by the resource’s host in our agent census); a mismatch with no valid payee delegation is BLOCK; an asset other than USDG or Base USDC, or a signed payment to another address or for more than the amount asked, is WARN; a seller we cannot find is a note. The seller’s last delivery spot-check is in the answer when there is one. An upto payment is flagged with its signed maximum (the seller may charge all of it), and an auth-capture payment’s escrow, token collector and hold are read: an unknown escrow or the wrong collector is WARN.
- Also: the transaction run against the chain first, what a signature lets someone take (simulated, in dollars where Toll has a price), Uniswap v4 liquidity calls, a v4 swap quoted on the coin’s main pool, and the text inside EIP-712 signatures read for hidden instructions. The whole list: what Toll checks.
- Calldata or a signature we cannot read is WARN “could not decode”, never ALLOW. Another chain is a 400.
- Toll’s AI: say what the agent means to do in plain words (intentText, up to 300 characters) and it is read into an intent (shown in x-toll.intent.understood) and compared with the simulation; a call we cannot decode to a contract with verified source gets a low line on what its function does, read from that source, not a verdict.
curl -s https://t0ll.xyz/api/tx/check -H 'content-type: application/json' -d '{
"chainId": 4663,
"from": "0x<the agent's wallet>",
"to": "0x5fc5360d0400a0fd4f2af552add042d716f1d168",
"data": "0x095ea7b3<spender, 32 bytes><amount, 32 bytes>",
"value": "0"
}'{
"action": "BLOCK",
"warnings": [{
"code": "unbounded-approval-to-eoa",
"severity": "critical",
"message": "This approve lets a plain wallet (EOA, no code) 0x... spend an unlimited amount of this token: the usual drainer pattern.",
"x-toll-evidence": { "token": "0x5fc5...", "spender": "0x...", "amount": "unlimited" }
}],
"scanners": [{ "provider": "Toll (ERC-8004 agent #20030 on chain 4663)", "verdict": "BLOCK", "url": "https://t0ll.xyz/agents/x402#presign" }],
"x-toll": { "scanner": { "agent_id": 20030, "chain_id": 4663 }, "checked_at": "2026-10-30T09:00:00.000Z", "decoded": [ ... ], "link": "..." }
}Free at POST /api/tx/check (thirty a minute; the coin a swap buys counts against the free coins a day, as the coin check), paid at POST /api/x402/tx ($0.005 USDG, no daily limit, charged only for a whole answer), and over MCP as check_tx. Facts, not advice: ALLOW means none of our checks found a reason to stop, nothing more.
Add "ticket": true (or {consumer, scope}) and a qualifying answer also carries a single-use ALLOW ticket signed by Toll for this exact call, which a contract can require before it runs it: ALLOW tickets.
Add "summary": true for one or two plain sentences in x-toll.summary, opening with the action word ("BLOCK: ..."), written by AI from the action and warnings only. Every number in it is checked against the warnings and a line that fails (a new number, another action word, a reassurance or advice) is dropped, never shown. Add "lang": "ar" for Arabic ([BLOCK] ...). It waits at most 2.5 s (less within your budgetMs); not ready in time means no field, the answer itself is never held. Over MCP, check_tx adds the line by default when it is ready within about a second (summary: false leaves it out).
How paying works
- Call the endpoint with no payment. You get 402 and what to pay: x402 v2 in the PAYMENT-REQUIRED header, the v1 shape in the body.
- Sign a USDG transfer authorization (EIP-3009) for that amount and send it in PAYMENT-SIGNATURE (v2) or X-PAYMENT (v1).
- We verify it, read the chain, and only then settle. You get the JSON and a receipt in PAYMENT-RESPONSE and X-PAYMENT-RESPONSE.
You are only charged for a whole answer. If the read fails you get 503 and nothing is settled. If a coin is new to us and the read is still running, or a key part of it is not read yet (who holds it now, its launch, the dev’s record), you get 402 with {"pending": true} and a Retry-After: resend the same signed header. Never sign a second payment for the same call.
A partial answer is free. If those parts still cannot be read after a few minutes, you get the answer as it stands with "charged": false, "why": "partial" and the parts in missing. Nothing is settled; ask again later with a new payment for the whole check. A payment that was settled and resent gets the same answer and receipt back, never a second charge.
Every payment, on chain
All-time: 3 paid checks from other agents · 2 payers
0.15 USDG · 1 test from our own wallet, not counted · 11 transfers in that are not a payment (transfer, not x402, our own transaction, Priors loan), not counted
| Time | Payer | USDG | Tx |
|---|---|---|---|
| 0xf585…bb65 | 0.05x402 | proof | |
| 0xb240…b6ca | 0.05x402 | proof | |
| 0xf585…bb65 | 0.05x402 | proof | |
| 0x7fbd…a37d | 0.05our own test, not counted | proof |
Read from Robinhood Chain: every USDG transfer into Toll's agent wallet 0xdC36…7F40. Counted: x402 payments for checks from wallets that are not ours. Our own tests, loans and our own swaps are not payments. Anyone can check it on the explorer.
Try it
curl -i https://t0ll.xyz/api/x402/check/<token address>
HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64 JSON, x402 v2: scheme "exact", network "eip155:4663",
asset USDG, amount "5000", payTo Toll's wallet>
{"x402Version":1,"error":"Payment required","accepts":[{"scheme":"exact",
"network":"robinhood","maxAmountRequired":"5000","asset":"0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", ...}]}Client example
With @priors/x402, which pays USDG on Robinhood Chain and resends a pending payment for you:
import { ethers } from "ethers";
import { createPayer, robinhood } from "@priors/x402";
const provider = new ethers.JsonRpcProvider(robinhood.rpcUrl);
const signer = new ethers.Wallet(process.env.AGENT_KEY, provider); // holds USDG
const payer = createPayer({ signer, maxPrice: "$0.02" });
const r = await payer.pay("https://t0ll.xyz/api/x402/check/<token address>");
if (r.pending) throw new Error("still reading: resend r.signed.paymentHeaders");
console.log(await r.response.json()); // the check; receipt in PAYMENT-RESPONSEIt also works with wrapFetchWithPayment from @x402/fetch and createUsdgClient from @priors/x402, but that wrapper does not resend a pending payment.
From a Priors line
Toll is ERC-8004 agent #20030, listed on Priors with its x402 offers (its Priors page). An agent with a Priors line pays the check from its own wallet, or borrows the gap from its line where its owner allows it, with Priors’ local MCP server. Add it with the wallet key in a file only your user can read, Toll’s host as the only one it may pay, and one check’s price as the most a call may cost:
{
"mcpServers": {
"priors": {
"command": "npx",
"args": ["-y", "@priors/mcp@0.12.2"],
"env": {
"PRIORS_KEY_FILE": "/path/to/agent-wallet.key",
"PRIORS_AGENT_ID": "<your agent id>",
"PRIORS_PAY_HOSTS": "t0ll.xyz",
"PRIORS_MAX_PRICE_USD": "0.005"
}
}
}
}Then one call per coin, before the agent buys it:
pay_url {
"url": "https://t0ll.xyz/api/x402/check/<token address>?chain=rh",
"max_price_usd": 0.005
}- Its answer names the address it paid. It should be Toll’s wallet, 0xdC36D51963d08862c525045ccFD39FAe6a0C7F40. If it names another, stop and tell the owner.
- A coin still being read answers 402 with {"pending": true} and nothing is charged for it. If pay_url hands that back, call it again after the seconds in Retry-After: the first signature is never settled.
- Add max_borrow_usd only when the agent’s owner allows borrowing. A loan it opens is repaid on Priors before its due date.
Notes
- A token is 0x followed by 40 hex characters, e.g. 0x0000000000000000000000000000000000000000. A wallet for the deployer history is an 0x address on Robinhood Chain. The fresh list takes no address. Anything else, or an address that is not on the chain named, is a 400, before any payment.
- Machine-readable list: /.well-known/x402 and /llms.txt.
- Selling your own API over x402? A seller is verified when its payTo is its ERC-8004 agent wallet: verify your agent (free to read: GET /api/x402/verify-agent?id=), and settle through our facilitator (no fee; we pay the gas).
- Using Claude, ChatGPT, Cursor or another AI app? The same reads are free over MCP: Use Toll in your AI.
- Building in code? Plugins & SDKs for JavaScript, Python, ElizaOS, AgentKit, the Vercel AI SDK, LangChain and Mastra, and a guard for the agent’s wallet.
- Information only. Facts read from the chain, not advice.