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.
To stream new Solana token launches, connect one WebSocket to wss://madeonsol.com/ws/v1/stream with a stream token from the MadeOnSol Solana API and subscribe to three channels. sniper:deploys pushes every pump.fun token creation as it is detected from the shred stream, roughly 500 to 800 ms before the transaction is confirmed. token:graduations pushes every pump.fun bonding-curve completion (a "bond"), tracked deployer or not. token:surges pushes the moment a token under 30 minutes old runs 3×, 6× or 8× against its launch market cap, with a tape summary and risk flags attached. All three sit on PRO (€43/mo) and above, share one connection, and do not count against the daily REST quota.
In a four-minute test window on 2026-09-05 (16:53 to 16:57 UTC) that one socket delivered 91 deploys, 3 graduations and 5 surges (plus 31 KOL trades on a fourth channel). Every frame below is copied from that session.
curl -s -X POST "https://madeonsol.com/api/v1/stream/token" \
-H "Authorization: Bearer msk_your_key"
{
"token": "msk_…",
"expires_at": null,
"ws_url": "wss://madeonsol.com/ws/v1/stream",
"subscribe_example": { "type": "subscribe", "channels": ["kol:trades"] },
"channels": ["kol:trades", "kol:coordination", "kol:first_touches", "deployer:alerts", "sniper:deploys", "token:graduations", "token:prices", "token:surges", "…19 total"]
}
The token does not expire (expires_at: null) and the same value comes back on every call, so a multi-process client can mint from anywhere. ws_url is bare; append the token yourself. Then connect and subscribe; nothing is delivered until you send a subscribe frame, and the server sends a hint after 10 seconds if you have not:
import WebSocket from "ws";
const KEY = process.env.MADEONSOL_KEY;
const { token, ws_url } = await (await fetch("https://madeonsol.com/api/v1/stream/token", {
method: "POST", headers: { Authorization: `Bearer ${KEY}` },
})).json();
const ws = new WebSocket(`${ws_url}?token=${token}`);
ws.on("open", () => {
ws.send(JSON.stringify({
type: "subscribe",
channels: ["sniper:deploys", "token:graduations", "token:surges"],
}));
});
ws.on("message", (raw) => {
const m = JSON.parse(raw);
if (m.type === "heartbeat") return; // every 15 s
if (!m.channel) return; // connected / subscribed / hint frames
switch (m.event) {
case "sniper:deploy": return onDeploy(m.data, m.seq);
case "token:graduation": return onGraduation(m.data, m.seq);
case "token:surge": return onSurge(m.data, m.seq);
}
});
The first frame you receive is , which includes your tier and a block (, , ). Then echoes the channels the server accepted. A channel your tier is not entitled to is silently dropped from that echo, so check it once.
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 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
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.
Developer Tools
Combine price dip webhooks, KOL coordination WebSocket streams, and wallet tracker events into a unified Solana alert system. TypeScript code for multi-signal trading decisions — sell when smart money exits, buy when they accumulate.
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.
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 Trackerconnectedreplayoldest_seqnewest_seqsize: 20000subscribedEvery event frame has the same envelope: channel, event, id (a natural key for deduping), seq (monotonic per server instance), data, and ts.
{
"channel": "sniper:deploys",
"event": "sniper:deploy",
"id": "sniper:deploy:1788627228535:151adbbd",
"seq": 61650559,
"data": {
"mint": "8rgJcqsaEJSuiqQaLLXxPHSE9e4FGxAAR2R2nCHfpump",
"name": "Bears are Cows",
"symbol": "BEARF",
"deployer": "4NjU9gcSaZ2Q4ouZH7EC7JGe1R4Ybp7cM1jCuvXJTBnj",
"deployer_wallet": "4NjU9gcSaZ2Q4ouZH7EC7JGe1R4Ybp7cM1jCuvXJTBnj",
"signature": "5NWQ2FvkCPMAvyv54ypVXMdGe3i7Q9GXEzW6fUsVMGJd4fooJQhx1BPKFx9fUAjPahB…",
"slot": "444569825",
"detected_at": "2026-09-05T16:53:48.535Z",
"detection_region": "Frankfurt",
"confidence": "deshred",
"launchpad": "pumpfun",
"deployer_tier": null,
"deployer_bond_rate": null,
"deployer_total_bonded": null,
"deployer_recent": null,
"deployer_runner_rate": null,
"deployer_labeled_tokens": null
},
"ts": 1788627228535
}
confidence: "deshred" is the important word. The frame is built from shreds, before the block is confirmed, which is where the head start comes from; it is also why the deployer attribution is a heuristic. The REST record at GET /api/v1/sniper/recent is cross-checked against the confirmed on-chain create every 15 minutes and carries attribution_status (unverified → confirmed or corrected) and confirmed_on_chain. Act on the frame, audit against REST.
The deployer_* fields are the deployer's track record from the deployer intelligence tables: deployer_tier (elite, good, moderate, rising, cold), deployer_bond_rate, deployer_recent (a last-10-outcomes string like DDDDDDDDDD), deployer_runner_rate and deployer_labeled_tokens (the confidence denominator; gate on 3 or more). They are null for a wallet that has never deployed before, which was the case above and is the case for most launches. A second frame from the same minute showed a cold deployer with deployer_bond_rate: "0.0003" and one bond in its history.
Two tier rules shape this channel. PRO receives only deploys by elite and good deployers, applied per message on delivery, so a PRO client sees the curated subset and cannot widen it with filters. ULTRA receives every tier, can pass filters.sniper_scope: "watchlist" to receive only deploys from its own deployer watchlist, and gets GET /api/v1/sniper/by-deployer/{wallet}. The 91 deploys in the test window were an ULTRA view.
{
"channel": "token:graduations",
"event": "token:graduation",
"id": "token:graduation:1788627371080:40bc5305",
"seq": 61672789,
"data": {
"token_mint": "8MvgWr48jBuW45Zpyy1KYAYJWHL1zk1byma54KSipump",
"token_name": "BRAINROT BARON",
"token_symbol": "brainrot",
"time_to_bond_minutes": 0,
"instant_bond": true,
"deployer_wallet": "6wsFnYmPg5VZpmQJJ1HesLHL93ME3aZzqq4yAzRse9g9",
"deployer_tier": "unranked",
"market_cap_usd": null,
"bonded_at": "2026-09-05T16:56:10.865Z"
},
"ts": 1788627371080
}
This channel fires on every pump.fun graduation, not only tracked deployers (that narrower event is deployer:bond on the deployer:alerts channel). The two fields that matter most are time_to_bond_minutes and instant_bond. instant_bond: true means the curve went from create to migrate within about 90 seconds, which on pump.fun means a bundle filled it, not organic demand; all three graduations in the test window were instant bonds. deployer_tier is unranked when the wallet has no scored history. market_cap_usd can be null on the frame because the graduation is emitted before the tracker has marked the new PumpSwap pool. If you need the number, GET /api/v1/deployer-hunter/recent-bonds returns the same tokens a few seconds later with mc_at_bond, peak_market_cap and the full deployers object (bonding_rate, instant_bonds, recent_outcomes), and it takes a since cursor for incremental reads.
You can pass filters.deployer_tier: ["elite","good"] on the subscribe frame to drop unranked and low-tier graduations at the server. The filter is fail-closed: a frame whose deployer is unknown (unranked here, null on surge frames) is dropped by any tier filter rather than let through.
{
"channel": "token:surges",
"event": "token:surge",
"id": "token:surge:9441",
"seq": 61664553,
"data": {
"id": "9441",
"kind": "surge",
"tier": "early",
"mint": "FxH8MaD9gUYQxCWtQh693N6Zn3uj7vLx7MmpTvbGpump",
"symbol": "Hot Whale",
"launchpad": "pumpfun",
"fired_at": "2026-09-05T16:55:12.212Z",
"birth_at": "2026-09-05T16:53:00.069Z",
"birth_source": "sniper",
"age_seconds": 132,
"market_cap_usd": 32616.61,
"liquidity_usd": 14635.04,
"baseline_mc_usd": 10081.87,
"baseline_source": "launch",
"mc_multiple": 3.235,
"mc_change_3m_pct": 223.52,
"peak_mc_usd": 36379.73,
"pct_of_peak": 89.66,
"bonding_progress_pct": 94.94,
"is_bonded": false,
"tape": { "buys": 21, "sells": 17, "trades": 38, "buy_volume_usd": 717.11, "sell_volume_usd": 2252.22, "unique_buyers": 18, "unique_wallets": 26, "trades_per_wallet": 1.85 },
"kol": { "buyers": 0, "buys": 0, "sells": 0, "names": [] },
"early_buyers": { "count": 17, "bundled": 3, "cohort_sol": 6.539, "sold": 12, "sniper_wallets": 11 }
},
"ts": 1788627252212
}
A surge is a token under 30 minutes old whose market cap runs against its launch cap (baseline_source: "launch", baseline_mc_usd). Tiers are early (≥ 3× within 10 min, ≥ $12K), strong (≥ 6× within 30 min, still climbing) and breakout (≥ 8× within 2 min); each fires once per mint. The frame is a decision packet: the multiple, how far off the peak it already is (pct_of_peak), the tape since birth, KOL involvement, and the early-buyer cohort. The one above is instructive: 3.2× in 132 seconds, but early_buyers.sold: 12 of 17, 11 of them known sniper wallets, and sell volume three times buy volume. The full row on GET /api/v1/tokens/surges also carries risk_flags and, later, an outcome. The day-one outcome post has the numbers: fires with no risk flag were above their fire price an hour later 60 % of the time, fires flagged early_buyers_exiting 6 %. Subscribe filters: kinds (surge / revival), tiers, launchpads, exclude_flags, min_mc_usd / max_mc_usd, deployer_tier.
kind: "revival" frames on the same channel are the opposite shape: a token with no trade candle for 24 hours or more that is confirmed trading again by real buys (never by a price mark alone), with dormant_hours and mc_vs_prev_multiple filled in.
| You want | Channel | It gives you | It does not give you |
|---|---|---|---|
| Every launch, earliest | sniper:deploys | mint, deployer, deployer track record, ~0.5 s before confirm | the confirmed attribution (poll /sniper/recent), any price |
| Launches by deployers you track | deployer:alerts | new_deploy and bonded alerts with market_cap_at_alert, deployer_sol_balance, kol_buys | untracked deployers (use sniper:deploys) |
| Every graduation | token:graduations | bond time, instant_bond, deployer tier | market cap at bond on the frame (use recent-bonds) |
| Tokens actually running | token:surges | multiple vs launch, tape, early-buyer exits, KOL buyers, risk flags | anything about tokens that did not move |
| Price per mint | token:prices | coalesced price/MC ticks, 25 mints per connection on PRO (100 ULTRA, 250 BUSINESS) | trades (that is the ULTRA dex_ws_url firehose) |
Handle reconnects with replay_since_seq: on reconnect, include the last seq you processed in the subscribe frame and the server re-delivers the gap from its 20,000-frame buffer (about 10 minutes at current volume), through the same filters. Store seq per instance (connected.instance), because a server restart resets it. The reconnect-loop guide has a complete client with backoff. Connection slots are 2 on PRO, 3 on ULTRA, 10 on BUSINESS, so multiplex channels on one socket rather than opening one per channel.
For a Discord or Telegram consumer that only needs a few events a minute, the same events are available as webhooks (sniper:deploy, deployer:alert, deployer:bond, token:surge, token:revival) with HMAC signatures; the deployer Discord bot tutorial shows that path.
Subscribe to the sniper:deploys channel on wss://madeonsol.com/ws/v1/stream with a stream token from POST /api/v1/stream/token. Each pump.fun creation is pushed as a sniper:deploy frame about 500 to 800 ms before the chain confirms it, with the deployer's track record attached. PRO and above.
sniper:deploys is every pump.fun launch, detected pre-confirmation from shreds. deployer:alerts fires only for deployers with a tracked history and includes richer context (market cap at alert, deployer SOL balance, KOL buys) as new_deploy and bonded alert rows. Use the first for coverage, the second for curation.
PRO is curated to deploys by elite and good tier deployers, applied per message at delivery. ULTRA receives every tier and can scope the channel to its own deployer watchlist with filters.sniper_scope.
No. Pushed events on any channel do not count toward the daily REST quota. Only the REST calls you make (including POST /api/v1/stream/token, which has its own 10/min bucket) do.
Reconnect and subscribe with replay_since_seq set to the last seq you processed. The server keeps the last 20,000 frames (about 10 minutes) and re-delivers the gap through your filters. For longer outages, backfill from REST: /sniper/recent?since=, /deployer-hunter/recent-bonds?since=, /tokens/surges.
Usually bad. instant_bond: true means the curve filled within about 90 seconds of creation, which on pump.fun is a bundle, not organic demand. All three graduations in the test window were instant bonds. Combine it with deployer_tier and, once the surge engine has seen the token, the early_buyers.bundled and sold counts.