One GET returns every buy and sell on a pump.fun token, newest first, with the executed price, the pool price at that slot, the wallet and the early-buyer rank. Cursor paging, buy/sell and wallet filters, and what the coverage block tells you before you trust the numbers.
To get every trade on a pump.fun token through the MadeOnSol Solana API, call GET /api/v1/tokens/{mint}/trades with your msk_ key. It returns the token's raw trade tape, newest first: one row per buy or sell with the transaction signature, the wallet, the SOL and token amounts, the price that trade actually executed at, the pool's market price near that slot, and the wallet's early-buyer rank if it was one of the first buyers. Pages are cursor-based (next_cursor / has_more), and the tape can be narrowed to buys or sells, to one wallet, or to a Unix-seconds window. The endpoint sits on the PRO tier (€43/mo); a free key gets a 403 naming the tier.
Everything below was run against production on 2026-09-05 with a real key. Field names and values are copied from the responses, not from the docs.
curl -s "https://madeonsol.com/api/v1/tokens/2P49i8PFgRKYjb8NWMBHWNY5BW7nr7G9AJeAzx6mpump/trades?limit=3" \
-H "Authorization: Bearer msk_your_key"
Response (one of the three rows shown, the mint is a token that was 4 minutes old at the time):
{
"mint": "2P49i8PFgRKYjb8NWMBHWNY5BW7nr7G9AJeAzx6mpump",
"trades": [
{
"tx_signature": "52YXumMVNe1i15pdQamgS53U47QnFNB4DCuwc5eMbUA8re2iZhBHXx2QcQqdesEY91R…",
"wallet_address": "F2SsGGeGiDAyqhayraMo97R5ikinsVm6MgZyHSpHNq9e",
"action": "sell",
"sol_amount": 0.001331562,
"token_amount": 15329.217838,
"price_sol": 8.686431454442221e-8,
"price_usd": 0.000008976558265020593,
"market_price_sol": 8.9613303347667e-8,
"market_price_usd": 0.00000926063876794791,
"early_buyer_rank": null,
"slot": 444569798,
"block_time": 1788627220,
"traded_at": "2026-09-05T16:53:40.000Z"
}
],
"next_cursor": "MTc4ODYyNzIxNTo4NjQ0MTg1ODE=",
"has_more": true,
"filters": { "action": null, "wallet": null, "since": 1775984757, "until": 1788627222 },
"history": { "postgres_from": 1780272000, "archive_used": false, "archive_months": [], "archive_available": true, "truncated": false },
"coverage": { "history_start": 1775984757, "scope": "pump.fun pipeline (pump.fun, LaunchLab/bonk, bags)", "in_scope": true }
}
Two prices per row is deliberate. price_sol / price_usd is what this trade executed at (sol_amount / token_amount). market_price_sol / market_price_usd is the canonical pool price our market-cap tracker sampled near the same slot. The gap between them is the trade's slippage against the curve, which is how you tell a 0.001 SOL dust sell (the row above, executed 3 % below market) from a real exit.
early_buyer_rank is non-null only for wallets in the launch cohort, so is the one-line "early buyers are leaving" query. The launch cohort itself is on as and .
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
Proprietary AMM handling up to 60% of Jupiter-routed volume
Proactive market maker DEX with oracle-driven pricing
Chrome extension that lets you snipe and trade Solana memecoins directly from Twitter and Discord
Y Combinator-backed all-in-one Solana trading terminal with non-custodial wallets, wallet tracking, and tiered cashback fees.
Leading AMM and liquidity protocol powering Solana DeFi
Build a deployer sniper bot
Access deployer alerts, bonding stats, and tier data via API. Free tier: 200 requests/day.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: "msk_your_key" });
// Elite deployer alerts with KOL buy enrichment
const { alerts } = await client.deployer.alerts({ limit: 5 });
// Top deployers by bonding rate
const { deployers } = await client.deployer.leaderboard({ tier: "elite" });Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 2,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Guides
One socket, three channels: sniper:deploys pushes every pump.fun launch about half a second before the chain confirms it, token:graduations pushes every bonding-curve completion, token:surges pushes young tokens running 3×, 6× or 8× against their launch cap. Handshake, real frames, filters, and what each channel does not tell you.
Guides
Two ways to follow the trades of 1,000+ tracked Solana KOL wallets: poll GET /api/v1/kol/feed with the next_since cursor, or subscribe to the kol:trades WebSocket channel. Real response fields, the per-KOL scores that ride on every row, and how to pick wallets from the leaderboard.
Analytics
First live day of surge alerts, 28 Aug 2026: 138 pump.fun surges on 104 mints. Fires with no risk flag were above their fire price an hour later 60% of the time; fires flagged early_buyers_exiting, 6%.
Analytics
August 1–28, 2026: 1,032,440 launchpad deploys from 223,339 wallets, 18,202 graduations (1.8%), median time to bond 1 minute, median graduate peak $31K. 1,170 wallets minted 40% of the month's tokens.
Developer Tools
Get a Discord embed the moment a proven Solana deployer — one with a real bonding track record on pump.fun or LaunchLab — launches a new token or one of their tokens bonds. This tutorial walks the open-source deployer-alert-discord-bot starter: zero dependencies, ~130 lines, a Discord webhook, and a free MadeOnSol API key.
Guides
Of the 7 million tokens launched on pump.fun, only 97,000 maintained over $1,000 in liquidity. The difference between the 1.4% that survive and the 98.6% that don't is readable on-chain before you buy.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana & Robinhood Chain tools — free to explore.
Open the KOL TrackerWHERE early_buyer_rank IS NOT NULL AND action = 'sell'launch_cohort_sizeearly_buyer_exitThe tape of an active pump.fun token grows by hundreds of rows a minute, so offset paging would skip or repeat rows between calls. Pass next_cursor back as cursor until has_more is false:
const KEY = process.env.MADEONSOL_KEY;
const BASE = "https://madeonsol.com/api/v1";
async function* tape(mint, params = {}) {
let cursor = null;
do {
const qs = new URLSearchParams({ limit: "200", ...params });
if (cursor) qs.set("cursor", cursor);
const res = await fetch(`${BASE}/tokens/${mint}/trades?${qs}`, {
headers: { Authorization: `Bearer ${KEY}` },
});
if (res.status === 429) {
// x-ratelimit-reset is a Unix timestamp; sleep until it instead of hammering
const reset = Number(res.headers.get("x-ratelimit-reset")) * 1000;
await new Promise((r) => setTimeout(r, Math.max(1000, reset - Date.now())));
continue;
}
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
const page = await res.json();
for (const t of page.trades) yield t;
cursor = page.has_more ? page.next_cursor : null;
} while (cursor);
}
let buys = 0, sells = 0, netSol = 0;
for await (const t of tape("2P49i8PFgRKYjb8NWMBHWNY5BW7nr7G9AJeAzx6mpump")) {
if (t.action === "buy") { buys++; netSol += t.sol_amount; } else { sells++; netSol -= t.sol_amount; }
}
console.log({ buys, sells, netSol });
The cursor is opaque (it encodes the last row's block_time and id), so never build one yourself. Every response also carries x-ratelimit-limit, x-ratelimit-remaining and x-ratelimit-reset headers; the loop above respects them, and GET /api/v1/me returns the same quota without spending a call on a data endpoint.
| Query parameter | What it does | Example |
|---|---|---|
action | buy or sell only | ?action=buy |
wallet | one wallet's trades on this mint | ?wallet=9St6ETbe…j89U |
since / until | Unix seconds bounds (default: full history → now) | ?since=1788620000 |
limit | rows per page | ?limit=200 |
cursor | opaque page cursor from next_cursor | ?cursor=MTc4ODYy… |
The wallet filter is the fastest way to answer "what did this KOL do on this token". Filtering the same mint to the wallet that the KOL feed showed buying it returned exactly one row, the buy, at 1.518992234 SOL for 20753796.159031 tokens, executed at 7.32e-8 SOL against a pool price of 7.61e-8 (that is, 3.9 % below market, because a 1.5 SOL buy on a 4-minute-old curve moves the curve). Two things in that response are worth noticing:
history.archive_used flipped to true with archive_months: ["2026-05", "2026-04"], and the response header X-Read-Source read core+archive. A wallet filter with no since bound scans the whole history, so the API also consulted the Parquet archive for the months that are no longer in Postgres. Add since if you only need recent rows; the call is cheaper and the read stays on core.filters.since echoes 1775984757 even when you passed nothing. That is coverage.history_start: 2026-04-12, the first day the trade tape was persisted.The coverage object is on every response and is the honest part of the API. scope says the tape is built from the launchpad pipeline: pump.fun, LaunchLab (bonk) and bags. A mint that never went through those programs is in_scope: false and returns an empty trades array with a note, which is exactly what happened when the tape was requested for a token that trades on a Raydium pool only:
{
"mint": "3cWb3fkAuqcH1CqJdqZoy5qAAqpZpG8pxiFR68MXAcf4",
"trades": [],
"next_cursor": null,
"has_more": false,
"coverage": {
"history_start": 1775984757,
"scope": "pump.fun pipeline (pump.fun, LaunchLab/bonk, bags)",
"in_scope": false,
"note": "No persisted trades for this subject — it sits outside the pump.fun pipeline scope…"
}
}
An empty array with in_scope: false is not "no trades happened", it is "we do not index this venue". A full-chain DEX archive (Bitquery, Birdeye) is the right tool for that mint; the data-API comparison says where each provider wins. Where this tape is strongest is the part those archives see least: the bonding-curve phase before a token graduates to PumpSwap, which is where early_buyer_rank and the executed-vs-market price gap carry the signal.
Three sibling endpoints save you from rebuilding the tape into metrics:
/api/v1/tokens/{mint}/candles (PRO) returns 1-minute-derived OHLCV with buy_volume_usd, sell_volume_usd, net_volume_usd, buy_count, sell_count, volume_mev_usd and open_liquidity_usd / close_liquidity_usd per bucket. The same 4-minute-old token above already had a 1h candle: 224 trades, $10,615 volume, of which $1,572 flagged as MEV/bot volume./api/v1/tokens/{mint}/buyer-quality scores who is buying: the token returned score: 0, signal: "negative", bundle_buyer_count: 17, recycled_early_buyer_count: 17. Seventeen of the first buyers were bundled and had been early buyers of previous launches./api/v1/token/{mint} gives the snapshot: launch_cohort_size: 20, early_buyer_exit.still_holding_pct: 100, kol_activity.signal: "accumulating" with the KOL's name and buy size.Pull the tape when you need row-level truth (who, when, at what price, with what slippage). Pull the aggregates when you need a decision in one call.
If the loop in Step 2 runs on a timer, it is a polling client, and the free-tier quota (200 calls/day, 60/min) will show it. The paid tiers include WebSocket streaming on the same key: token:prices pushes per-mint price and market-cap ticks (subscribe with filters.mints; 25 mints per connection on PRO, 100 on ULTRA, 250 on BUSINESS), and token:surges pushes the moment a young token runs 3×, 6× or 8× against its launch cap. Pushed events do not count against the daily quota. The WebSocket reconnect guide covers the handshake and replay_since_seq.
Tokens launched through pump.fun, Raydium LaunchLab (bonk) and bags, from 2026-04-12 onward. The coverage block on every response states the scope and whether the requested mint is in_scope. A mint that only ever traded on a Raydium or Orca pool returns an empty tape with in_scope: false, not a partial one.
price_usd is the price that trade executed at (sol_amount / token_amount, converted at the SOL price of the moment). market_price_usd is the pool's canonical price sampled by the market-cap tracker near the same slot. The difference is the trade's slippage against the curve.
Postgres holds the most recent months (history.postgres_from, 2026-06-01 at the time of writing); older closed months are served from a Parquet archive. When a query reaches into it the response says so (history.archive_used: true, archive_months, and an X-Read-Source: core+archive header). Add a since bound to keep a query on the hot path.
PRO or higher (€43/mo). A free BASIC key receives a 403 whose body names the required tier. PRO includes 10,000 calls/day and the WebSocket channels; the free tier is 200 calls/day with live feeds delayed by 5 minutes.
Add ?wallet=<address> to the tape call. Combine with since (Unix seconds) to limit the scan; a wallet filter over the full history reads the Parquet archive as well as Postgres.
Per-mint price and market-cap ticks stream on the token:prices WebSocket channel, and momentum events on token:surges. The full per-trade DEX firehose is a separate ULTRA/BUSINESS socket (dex_ws_url in the /stream/token response). REST paging is the right tool for backfills and audits; the socket is the right tool for a live bot.