How Much Faster Is the On-Chain Stream Than 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 on production, and it is a few seconds — not the fifteen this page used to claim. The on-chain stream on fomoapi.io reads trades straight off the chain and hands them to you inside that window.

What the gap actually is

We measured it two independent ways on 2026-09-29.

The first way pairs individual trades: connect to both streams, match the same execution on chain, token, side and trader, and compare when each stream delivered it. Over 40 matched pairs (all 40 agreeing on the side) the on-chain stream arrived 2.2 seconds earlier at the median.

The second way measures each leg separately, which gives far more samples than pairing can:

That puts the app feed at roughly 4.9 seconds after the block and the on-chain stream at 1.37 seconds, so the lead is about 3.5 seconds at the median.

So: two to four seconds, call it ~3.5s. Both methods agree on the order of magnitude and neither is close to fifteen. The old figure came from an early, small-sample reading that was never re-checked, and it stayed in this post and sixteen other places until a data-quality audit went looking for it.

What a few seconds is worth, honestly

Two to four seconds is still the difference between the fill and the crowd. 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. Reacting to the notification puts you in the second wave, paying the first wave's markup, and a few seconds of head start on a memecoin is not nothing.

But it is seconds, not a quarter of a minute, and you should size your expectations to that. If your strategy needs fifteen seconds of warning to work, it does not work — on this data or anyone else's.

The bigger edge is completeness, not speed

This is the part worth paying for, and it is much larger than the timing difference.

The FOMO app feed only emits its own LARGE_* events. Measured over 500 consecutive alerts: the smallest buy on the entire stream was $2,985, and there were zero below $2,950 — a hard cliff at roughly $3,000 of position value. Checked against FOMO's own per-token feed for one active coin over the same window, 86% of real buys and 88% of real sells were under $3,000 and none of them appeared on the app feed at all.

The floor is FOMO's and it sits upstream of anything we do. On-chain there is no floor. Every execution is there with its real fill size and transaction hash, including the small first entries and the scale-ins the app feed never shows. If you are modelling what a trader is doing rather than chasing their alerts, that tail is where the signal is: the first small buy on a new token often comes well before the large one that trips an alert.

Two streams, two jobs

We 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 you need every fill, the real sizes, and a few seconds of head start.

Both cost zero credits: the connection, every message and every reconnect are free on every plan.

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.

One caveat on the username: we resolve one verified main wallet per chain per trader, so trader.handle is populated only when we have proven that trader's wallet — about a fifth of executions today. trader.wallet is always there.

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