Building a fomo wallet tracker: who is behind a wallet, and every trade a fomo trader makes

A wallet tracker answers two questions. What is this person trading right now? And going the other way, who is behind this wallet? For pump.fun traders both are fairly direct. For fomo.family traders they are harder than they look, and most fomo wallet trackers built on a block explorer quietly show the wrong thing.

This guide explains why, then builds a fomo wallet tracker that works. It follows fomo.family and pump.fun traders live, alerts you on their trades and names the people behind wallets you come across. The code is in TypeScript, and every endpoint is in our reference.

#Why the address on a fomo profile won't track a fomo trader

Open any fomo.family profile through the app's data and you get two addresses: address (Solana) and evmAddress. The natural move is to paste the Solana one into Solscan and watch it. You'll see little or nothing, because those aren't the accounts that sign the trader's swaps.

Here is what a fomo trade looks like on-chain:

• On Solana, every swap is a transaction signed by fomo's own fee payer together with the wallet that holds the tokens. fomo pays the network fee, so the user never needs SOL. In our checks of 100 active fomo traders, the address shown on the profile was never the wallet their swaps executed from.
• On EVM chains, fomo wallets are smart accounts under EIP-7702. Transactions are submitted by ERC-4337 bundlers and relayers, so the from of the transaction is the bundler, not the trader.
• Cross-chain buys (pay with USDC on Solana, receive a token on Base, say) go through Relay. A solver delivers the token on the other chain, adding another hop between the trader and what the explorer shows.

So an explorer-based fomo tracker is watching an empty room, or worse, the fee payer that every fomo user shares. Track fomo traders by who they are on fomo (handle or user id) and read their trades from fomo's own data. pump.fun is simpler: its trades carry the trader's wallet, and pump.fun profiles name their canonical Solana and EVM wallets.

#Part 1: follow traders live

The stream's traders channel takes people, not addresses:

{
  "op": "subscribe",
  "channel": "traders",
  "fomo": ["pointfarmcap", "The__Solstice"],
  "pump": ["400bfe0b-a8e9-4d4f-aac0-46408e7b6127", "4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR"]
}

• fomo takes fomo.family handles, up to 100. Their buys, sells and theses arrive as fomo_trade messages, read from fomo's data, so it doesn't matter which wallet executed them.
• pump takes pump.fun user ids or wallets, up to 1,000. For a user id, we follow every wallet we know for that person, so a trader moving to a new wallet doesn't drop off your tracker.
• The subscribed answer lists anything we couldn't find (fomoNotFound, pumpNotFound), so you catch typos right away.

#A tracker that posts to Telegram

import WebSocket from "ws"

const KEY = process.env.PUMPFOMO_KEY!
const TG = `https://api.telegram.org/bot${process.env.TG_BOT_TOKEN}/sendMessage`
const CHAT = process.env.TG_CHAT_ID!

const WATCH = {
  fomo: ["pointfarmcap", "The__Solstice"],
  pump: ["4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR"],
}
const MIN_USD = 250

async function notify(text: string) {
  await fetch(TG, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ chat_id: CHAT, text, disable_web_page_preview: true }),
  })
}

function usd(n: number) {
  return "$" + Math.round(n).toLocaleString("en-US")
}

function connect(attempt = 0) {
  const ws = new WebSocket("wss://api.pumpfomo.com/v1/stream", {
    headers: { Authorization: `Bearer ${KEY}` },
  })
  ws.on("open", () => {
    attempt = 0
    ws.send(JSON.stringify({ op: "subscribe", channel: "traders", ...WATCH, replay: false }))
  })
  ws.on("message", async (raw) => {
    const m = JSON.parse(raw.toString())
    if (m.type === "subscribed" && (m.fomoNotFound || m.pumpNotFound)) {
      await notify(`Not found: ${[...(m.fomoNotFound ?? []), ...(m.pumpNotFound ?? [])].join(", ")}`)
    }
    if (m.type === "fomo_trade" && m.kind !== "thesis" && m.amountUsd >= MIN_USD) {
      await notify(
        `fomo @${m.trader.handle} ${m.kind.toUpperCase()} ${usd(m.amountUsd)} of $${m.token.ticker} ` +
          `(${m.token.chain}, mcap ${usd(m.marketCapUsd)})\n${m.links.trader}`,
      )
    }
    if (m.type === "trade" && m.amountUsd >= MIN_USD) {
      const who = m.trader?.handle ?? m.trader?.displayName ?? m.wallet.slice(0, 6)
      await notify(`pump ${who} ${m.side.toUpperCase()} ${usd(m.amountUsd)} of ${m.mint} on ${m.chain}`)
    }
  })
  ws.on("close", () => setTimeout(() => connect(attempt + 1), Math.min(30_000, 1000 * 2 ** attempt)))
  ws.on("error", () => {})
}

connect()

Run it with your key, a Telegram bot token and a chat id, and every trade of the people you listed lands in the chat within seconds. To change the watchlist while it runs, send the subscribe again with the full list. It replaces the old one.

#Backfilling what they did before

The stream starts at "now". For history, read the trader's swaps and positions over REST:

• /v1/fomo/users/{handle}/positions: every swap, newest first, with amounts, USD value, provider and chains.
• /v1/fomo/users/{handle}/trades: positions, open and closed, with realized and unrealized PnL and the thesis.
• /v1/pump/users/{id}/trades: a pump.fun trader's trades, 100 a page.
• /v1/pump/users/{wallet}/pnl: pump.fun PnL over a day, week, month or all time.

#Part 2: who is behind this wallet?

The other direction starts from an address. It might be a wallet that just bought a coin you hold, or the creator of a new launch, or an address someone pasted in your Discord. GET /v1/wallets/{address} answers with the pump.fun and fomo.family people we know for it:

curl -s https://api.pumpfomo.com/v1/wallets/FgactYhd2nkUxWfBgY435reoWq2HYsw3AqyRnfaRDfbF \
  -H "Authorization: Bearer $PUMPFOMO_KEY"

{
  "data": {
    "address": "FgactYhd2nkUxWfBgY435reoWq2HYsw3AqyRnfaRDfbF",
    "chainKind": "svm",
    "fomo": [
      {
        "platform": "fomo",
        "handle": "pointfarmcap",
        "displayName": "point farm capital",
        "wallets": [
          { "address": "6cerGpSGzCrA1NeHUNtyoNm4rWQx5SnK3DSAXb4e615t", "chainKind": "svm", "role": "main" },
          { "address": "0x2c56846e43eb73d39c5d3791f8ff1e02f10ba596", "chainKind": "evm", "role": "main" },
          { "address": "FgactYhd2nkUxWfBgY435reoWq2HYsw3AqyRnfaRDfbF", "chainKind": "svm", "role": "signer" },
          { "address": "0xa94c44a872931873252899347729ac780cb9ede5", "chainKind": "evm", "role": "signer" }
        ]
      }
    ],
    "pump": []
  },
  "meta": { "fomo": "indexed", "pumpAskedLive": true }
}

Each person comes with every wallet we know for them, and each wallet has a role saying how it is tied to the person:

Each wallet also has source, firstSeen and lastSeen, so you can tell an old link from a fresh one.

#Trading wallets: the wallets fomo trades really run from

Since late October 2026 the index also holds trading wallets. We take a fomo.family trader's recent swaps and find each one on-chain, and the wallet that sent it is filed under them. Unlike the addresses on the profile, that is the wallet you would see in a block explorer. Each one carries matches, the number of the trader's swaps it was found from. One is a fit; two or more is a wallet you can rely on.

In a test on 100 active fomo traders, 96 had swaps, and we found the trading wallet of 86 of them. 70 were confirmed by two or more swaps, and every one of 40 matches we checked on-chain was right. Coverage on EVM chains is lower, mostly on BNB Chain and Robinhood Chain. The index is filling in gradually, traders active in the live feed first, so a trader we haven't reached yet simply has no trading wallet so far.

A reverse lookup on a trading wallet names the fomo trader behind it. That is the question most fomo wallet trackers can't answer.

#Where the answers come from

pump.fun lets you look up a wallet; fomo.family doesn't. So we answer from our own index, which is built from every person and wallet that appears in the data we serve (profiles, leaderboards, holders, trades, followers) and from a crawler that walks fomo.family and pump.fun continuously. When the index has no pump.fun person for a wallet, we also ask pump.fun live, for up to 3 seconds, and index what it says.

That has two consequences you should design for:

• meta.fomo: "not_indexed" means we haven't seen the wallet in fomo.family data yet. It doesn't mean the wallet isn't a fomo user.
• The index only grows. A wallet that misses today can answer next week.

#Enriching a coin's buyers in batch

A common job: someone is buying a coin, and you want to know who. Take the wallets from the coin's trade tape (or from the stream), then look them up 100 at a time:

const BASE = "https://api.pumpfomo.com"
const headers = { Authorization: `Bearer ${process.env.PUMPFOMO_KEY}`, "Content-Type": "application/json" }

const mint = "6GmAFSYs4gk3FDao5FzzySQpPZaWsa4rUJHacpMpUNgx"
const tape = await (await fetch(`${BASE}/v1/pump/coins/${mint}/trades?minUsd=1000`, { headers })).json()
const buyers = [...new Set(tape.data.trades.filter((t) => t.side === "buy").map((t) => t.trader.address))]

const res = await fetch(`${BASE}/v1/wallets/batch`, {
  method: "POST",
  headers,
  body: JSON.stringify({ addresses: buyers.slice(0, 100) }),
})
const { data } = await res.json()
for (const [wallet, who] of Object.entries(data.results ?? {})) {
  const names = [...(who.fomo ?? []), ...(who.pump ?? [])].map((p) => `${p.platform}:${p.handle ?? p.displayName}`)
  console.log(wallet, names.join(", "))
}
console.log("unknown:", data.notFound?.length ?? 0)

Check the batch reference for the exact answer shape. You pay 250 credits for each wallet that comes back with a person and nothing for the rest (50 credits if none do), so a batch of mostly-unknown wallets costs little. Each wallet answered is a wallet reveal, and each plan allows a number of them a month.

#What a tracker costs to run

A tracker that runs all month and names 30 new wallets a day in batches uses about 900 wallet reveals and 225,000 credits, inside the Builder plan's 1,000 reveals and 500,000 credits ($149, with the stream included). See pricing.

#Limits worth knowing

• Up to 100 fomo handles and 1,000 pump.fun traders per stream connection. Need more? Open a second connection (Growth includes 5).
• Wallet reveals are counted a month: Free 10, Starter 300, Builder 1,000, Growth 3,000, Scale 8,000. Lookups that find nobody don't count.
• Private fomo profiles don't expose their trades, so they won't show up in your tracker.
• Reverse lookups cover the wallets in our index plus what pump.fun answers live. They're good for "who is this?", but they aren't proof that a wallet is nobody's.
• A tracker gets you information, not an edge. By the time a trade reaches you it is a few seconds old, and the trader may already be selling. If you want to act on it, read the copy-trading guide first.

#Frequently asked questions

#Can I see a fomo trader's wallet?

Every fomo profile shows a Solana and an EVM address, which GET /v1/fomo/users/{handle} returns. Those are generally not the wallets that sign the trader's swaps. The wallets that do are filed in our index as trading wallets, found by matching the trader's swaps on-chain; they come back from the wallet lookup with how many swaps confirmed them. To follow what a trader does, the handle-based routes and the stream remain the most complete.

#Is there a fomo wallet finder?

To go from a wallet to a person, GET /v1/wallets/{address} returns the fomo.family and pump.fun people we know for that wallet, with all their other known wallets, including the trading wallets their swaps were found from on-chain. To go from a person to their activity, follow their fomo handle.

#Why doesn't a fomo profile address show any trades on Solscan?

fomo's swaps on Solana are signed by fomo's fee payer together with a different wallet of the user's, and on EVM chains they're sent by bundlers for smart-account wallets. The address on the profile is usually not the account you'd see in those transactions.

#Can I track pump.fun wallets the same way?

Yes. pump.fun trades carry the trader's wallet, so you can follow wallets directly with trades and wallets: [...], or follow people with traders and pump.fun user ids.

#How fast are alerts?

The stream pushes trades as soon as pump.fun and fomo.family publish them, typically within seconds of the trade. Your own processing (and Telegram) adds a little on top.

#Is pumpfomo affiliated with fomo.family or pump.fun?

No. pumpfomo is independent. It reads public trading data and never touches anyone's keys or funds.

#Where to go next

• Wallet lookup reference and batch lookup.
• The WebSocket guide for every channel and message.
• The fomo.family API guide for profiles, swaps and leaderboards.
• Get a free key. Lookups work on the Free plan; streams start at Builder.