An open-source fomo.family copy trader you can run today

A ready-made fomo.family copy trading bot. It follows the traders you pick, copies their Solana buys and sells within your limits, and shows everything on a live dashboard. Open source, with a live demo.

fomo.familyNext.jsshadcn/uiJupiterSolana

16 min read

Credits
about 461,000 a month with 20 traders
Runs on
Node.js 22 on any always-on machine
License
MIT, open source
The fomo.family copy trader's dashboard, with each followed trader's picture and 7-day PnL, and their trades as they come in

Watching good traders and buying what they buy works, until you're asleep or away from your screen. This app does the watching for you. You pick fomo.family traders. When one of them buys or sells a Solana token, the app sees it within a second and makes the same trade from your own wallet, with the size and the limits you set.

It's a complete Next.js app, open source under MIT, and it starts in dry run: it shows every trade it would copy and signs nothing until you say so. Open the live demo to see it running on real data, or download the code (it's also on GitHub). This page is its full documentation.

What it does

  • Follows the fomo.family traders you choose. Type a handle, paste a profile link, or pick people from the 24-hour, 7-day, 30-day or all-time leaderboard. One stream follows up to 100 of them.
  • Copies their buys and sells as they happen. It holds one connection to the pumpfomo live stream and never polls.
  • Sizes every trade your way. A fixed amount of SOL per copied buy, a cap per token, a cap per day and a cap on how many tokens you hold.
  • Skips what you don't want:
    • buys smaller than a dollar amount
    • tokens under a market cap
    • tokens the trader made
    • quotes that lose too much to price impact
    • trades that arrive late
    • anything on your never-buy list
  • Sells when they sell. A position closes in full when the trader it was copied from sells that token. You can also sell it yourself from the dashboard.
  • Shows who you copy, with real numbers. Each trader has their picture, name and 7-day PnL. Click one for a card with PnL over four windows, rank, volume, trades, followers and a 7-day chart.
  • Names every token. Each token shows its logo, name and market cap, and every position shows the market cap when you bought and now.
  • Changes settings while it runs. Sizes, limits and filters are edited in the dashboard and saved, with no restart.
  • Stays on your machine. The dashboard answers on 127.0.0.1 only, and the private key is read in live mode alone.

Try the live demo

The demo is the same app in a read-only mode:

  • It follows the top 20 fomo.family traders of the week, on live data.
  • It shows their trades as they happen, and what the app would have done about each one.
  • It stays in dry run, so nothing is ever signed.
  • Nobody can change who it follows, its settings or its positions, and the credit balance is hidden.

Your own copy has none of those locks.

What you need

What Why
Node.js 22 or newer The app uses Node's built-in WebSocket and fetch.
A pumpfomo API key with the stream scope Streams come with the Builder plan and up, at $149 a month or $1,249.90 a year. Free and Starter keys can call the REST API but can't open a stream. See pricing.
A Jupiter API key (optional in dry run) For real quotes and swaps. It's free at portal.jup.ag. Without one, dry run records trades with no amounts.
A Solana wallet (live only) A wallet of its own, holding only what you're ready to lose.

Each running copy of the app holds one stream. To run this app and the pump.fun copy trader at the same time you need two streams, which is the Growth plan.

Quick start

bash
curl -LO https://pumpfomo.com/downloads/fomo-copy-trader.zip
unzip fomo-copy-trader.zip
cd fomo-copy-trader
npm install
cp .env.example .env.local

Open .env.local and set at least your key. To start with people to watch, add handles or the week's top 20:

ini
PUMPFOMO_API_KEY=pf_live_...
FOLLOW=someone,someoneelse
FOLLOW_TOP=20

Then start it:

bash
npm run dev

Open http://127.0.0.1:3000. On first start you should see:

  • DRY RUN and stream live in the header.
  • The people you follow under Who you copy, filling in with pictures and 7-day PnL within a minute.
  • Recent trades by them under Their trades, marked history: they happened before the app was listening and are never copied.

From then on, every new trade by someone you follow appears at the top of Their trades, with what the app decided. For less overhead, run the production build instead: npm run build && npm start, at the same address.

Configuration

Everything is set in .env.local. The file is read when the app starts, so restart after changing it. Sizes, limits and filters can also be changed in the dashboard while it runs (see the Settings panel below).

Keys and mode

Variable Default What it does
PUMPFOMO_API_KEY – Your pumpfomo key. It needs the stream scope.
JUPITER_API_KEY – Jupiter key for quotes and swaps. Optional in dry run, required in live mode.
SOLANA_PRIVATE_KEY – The trading wallet: a base58 secret key, or the JSON byte array from a Solana keyfile. Read only when DRY_RUN=false.
DRY_RUN true true signs and sends nothing. false makes real swaps from the wallet above.

Who to copy (first run)

These only apply the first time the app starts, when it has no follow list yet. After that, use the dashboard.

Variable Default What it does
FOLLOW – fomo.family handles to follow, comma separated (up to 100).
FOLLOW_TOP 0 Also follow the top N of the leaderboard (1 credit). 0 doesn't.
TOP_WINDOW 7d The leaderboard window for FOLLOW_TOP: 24h, 7d, 30d or all.

Sizing and limits

Variable Default What it does
BUY_SIZE_SOL 0.02 SOL spent on each copied buy. Must not be larger than MAX_POSITION_SOL.
MAX_POSITION_SOL 0.06 Most SOL put into one token, across repeated buys.
MAX_DAILY_SOL 0.2 Most SOL spent on buys per UTC day.
MAX_OPEN_POSITIONS 5 Most tokens held at once.

Filters and rules

Variable Default What it does
MIN_TRADER_USD 50 Ignore a trader's buy smaller than this, in USD.
MIN_MARKET_CAP_USD 50000 Ignore tokens under this market cap, in USD. 0 turns it off.
MAX_PRICE_IMPACT_PCT 5 Skip a buy whose quote loses more than this percentage to price impact. Sells are never blocked by it.
MAX_EVENT_AGE_MS 15000 Ignore a trade older than this when it arrives, in milliseconds.
SKIP_DEV_TRADES true Skip buys of a token the trader made.
COPY_SELLS true Sell the whole copied position when the trader it came from sells.
BLOCKED_MINTS – Token mints never to buy, comma separated. SOL, USDC and USDT are never bought anyway.
SLIPPAGE_BPS (Jupiter's) Slippage in basis points. Empty lets Jupiter choose.

Profiles, data and display

Variable Default What it does
PROFILE_REFRESH_MIN 360 How often followed traders' pictures, names and PnL are looked up again, in minutes (2 credits a trader each time). 0 never looks them up.
DATA_DIR data Where the follow list, settings, positions and history are kept.
HIDE_OFFENSIVE false true leaves out tokens and traders whose names carry a slur or a hate term. Always on with DEMO_MODE.
DEMO_MODE false true makes a read-only public demo (see Running it for real). Not in .env.example, since your own copy doesn't need it.

The Settings panel

The sliders icon in the header opens Settings, with three groups:

  • Sizing: SOL per copied buy, most SOL in one token, most SOL spent per day, most tokens held at once.
  • Filters: ignore their buys under a dollar amount, ignore tokens under a market cap, skip buys losing more than a price-impact percentage, ignore trades older than a number of seconds.
  • Rules: sell when they sell, and skip their own tokens.

A change applies at once and is saved in DATA_DIR/settings.json. From then on that file wins over .env.local. To go back to the values in .env.local, delete it and restart.

Using the dashboard

The header shows the mode (DRY RUN or LIVE, with the wallet in live mode), the stream's state, your credits left, the light and dark switch, Settings and Pause. Pause stops copying but keeps the stream open, so you still see trades; the button turns into Resume.

Stats

Four cards: realized PnL (simulated in dry run), SOL spent today against your daily limit, open positions against your limit, and the size of each copied buy.

Who you copy

Two tabs:

  • Following is your list. Type a handle (someone or @someone) or paste a profile link (https://fomo.family/profile/someone) and press Follow. Remove someone with the cross next to their name. A handle that doesn't exist on fomo.family is marked not found.
  • Leaderboard loads fomo.family's top traders for 24 hours, 7 days, 30 days or all time, for 1 credit. Press Follow next to anyone.

Changes take effect at once: the app re-sends its subscription with the new list.

Trader card

Click a trader to open their card: PnL over 24 hours, 7 days, 30 days and all time, their 7-day rank, volume, trade count and followers, a 7-day PnL chart (5 credits, loaded when you open it) and their recent trades.

Their trades

Every trade by the people you follow, newest first. Each row shows the trader, the side, the token with its logo, the size in USD, the market cap, and the outcome:

  • copied or simulated: the app bought or sold (simulated in dry run).
  • skipped, with the reason: for example "market cap is under $50000" or "daily spend limit reached".
  • history: the trade happened before the app was listening.
  • failed: the swap didn't go through, with the reason.

Theses show up too. They're never copied.

Open positions

A card for each token the app holds: what it cost, the market cap at your buy and now, and who it was copied from. Sell all sells it now. Forget drops it from the books without selling, for a position you closed by hand. Both ask before acting.

Swaps by this app

Each buy and sell the app made or simulated, with the amount, price impact and, in live mode, a link to the transaction.

How it works

  1. It checks your key. At start, GET /v1/ping (free) confirms the key works and has the stream scope.
  2. It subscribes. It opens wss://api.pumpfomo.com/v1/stream and subscribes to the traders channel with your handles. The stream answers with recent trades as a replay, shown as history.
  3. A trade arrives. Each new trade by a followed trader comes as a fomo_trade message: buy, sell or thesis, with the token, the USD amount and the market cap.
  4. It decides. The trade goes through these checks, in order, and the outcome is shown next to it:
    1. Is it from someone you follow?
    2. Is it a buy or a sell on Solana? Theses and other chains are shown, not copied.
    3. Is copying running, and is the trade younger than the age limit?
    4. For a buy: the token isn't blocked, the trader didn't make it, their buy and the token's market cap are big enough, and your caps per buy, per token, per day and on open positions have room.
    5. For a sell: you hold a position copied from that trader. If so, all of it goes.
  5. It quotes and swaps. For a buy, it asks Jupiter for a quote and checks the price impact. In dry run it records the simulated fill. In live mode it signs the swap with your wallet and sends it. Swaps run one at a time, so the limits are always checked against current numbers.
  6. It fills in the details. Tokens it hasn't seen are named in batches of up to 50 with GET /v1/fomo/tokens/batch. Followed traders' pictures and PnL come from GET /v1/fomo/users/{handle}/rank when they're added and every 6 hours. The market caps of what you hold are refreshed every 15 minutes.
  7. It shows it live. The page gets every change over server-sent events.

Project layout

Path What's in it
app/page.js The dashboard page, kept live through /api/events.
app/api/ Route handlers: state, events, follows, leaderboard, trader chart, pause, settings, positions.
components/dashboard/ Header, stats, traders, trader card, live trades, positions, swaps, settings, setup.
components/ui/ shadcn/ui components.
instrumentation.js Starts the copier once when the Next.js server starts.
lib/runtime.js The one copier per server: the stream, the store and the copier, wired together.
lib/source.js Everything fomo.family-specific: handles, the subscription, how a trade becomes a signal, the leaderboard, profiles.
lib/engine/ The copier: config, limits, positions, Jupiter and wallet signing.
lib/pumpfomo/ A small pumpfomo client: REST with retries, and a stream that reconnects.
lib/settings.js The settings the dashboard can change.
lib/guard.js The localhost-only checks for the API routes, and the demo's read-only rule.
data/ follows.json, settings.json, coins.json, and positions in state.dry-run.json or state.live.json.

lib/pumpfomo and lib/engine have no dependencies. Copy them into your own project if you only need the stream client or the swap logic.

What it costs to run

An open stream costs 10 credits a minute, whether it follows 1 trader or 100, with no charge per message. Left on day and night, that's 14,400 credits a day, or 432,000 for a 30-day month. Here is a full month with 20 traders followed and the default settings:

What When Credits a month
The live stream always, 10 a minute 432,000
Traders' pictures, names and PnL every 6 hours, 2 a trader about 4,800
Token names, logos and market caps new tokens, up to 50 per lookup, 5 a lookup about 10,000
Market caps of what you hold every 15 minutes while you hold anything, 5 a lookup up to 14,400
Leaderboard, trader chart when you open them, 1 and 5 a few
Key check at start free
Total about 461,000

That fits in Builder's 500,000 credits. How it scales:

  • More traders cost nothing extra on the stream. Profiles cost 2 credits per trader per refresh: 100 traders at the default 6 hours is about 24,000 a month.
  • To spend less, set PROFILE_REFRESH_MIN=0 (no pictures or PnL), raise it to 720 or more, or only run the app while you watch it. A stream that's closed costs nothing.

Running it for real

The copier lives inside the Next.js server, so it needs a machine that stays on: a VPS, a home server or a container. Build once, then start:

bash
npm run build
npm start

Keep it running

With pm2:

bash
npm install -g pm2
pm2 start npm --name fomo-copy-trader -- start
pm2 save

Or with systemd, in /etc/systemd/system/fomo-copy-trader.service:

ini
[Unit]
Description=fomo.family copy trader
After=network-online.target

[Service]
WorkingDirectory=/home/you/fomo-copy-trader
ExecStart=/usr/bin/npm start
Restart=always
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

Then sudo systemctl enable --now fomo-copy-trader.

Watch it from another machine

The dashboard only answers requests addressed to localhost or 127.0.0.1, because it can follow people and sell positions. Don't open the port. Use an SSH tunnel instead:

bash
ssh -L 3000:127.0.0.1:3000 you@your-server

and open http://127.0.0.1:3000 on your own computer.

Serverless hosts

Vercel functions and the like stop between requests, so nothing keeps the stream open and nothing gets copied. They're fine for a read-only showcase, like our demo, and nothing else.

A public read-only demo

DEMO_MODE=true turns a copy into a showcase anyone can open:

  • the dashboard answers any address, not just localhost;
  • following, settings, pause and selling are all refused;
  • the app stays in dry run, whatever DRY_RUN says;
  • the credit balance is hidden;
  • tokens and traders whose names carry a slur or a hate term are left out, as with HIDE_OFFENSIVE=true.

Seed it with FOLLOW_TOP so it has traders to show. On a host whose files don't last, set DATA_DIR=/tmp/data.

Going live safely

  1. Run in dry run first, with a Jupiter key so the simulated fills carry real quotes. Watch what it would have done for a day or two.

  2. Create a wallet just for this, and fund it with a small amount of SOL. Never use a wallet that holds anything else.

  3. Set three values in .env.local:

    ini
    JUPITER_API_KEY=your-jupiter-key
    SOLANA_PRIVATE_KEY=your-base58-secret-key
    DRY_RUN=false
  4. Restart. The header turns to LIVE and shows the wallet address.

What protects you while it runs:

  • The limits per buy, per token, per day and on open positions are checked before every swap.
  • It pauses itself if a swap's outcome is unclear, for example a timeout while it lands. Check the wallet, then press Resume.
  • Dry-run and live positions are kept in separate files, so simulated holdings are never mistaken for real ones.
  • The private key is read only in live mode and never leaves your machine.

The pumpfomo API behind it

Call What for Credits
wss://api.pumpfomo.com/v1/stream, channel traders the followed traders' trades, live 10 a minute
GET /v1/fomo/users/{handle}/rank a trader's picture, name, PnL and rank 2
GET /v1/fomo/users/{handle}/pnl-chart the 7-day chart on a trader's card 5
GET /v1/fomo/leaderboard/{window} the leaderboard tab and FOLLOW_TOP 1
GET /v1/fomo/tokens/batch token names, logos and market caps, 50 at a time 5
GET /v1/ping checking the key at start free

The subscribe message is one line:

json
{ "op": "subscribe", "channel": "traders", "fomo": ["someone", "someoneelse"] }

A trade it receives looks like this, trimmed:

json
{
  "type": "fomo_trade",
  "kind": "buy",
  "amountUsd": 100,
  "marketCapUsd": 25122.7,
  "isDev": false,
  "token": { "address": "3NVM…pump", "chain": "solana", "ticker": "CRIME" },
  "trader": { "handle": "someone", "displayName": "Someone" },
  "ts": 1792966780000
}

The stream reference has every message and close code.

Troubleshooting

The page says PUMPFOMO_API_KEY is not set

Copy .env.example to .env.local, put your key in PUMPFOMO_API_KEY, and restart. The setup card on the page walks through the same steps.

pumpfomo refused the key (401)

The key is wrong, revoked or expired. Check it at your dashboard's keys page, or create a new one, then restart.

This pumpfomo key has no stream scope

The key was created with limited scopes. Edit its scopes to include stream, or create a new key, then restart.

The stream stopped with close code 4003

Your plan has no stream, or all of its streams are already open somewhere else. Streams start at Builder, which allows one at a time. Close the other copy, or move to Growth for five.

The stream stopped with close code 4002

The account is out of credits. Add credits or a pack, then restart. The app doesn't retry this one on its own.

The stream keeps closing with code 4008

The app fell too far behind reading messages, usually because the machine was asleep or overloaded. It reconnects by itself. If it repeats, give the machine more room or follow fewer traders.

Nothing shows up under Their trades

  • Check that someone you follow is actually trading. Many top traders go hours without a trade.
  • A trader marked not found doesn't exist on fomo.family under that handle.
  • Make sure Pause isn't on.

Trades show up but nothing is copied

Look at the reason on each row. Most skips are the filters doing their job: a buy under MIN_TRADER_USD, a token under MIN_MARKET_CAP_USD, the daily limit reached. Loosen them in Settings if you want more copies.

Dry run shows trades without amounts or PnL

That's dry run without a Jupiter key: trades are recorded, but with no quote there's no amount. Add JUPITER_API_KEY for real quotes.

The app paused itself

A swap's outcome was unclear, for example a timeout while it landed. Check the wallet on a Solana explorer. If the position is wrong, sell it or press Forget, then press Resume.

Port 3000 is already in use

Another app holds it. Stop that app, or start this one on another port: npx next start -H 127.0.0.1 -p 3100.

Make it your own

The copy logic lives in lib/engine, the API client in lib/pumpfomo, and everything fomo.family-specific in one file, lib/source.js. Some directions people take it:

  • Alerts instead of trades. Send each copied trade to Telegram or Discord, and decide yourself. The Telegram alert bot is a finished example.
  • Different sizing. Scale your buy to the trader's, or to how they've done this week.
  • A tighter list. Follow only traders whose 7-day PnL stays above a line, re-checked every few hours.

If you build with an AI assistant, the pumpfomo Claude skill and llms.txt give it the whole API. There's a walkthrough of writing a copy bot that way in this guide.

Frequently asked questions

Is the app free?

Yes. The code is MIT licensed. You need a pumpfomo plan with streams (Builder or higher) for the live data, and a free Jupiter key for real quotes.

Can I run it on Vercel or another serverless host?

You can host the read-only demo that way, but not the real copier. Copying needs a process that stays up and keeps the stream open. Run it with npm start on a VPS, a home server or a container.

Does it need my private key?

Only in live mode, and the key stays in .env.local on your machine. The dashboard only answers on 127.0.0.1. In dry run the key isn't read at all.

How fast does it copy a trade?

The trade reaches the app within about a second of happening. The rest is the time Jupiter takes to quote and land the swap.

How many traders can it follow?

Up to 100 fomo.family traders on one stream connection, for the same 10 credits a minute.

Does it copy theses?

No. A thesis shows up in the trades list so you can read it, but there's nothing to buy or sell.

Can I run it next to the pump.fun copy trader?

Yes, but each holds its own stream, so you need two streams at once. That's the Growth plan.

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 apps