The MadeOnSol API gives you programmatic access to three datasets that are hard to build yourself: real-time KOL trades from 1,000+ tracked wallets, reputation scores for 15,500+ Pump.fun deployers, and a searchable directory of 1,000+ Solana tools. The madeonsol TypeScript SDK wraps all of it in a typed client you can install from npm.
This tutorial covers three practical use cases: a KOL trade alert bot, a deployer reputation checker, and a multi-KOL convergence scanner. Each one is a standalone script you can run today.
Prerequisites
- Node.js 18+ and TypeScript
- A MadeOnSol API key (free tier gives you 200 calls/day, no payment required)
- Basic familiarity with async/await
Installation and Setup
Install the SDK:
npm install madeonsol
Create a .env file:
MADEONSOL_API_KEY=msk_your_api_key_here
Initialize the client:
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({
apiKey: process.env.MADEONSOL_API_KEY!,
});
See pricing at madeonsol.com/pricing, generate a free msk_ key, and copy it into your .env. You get 200 requests per day at no cost — enough to prototype and test all three examples below. The SDK auto-detects the msk_ prefix and authenticates directly with MadeOnSol's REST API using a Bearer token. Prefer to generate your own client instead of using the SDK? Our walkthrough on scaffolding a typed TypeScript client from any Solana API's OpenAPI spec shows the codegen route.
Use Case 1: KOL Trade Alert Bot
The KOL Tracker monitors 1,000+ Solana KOL wallets and detects trades in under 3 seconds. You can poll the feed endpoint to get the latest buys and sells, then filter for the trades that matter to you.
Here is a complete script that polls for large KOL buys every 30 seconds and logs them:
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY! });
async function pollKolBuys() {
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });
for (const trade of trades) {
if (trade.sol_amount > 5) {
console.log(
`${trade.kol_name} bought $${trade.token_symbol} for ${trade.sol_amount} SOL`
);
// Send to Telegram, Discord, etc.
}
}
}
// Poll every 30 seconds
setInterval(pollKolBuys, 30_000);
// Run immediately on start
pollKolBuys();
What You Can Do With This
- Telegram alerts: Pipe the output to a Telegram bot using
node-telegram-bot-api. Filter by SOL amount, specific KOL names, or token age.
- Discord webhooks: POST formatted embeds to a Discord channel whenever a trade matches your criteria.
- CSV logging: Append trades to a file for later analysis — track which KOLs have the best hit rate over time.
Rate Limit Considerations
At 30-second intervals, this script uses about 2,880 calls per day. The free tier caps at 100, so you will need a paid plan for continuous polling. For testing, increase the interval to 5 minutes (300,000ms) to stay within the free tier.
Use Case 2: Deployer Reputation Checker
Before buying a newly launched Pump.fun token, you want to know whether the deployer has a track record of creating tokens that actually bond to Raydium — or whether they are a serial rugger. The Deployer Hunter endpoint gives you exactly that.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY! });
async function checkDeployer(wallet: string) {
const { deployer } = await client.deployer.profile(wallet);
console.log(`Tier: ${deployer.tier}`);
console.log(`Bond rate: ${(deployer.bonding_rate * 100).toFixed(1)}%`);
console.log(`Total deployed: ${deployer.total_tokens_deployed}`);
console.log(`Total bonded: ${deployer.total_bonded}`);
if (deployer.tier === "elite" || deployer.tier === "good") {
console.log("This deployer has a solid track record");
} else {
console.log("Proceed with caution");
}
}
// Example: check a deployer wallet
checkDeployer("7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU");
Understanding the Tiers
The API categorizes deployers into tiers based on their bonding rate (percentage of tokens that successfully bond to Raydium) and total deployment count:
- Elite: High bonding rate with significant volume. These deployers consistently create tokens that graduate.
- Good: Above-average bonding rate. A reasonable signal of quality.
- Average: Mixed results. Not necessarily bad, but not a strong signal either.
- Poor: Low bonding rate. Most tokens from this deployer die on the bonding curve.
Building a Screening Pipeline
You can combine this with on-chain monitoring to build an automated screening pipeline:
async function screenNewToken(deployerWallet: string, tokenMint: string) {
const { deployer } = await client.deployer.profile(deployerWallet);
const score = {
tier: deployer.tier,
bondRate: deployer.bonding_rate,
totalDeployed: deployer.total_tokens_deployed,
pass: deployer.tier === "elite" || deployer.tier === "good",
};
if (score.pass) {
console.log(`Token ${tokenMint} passed deployer check — consider buying`);
} else {
console.log(`Token ${tokenMint} failed deployer check — skipping`);
}
return score;
}
This is one API call per token. At 200 free calls per day, you can screen 200 new launches — more than enough for manual review workflows.
Use Case 3: Multi-KOL Convergence Scanner
When multiple KOLs buy the same token within a short window, it can signal genuine interest rather than a single influencer pumping their bags. The coordination endpoint surfaces exactly these patterns.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY! });
async function findConvergence() {
const { tokens } = await client.kol.coordination({
period: "24h",
min_kols: 3,
});
for (const token of tokens) {
const direction = token.net_flow > 0 ? "accumulating" : "distributing";
console.log(
`${token.token_symbol}: ${token.kol_count} KOLs, net flow: ${direction}`
);
}
}
findConvergence();
Interpreting the Results
- kol_count: How many distinct KOL wallets traded this token in the period.
- net_flow: Positive means more SOL flowed in (buys outweigh sells). Negative means KOLs are exiting.
- period: Use
"1h", "4h", "12h", or "24h" depending on how fresh you want the signal.
A token with 5+ KOLs accumulating in the last 4 hours is a stronger signal than one with 3 KOLs over 24 hours. Combine this with deployer checks and your own on-chain analysis before making any trading decisions.
Filtering for Actionable Signals
async function getTopConvergence() {
const { tokens } = await client.kol.coordination({
period: "4h",
min_kols: 3,
});
// Only show tokens where KOLs are net buying
const accumulating = tokens.filter((t) => t.net_flow > 0);
// Sort by number of KOLs
accumulating.sort((a, b) => b.kol_count - a.kol_count);
console.log("Top convergence signals (last 4h):");
for (const token of accumulating.slice(0, 5)) {
console.log(
` ${token.token_symbol} — ${token.kol_count} KOLs accumulating`
);
}
}
Combining All Three
The real power comes from chaining these endpoints together. Here is a workflow that finds convergence signals, checks deployer reputation for each token, and outputs a ranked list:
async function fullScan() {
// Step 1: Find tokens multiple KOLs are buying
const { tokens } = await client.kol.coordination({
period: "4h",
min_kols: 3,
});
const results = [];
for (const token of tokens.filter((t) => t.net_flow > 0)) {
// Step 2: Check deployer reputation (if available)
if (token.deployer_wallet) {
const { deployer } = await client.deployer.profile(token.deployer_wallet);
results.push({
symbol: token.token_symbol,
kolCount: token.kol_count,
deployerTier: deployer.tier,
bondRate: deployer.bonding_rate,
});
}
}
// Step 3: Rank by deployer quality + KOL count
results.sort((a, b) => {
const tierOrder = { elite: 4, good: 3, average: 2, poor: 1 };
const tierDiff =
(tierOrder[b.deployerTier] || 0) - (tierOrder[a.deployerTier] || 0);
return tierDiff !== 0 ? tierDiff : b.kolCount - a.kolCount;
});
console.log("Ranked signals:");
for (const r of results) {
console.log(
` ${r.symbol} — ${r.kolCount} KOLs, deployer: ${r.deployerTier} (${(r.bondRate * 100).toFixed(1)}% bond rate)`
);
}
}
fullScan();
