The On-Chain Stream Is About 15 Seconds Ahead of the FOMO Feed

Every FOMO trade lands on a blockchain before it lands in the FOMO app. The app's feed, the push notification, the Telegram forward of the push notification: all of it comes after the block. We measured the gap, and it is about 15 seconds. The on-chain stream on fomoapi.io reads trades straight off the chain and hands them to you inside that window.

Where the 15 seconds go

When a trader buys on FOMO, the transaction confirms on Robinhood Chain or Solana in well under a second. FOMO then notices the trade, decides whether it clears the bar for the feed, writes the feed item, and pushes it out to phones. By the time a human sees the alert, the block that carried the trade is roughly 15 seconds old.

That is not a complaint about FOMO. Feeds are curated, and curation takes time. It is just physics: the chain is the source, and everything downstream of it is later.

We ran the on-chain stream next to our own feed view stream, which relays the FOMO feed the moment it is published, and matched the same trades on both. The on-chain copy arrived first almost every time, and the typical lead was a little over 15 seconds. Some trades showed up on-chain more than 20 seconds before the app mentioned them.

What 15 seconds is worth

On a memecoin, 15 seconds is the difference between the entry the trader got and the entry the crowd gets. A large buy by a followed trader moves the price twice: once when it fills, and once more when the notification lands and everyone else piles in. If you are reacting to the notification, you are in the second wave, paying the first wave's markup.

The on-chain stream puts you in the first wave. You see the fill, the wallet, the token contract and the real size while the app is still deciding whether to tell anyone.

It also sees the trades the feed skips

The FOMO feed only shows trades that clear its own thresholds, and it labels them by position size rather than by what was actually bought or sold. On-chain there is no threshold. Every trade is there, including the small entries and the scale-ins that never make the feed, with the exact fill size and the transaction hash.

In practice that means roughly twice as many trades above $1,500 as the feed surfaces, plus the long tail of small trades the feed never shows at all. If you are building a model of what a trader is doing, that tail is where the signal usually is: the first small buy on a new token often comes minutes before the big one that gets an alert.

Two streams, two jobs

We now run both, and they are meant to be used together.

Use the feed view stream (wss://api.fomoapi.io/ws/alerts) when you want to react to what the crowd is seeing, or when you need theses and price alerts, which only exist in the app. Use the on-chain stream when being first is the point.

Connecting

const url = "wss://api.fomoapi.io/ws/trades";
const ws = new WebSocket(url + "?key=YOUR_API_KEY&chain=robinhood&minUsd=500");
ws.onmessage = (e) => {
  const t = JSON.parse(e.data);
  if (t.type !== "trade" || t.replay) return;
  console.log(t.side, t.token.symbol, t.usdValue, t.trader.handle ?? t.trader.wallet);
};

Each message carries the side, the token and its contract, the chain, the USD size, the trader's wallet and username when we know it, the transaction hash and the block. Filter by chain, trader, token, minUsd or side on the URL or with a subscribe message. Nothing is stored server side; the stream exists to be live.

The on-chain stream is included on the Growth and Scale plans. The full reference is in the docs.