An open-source pump.fun new coin scanner with a live dashboard

A ready-made pump.fun new coin scanner. It sees every coin the second it launches, watches its first trades live, scores its momentum and alerts you to the ones taking off. Open source, with a live demo.

pump.funNext.jsshadcn/uiSolana

18 min read

Credits
at most 496,800 a month with the default settings
Runs on
Node.js 22 on any always-on machine
License
MIT, open source
The pump.fun new coin scanner's dashboard: every new coin with its market cap, buyers, volume and score, and the coins taking off

pump.fun launches dozens of coins a minute, and almost all of them go nowhere. The few that run usually show it in their first minutes: real buyers pile in, volume climbs, the market cap moves. This app watches for exactly that. It sees every coin the second it's created, follows its first trades live, scores its momentum and tells you when one takes off.

It's a complete Next.js app, open source under MIT. It doesn't trade: it finds coins, and what you do with them is up to you. Open the live demo to watch pump.fun's launches as they happen, or download the code (it's also on GitHub). This page is the full documentation: setup, every setting, how the score works, what it costs and how to fix common problems.

What it does

  • Sees every new coin as it's created, about a second after launch, from the pumpfomo live stream.
  • Filters for free, before any credit is spent on a coin:
    • launchpad (pump.fun by default, or any you pick)
    • chain (Solana by default)
    • words a name or symbol must contain, or mustn't
    • creators on your block list
    • Mayhem Mode coins, if you like
  • Watches each coin's first 30 minutes, up to 1,000 coins at once, on the same stream connection. For each coin it keeps:
    • market cap, its high since launch, and how far it has come from launch
    • buys and sells, and how many different wallets bought
    • volume, and how much of it is buying
    • whether the creator (the dev) has sold
    • which traders with a pump.fun profile have traded it
    • how long it took to get its first trade
  • Scores momentum from 0 to 100, in five parts you can see: buyers, volume, buy pressure, growth and profiles. A dev who sold costs 20 points.
  • Flags coins that take off. A coin turns hot when it meets your rules within its first minutes. By default that's 20 buyers, $5,000 of volume and a $10,000 market cap within 15 minutes. Hot coins get their own list and a toast; with alerts on, a chime and a browser notification too.
  • Keeps bots out of the counts. Buys under $5 don't make a buyer, and trades by pump.fun's Mayhem agent move the price but never count as buyers or volume.
  • Shows each coin's logo and market cap, looked up 50 to a batch: by default as soon as a coin gets a real buyer, or every coin if you choose.
  • Opens any coin into a card with the score part by part, a candlestick chart, pump.fun's live numbers (curve progress, holders, top-10 share, dev holdings, snipers, KOLs), its links and its latest trades.
  • Spends credits inside a budget you set. The stream is a flat 10 credits a minute; logos, links and coin cards stay inside an hourly cap.
  • Changes settings while it runs. Filters, hot rules and budgets are edited in the dashboard and saved, with no restart.

Try the live demo

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

  • Every pump.fun launch shows up as it happens, with its logo and live numbers.
  • Coins that take off move to the Taking off list.
  • It runs with the default filters and hot rules. Nobody can change them, pause it or see the credit balance.
  • It looks up every coin's logo (ENRICH=all), which takes more credits than Builder holds. Your own copy starts with ENRICH=active; see What it costs to run.

The demo starts from nothing each time its server wakes up, so its "hot today" count can sit at zero for a while. Your own copy keeps its hot coins and today's counts on disk.

What you need

What Why
Node.js 22 or newer For the built-in WebSocket and fetch.
A pumpfomo API key with the stream scope Create one at pumpfomo.com/dashboard/keys. Streams come with the Builder plan and up ($149 a month, or $1,249.90 a year). Free and Starter keys can't open a stream. See pricing.
A machine that stays on A VPS, a home server or a container. The scanner only sees what launches while it runs.

That's all: no wallet and no other service.

Running two apps. Each running copy of an app holds one stream, and Builder allows one at a time. To run the scanner and, say, the pump.fun copy trader together, you need 2 streams: that's Growth.

Quick start

bash
curl -LO https://pumpfomo.com/downloads/pumpfun-new-coin-scanner.zip
unzip pumpfun-new-coin-scanner.zip
cd pumpfun-new-coin-scanner
npm install
cp .env.example .env.local

Open .env.local and set your key:

ini
PUMPFOMO_API_KEY=pf_live_...

Then start it:

bash
npm run dev

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

  • the header saying live with the coins per minute;
  • new coins sliding into the New coins table within seconds;
  • logos and market caps filling in as coins get their first real buyers.

The first hot coin usually shows up within the hour. To see more, loosen the hot rules in Settings. For everyday use, run the production build instead: npm run build && npm start, on the same address.

Configuration

Your key goes in .env.local. Everything else there is optional and only sets where a dashboard setting starts. When you change a setting in the dashboard, it's saved in DATA_DIR/settings.json and wins over .env.local from then on. Delete that file to go back to .env.local.

Key and storage

Variable Default What it does
PUMPFOMO_API_KEY – Your pumpfomo key. Required, with the stream scope.
DATA_DIR data Where settings, hot coins and coin logos are kept. On a serverless host: /tmp/data.

Which coins

Variable Default What it does
LAUNCHPADS pump Launchpads to look at, comma separated (pump, bags, dbc, raydium_launchpad…). Empty: every launchpad.
CHAINS solana Chains to look at, comma separated. Empty: every chain.
INCLUDE_WORDS – Only names or symbols containing one of these words.
EXCLUDE_WORDS – Skip names or symbols containing any of these.
BLOCKED_CREATORS – Skip coins made by these creator wallets.
SKIP_MAYHEM false Skip coins that pump.fun's Mayhem agent trades. Its own trades never count toward buyers or volume either way.

When a coin is hot

Variable Default What it does
MIN_BUY_USD 5 A wallet counts as a buyer only from a buy of at least this many dollars. Keeps dust-buying bots out.
HOT_WITHIN_MIN 15 A coin must meet every hot rule within this many minutes of launch.
HOT_MIN_BUYERS 20 Hot rule: at least this many buyers.
HOT_MIN_VOLUME_USD 5000 Hot rule: at least this much volume.
HOT_MIN_MCAP_USD 10000 Hot rule: at least this market cap.
HOT_DEV_HOLDING false Hot rule: the creator hasn't sold. Off by default, since most pump.fun devs sell early, runners included.

Watching

Variable Default What it does
WATCH_MIN 30 How long each new coin's trades are followed, in minutes. The stream follows up to 1,000 coins at once.
KEEP_HOT_MIN 120 How long hot coins stay on the list and keep being followed.

Credits

Variable Default What it does
ENRICH active Which coins get a logo, market cap and links: active (a coin's first real buyer), all (every coin that passes the filters) or hot (hot coins only).
CREDITS_PER_HOUR empty The most credits an hour for logos, links and coin cards. Empty means 90, or 2,000 with ENRICH=all. The stream itself is a flat 10 credits a minute.

Public copies

Variable Default What it does
HIDE_OFFENSIVE false true leaves coins named with slurs or hate terms off the dashboard. Always on with DEMO_MODE.
DEMO_MODE false true makes a read-only showcase that answers any host and refuses every change.

The Settings panel

Open Settings (the sliders icon in the header). It has the same groups as above: Which coins, Hot rules, Watching and Credits. Each field shows its range and a short explanation. Press save and the change applies at once: new filters decide which coins get watched from then on, and new hot rules are checked against every watched coin.

Using the dashboard

The stream's state (live, connecting, stopped) and the coins per minute, the credits left on your account, the alerts bell, the theme switch, Settings and Pause. A paused scanner closes the stream and spends nothing; Resume opens it again.

Stats

Four cards: new coins today, how many passed your filters, how many are watched now (out of 1,000), and how many turned hot today with how many are still on the list.

New coins

Every watched coin, live:

  • Coin: logo, name, symbol and a copy button for the mint, with tags such as HOT, DEV SOLD or MAYHEM.
  • Age since launch.
  • Market cap, and below it the growth since launch (2.0× means it has doubled).
  • Buyers: different wallets with a real buy.
  • Buys / sells, with a thin bar for the split.
  • Volume in dollars.
  • Profiles: the pictures of pump.fun traders in the coin.
  • Score, from 0 to 100.

Sort by newest, score, market cap, buyers or volume, or search by name, symbol or mint. Hide quiet is on by default: it hides coins over a minute old with fewer than 3 trades, which is most of them. The table shows the top 100 rows for the sort you picked. Numbers update every second, and flash green or red when they move.

Taking off

The hot coins, newest first. Each one shows when it turned hot and how soon after launch, a market-cap sparkline, its market cap, growth, buyers and volume, and the profiles in it.

Coin card

Click any coin. The card shows:

  • the score, part by part, and whether the dev has sold;
  • a candlestick chart of its market cap, with 15-second bars for a coin under 15 minutes old, 1-minute bars up to 3 hours and 5-minute bars after that;
  • pump.fun's live numbers: bonding-curve progress, holders, top-10 share, dev holdings, snipers and KOLs;
  • links to pump.fun, DEX Screener and Solscan, and a copy button for the mint;
  • the profiles in it and the latest trades.

Opening a card costs 3 credits (1 for the live numbers, 2 for the chart). It's kept for a minute, so opening it again costs nothing.

Alerts

Press the bell in the header. The browser asks once whether the page may show notifications. From then on, every coin that turns hot plays a short chime, and shows a notification when the tab isn't in front. The choice is remembered in your browser. Without alerts on, a hot coin still shows a toast.

Filters and rules, and How the score works

Two cards under the table. The first sums up what the scanner looks at, this hour's detail budget and today's launches by launchpad. The second lists the score's parts and their points.

How it works

  1. New coins. The app opens one connection to the pumpfomo stream and subscribes to the coins channel. Each new coin arrives with its mint, name, symbol, creator, launchpad, chain and launch market cap in SOL.
  2. Filters. Coins from other launchpads or chains, with the wrong words, from blocked creators or (if you chose) with Mayhem Mode are dropped there and then, at no cost.
  3. Watch list. Every coin that passes joins the watch list for WATCH_MIN minutes, and hot coins for KEEP_HOT_MIN. The list holds up to 1,000 coins.
  4. Trades. On the same connection, the app subscribes to the trades channel with the watch list's mints. A new trades subscribe replaces the last one, so the app sends the whole list again whenever it changes, at most every 2 seconds.
  5. Numbers. Each trade updates its coin: market cap and high, buyers, buys and sells, volume, whether the creator sold, and the profiles in it.
  6. Score and hot rules. After each trade the coin is scored, and checked against the hot rules if it's still within HOT_WITHIN_MIN of launch.
  7. Details. Logos, market caps and links come from coin lookups, inside the hourly budget, for the coins ENRICH picks. Hot coins go first.
  8. Dashboard. The page gets a fresh snapshot once a second over server-sent events, so it stays smooth however busy pump.fun gets.

The scanner runs inside the Next.js server: instrumentation.js starts it once when the server boots.

The score

Each part comes from the coin's own trades on the stream:

Part Points Full marks at
Buyers 30 40 different wallets with a real buy (buys under MIN_BUY_USD don't count)
Volume 25 $25,000, on a log scale from $100
Buy pressure 15 90% of the volume is buying (nothing at half or less)
Growth 20 8× the launch market cap
Profiles 10 5 traders with a pump.fun profile
Dev sold −20 the creator has sold since launch

Buy pressure and profiles count in full only from $1,000 of volume, and growth from $2,000, so a jump on a few dollars of trading doesn't score. The score never goes below 0.

The hot rules

The score ranks coins; the hot rules decide what gets flagged. They're separate on purpose: sort by score to browse, and keep the rules strict so alerts stay rare. A coin turns hot when, within HOT_WITHIN_MIN minutes of launch, it has at least HOT_MIN_BUYERS buyers, HOT_MIN_VOLUME_USD of volume and a HOT_MIN_MCAP_USD market cap, all at once. With HOT_DEV_HOLDING=true, a coin whose creator has sold before it qualifies never turns hot. Hot coins are kept on disk, so they survive a restart.

Project layout

Path What's in it
app/page.js The dashboard, live through /api/events.
app/api/ Routes for state, events (server-sent events), settings, pause, and a coin's details, live numbers and candles.
components/dashboard/ Header, stats, coins table, hot list, coin card, chart, rules, settings and setup.
components/ui/ shadcn/ui components.
instrumentation.js Starts the scanner when the Next.js server starts.
lib/runtime.js The one scanner per server: the stream, the scanner and the details.
lib/scanner/scanner.js Filters, the watch list, each coin's numbers, the score and the hot rules.
lib/scanner/details.js Logos, market caps, links and coin cards, inside the hourly budget.
lib/scanner/store.js Settings, hot coins and coin logos on disk.
lib/settings.js The settings the dashboard can change.
lib/clean.js The offensive-name filter.
lib/pumpfomo/ A small pumpfomo client: REST and the live stream.

lib/pumpfomo and lib/scanner have no dependencies. Copy them into your own project if you want the scanner without the dashboard.

What it costs to run

An open stream costs 10 credits a minute, whatever it carries: every new coin, and the trades of up to 1,000 of them, on one connection. There's no charge per message. Left on day and night, that's 14,400 credits a day, or 432,000 a month.

Everything else comes out of the hourly budget, CREDITS_PER_HOUR:

  • Logos, market caps and links may spend four fifths of it, spread evenly over the hour. A lookup is 1 credit for one coin, or 5 for a batch of up to 50. No coin is looked up twice.
  • The rest is kept for the coin cards you open, at 3 credits each.

Which coins get a logo is up to ENRICH. Measured on pump.fun on 12 November 2026, about 1,325 coins an hour passed the default filters (22 a minute), 58% of them got a real buyer, and a few an hour turned hot:

ENRICH Coins looked up Default budget Credits a month, stream included Plan
active (default) about 770 an hour, 50 to a batch 90 an hour at most 496,800 Builder
hot a few an hour 90 an hour about 437,000 Builder
all about 1,325 an hour, as they launch 2,000 an hour about 1,390,000 Growth

The default line works out like this:

What When Credits a month
The live stream always, 10 a minute 432,000
Logos, links and coin cards at most 90 an hour at most 64,800
SOL price and key check every 5 minutes, and at start free
Total at most 496,800, inside Builder's 500,000

With active and the default budget, logos arrive in batches when pump.fun is busy: up to 50 coins about every 4 minutes, the busiest first. When it's quiet they arrive within seconds. all gives every row a logo within seconds, but that's about one credit a coin, roughly 950,000 a month on top of the stream: run it on Growth, or set a smaller CREDITS_PER_HOUR and accept that logos lag behind.

To spend less, use ENRICH=hot, lower CREDITS_PER_HOUR, or press Pause.

Running it for real

The scanner lives inside the Next.js server, so it needs a machine that stays up. Build once, then start it:

bash
npm run build
npm start

To keep it running after you log out and bring it back after a reboot, use a process manager. With pm2:

bash
npm install -g pm2
pm2 start npm --name pumpfun-new-coin-scanner -- start
pm2 save
pm2 startup

Or with systemd, in /etc/systemd/system/pumpfun-new-coin-scanner.service:

ini
[Unit]
Description=pump.fun new coin scanner
After=network-online.target

[Service]
WorkingDirectory=/home/you/pumpfun-new-coin-scanner
ExecStart=/usr/bin/npm start
Restart=always
User=you

[Install]
WantedBy=multi-user.target

Then sudo systemctl enable --now pumpfun-new-coin-scanner.

Reaching the dashboard. It only answers to localhost and 127.0.0.1, on port 3004. To watch it from another machine, use an SSH tunnel instead of opening the port, then open http://127.0.0.1:3004 locally:

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

Serverless hosts. Vercel functions and the like only suit a demo. The scanner sleeps when nobody has the page open, and misses whatever launches meanwhile.

A public, read-only copy. Set DEMO_MODE=true. The dashboard then answers any host, refuses settings and pause, hides the credit balance and leaves out coins named with slurs or hate terms. On a host whose files don't last, also set DATA_DIR=/tmp/data. To filter names in your own private copy, set HIDE_OFFENSIVE=true.

The pumpfomo API behind it

Call What for Credits
wss://api.pumpfomo.com/v1/stream, channels coins and trades every new coin, and the watched coins' trades, live 10 a minute
GET /v1/pump/coins/{mint} a coin's logo, market cap and links, when fewer than 5 are waiting 1
POST /v1/pump/coins/batch logos, market caps and links of up to 50 coins 5
GET /v1/pump/coins/{mint}/live the coin card: curve, holders, snipers, KOLs 1
GET /v1/pump/coins/{mint}/candles the coin card's chart 2
GET /v1/pump/sol-price launch market caps in USD, every 5 minutes free
GET /v1/ping checking the key and its scopes at start free

The two subscriptions:

json
{ "op": "subscribe", "channel": "coins" }
{ "op": "subscribe", "channel": "trades", "mints": ["<mint>", "<mint>"], "replay": false }

A new coin arrives like this (trimmed). market_cap is in SOL:

json
{
  "type": "coin",
  "mint": "<mint>",
  "name": "attention",
  "symbol": "att",
  "creator": "<creator wallet>",
  "launchpad": "pump",
  "chain": "solana",
  "market_cap": "27.96",
  "ts": 1794475183000
}

And a trade in a watched coin:

json
{
  "type": "trade",
  "mint": "<mint>",
  "side": "buy",
  "wallet": "<wallet>",
  "amountUsd": 15.86,
  "marketCapUsd": 2880.32,
  "trader": { "handle": "someone", "avatar": "https://…" },
  "ts": 1794474941000
}

The stream reference has every message and close code, and the pump.fun WebSocket guide walks through the channels.

Troubleshooting

"PUMPFOMO_API_KEY is not set"

Copy .env.example to .env.local, put your key in PUMPFOMO_API_KEY, and restart the app.

"pumpfomo refused the key" (401)

The key is wrong, was revoked or has expired. Copy it again from your keys, with no spaces around it, and restart.

"This pumpfomo key has no stream scope"

The key was made with limited scopes. Edit its scopes in the dashboard, or create a new key with stream.

The stream stopped with code 4003

Your plan has no stream, or all of its streams are already open elsewhere. Streams start at Builder, and Builder allows one at a time: stop the other app, or move to Growth for five.

The stream stopped with code 4002

The account is out of credits. Add credits or a pack in the dashboard, then restart. Press Pause whenever you don't need the scanner: a paused scanner spends nothing.

The stream keeps reconnecting with code 4008

The app fell behind reading the stream, which happens on a very slow or overloaded machine or connection. The app reconnects by itself. If it keeps happening, run it somewhere with a steadier connection, or watch fewer coins with a shorter WATCH_MIN or tighter filters.

No coin turns hot

That's normal for a while: most new coins never get 20 real buyers. Loosen the hot rules in Settings, or sort the table by score to see what's closest.

Rows have letters instead of logos

With ENRICH=active, a coin gets its logo after its first real buyer, and on a busy day logos arrive in batches every few minutes. If the coin card says the budget is used up, this hour's CREDITS_PER_HOUR is spent: wait a few minutes or raise it.

Numbers look low for a coin that was there at start

The scanner counts from when it saw a coin. Coins launched before it started miss their first trades.

Port 3004 is already in use

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

Make it your own

The scanning logic is in lib/scanner, the API client in lib/pumpfomo, and both have no dependencies. Some directions:

  • Trade the hot ones. Hand each hot coin to a swap, the way the pump.fun copy trader quotes and signs with Jupiter.
  • Alerts where you are. Post each hot coin to Telegram or Discord from the onHot callback in lib/runtime.js, or use the Telegram alert bot.
  • Your own score. Change the parts in Scanner.score(): weight profiles more, or add the dev's past launches from GET /v1/pump/users/{wallet}/created-coins.

The pump.fun API guide covers the REST side, and the Claude skill helps if you build with AI.

Frequently asked questions

Is the app free?

The code is free and MIT licensed. The live data needs a pumpfomo plan with streams, Builder or higher.

How fast does it see a new coin?

About a second after the coin is created. Its trades arrive as they happen, on the same connection.

Does it buy coins for me?

No. It finds coins and alerts you. The copy trader apps show how to add swaps through Jupiter if you want to trade from it.

Can I run it on Vercel?

The read-only demo runs there. A real scanner needs a server that stays up, so run it with next start on a VPS, a home server or a container: on a serverless host it sleeps when nobody has the page open.

Why does a coin with lots of trades have few buyers?

Buys under $5 don't count as a buyer, and the trades of pump.fun's Mayhem agent never count at all. Both keep bots from inflating the numbers. You can change the $5 in Settings.

Which ENRICH mode should I use?

active, the default, if you're on Builder: coins get logos once they have a real buyer, and the month stays under 500,000 credits. hot is the cheapest. all gives every row a logo within seconds but needs Growth.

Does it see coins from other launchpads?

Yes, if you want them. The stream carries coins from several launchpads; the default filter keeps pump.fun's only. Pick others in Settings or with LAUNCHPADS, or leave it empty for all of them.

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