DEV Community: x402 API Builder

Part 3: `tokenprice` ($0.001) vs the price-feed incumbents — measured, not marketed

x402 API Builder — Tue, 20 Oct 2026 11:05:19 +0000

Part 3 of the x402 benchmark series. Part 1 covered the method and our baseline across 7 endpoints. Part 2 (websearch vs Exa vs Tavily) is still in the queue — we're waiting on API keys to run that head-to-head fairly, and we'd rather delay than fake it.

1. Why price feeds are the right fight

Every trading agent, portfolio tracker, and research bot needs the same primitive: "what is this token worth right now?" The incumbent answers are CoinGecko and CoinMarketCap — both excellent, both subscription-shaped. CoinGecko's paid plans start at $29–35/month for 100,000 calls (Analyst is $103–129/month for 500,000). CoinMarketCap's Builder is $29–35/month for 150,000 calls, Startup $79–95/month for 450,000.

Subscriptions punish experimentation. If your agent makes 200 price checks a day while you're still figuring out product-market fit, you're paying $29+/month for the privilege of learning. And here's the detail that makes this comparison interesting: CoinMarketCap itself now offers an x402 pay-per-call path — at $0.01 USDC per call, rate-limited to 30 req/min per wallet. So the per-call model isn't our invention; it's where the market is going. The question is just price and execution.

Our tokenprice endpoint charges $0.001 per call — one tenth of CMC's x402 price — backed by DexScreener data. Same method as Part 1: fixed queries, real latency, real output, no cherry-picking.

2. The measurements (2026-10-20, live)

Four queries, one 10-minute window, wall-clock latency including network. All via the public endpoint, paid x402 flow:

Query	How	Price returned	Market cap	24h vol	Liquidity	Latency
WETH	by address (ethereum)	$2,381.81	$5.24B	$43.4M	$7.9M	1.77s
USDC	by address (base)	$1.000053	$72.4B	$2,037	$127K	1.79s
SOL	by ticker	$122.08	$2.56B	$121	$2.56B	2.09s
ETH	by ticker	$1,773.17	$1.73B	$107K	$1.73B	1.81s

Median latency: ~1.8s. Nothing here bottlenecks an agent loop.

3. The honest caveat (we're not hiding this)

Look at row 4. Real ETH is ~$2,381 (see the WETH row). The ticker query for "ETH" returned $1,773 — a different token on Solana (Raydium) that happens to share the ticker. Ticker search is inherently ambiguous; DexScreener matches by symbol across every chain, and the top match isn't always the one you meant.

This is a real limitation, not a footnote: if precision matters, query by {"chain", "address"} — the by-address rows are exact. We'd rather tell you this in a benchmark than have your agent buy the wrong "ETH". (We're considering making ticker queries return the top-3 candidates with chains instead of silently picking one — feedback welcome.)

4. The cost math at agent scale

Workload	tokenprice ($0.001)	CMC x402 ($0.01)	CoinGecko Basic ($29/mo)
1,000 calls	$1.00	$10.00	$29 (100K included)
10,000 calls	$10.00	$100.00	$29
100,000 calls	$100.00	$1,000.00	$29–35
1,000,000 calls	$1,000.00	$10,000.00	$103–129 (Analyst)

Read it straight: under ~30K calls/month, per-call wins. Past ~100K/month, the subscription wins — no surprise, that's how volume pricing works. The per-call model isn't "cheaper at every scale"; it's cheaper at experiment scale, which is exactly where agents live while their builders are still iterating. You don't buy a $29/month plan to find out whether your idea works.

Two more things the table doesn't show:

No signup, no key. CoinGecko's free Demo tier (10K credits/month) carries no commercial license, and every paid tier means an API key your agent has to hold. With x402, the wallet is the credential — nothing to leak from context.
What you're not getting. We don't do 10 years of historical candles, order books, or 10,000-coin coverage. If you need all-time history from 2010, buy the subscription — genuinely. We're a live-quote + DEX liquidity layer: price, market cap, 24h volume, liquidity, pair link. That's the whole product, and the price reflects it.

5. Try it yourself

Free trial, no signup — the trial quota applies automatically per IP:

curl -X POST https://api.mekongtradeintel.com/tokenprice/api/token-price \
  -H "Content-Type: application/json" \
  -d '{"chain":"base","address":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"}'

Watch for the X-Free-Remaining header. When the trial runs out you get a standard 402 with payment instructions — sign with any Base wallet and retry with X-PAYMENT. The full agent demo (tokenprice → aiverdict → websearch pipeline, ~$0.021/run) is here: https://github.com/judomanmk19xx-bot/x402-agent-demo

Pricing for all 43 endpoints: https://api.mekongtradeintel.com/pricing

Next in the series: Part 2, websearch vs Exa vs Tavily — the moment we have the keys. If you re-run these numbers and get something different, say so; a benchmark that can't survive reproduction is just an ad.

Pricing sources: CoinGecko/CoinMarketCap plan details via their published 2026 pricing (coinmarketcap.com academy & api resources, coinstats.app comparison, July–August 2026). CMC x402 path: 0.01 USDC/call per CMC's own API resources page.

I benchmarked 41 pay-per-call x402 APIs: here's what actually works

x402 API Builder — Tue, 20 Oct 2026 02:31:32 +0000

I benchmarked 41 pay-per-call x402 APIs: here's what actually works

Most benchmarks in the x402 / AI-agent space are marketing in disguise: one vendor's chart, zero reproducible method, no raw numbers. So when we shipped our fleet of pay-per-call APIs on Base, we decided to benchmark them the way we'd want to read it — same queries, same time window, published method, and every number either real or explicitly marked as missing.

This is the first post in the series. It covers the method and our own baseline: real latency and cost numbers from 7 live endpoints, measured today.

1. The problem agents actually have

An agent that can't reach the live web is a very expensive parrot. It hallucinates prices, invents news, and cites sources that don't exist. The fixes are obvious — plug in a search API, a price API, a market-data API — but every option comes with friction:

API keys and accounts for each provider. Five services = five signups, five bills, five ways to leak a key from an agent's context.
Subscriptions that punish experimentation. $50/mo to test whether search quality is even good enough for your use case.
Zero verifiability. You get billed; you trust the invoice.

x402 flips this: the agent pays per call in USDC, on-chain, no account. A machine paying a machine. That's the thesis we built on — 41 pay-per-call endpoints covering web search, AI verdicts, token prices, market data, contract audits, AML screening, document extraction, trend intel, sentiment, GPU brokerage, and more. No signup, no subscription, no key management.

But "x402 makes payment easy" is a claim, not a proof. What agents actually care about is: does the data work, and is the price fair? So we benchmarked.

2. The method (steal this)

We picked the hardest fair fight we could find: web search quality. Search is the backbone of every research agent, and there are credible incumbents — Exa and Tavily — with published pricing. Here's the protocol:

One fixed query set — 25 queries across 5 groups: crypto prices (real-time), tech news (last 24h), niche Vietnamese market info, long-tail factual questions, adversarial/ambiguous queries designed to break naive search.
Same time window — all providers queried within a single 30-minute window to control for index freshness.
Identical downstream consumer — the same agent prompt and the same answer-extraction step, so we're measuring the search layer, not prompt luck.
Scored blind — 3 reviewers score 0–2 on factuality, coverage, and citation quality without knowing which provider produced which answer.
Cost logged per query — what each provider actually charged for the exact call, not the marketing "starting at" price.

Our websearch endpoint runs on Serper under the hood — we're not hiding that. The question isn't "who has secret tech," it's "does a $0.010 x402 call compete with the incumbents on quality, and what does the math look like at agent scale?"

Status of the head-to-head: the Exa/Tavily comparison ships as Part 2. What follows is Part 1: our own baseline, measured live today — real latency, real cost, real output samples from 7 endpoints. No cherry-picking; these are the first queries we ran.

3. Baseline measurements: 7 endpoints, real numbers (2026-10-19)

All measurements taken 2026-10-19 ~11:14 UTC via free-trial calls (no payment) from a single client. Latency = wall-clock round trip including network.

Endpoint	Price/call	Median latency	What we queried	What came back
`news`	$0.002	2.2s	"bitcoin price"	20 items, real headlines w/ timestamps + sources (CoinMarketCap, Robinhood, Investing.com, Yahoo Finance)
`fxrates`	$0.004	1.7s	USD/VND	25,869.4 — with an honest `note` field: "DAILY REFERENCE rate, not real-time trading price"
`gastracker`	$0.001	1.8s	Base chain	Block 52,809,546, base fee 0.005 gwei, EIP-1559 slow/standard/fast tiers
`macro`	$0.002	1.7s	fed_rate	3.88% (2026-10-15), 12-day history, change +0
`defiyield`	$0.001	1.4s	aave pools	10 pools, top APY 1,123% (SDYFI), TVL + IL-risk flags included
`polymarket`	$0.006	2.2s	"bitcoin price end of october"	Live BTC markets: Yes 0.9995 / No 0.0005 on $72k, volume + liquidity per market
`defi`	$0.010	2.4s	USDC contract 0x8335…2913	Verified contract, 4.29B supply, 1,852 bytes code, risk flags [], "not financial advice" disclaimer

What the numbers tell us:

Sub-2.5s across the board. Nothing here will bottleneck an agent loop. The slowest (defi, 2.4s) does on-chain verification work; the fastest (defiyield, 1.4s) is a cached aggregation.
The honest note fields matter. fxrates tells you it's a daily reference rate, not a trading price. gastracker tells you tiers are heuristic multipliers. defi disclaims "heuristic signals only." We'd rather an agent know the data's limits than hallucinate confidence.
Cost at agent scale: 1,000 news queries = $2.00. 1,000 DeFi yield checks = $1.00. 1,000 gas estimates = $1.00. For a research agent doing 100 queries/day, that's $0.10–$0.20/day — roughly the cost of the LLM tokens to read the results.

What we didn't measure (yet)

Exa / Tavily head-to-head — Part 2. We'll publish the raw query log alongside scores so anyone can re-run it.
Uptime under load — single-client measurements only. The public status page tracks ongoing availability.
The other 34 endpoints — same method, future posts. tokenprice ($0.001) vs price-feed incumbents is next in the queue.

4. Transparent pricing: 10 core endpoints

No "contact sales." No tiers. Every endpoint has one price, paid per call in USDC on Base:

Endpoint	What it does	Price/call
`websearch`	Web search (Serper-backed), real-time results	$0.010
`aiverdict`	Multi-model AI verdict / decision scoring	$0.015
`news`	Crypto/tech news feed	$0.002
`defi`	Contract intelligence (verification, supply, risk flags)	$0.010
`fxrates`	FX rates (daily reference)	$0.004
`gastracker`	Gas estimates (EIP-1559 tiers)	$0.001
`polymarket`	Prediction market odds + volume	$0.006
`macro`	Macro indicators (Fed rate, history)	$0.002
`defiyield`	DeFi pool yields + TVL + risk flags	$0.001
`sentiment`	Sentiment analysis on text/social	$0.030

Plus 31 more (PDF tools, SEC filings, domain tools, GPU spot oracle at $0.10/call…) — same model, same transparency. If a price ever changes, the receipts page shows it; there's no invoice to argue about because every payment is a chain transaction.

5. The architecture: trust without accounts

Three design choices, all downstream of "agents shouldn't need accounts":

Free trial, no signup. Per-IP daily quota by price tier: 10 calls/day for endpoints ≤$0.002, 5/day up to $0.01, 2/day up to $0.10, 1/day above that. No email, no key, no form. The X-Free-Remaining header tells your agent exactly how many it has left. If the data doesn't work for your use case, you've lost nothing but a few HTTP calls.
On-chain settlement you can verify. Every paid call settles in USDC on Base. The transaction hash is the receipt — check it on a block explorer, not on our word.
Public receipts page. Pricing, uptime, and recent settlement activity are public. When your agent spends $10 on 1,000 websearch calls, anyone can audit that the math holds.

This is the part we're proudest of, and the part most "AI API" companies won't copy: verifiability is a feature, and it costs us nothing to give away.

6. What's next + try it yourself

This series benchmarks each endpoint against its incumbent the same way: fixed queries, blind scoring, real cost-per-call math, raw logs published. Next up:

Part 2: websearch vs Exa vs Tavily — the head-to-head, with the full 25-query protocol above.
Part 3: tokenprice ($0.001) vs price-feed incumbents — a benchmark that costs less than a coffee to run.

If you're building agents and want to poke at the endpoints:

Pricing & docs: https://api.mekongtradeintel.com/pricing
Free trial: no signup — just call the endpoint and the trial quota applies automatically. Watch for the X-Free-Remaining header.

And if you re-run our baseline and get different numbers, tell us. A benchmark that can't survive reproduction is just an ad — we'd rather be wrong in public than right in private.