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.
To track Solana KOL wallet trades programmatically, call GET /api/v1/kol/feed on the MadeOnSol Solana API: every buy and sell by a tracked KOL wallet, newest first, each row carrying the KOL's name and X handle, their 7-day and 30-day win rate, their percentile rank against other KOLs, the token, the SOL size, and the market cap at the moment of the trade. Poll it with the since cursor the response hands back, or, on a paid key, subscribe to the kol:trades WebSocket channel and receive the same rows pushed within a second of confirmation. The free tier reads the feed on a 5-minute delay; PRO (€43/mo) is real-time and includes the socket.
This is the hands-on how-to. The strategy guide explains why KOL wallets differ from whale wallets and which patterns to weight; the wallet-tracker setup guide covers watching your own list of wallets. All requests below were run against production on 2026-09-05; values are copied from the responses.
curl -s "https://madeonsol.com/api/v1/kol/feed?limit=2&exclude_sells=true&token_age_max_min=60" \
-H "Authorization: Bearer msk_your_key"
exclude_sells=true keeps buys only and token_age_max_min=60 keeps tokens under an hour old, which together is the "KOL just entered a fresh launch" filter. One row of the response:
{
"trades": [
{
"wallet_address": "8deJ9xeUvXSJwicYptA9mHsU2rN2pDx37KWzkDkEXhU6",
"kol_name": "Cooker",
"kol_twitter": "https://x.com/CookerFlips",
"kol_strategy_tag": "mixed",
"kol_auto_strategy_tag": "scalper",
"kol_winrate_7d": 75.82,
"kol_winrate_30d": 62.04,
"kol_early_entry_pct_30d": 44.11,
"kol_is_heating_up": false,
"kol_percentile_pnl_7d": 7.64,
"kol_percentile_winrate_7d": 87.04,
"token_mint": "7PkSfZPKMDX1jyYPxGjtiXpL7oYdTk9W9Uw51m7ppump",
"token_name": "Sons",
"token_symbol": "SONS",
"token_image_url": "https://ipfs.io/ipfs/Qmcyp…",
"launchpad": null,
"token_age_minutes": 2,
"action": "buy",
"sol_amount": 0.10102499999999992,
"token_amount": 844558.2066310011,
"market_cap_usd_at_trade": 12357.17,
"price_usd_at_trade": 0.000012357174577264,
"tx_signature": "3zciWKYrjHBnAWUaHLAbVj5cYtez87uayqAp74H4rLPGqHS7BKAPZeALRyiajCqQeeK…",
"traded_at": "2026-09-05T16:53:30+00:00"
}
],
"count": 2,
"data_age_seconds": 13,
"next_before": "2026-09-05T16:53:28+00:00",
"next_since": "2026-09-05T16:53:30+00:00",
"since": null,
"stream": {
"channel": "kol:trades",
"url": "wss://madeonsol.com/ws/v1/stream",
"token_endpoint": "POST /api/v1/stream/token",
"subscribe": { "type": "subscribe", "channels": ["kol:trades"] }
}
}
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
Get this data via API
Stream real-time KOL trades, PnL rankings, and coordination signals programmatically.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: "msk_your_key" });
// Real-time KOL trades
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });
// KOL convergence signals
const { tokens } = await client.kol.coordination({ min_kols: 3 });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 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.
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.
Developer Tools
Paste a mint into Telegram, get a scored rug-risk report back in seconds. This tutorial walks the open-source rug-check-telegram-bot starter: zero dependencies, ~150 lines of Node, a free MadeOnSol API key, and a transparent 0–100 score where every point is attributed to a named factor — mint authority, liquidity depth, LP burn, bundled launch, deployer track record.
Developer Tools
You can embed a Solana data API in your app on a standard plan — but the moment you resell the data, expose it as your own feed, or strip the branding, you're in licensing territory most builders discover too late. This guide maps the three usage zones (internal use, user-facing display, redistribution), the questions to ask any data vendor before you build, and what an Enterprise data license actually covers: white-label, bulk export, extended caching, SLA, and dedicated limits.
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.
Developer Tools
Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.
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 TrackerEvery row is a joined record: the trade, the token's state at that moment (market_cap_usd_at_trade, price_usd_at_trade, token_age_minutes), and the trader's current scorecard (kol_winrate_7d, kol_percentile_pnl_7d, kol_auto_strategy_tag, kol_is_heating_up). That last group is what makes the feed filterable without a second lookup per row. The row above is a 0.1 SOL buy by a scalper with a 76 % 7-day win rate but a 7.6th-percentile 7-day PnL: he wins often and small. data_age_seconds: 13 is the age of the newest row relative to now, your freshness check.
Do not poll with limit=50 and dedupe on tx_signature; two churned accounts did exactly that (76k and 67k calls) and burned quota on rows they had already seen. The response returns next_since, the traded_at of the newest row. Feed it back as since and you receive only rows strictly newer than that:
curl -s "https://madeonsol.com/api/v1/kol/feed?since=2026-09-05T16%3A53%3A30%2B00%3A00&limit=5" \
-H "Authorization: Bearer msk_your_key"
Eight seconds later that returned one row (count: 1, since echoed, a fresh next_since of 16:53:38). A minimal poller:
const KEY = process.env.MADEONSOL_KEY;
let since = null;
async function pollOnce() {
const qs = new URLSearchParams({ limit: "100", min_sol: "0.5" });
if (since) qs.set("since", since);
const res = await fetch(`https://madeonsol.com/api/v1/kol/feed?${qs}`, {
headers: { Authorization: `Bearer ${KEY}` },
});
if (!res.ok) throw new Error(`${res.status}`);
const page = await res.json();
for (const t of page.trades) handle(t);
if (page.next_since) since = page.next_since;
// count === limit means the window filled up: page back with before= until it doesn't
return page.count === 100;
}
setInterval(() => pollOnce().catch(console.error), 15_000);
If count equals your limit, more rows arrived inside the window than one page holds. Page down with before=next_before until it does not, then resume with since. Useful feed filters, all combinable:
| Parameter | Effect |
|---|---|
since / before | poll cursor (strictly newer) / page cursor (strictly older), ISO 8601 |
kol | one KOL wallet address |
action / exclude_sells | buy or sell / drop sells |
min_sol | minimum trade size in SOL |
token_age_max_min | token younger than N minutes at trade time |
min_kol_winrate | minimum 7-day win rate of the buying KOL |
strategy | auto-classified style (scalper, swing_trader, hodler, …) |
min_mc_usd / max_mc_usd | market cap at trade inside a band (rows with unknown MC drop out) |
include=token | embed the /token/{mint} snapshot on each row (≤ 20 distinct mints per page) |
The feed covers every tracked wallet. To follow a subset, start from the leaderboard and then filter the feed with kol=:
curl -s "https://madeonsol.com/api/v1/kol/leaderboard?period=7d&limit=3" \
-H "Authorization: Bearer msk_your_key"
{
"leaderboard": [
{
"name": "Fox 🦊",
"wallet": "DAEdBmTPEKM6xkwfzC3d411QUe6coKpkND6UURa4CvHC",
"strategy_tag": "mixed",
"auto_strategy_tag": "scalper",
"pnl": 2815.184207,
"buy_count": 42,
"sell_count": 110,
"volume": 3576.302046,
"win_rate": 60,
"avg_roi": 209.83,
"profit_factor": 67.8617,
"early_entry_pct_30d": 41.53,
"consistency_7d": 62.5,
"median_hold_minutes_30d": 24.7,
"is_heating_up": false,
"is_cold": false,
"percentile_pnl_7d": 100,
"percentile_winrate_7d": 80.09
}
],
"pagination": { "limit": 3, "offset": 0, "returned": 3, "total": 50, "has_more": true },
"period": "7d",
"sort": "pnl"
}
pnl is SOL over the period, profit_factor is gross wins over gross losses, median_hold_minutes_30d tells you whether copying this wallet is even feasible at your latency (24.7 minutes here; scalpers under 3 minutes are not copyable through a 15-second poller). For a single wallet, GET /api/v1/kol/{wallet} returns the same scores plus peer_ranks and the 50 most recent trades. The profit-factor percentile guide goes deeper on selection.
Then narrow the feed:
curl -s "https://madeonsol.com/api/v1/kol/feed?kol=9St6ETbe3CFitw6UNSd8kg7kZ6STXy71wEGiERqQj89U&limit=2" \
-H "Authorization: Bearer msk_your_key"
That returned the wallet's latest two trades, the newest a 1.52 SOL buy of a 3-minute-old token at a $7,642 market cap.
Every feed response carries a stream object pointing at the socket that pushes the same rows. On PRO and above:
import WebSocket from "ws";
const KEY = process.env.MADEONSOL_KEY;
// 1. Mint a stream token (does not expire; the same value is returned on every call)
const { token, ws_url } = await (await fetch("https://madeonsol.com/api/v1/stream/token", {
method: "POST", headers: { Authorization: `Bearer ${KEY}` },
})).json();
// 2. Connect and subscribe — nothing is delivered until you subscribe
const ws = new WebSocket(`${ws_url}?token=${token}`);
ws.on("open", () => ws.send(JSON.stringify({ type: "subscribe", channels: ["kol:trades"] })));
ws.on("message", (raw) => {
const m = JSON.parse(raw);
if (m.channel === "kol:trades") handle(m.data); // m.seq and m.id are your dedupe keys
});
A frame received during the test session:
{
"channel": "kol:trades",
"event": "kol:trade",
"id": "kol:trade:5qKGdtkz1LXnj6GSDQg63fU88b6qhB4Ct5YUbscFAvM2ozFWCk4k7zbRe…",
"seq": 61650562,
"data": {
"kol_name": "",
"wallet_address": "3oApZug9zFHshrer3kJnHPtjSCXrQh2FAib2CzT8Q4KT",
"token_mint": "AfX2Su3aLfYu7dmrKXEu6KyK748YWjSr74e6F3TTWWYe",
"token_name": null,
"token_symbol": null,
"action": "buy",
"sol_amount": 0.31248314099999996,
"token_amount": 5079483.157030722,
"tx_signature": "5qKGdtkz1LXnj6GSDQg63fU88b6qhB4Ct5YUbscFAvM2ozFWCk4k7zbReqTo4TpQscc…",
"slot": 444569826,
"traded_at": "2026-09-05T16:53:49.000Z",
"price_usd_at_trade": 0.000006356110873885258,
"market_cap_usd_at_trade": null,
"fdv_usd_at_trade": null,
"liquidity_usd_at_trade": null,
"primary_dex": null,
"primary_pool_address": null
},
"ts": 1788627229154
}
Notice what the pushed row does not have: the kol_winrate_* and kol_percentile_* scores that ride on the REST rows, and the token fields (token_name, market_cap_usd_at_trade) can be null for a token so new the market-cap tracker has not sampled it yet. The socket optimises for latency, the REST feed for context. The usual pattern is: act on the frame, then enrich with one GET /api/v1/token/{mint} or by reading the KOL's scores once and caching them per wallet. Frames carry seq; on reconnect, subscribe with replay_since_seq set to the last one you processed and the server re-delivers the gap (the last ~20,000 frames, about 10 minutes). Heartbeats arrive every 15 seconds. In a four-minute test window the channel delivered 31 KOL trades.
Pushed events do not count against the daily quota, so a socket replaces a polling loop entirely. The reconnect-loop guide has the full client.
data_age_seconds will show it). Enough to prototype, not enough to trade on.kol:trades, kol:first_touches and kol:coordination sockets, webhooks, copy-trade signals.GET /api/v1/me returns your tier and remaining quota, so a client can self-throttle instead of collecting 429s.
Call GET /api/v1/kol/feed with a MadeOnSol msk_ key. Each row is one buy or sell by a tracked KOL wallet with the KOL's name, X handle, win rates and percentile ranks, plus the token and the market cap at trade time. Free keys read it on a 5-minute delay; PRO is real-time.
Pass the next_since value from each response back as since. You then receive only rows strictly newer than your last one. If count equals your limit, page down with before=next_before before resuming.
Yes. On PRO and above, mint a token with POST /api/v1/stream/token, connect to wss://madeonsol.com/ws/v1/stream?token=… and send {"type":"subscribe","channels":["kol:trades"]}. Frames arrive within about a second of confirmation and do not count against the daily quota.
No. The pushed row has the trade, wallet, token mint and price at trade, but not the KOL's win-rate and percentile scores, and token name / market cap can be null for a brand-new token. Enrich from GET /api/v1/token/{mint} or cache the KOL scores per wallet.
Pick wallets from GET /api/v1/kol/leaderboard (7d/30d PnL, win rate, profit factor, median hold time) and add kol=<wallet> to the feed call. For your own arbitrary wallet list, use the Wallet Tracker endpoints instead.
Over a thousand Solana wallets; the methodology post explains how wallets are sourced and verified. Robinhood Chain KOL trades are a separate feed at GET /api/v1/rhc/kol/feed and the rhc:kol_trades channel.