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

The pump.fun callouts API and the fomo.family thesis API: trader calls with the market cap, the multiple and the follower PnL behind them
On this page
  1. What a pump.fun callout contains
  2. The pump.fun callouts API
  3. A caller's record: averages lie, medians don't
  4. What a fomo.family thesis contains
  5. The fomo.family thesis API
  6. Six things to build with callouts and theses
  7. What it costs
  8. Frequently asked questions

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), marketCap and calloutPriceUsd at the moment it was posted, and createdAt (unix milliseconds).
  • What happened next: maxMultiplier (the best price since, over the call price) and maxMultiplierAt, plus multiple, 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. tailBuyers counts them, and tailPnl1hUsd, tailPnl4hUsd and tailPnl24hUsd add 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:

bash
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:

json
{
  "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, userId is the caller's wallet. Their pump.fun account id is user_uuid (and author.userId in lists).
  • createdAt is unix milliseconds in callouts, but an ISO date in replies.
  • multiple and maxMultiplier are ratios to the call price, not percentages. 0.58 means down 42%.
  • tailCohort24h and tailPnl24hUsd are null until 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:

json
{
  "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, and isDev when 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:

bash
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:

ts
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:

ts
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:

ts
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:

ts
// 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:

ts
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:

ts
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:

ts
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:

ts
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