How to Build Solana Trading Tools with the MadeOnSol SDK

The MadeOnSol API gives you programmatic access to three datasets that are hard to build yourself: real-time KOL trades from 946 tracked wallets, reputation scores for 6,700+ 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 RapidAPI key (free tier gives you 100 calls/day, no credit card required)
Basic familiarity with async/await

Installation and Setup

Install the SDK:

npm install madeonsol

Create a .env file:

RAPIDAPI_KEY=your_rapidapi_key_here

Initialize the client:

import { MadeOnSol } from "madeonsol";

const client = new MadeOnSol({
  apiKey: process.env.RAPIDAPI_KEY!,
});

Authentication goes through RapidAPI. Sign up at the MadeOnSol API page, subscribe to the free tier, and copy your key. You get 100 requests per day at no cost — enough to prototype and test all three examples below.

Use Case 1: KOL Trade Alert Bot

The KOL Tracker monitors 946 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.RAPIDAPI_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.RAPIDAPI_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 100 free calls per day, you can screen 100 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.RAPIDAPI_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();

Be mindful of rate limits here. Each token in the convergence results triggers a deployer lookup, so a scan with 10 tokens uses 11 API calls total (1 for coordination + 10 for deployer profiles).

Error Handling

The SDK throws typed errors you can catch:

try {
  const { deployer } = await client.deployer.profile(wallet);
} catch (error) {
  if (error.status === 404) {
    console.log("Deployer not found in database");
  } else if (error.status === 429) {
    console.log("Rate limit exceeded — wait and retry");
  } else {
    console.error("Unexpected error:", error.message);
  }
}

For production scripts, add exponential backoff on 429 responses and circuit breakers for sustained failures.

What to Build Next

These three examples are starting points. Here are some ideas for more complete tools:

Portfolio tracker: Combine KOL feed data with on-chain balance checks to track what top wallets are holding right now, not just what they traded recently.
Token screening pipeline: Wire up the deployer checker to a Helius webhook that fires on every new Pump.fun launch. Auto-score tokens the moment they deploy.
Telegram alert bot: Package the convergence scanner into a Telegram bot that sends alerts when a new multi-KOL signal appears. Use inline keyboards to let users set their own thresholds.
KOL performance dashboard: Track historical trades from the feed and calculate per-KOL win rates, average hold times, and P&L. Publish results on a web dashboard.
Sniper filter: Before your trading bot executes a buy, run the deployer check as a gate. Only buy tokens from deployers with a "good" or "elite" tier.

Resources

MadeOnSol API product page — pricing, features, and sign-up
Full API reference — all endpoints, parameters, and response schemas
npm package — npm install madeonsol

All code in this tutorial works with the free tier (100 calls/day, no credit card). For production use with continuous polling, check the paid plans on the API page.