An open-source tool to airdrop a Solana token to fomo.family traders
Airdrop any Solana token to fomo.family traders. Pick them by leaderboard, clan, followers or token holders, find each trader's wallet with the pumpfomo API, and send in batches with a dry run first. Open source, with a demo.
17 min read

Airdrops work best when they reach people who'll notice them. On fomo.family, those people have names and track records: the week's best traders, a clan, a trader's followers, everyone holding a token. This app turns any of those groups into an airdrop. It finds the Solana address on each trader's profile, splits your amount, checks the whole thing on-chain and sends it in batches.
It's a complete Next.js app, open source under MIT, and it starts in dry run: every transaction is built and checked, and nothing is signed until you say so. Open the live demo to see a sample airdrop to the week's top 50, or download the code (it's also on GitHub). This page is the full documentation: setup, every setting, the five steps, what it costs in credits and SOL, and how to fix common problems.
What it does
- Builds the audience from fomo.family. Mix any of these sources; a trader found twice counts once and keeps both sources:
- the PnL leaderboard, over 24 hours, 7 days, 30 days or all time (up to 150)
- a clan's members
- a trader's followers, or who they follow
- the fomo.family holders of any token
- the traders who wrote a thesis on a token
- a list of handles you paste
- Filters it. A minimum PnL, a cap on recipients, a never-include list, and an option to skip private or restricted profiles. Leave anyone out by hand with one click.
- Finds each trader's wallet: the Solana address on their fomo.family profile. Most sources include it at no extra cost; the rest are looked up once and saved.
- Splits the amount your way:
- the same amount each
- a total shared equally
- a total weighted by PnL or by what they hold, with an optional minimum for everyone
- your own amounts from a CSV
- Checks it on-chain before anything is signed. It reads the mint (Token or Token-2022), warns about transfer fees, permanent delegates and freeze authorities, finds who already has a token account, and adds up the rent and fees in SOL.
- Sends in batches. About 9 recipients fit in one transaction when their token accounts need creating, and about 19 when they exist. Each batch pays a priority fee, is confirmed, and is resent until it lands or expires.
- Pauses, resumes, and never pays anyone twice. Each batch's signature is saved before it's sent. After a pause or a crash, unfinished batches are looked up before anything else goes out.
- Imports and exports CSV, so the list can come from your own tools and the results can go back into them.
- Runs locally. The dashboard only answers on
127.0.0.1, and the private key never leaves your machine.
Try the live demo
The demo is the same app in a read-only mode:
- It shows a sample airdrop of USDC to the week's top 50 traders, weighted by PnL and caught part way through: 34 sent, 2 failed, 14 waiting.
- The traders, pictures and PnL are live, from one leaderboard call refreshed every 6 hours. The airdrop itself is a sample: nothing was sent.
- Every step, the recipients table and the progress are there, so you can see how a run looks.
What the demo hides, and why: finding wallets is what your own API key is for, so the public demo never does it. It makes no wallet lookups at all, and no address, signature or mint ever reaches the browser. The wallet column shows a lock. Creating a campaign, looking up wallets, importing, exporting CSV and sending are refused by the server, not only hidden in the page.
Your own copy, with your own API key, finds the wallets and sends.
What you need
| What | Why |
|---|---|
| Node.js 22 or newer | For the built-in fetch. |
A pumpfomo API key with the read:fomo scope |
Create one at pumpfomo.com/dashboard/keys. The app needs no stream, so any plan works, the Free plan included. See pricing. |
| A Solana RPC URL (recommended) | The public one works for small airdrops but limits how fast you may ask. Use your own (Helius, Triton, QuickNode…) for hundreds of recipients. |
| A Solana wallet (live sends only) | A wallet of its own, holding the token and some SOL for rent and fees. |
Which plan fits:
| Plan | Credits a month | Good for |
|---|---|---|
| Free | 2,500 | Airdrops from the leaderboard, clans, followers and holders, and about 1,200 pasted handles a month. |
| Starter | 100,000 | Long pasted lists, thesis writers across many tokens, frequent campaigns. |
| Builder and up | 500,000+ | Only if you also run apps that need a live stream. |
Quick start
curl -LO https://pumpfomo.com/downloads/fomo-airdrop.zip
unzip fomo-airdrop.zip
cd fomo-airdrop
npm install
cp .env.example .env.localOpen .env.local and set your key:
PUMPFOMO_API_KEY=pf_live_...Then start it:
npm run devOpen http://127.0.0.1:3006. You should see the header saying DRY RUN, an empty campaigns list, and a New airdrop button. Press it to start your first campaign. For everyday use, run the production build instead: npm run build && npm start, on the same address.
Configuration
Everything is set in .env.local. Restart the app after a change.
| Variable | Default | What it does |
|---|---|---|
PUMPFOMO_API_KEY |
– | Your pumpfomo key. Required, with the read:fomo scope. |
DRY_RUN |
true |
true builds and checks every transaction and signs nothing. false signs and sends. |
SOLANA_PRIVATE_KEY |
– | The sending wallet, as base58 or the JSON byte array from solana-keygen. Read in live mode only. Use a wallet of its own. |
SENDER_ADDRESS |
– | The sending wallet's public address. In dry run it's used for balance checks and to simulate each batch against the chain. Live mode takes the address from SOLANA_PRIVATE_KEY. |
SOLANA_RPC_URL |
https://api.mainnet-beta.solana.com |
Your Solana RPC. The public one is fine for small airdrops. |
PRIORITY_FEE_MICROLAMPORTS |
20000 |
Priority fee per compute unit. 20,000 is about 0.000006 SOL a transaction. |
WALLET_CACHE_DAYS |
30 |
How long a looked-up wallet is reused before it's looked up again. |
DATA_DIR |
data |
Where campaigns and found wallets are kept, as JSON files. |
DEMO_MODE |
false |
true makes the read-only showcase: any host, sample data, nothing can change, and no wallet is ever looked up or shown. |
Campaign choices (sources, filters, token, amounts) are made in the app and saved with each campaign in DATA_DIR.
Using the app
The page has your campaigns on the left, each with its status and progress, and the open campaign's five steps on the right. Each step shows a check once it's done; you can go back to an earlier step until sending starts.
1. Audience
Add one or more sources:
| Source | What you choose | What you get |
|---|---|---|
| Leaderboard | a window (24h, 7d, 30d or all time) and how many, up to 150 | the top traders by PnL, wallets included |
| Clan | a clan, picked from the clan leaderboard or by search, and a window | all its members, with their PnL for that window, wallets included |
| Followers | a trader's handle | their followers (up to 200), wallets included |
| Following | a trader's handle and how many pages | who they follow, 30 a page, up to 10 pages, wallets included |
| Token holders | a token (by search or address) and its chain | the fomo.family traders holding it (about 100), with the value they hold, wallets included |
| Thesis writers | a token, its chain, an optional minimum position size and how many pages | the traders who wrote a thesis on it, 100 a page |
| Handles | a pasted list, up to 5,000 | those traders |
Each source shows what it costs before it runs. Then set the filters: a minimum PnL, the most recipients, a never-include list, and whether to skip private or restricted profiles. Press Build the audience. A token from another chain works as a source, such as its holders on Base; the airdrop still goes to the traders' Solana addresses.
2. Recipients
Every trader appears with their picture, name, PnL, where they came from and their wallet. Find their wallets looks up the ones the sources didn't include (thesis writers and pasted handles), at 2 credits each, once. A handle that doesn't exist on fomo.family is marked not found and skipped. Leave anyone out with one click.
You can also import a CSV here. Each line is a handle, then optionally a wallet and an amount, separated by commas; a header line is skipped, and up to 5,000 lines are read. An import replaces the recipient list. A handle without a wallet in the file uses a saved one if there is one, or waits for Find their wallets. When every line has an amount, the campaign uses those amounts.
handle,wallet,amount
someone,,250
someoneelse,<solana address>,1003. Token and amounts
Paste the token's mint address. The app reads it from the chain: its program (Token or Token-2022), decimals and supply, plus its name and logo. It warns about anything that would get in the way: a transfer fee (each recipient gets that much less), a permanent delegate (who can move anyone's balance) or a freeze authority (who can freeze recipients' accounts).
Choose how to split:
- Same amount each: every recipient gets the amount you enter.
- Split a total: the total is shared equally.
- Weighted by PnL or weighted by holding: the total is shared in proportion to each trader's PnL or the value they hold, with an optional minimum for everyone.
- From the CSV: the amounts you imported.
Press Apply. You see the smallest, the largest and the top amounts at once. Amounts are worked out with whole numbers in the token's smallest unit, so a total is shared exactly, to the last unit.
4. Review
Check on-chain finds which recipients already have a token account, packs the transfers into transactions and adds up the SOL: rent for new token accounts, network fees and priority fees. With SENDER_ADDRESS (or the live key) set, it also compares that with the sending wallet's token and SOL balances, and stops you before sending anything if the token would run short.
5. Send
In dry run, this builds every batch, and simulates each one against the chain if SENDER_ADDRESS is set. Recipients are marked simulated, and a failed simulation tells you why.
Live, it sends batch by batch. You see:
- a progress bar with sent, failed and waiting counts;
- each recipient's status (pending, sending, sent or failed), with a transaction link once sent, or the reason it failed;
- an activity log.
Press Pause at any time and Resume to carry on where it stopped. Retry failed puts the failed recipients back in the queue. To take the results into your own tools, go back to Recipients and press Export CSV: one line per recipient with handle, display_name, wallet, amount, status, signature, error, sources and pnl.
How it works
- Audience. Each source is one or a few pumpfomo REST calls. The results are merged by handle, and only a short list of fields is kept: handle, name, picture, followers, PnL, rank, holding value, sources and wallet.
- Wallets. The airdrop goes to the
addresson each trader's fomo.family profile. Tokens sent there land in the trader's fomo.family account, and a token with a market shows up in their portfolio as received. The leaderboard, clan, followers, following and holders sources carry this address with each trader. Thesis writers and pasted handles needGET /v1/fomo/users/{handle}once each; the answer is saved inDATA_DIR/wallets.jsonforWALLET_CACHE_DAYS. - Amounts. The split runs in the token's smallest unit with exact integer maths, so the total never drifts by a rounding error.
- On-chain check. The app reads the mint and every recipient's token account through your RPC, then packs transfers into transactions that fit Solana's size and compute limits: a create-account-if-missing plus a transfer per recipient, with a compute budget and your priority fee.
- Sending. Before a batch goes out, its signature and expiry are saved with the campaign. The batch is sent, confirmed, and resent until it lands or its blockhash expires. If the app can't tell whether a batch landed, for example because the RPC stopped answering, it pauses itself. On resume it looks that batch up first: recipients it reached are marked sent, the rest go back in the queue. Nobody is paid twice.
A note on fomo.family wallets: many profile addresses are smart wallets rather than ordinary keypairs. They receive tokens just the same, and the app creates their token account the standard way. Don't use an address you saw in a fomo trade on an explorer: the wallet that signs a fomo trader's swaps isn't the one on their profile. The fomo wallet tracker guide explains the difference.
Project layout
| Path | What's in it |
|---|---|
app/page.js |
The dashboard: campaigns on the left, five steps on the right. |
app/api/ |
Routes for state, campaigns (create, read, change, delete; audience, wallets, token, plan, send, pause, retry, CSV) and the clan and token pickers. |
components/airdrop/ |
Header, campaigns list, the five steps and the recipients table. |
components/ui/ |
shadcn/ui components. |
lib/audience.js |
Sources to traders, merging and filters. |
lib/campaigns.js |
Each step, and what the page may see of a campaign. |
lib/amounts.js |
Exact splits in the token's smallest unit. |
lib/sample.js |
The demo's sample campaign. |
lib/runtime.js, lib/store.js |
The server side, and campaigns as JSON files in DATA_DIR. |
lib/solana/token.js |
Mints, token accounts and balances. |
lib/solana/batch.js |
Transfers packed into transactions that fit. |
lib/solana/run.js |
Sending, confirming and resuming. |
lib/pumpfomo/ |
A small pumpfomo REST client. |
scripts/check-demo.mjs |
Checks that no wallet leaves a demo. |
scripts/localnet-test.mjs |
The sending code end to end on a local validator. |
What it costs to run
In pumpfomo credits
The app needs no live stream, only a few REST calls per campaign, so it runs on any plan.
| What | When | Credits |
|---|---|---|
| Leaderboard source (up to 150, wallets included) | each time you build the audience | 1 |
| Clan source (all members, wallets included) | each time | 2 |
| Followers source (up to 200, wallets included) | each time | 2 |
| Following source (30 a page, wallets included) | each time | 2 a page |
| Token holders source (about 100, wallets included) | each time | 2 |
| Thesis writers source (100 a page) | each time | 2 a page |
| A wallet the source didn't give | once per trader, then saved for 30 days | 2 each |
| The token's name and logo | once per campaign | 2 |
| The clan and token pickers | when you search | 1–2 |
| Checking your key | at start | free |
Some examples:
- The top 150 of the week: 1 credit for the list and the wallets, plus 2 for the token's name. 3 credits.
- About 500 traders from the top 150, two clans and two traders' followers: about 11 credits.
- 500 pasted handles: 500 lookups at 2 credits, so about 1,002 credits the first time, and about 2 if you run it again within 30 days.
There's no monthly running cost: the app spends nothing while it sits idle.
In SOL
- Rent: a new token account holds about 0.00204 SOL (a little more for Token-2022). The airdrop pays it for every recipient who doesn't have an account for the token yet. The rent stays with the recipient, who can reclaim it by closing the account.
- Fees: 5,000 lamports per transaction plus the priority fee, about 0.000006 SOL a transaction at the default.
- An example: 500 traders with no token account yet is about 56 transactions: about 1.02 SOL of rent and under 0.001 SOL of fees.
The Review step works out the real figure for your list before you send.
Running it for real
Sending runs inside the Next.js server, so the app must stay up while a campaign sends. Your own computer is fine for small airdrops. For big ones, use a machine that stays on:
npm run build
npm startTo keep it running in the background, use a process manager, for example pm2:
npm install -g pm2
pm2 start npm --name fomo-airdrop -- start
pm2 saveIf the app stops mid-send, start it again and press Resume: it looks up the batch it was on before sending anything else.
Reaching the dashboard. It only answers to localhost and 127.0.0.1, on port 3006. To use it from another machine, open an SSH tunnel instead of opening the port, then open http://127.0.0.1:3006 locally:
ssh -L 3006:127.0.0.1:3006 you@your-serverServerless hosts. A host like Vercel suits the read-only demo only: a long send needs a process that stays up, and the campaign files need a disk that lasts.
A public, read-only copy. Set DEMO_MODE=true (and DATA_DIR=/tmp/data on a host whose files don't last). Then check it hides every wallet:
DEMO_MODE=true npm run build && DEMO_MODE=true npm start
npm run check:democheck:demo searches the page and every API answer for Solana and EVM addresses, checks that every action is refused, and fails if anything slips through. Point it at a deployed demo with BASE_URL=https://your-demo npm run check:demo.
Going live safely
- Run the whole flow in dry run. Set
SENDER_ADDRESSto your sending wallet's public address, so the Review step checks its balances and the Send step simulates each batch against the chain. - Use a wallet of its own for airdrops, holding the token and a little more SOL than the Review step asks for.
- Set your own RPC. Put a
SOLANA_RPC_URLof your own in.env.local. The public RPC is slow for big lists and may answer429. - Switch to live. Set
SOLANA_PRIVATE_KEYandDRY_RUN=false, then restart. The header turns to LIVE. - Try a small campaign first, five traders say, and check them on Solscan before the big one.
To test the sending code without touching mainnet, run it against a local validator from the Solana CLI. It makes throwaway wallets and test tokens (Token and Token-2022), airdrops to 30 recipients, and checks every balance, the batching, a dry run, a resume after a crash, that a second run sends nothing twice, and that it stops when the token runs short:
solana-test-validator --reset --quiet &
npm run test:localnetOn macOS, if the validator stops with blockstore error, start it with COPYFILE_DISABLE=1 solana-test-validator --reset --quiet.
The pumpfomo API behind it
| Call | What for | Credits |
|---|---|---|
GET /v1/fomo/leaderboard/{window} |
the top traders, wallets included (up to 150) | 1 |
GET /v1/fomo/clans/{id} |
a clan's members, wallets included | 2 |
GET /v1/fomo/users/{handle}/followers |
a trader's followers, wallets included (up to 200) | 2 |
GET /v1/fomo/users/{handle}/following |
who a trader follows, wallets included | 2 a page |
GET /v1/fomo/tokens/{chain}/{address}/holders |
the fomo.family holders of a token, wallets included | 2 |
GET /v1/fomo/tokens/{chain}/{address}/theses |
traders with a thesis on a token | 2 a page |
GET /v1/fomo/users/{handle} |
a wallet the source didn't give | 2 |
GET /v1/fomo/search/tokens |
the token's name and logo, and the token picker | 2 |
GET /v1/fomo/leaderboard/clans/{window}, GET /v1/fomo/clans/search |
the clan picker | 1–2 |
GET /v1/ping |
checking the key at start | free |
The fomo.family API guide covers these endpoints in more depth.
Troubleshooting
"PUMPFOMO_API_KEY is not set"
Copy .env.example to .env.local, put your key in PUMPFOMO_API_KEY, and restart the app.
"The API key was refused" (401)
The key is wrong, was revoked or has expired, or it lacks the read:fomo scope. Copy it again from your keys, check its scopes, and restart.
The account ran out of credits
A source or a wallet lookup fails once the month's credits are spent. Add credits or a pack in the dashboard. Leaderboard, clan, followers and holders sources cost 1–2 credits each, so they keep working on very little.
A trader is "not found"
The handle doesn't exist on fomo.family (handles aren't case-sensitive). That trader is skipped.
"The sending wallet has no account for this token"
The wallet in SENDER_ADDRESS or SOLANA_PRIVATE_KEY doesn't hold the token. Send the token to it, or use the right wallet.
"Doesn't have enough SOL"
Top up the sending wallet with what the Review step asks for, plus a little.
Slow checks, or 429 from the RPC
You're on the public RPC. Set SOLANA_RPC_URL to your own.
Sending paused by itself
The app couldn't tell whether a batch landed, usually because the RPC stopped answering. Press Resume: it looks the batch up first, marks whoever it reached as sent, and carries on.
Port 3006 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 3016.
Make it your own
The audience code is in lib/audience.js, the splits in lib/amounts.js, and the sending in lib/solana. Some directions:
- Reward a clan every week: rebuild the same audience on a schedule and send the top members a fixed amount.
- Thank your holders: use the holders source on your own token and weight by what each one holds.
- Reward good calls: pick the thesis writers on a token whose positions are above a size.
If you build with an AI assistant, the pumpfomo Claude skill and llms.txt give it the whole API.
Frequently asked questions
Is the app free?
Yes. The code is MIT licensed, and it runs on any pumpfomo plan, Free included. The airdrop itself costs SOL: about 0.002 per new token account, and a tiny fee per transaction.
How does it find a fomo.family trader's wallet?
It uses the Solana address on their fomo.family profile. Most audience sources include it at no extra cost. Pasted handles and thesis writers are looked up once each, for 2 credits, and saved for 30 days.
Will the token show up in their fomo.family portfolio?
Tokens sent to the profile's address land in the trader's account. fomo.family lists a received token in the portfolio once the token has a market. A token with no market at all may not show up.
Does the live demo show anyone's wallet?
No. The demo never looks a wallet up, and no address reaches the browser. Creating, exporting and sending are refused by its server. The repository includes a check, npm run check:demo, that proves it.
Does it work with Token-2022 tokens?
Yes. It detects the token's program, creates Token-2022 accounts where needed, and warns you if the token has a transfer fee, a permanent delegate or a freeze authority.
Can it airdrop to traders on EVM chains?
No. It sends SPL tokens on Solana. An audience can come from a token on another chain, such as its fomo.family holders on Base, but every airdrop goes to the traders' Solana addresses.
What if a batch fails halfway?
The batch's signature is saved before it's sent. On resume, the app looks it up first: recipients it reached are marked sent, and the rest go back in the queue. Nobody is paid twice.
Can I use my own list of traders?
Yes. Paste handles as a source, or import a CSV of handles with optional wallets and amounts.
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

Copy fomo.family's best traders
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.

Copy pump.fun's top traders
A ready-made pump.fun copy trading bot. Follow traders by username or wallet, copy their Solana buys and sells within your limits, and watch their PnL and trades on a live dashboard. Open source, with a demo.

Your traders, in your Telegram
A ready-made Telegram bot that alerts you the moment the traders you follow buy or sell on pump.fun or fomo.family, plus big trades, callouts and new coins. Commands in the chat, a live dashboard, open source, with a demo.

Watch any pump.fun wallet trade
A ready-made pump.fun wallet tracker. Watch any Solana or EVM wallets, see every trade they make within a second, with each wallet's value, 7-day PnL and holdings. Open source, with a live demo.