Nothing to sign up for
No account, no API key, no dashboard, no invoice. The first request tells you the price, the second carries the payment. Your agent runs that exchange on its own, start to finish.
TheFOMOfeed,pricedperrequest.
Every callout and trade from FOMO, indexed and paginated behind HTTP 402. Your agent pays USDC per response and reads the body. No signup, no key, no invoice.
x402 exact scheme · USDC on solana · from $0.001 a response · 25 free calls a day per IP so you can look before you spend.
Try a live requestcallouts from accounts over 5k followers
GET /v1/calls?minFollowers=5000&since=-24h&limit=3
idle
One click, one round trip against the live API. It runs on the free tier, so the rows and cursors are real and you need no wallet.
Why
Built for agents that pay their own way
The same feed the FOMO extension docks into your terminal, exposed as an API. An autonomous client finds it, prices it and reads it without a signup form.
History upstream doesn't keep
FOMO's public feed shows the last 40 rows per view and nothing else. This service polls it every two seconds and keeps what rolls off, so you can ask what a handle said last Tuesday.
Exact pagination
Time-ordered pages use a keyset cursor over (ts, id). New rows landing at the head cannot make a later page skip or repeat one you already read.
Filters that run server-side
27 query parameters. The index applies them before it cuts the page: follower floors, USD and market cap windows, conviction size, ticker and mint lists, dev exclusion, time bounds.
Priced per response
From $0.001. A 500-row page costs what a 1-row page costs, so a wide limit walks a result set for less. The free tier covers your first calls each day, enough to shape a query before you pay for it.
Settle-then-serve
The order is verify, build the body, settle, send. A 402 means you were not charged. A 200 means the payment cleared and X-Payment-Response carries the receipt.
Same data, three shapes
Records are the raw rows: one call or one trade, with its actor, token, trade and conviction blocks. Actor and token endpoints roll the same rows up per handle or per mint: call counts, volume, distinct callers, realized PnL. Leaderboards rank those rollups over a window you choose.
Every shape reads the same index, so a leaderboard hit and a raw row agree on the numbers.
Surface
Fifteen endpoints, one price list
Price is per response. A 500-row page costs the same as a 1-row page, so paginate wide. Discovery, stats and the OpenAPI document are free and unauthenticated.
get/v1/feed$0.002
Calls and trades in one stream
get/v1/calls$0.002
Callouts with a written thesis
get/v1/trades$0.002
On-chain buys and sells
get/v1/search$0.005
Full-text over thesis, ticker, mint, handle
get/v1/records/{id}$0.001
One record by id
get/v1/actors/{handle}$0.003
Actor profile with rollup stats
get/v1/actors/{handle}/calls$0.002
Everything one actor has posted
get/v1/actors$0.005
Actor directory, ranked
get/v1/tokens/{mint}$0.003
Token rollup: buyers, volume, callers
get/v1/tokens/{mint}/calls$0.002
Everything said about one mint
get/v1/tokens$0.005
Token directory, ranked
get/v1/leaderboard$0.01
Actors ranked by conviction, volume or PnL
free/v1/statsfree
Index size, poll health, coverage window
free/v1/schemafree
OpenAPI 3.1 document
free/.well-known/x402free
x402 resource discovery
Pagination
Walk the whole thing
Every page carries a cursor to the next one. Follow it until hasMore goes false and you have every row that matched, however many requests that takes.
Keyset over (ts, id)
Time-ordered queries page on (ts, id), a total key that breaks ties, so the walk is exact. Rows landing at the head between two requests cannot push a row you have not read past your cursor.
Value sorts (usd, mcap, followers) have no stable key, so their cursor is an offset and the ranking can shift under a long walk. Sort by ts when you need every row; sort by value when you want the top of one.
limit goes to 500 and price is per response, so one wide page beats four narrow ones. pagination.total tells you how many requests the walk takes before you start.
p1cursor=— · 200 rows
p2cursor from page 1
p3cursor from page 2
p4cursor from page 3
p5hasMore: false, done
rows collected 200 / 941 · spend $0.002
Quickstart
Four lines to the first row
Any x402 client works, since the protocol is the whole integration. These four come up most.
# 1. ask, get quoted
curl -s 'https://fomo402.xyz/v1/calls?minFollowers=5000&limit=200' | jq .accepts
# 2. pay and read
curl -s -H "X-PAYMENT: $PAYLOAD" \
'https://fomo402.xyz/v1/calls?minFollowers=5000&limit=200' | jq '.data[0]'
# free either way
curl -s https://fomo402.xyz/.well-known/x402 | jq .resources
curl -s https://fomo402.xyz/v1/stats | jq .data.coverageHoursThe unpaid request costs nothing and answers with the full payment requirements, so you can price a query before you buy it.
FAQ
Questions worth asking first
What is x402, in one paragraph?+
An HTTP status code with a payload. You request a resource; the server answers 402 Payment Required with the exact terms it will accept: asset, amount, chain, recipient. Your client signs a USDC transfer for that amount, base64s it into an X-PAYMENT header, and retries. The server verifies with a facilitator, serves the body, settles on chain, and returns the receipt in X-Payment-Response. No accounts, no keys, no invoices.
What does a request cost?+
$0.001 to $0.01 in USDC, per response. Feed pages are $0.002 whether they carry one row or five hundred, which makes limit=500 the cheapest way to walk a result set: a 12,000-row export is 24 requests and about five cents.
/v1/stats, /v1/schema and /.well-known/x402 are free, so you can size a query before you pay for it.
Can I try it without a wallet?+
Yes. Every IP gets 25 unpaid calls a day across the whole surface. Paid endpoints answer as usual and set x-payment-mode: free-tier with the remaining count in x-free-tier-remaining. The playground runs on that allowance.
What happens if settlement fails after you served the body?+
It cannot. The server settles after it builds the body and before it sends: verify, build, settle, respond. A failed settlement turns into a 402 with the reason attached, so a 200 from this API means the payment cleared.
How far back does the data go?+
As far back as this service has been running. Upstream exposes only the most recent 40 rows per view, so the depth here comes from the poller: every two seconds, deduped by id, with the newest market cap and PnL merged onto the row already indexed. Ask /v1/stats for the live coverage window before you build on a time range.
Is the data the same as the extension's?+
Same source, same normalization. The FOMO extension polls the public feed and filters on your machine; this API indexes it and filters server-side. Field names match the extension's event envelope, so a row here drops into the same code.
Why keyset cursors instead of page numbers?+
Because the feed grows at the head. With page=2, rows arriving between requests shift everything down and you re-read what you already have, or miss what slipped past. A cursor on (ts, id) names an exact position in a total ordering, so the walk is exact no matter how long you take over it.
Rate limits?+
Your budget is the rate limit on paid requests. The free tier is 25 calls per IP per day. One shared poller reads upstream, so your request count never touches it.