The pump.fun callouts API and the fomo.family thesis API: reading trader calls, and checking them
Read pump.fun callouts and fomo.family theses over one API: each caller's hit rate, the market cap at every call, how followers did, and live alerts. With code.
8 min read
A call is the cheapest thing in crypto to make and the hardest to check. Anyone can post "this goes 10x". What's worth knowing is what the coin was worth when they said it, what it did next, and whether the people who listened made money.
pump.fun and fomo.family both keep that record. On pump.fun it's a callout: a short thesis pinned to a coin, with the market cap and price at the moment of the call. On fomo.family it's a thesis: a comment attached to a real position, so you can see how much the author put in and how they're doing. Neither platform publishes a developer API for them. This guide shows how to read both through pumpfomo, what the fields mean, where they trip people up, and six things you can build with them.
What a pump.fun callout contains
A callout is pump.fun's version of a public trade idea. Each one has:
- The call:
coinMint,thesis(the text),marketCapandcalloutPriceUsdat the moment it was posted, andcreatedAt(unix milliseconds). - What happened next:
maxMultiplier(the best price since, over the call price) andmaxMultiplierAt, plusmultiple, where the price stood against the call when it was read. - The crowd:
likes,replyCount,repostCount,viewCount. - The tail: pump.fun's name for the people who bought after the call.
tailBuyerscounts them, andtailPnl1hUsd,tailPnl4hUsdandtailPnl24hUsdadd up how they were doing 1, 4 and 24 hours later, with histograms. - The author: name, avatar, X handle and follower count, and whether pump.fun verified them.
The tail is the part you can't get anywhere else. A caller's own trade tells you they made money. The tail tells you whether following them did.
The pump.fun callouts API
| What | Endpoint | Credits |
|---|---|---|
| A trader's callouts, newest first (100) | GET /v1/pump/users/{wallet}/callouts |
2 |
| Their record: hit rates, multiples, tail PnL | GET /v1/pump/users/{wallet}/callout-stats |
2 |
| One callout with its author | GET /v1/pump/callouts/{id} |
1 |
| Replies, or only the author's follow-ups | GET /v1/pump/callouts/{id}/replies |
1 |
| Every new callout, live | the callouts channel of the stream |
10 a minute |
{wallet} takes a wallet address or a pump.fun user id. Make a key in the dashboard (the Free plan has 2,500 credits a month) and try it:
curl -s "https://api.pumpfomo.com/v1/pump/users/4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR/callouts" \
-H "Authorization: Bearer $PUMPFOMO_API_KEY"Here's one callout from that answer, cut down to the fields that matter. It's from the example we captured for the reference:
{
"calloutId": "24f30f64-c76b-4874-acbd-959b5faff047",
"coinMint": "9jBBwEK6UZgLv5vm7F1KsULgYAy5dHo9LEYmCfLWKPDj",
"thesis": "whitewhale but on STONK",
"marketCap": 62359,
"maxMultiplier": 10.406831303283584,
"maxMultiplierAt": "2026-10-25T07:08:24.481Z",
"multiple": 0.5795672318128364,
"viewCount": 14680,
"tailBuyers": 150,
"tailCohort1h": 123,
"tailPnl1hUsd": 11347.31,
"tailCohort4h": 148,
"tailPnl4hUsd": 3119.43
}Read it slowly, because it's a good example of why one number isn't enough. The coin was called at a $62,359 market cap and went 10.4x at its best. That's the headline anyone would screenshot. By the time we read it, the price was at 0.58 of the call. The 123 people who bought after the call were up $11,347 between them an hour later. Four hours later the cohort had grown to 148 and their combined PnL had fallen to $3,119. The call was great for people who took profit early, and much less so for everyone else.
Fields that trip people up
These are pump.fun's own field names, passed through as they are, and a few aren't what they look like:
- In a callout,
userIdis the caller's wallet. Their pump.fun account id isuser_uuid(andauthor.userIdin lists). createdAtis unix milliseconds in callouts, but an ISO date in replies.multipleandmaxMultiplierare ratios to the call price, not percentages. 0.58 means down 42%.tailCohort24handtailPnl24hUsdarenulluntil a day has passed.
A caller's record: averages lie, medians don't
Callout stats sum up a trader's calls for the day, the week, the month, all time, and their last round. The same caller's all-time record:
{
"totalCallouts": 170,
"twoXPercent": 50,
"onePointFiveXPercent": 64.7,
"onePointTwoXPercent": 81.2,
"averageMultiple": 4.18,
"medianMultiple": 2.0,
"averageTimeToPeakMs": 288703464
}An average multiple of 4.18x sounds better than it is. A few huge runs pull an average up. The median of 2.0x says that half of this trader's 170 calls doubled at some point and half didn't, which is still a strong record and a far more honest one. When you rank callers, rank on medianMultiple and twoXPercent, and use the average only to spot the ones with fat tails.
Each window also has ranks: where the caller's tail numbers fall as a percentile among every caller pump.fun scored (population). A tailPnl4hUsd rank of 99.75 means that four hours after this trader's calls, followers did better than after almost anyone else's.
What a fomo.family thesis contains
fomo.family does it differently. A thesis isn't a separate post. It's a comment on a position, so it always comes with the position behind it. That's the useful part: you can tell a thesis written on a $3,000 position from one written on $30.
Each thesis has:
- The text in
comment.comment, with the price, market cap and FDV when it was posted (priceUsdAtCreation,marketCapAtCreation,fdvAtCreation) and its likes and replies. - The author's position in
authorTrade:usdValue,unrealizedPnlUsd,realizedPnlUsd, and whether it's closed (closedAt). - The author:
userHandle,displayName,verified, andisDevwhen they're one of the token's developers. - The token:
tokenAddress,networkId,ticker.
The fomo.family thesis API
| What | Endpoint | Credits |
|---|---|---|
| Every thesis on a token, 100 a page, optionally only from big positions | GET /v1/fomo/tokens/{chain}/{address}/theses |
2 |
| The thesis and comments on one position | GET /v1/fomo/trades/{id}/comments |
2 |
| A trader's best trades and best theses | GET /v1/fomo/users/{handle}/spotlight |
2 |
| New theses across fomo.family | GET /v1/fomo/feed?types=thesis_created |
2 |
| Theses as they're posted | the fomo channel of the stream |
10 a minute |
The theses endpoint is the one you'll use most. minUsd keeps only theses whose author holds at least that much, which is the quickest way to cut the noise:
curl -s "https://api.pumpfomo.com/v1/fomo/tokens/solana/6GmAFSYs4gk3FDao5FzzySQpPZaWsa4rUJHacpMpUNgx/theses?minUsd=1000" \
-H "Authorization: Bearer $PUMPFOMO_API_KEY"When we captured the example, that token had 23,285 theses (count). Nobody reads 23,285 theses. Filtering by position size leaves the ones written by people with real money in it. The newest one in that capture read "Big week loading", posted at a $105 million market cap by a trader holding $3,345 of it and down 1.7%. Short, but you know exactly how much it's backed by. Page with the last item's id as cursor while hasNextPage is true.
Six things to build with callouts and theses
The examples use a small helper. The pumpfomo skill for Claude writes the same one, with retries, if you'd rather describe these than type them:
const BASE = "https://api.pumpfomo.com"
const pf = async (path: string) => {
const r = await fetch(BASE + path, { headers: { Authorization: `Bearer ${process.env.PUMPFOMO_API_KEY}` } })
if (!r.ok) throw new Error(`${path}: ${r.status}`)
return (await r.json()).data
}1. A caller leaderboard you can trust
Rank a list of callers by what their median call did, with a floor on how many calls they've made:
async function rankCallers(wallets: string[]) {
const rows = []
for (const w of wallets) {
const s = (await pf(`/v1/pump/users/${w}/callout-stats`)).monthly
if (!s || s.totalCallouts < 10) continue // too few to judge
rows.push({ wallet: w, calls: s.totalCallouts, median: s.medianMultiple, hit2x: s.twoXPercent, tail4h: s.tailPnl4hUsd })
}
return rows.sort((a, b) => b.median - a.median)
}Two credits a caller. Where do the wallets come from? The PnL leaderboard, its best positions (each comes with the callout behind it, if there was one), or the authors that show up on the stream.
2. A live alert for callers who've earned it
The stream's callouts channel sends every new pump.fun callout once, as it's posted. Check the caller's record the first time you see them, then remember it:
import WebSocket from "ws"
const record = new Map<string, any>() // caller wallet → monthly stats
const ws = new WebSocket("wss://api.pumpfomo.com/v1/stream", {
headers: { Authorization: `Bearer ${process.env.PUMPFOMO_API_KEY}` },
})
ws.on("open", () => ws.send(JSON.stringify({ op: "subscribe", channel: "callouts", replay: false })))
ws.on("message", async (raw) => {
const m = JSON.parse(raw.toString())
if (m.type !== "callout") return
const c = m.callout?.callout ?? {}
const caller = c.userId // the caller's wallet
if (!record.has(caller)) record.set(caller, (await pf(`/v1/pump/users/${caller}/callout-stats`)).monthly)
const s = record.get(caller)
if (!s || s.totalCallouts < 10 || s.medianMultiple < 1.8) return
notify(`${c.userName} called ${m.mint} at $${Math.round(m.calledOutAtMcap).toLocaleString()} ` +
`(median ${s.medianMultiple.toFixed(1)}x over ${s.totalCallouts} calls): "${c.thesis}"`)
})Each message carries the coin (mint, chain), calledOutAtMcap, the caller's costBasisUsd in it, and pump.fun's full callout record under callout.callout. Point notify at a Telegram bot or a Discord webhook. In production, move the stats lookup off the message handler and refresh the cache daily. The stream needs the Builder plan or above.
3. "What traders say" on a token page
pump.fun callouts are listed by caller over REST, so for a single coin collect them from the stream with a mints filter. fomo.family theses on the same token come straight from the theses endpoint. Put both side by side:
// live callouts on the coins your page shows
ws.send(JSON.stringify({ op: "subscribe", channel: "callouts", mints: [mint] }))
// and fomo.family's theses on it, from people holding $500 or more
const { items } = await pf(`/v1/fomo/tokens/solana/${mint}/theses?minUsd=500`)
const theses = items.map((t: any) => ({
who: t.userHandle,
text: t.comment?.comment,
mcapThen: t.comment?.marketCapAtCreation,
holding: t.authorTrade?.usdValue,
pnl: t.authorTrade?.unrealizedPnlUsd,
dev: t.isDev,
}))Show the market cap each was written at. A bullish thesis at $2 million reads differently when the coin is at $40 million.
4. Theses with skin in the game
Go further than minUsd: keep a thesis only while its author still holds and isn't deep underwater. A thesis whose author has sold is a memory, not an opinion:
const live = theses.filter((t) => t.holding >= 1000 && t.pnl > -0.5 * t.holding && !t.dev)Then watch for new ones live. On the stream's fomo channel a thesis arrives as a fomo_trade message with kind: "thesis", with the trader, the token and the text under comment:
ws.send(JSON.stringify({ op: "subscribe", channel: "fomo", fomo: ["handle1", "handle2"], replay: false }))
// m.type === "fomo_trade" && m.kind === "thesis"Leave fomo empty to get theses from every trader the stream tracks, or add "alerts": true for fomo.family's global feed, where thesis_created is one of the alert types.
5. Follow a caller's own updates
A call is a beginning. What the caller says afterwards is often more useful: "taking some profit", "still holding", "I'm out". Replies with authorOnly=true keep only the author's own follow-ups:
const { replies } = await pf(`/v1/pump/callouts/${calloutId}/replies?authorOnly=true`)
for (const r of replies) console.log(r.createdAt, r.content, r.positionRealizedPnlUsd)Each reply carries the replier's position in the coin. On the callout above, the author's update read "Taking some profits hope it continues to run", with $1,110 bought and $3,855 of realized PnL beside it. That's a caller telling you, with numbers, when they sold.
6. Check a call against what happened
Every callout already has the call price, the best price since and the tail's PnL. That's enough to score your own rules on history before you trust them live:
const { callouts } = await pf(`/v1/pump/users/${wallet}/callouts`)
for (const c of callouts) {
const peak = c.maxPriceUsd / c.calloutPriceUsd
const minutesToPeak = c.maxMultiplierAt ? (Date.parse(c.maxMultiplierAt) - c.createdAt) / 60000 : null
console.log(c.thesis.slice(0, 40), peak.toFixed(1) + "x", minutesToPeak, c.tailPnl1hUsd, c.tailPnl4hUsd)
}You'll usually find what the example above showed: the tail does best early. If a caller's peaks come within the first hour, a rule that holds for a day will give most of it back.
What it costs
Callout lists and stats are 2 credits each; one callout and its replies are 1. Theses, comments and spotlights are 2. The stream needs Builder or above and costs 10 credits a minute while it's open, whatever channels it carries; nothing is charged by the message. Scoring 200 callers' monthly stats once a day is 400 credits; the Free plan's 2,500 a month is enough to try every endpoint here, and the paid plans start at $49 a month (or less, paid yearly). See pricing.
Frequently asked questions
Does pump.fun have an official callouts API?
No. pump.fun doesn't publish a documented API or issue keys for callouts. pumpfomo serves them as documented endpoints: a trader's callouts and stats, one callout and its replies, and every new callout live on the stream.
Is there a fomo.family thesis API?
Not from fomo.family. pumpfomo gives you theses on any token (with a filter by the author's position size), the thesis and comments on a position, a trader's best theses, and new theses live on the stream.
Can I get every callout on one coin?
Live, yes: subscribe to the callouts channel with that coin in mints. Over REST, callouts are listed by caller, so collect a coin's callouts from the stream as they come, or from the callers you already track.
What is "tail" in pump.fun callout data?
The people who bought after a callout. pump.fun counts them and adds up their PnL 1, 4 and 24 hours later. It's the closest thing to an answer to "would following this caller have made me money".
Which plan do I need?
The REST endpoints work on every plan, Free included. The live stream, for callout alerts and live theses, needs Builder or above.
Can I build this with AI?
Yes. Add the pumpfomo skill to Claude and ask for any of the six examples in plain words. Other assistants can read the same reference from llms.txt.
Try it on real data, free.
2,500 credits a month, wallet or Telegram sign-in, no card. Every endpoint in these guides works on the Free plan; streams start at Builder.
More guides

7 min read
How to build a fomo copy trading bot with AI, using Claude and the pumpfomo skill
Build a fomo.family copy trading bot with AI. Add the pumpfomo skill to Claude, pick traders worth copying, follow them live and filter their buys, on paper first.
Read the guide
8 min read
The pump.fun API in 2026: what exists, what doesn't, and how to use it
Does pump.fun have a public API? What its apps call, which pump.fun data you can get (profiles, trades, PnL, callouts) and how to start with curl and Python.
Read the guide
6 min read
The fomo.family API: trader profiles, swaps, PnL and leaderboards from the fomo app
fomo.family has no public API. Here is what fomo data exists (traders, swaps, PnL, leaderboards, clans, theses) and how to read it with one key, with code.
Read the guide
7 min read
The pump.fun WebSocket API: stream every trade, new coin and callout as it happens
Stream pump.fun trades on Solana and 11 EVM chains, new coins, callouts and fomo.family traders over one WebSocket. Channels, filters and Node and Python code.
Read the guide