The fomo.family API: trader profiles, swaps, PnL and leaderboards from the fomo app

fomo (at fomo.family) is a social trading app. You follow traders, see what they buy in a live feed and buy the same token in a couple of taps, on Solana and several EVM chains. If you are building on top of it (a tracker, a leaderboard, a Telegram bot, research), you will look for a fomo.family API. You won't find one. fomo doesn't publish a developer API or hand out keys.

This guide covers the data fomo.family has and how it fits together. It shows how to read it with a key and working code, and it explains one wallet caveat that catches nearly everyone who tries this on-chain.

One note before we start. If you searched "fomo API" and expected notification widgets, that is Fomo the social-proof tool, a different company. This page is about fomo.family, the trading app.

#Does fomo.family have a public API?

No. The fomo app talks to its own backend, and that backend is built for the app. Users sign in through Privy, which also creates their self-custodial wallets. Every request carries that signed-in session, and there is no developer program, documentation or rate-limit policy for third parties.

That leaves three ways to get fomo data:

1. Read the chain. On Solana, fomo's swaps go through a fee payer of fomo's own, which co-signs every trade. Bitquery documents this route. It works for raw Solana trades, but you get no handles, no profiles and no theses, and fomo's EVM trades look like any other relayed transaction.
2. Run your own client against fomo's backend. You'd need real accounts, sessions that refresh, and care to stay within limits, and it breaks whenever the app changes.
3. Use a data API that does the second for you. That is what pumpfomo is. We run the accounts, keep sessions alive, cache what's cacheable and give you 29 documented fomo.family endpoints behind one key.

#What fomo.family data exists

fomo's data model is small and consistent once you see it:

Two of these trip people up.

Swaps and trades are different things. A swap is one fill. A trade is fomo's word for a position, which can hold many swaps (buy, buy again, sell half, sell the rest). For PnL, use trades. To replay exactly what someone did and when, use swaps.

A thesis is a comment on a trade. When a fomo trader posts why they bought, fomo stores it on the position, with the price and market cap at the moment they wrote it. That makes theses measurable: you can see whether the token went up after the call. They come back on token holders, on theses on a token and in the feed.

#Chains and network ids

fomo trades on Solana, Base, BNB Chain, Ethereum, Robinhood Chain, Monad and Arc. Its data names chains by numeric network id, and our token routes take either the id or a name:

A fomo user trades from a USDC balance. On Solana, a buy is usually USDC in and the token out, and a sell is the reverse. Many EVM buys are cross-chain: paid with USDC on one chain and delivered on another, through Relay. You can spot them in swap data when inNetworkId and outNetworkId differ.

#Getting started

Sign in with a wallet or Telegram, create a key in the dashboard (it starts with pf_live_), and send it in Authorization: Bearer. The Free plan's 10,000 credits a month cover about 5,000 fomo reads, since most cost 2 credits. You don't need a fomo account.

#A trader's profile

curl -s https://api.pumpfomo.com/v1/fomo/users/pointfarmcap \
  -H "Authorization: Bearer $PUMPFOMO_KEY"

{
  "data": {
    "id": "6d8c0bf3-5d42-506c-a0ea-9e1e75ff38af",
    "userHandle": "pointfarmcap",
    "displayName": "point farm capital",
    "followers": 462266,
    "swapCount": 31520,
    "numTrades": 3672,
    "totalVolume": 20725526.06,
    "averageHoldTimeSeconds": 121004,
    "badge": { "type": "top_100_badge", "title": "Top 2", "metadata": { "rank": 2, "totalPnL": 3085598.31 } }
  },
  "meta": { "source": "fomo.family", "cache": "live", "fetchedAt": "2026-10-25T23:11:29Z" }
}

Trimmed from a real answer. Handles are case-insensitive and may start with @. The id is the stable key: handles can change, ids don't.

#The 7-day leaderboard in Python

import os
import requests

BASE = "https://api.pumpfomo.com"
HEADERS = {"Authorization": f"Bearer {os.environ['PUMPFOMO_KEY']}"}

r = requests.get(f"{BASE}/v1/fomo/leaderboard/7d", headers=HEADERS, timeout=15)
r.raise_for_status()

for i, t in enumerate(r.json()["data"]["leaderboard"][:10], 1):
    top = t["topHoldings"][0]["tokenAddress"][:6] if t["topHoldings"] else "-"
    print(f"{i:>2}. @{t['userHandle']:<20} 7d PnL ${t['pnl7d']:>12,.0f}  "
          f"{t['totalHoldings']} holdings, biggest {top}…")

The PnL field is named after the window: pnl24h, pnl7d, pnl30d. A leaderboard call costs 1 credit.

#Every swap of a trader, page by page

def swaps(handle, pages=4):
    cursor = None
    for _ in range(pages):
        params = {"cursor": cursor} if cursor else {}
        r = requests.get(f"{BASE}/v1/fomo/users/{handle}/positions",
                         headers=HEADERS, params=params, timeout=15)
        r.raise_for_status()
        page = r.json()["data"]
        yield from page["swaps"]
        if not page.get("hasNextPage") or not page["swaps"]:
            break
        cursor = page["swaps"][-1]["id"]

for s in swaps("pointfarmcap"):
    cross = s["inNetworkId"] != s["outNetworkId"]
    print(s["createdAt"], s["display"]["side"], round(s["humanUsdAmountIn"], 2),
          s["provider"], "cross-chain" if cross else "", "off fomo" if s["isOffPlatform"] else "")

Each swap has inTokenAddress/outTokenAddress, human amounts on both sides, humanUsdAmountIn, provider (we see DFLOW, RELAY and OKX among others) and isOffPlatform. That flag is true for swaps fomo saw in the user's wallet but that weren't made in the fomo app.

#Who on fomo holds a token, and why

const res = await fetch(
  "https://api.pumpfomo.com/v1/fomo/tokens/solana/6GmAFSYs4gk3FDao5FzzySQpPZaWsa4rUJHacpMpUNgx/holders",
  { headers: { Authorization: `Bearer ${process.env.PUMPFOMO_KEY}` } },
)
const [token] = (await res.json()).data
for (const h of token.topHolders) {
  console.log(
    `@${h.user.userHandle}`.padEnd(22),
    `$${Math.round(h.value).toLocaleString()}`.padStart(12),
    `PnL $${Math.round(h.pnl).toLocaleString()}`,
    h.comment ? `"${h.comment.comment.slice(0, 60)}"` : "",
  )
}

Each holder comes with value, cost basis, realized and unrealized PnL, average entry, and the thesis if they wrote one. A thesis carries marketCapAtCreation, so you can measure every call against what happened next.

#A caveat about fomo wallets

Every fomo profile shows a Solana address and an evmAddress. It is tempting to paste them into a block explorer and read the trader's history from the chain. That doesn't work.

On Solana, each swap is a transaction that fomo's fee payer signs together with the wallet that actually holds the tokens. In our tests, the address shown on the profile was not that wallet. On EVM chains, fomo wallets are smart accounts (EIP-7702), and transactions are submitted by bundlers and relayers, so tx.from is not the trader either. Cross-chain buys add a solver in the middle.

So identify fomo traders by handle or user id, and read their activity from fomo's data, as every route above does. If you need to go the other way, from a wallet to the person behind it, read our guide to tracking fomo wallets.

#Live fomo.family data

Polling a few hundred traders' swaps is slow and costs credits on every poll. The WebSocket does it for you:

{ "op": "subscribe", "channel": "traders", "fomo": ["pointfarmcap", "The__Solstice"] }

Every buy, sell and thesis of those traders arrives as a fomo_trade message with the token, size, price, market cap and the trader's profile. Add "alerts": true on the fomo channel to also get fomo's global feed (large buys, multi-user buys, new listings) as it happens. One connection follows up to 100 fomo handles, and streams come with the plan from Builder up. The WebSocket guide has full client code.

#What it costs

On the Starter plan ($49 for 100,000 credits) a profile read costs about a tenth of a cent. See pricing for every plan.

#Frequently asked questions

#Does fomo.family have an API?

Not a public one. The fomo app uses a private backend tied to signed-in sessions, with no documentation or keys for developers. pumpfomo offers 29 documented fomo.family endpoints and a live stream behind one API key.

#Is this the Fomo social-proof API?

No. "Fomo" is also the name of a social-proof notification product with its own API at fomo.com. This guide is about fomo.family, the social trading app, and the two are unrelated.

#Do I need a fomo account to use the fomo.family API?

No. You need a pumpfomo key. We run the fomo.family accounts the data is read through.

#Which chains does the fomo API cover?

Everything fomo.family trades on: Solana, Base, BNB Chain, Ethereum, Robinhood Chain, Monad and Arc. Token routes take the chain by name or network id.

#Can I place trades on fomo through the API?

No. pumpfomo is read-only. It never trades, follows or posts on anyone's behalf.

#How fresh is fomo data?

Profiles, swaps and holdings are read live or served from a cache a few seconds old. Each answer's meta.cache and meta.fetchedAt say which. The stream delivers trades as fomo publishes them.

#Is pumpfomo affiliated with fomo.family?

No. pumpfomo is independent and not affiliated with fomo.family or pump.fun.

#Where to go next

• Browse all fomo.family endpoints in the reference, each with a real answer.
• Follow traders live with the WebSocket guide.
• Pick traders worth following with the copy-trading guide.
• Get a free key.