Track whale and KOL trades on Solana

Query whale and KOL trades on Solana, filter by USD size or token, and subscribe to live Datastream feeds with wallet identity.

Load recent whale or KOL trades with REST, then subscribe to Datastream for new activity. Whale filters use fixed USD thresholds; the base KOL feed also includes trades below $1,000.

The REST API returns the latest indexed trades. Datastream delivers new trades in real time over WebSocket. Both use your Solana Tracker Data API key.

REST API

Latest whale trades

Request whale trades above a supported USD threshold:

curl "https://data.solanatracker.io/trades/whales?minVolume=10000&limit=50&hideArb=true" \
  -H "x-api-key: YOUR_API_KEY"

minVolume accepts 1000, 2500, 5000, or 10000. Results are sorted newest first.

Latest KOL trades

Fetch trades from wallets on the shared KOL roster:

curl "https://data.solanatracker.io/trades/kols?minVolume=2500&limit=100" \
  -H "x-api-key: YOUR_API_KEY"

For all eligible KOL trades, use minVolume=0 or omit minVolume entirely:

curl "https://data.solanatracker.io/trades/kols?limit=100" \
  -H "x-api-key: YOUR_API_KEY"

When identity data is available, each trade includes:

{
  "wallet": "9jyqFiLnruggWnN4EQwBNFXwpbLM9hrA4hV59ytyAVVz",
  "type": "buy",
  "volume": 1517.82,
  "identity": {
    "name": "Example KOL",
    "twitter": "@example"
  }
}

KOL trades for one token

Scope KOL trades to a mint for a token page or alert:

curl "https://data.solanatracker.io/trades/kols/TOKEN_MINT?minVolume=1000&hideArb=true" \
  -H "x-api-key: YOUR_API_KEY"

The token-scoped KOL endpoint also defaults to minVolume=0; pass minVolume=0 explicitly when you want to make that behavior clear.

With hideArb=true, the response keeps only rows where the requested mint is one side of the trade.

Paginate through history

Responses include nextCursor and hasNextPage. Pass the opaque cursor back unchanged:

const base = "https://data.solanatracker.io/trades/whales";
const params = new URLSearchParams({
  minVolume: "5000",
  limit: "250",
  showMeta: "true",
});

let cursor;
do {
  if (cursor) params.set("cursor", cursor);

  const response = await fetch(`${base}?${params}`, {
    headers: { "x-api-key": process.env.SOLANA_TRACKER_API_KEY },
  });
  const page = await response.json();

  for (const trade of page.trades) {
    console.log(trade.time, trade.type, trade.volume, trade.wallet);
  }

  cursor = page.hasNextPage ? page.nextCursor : null;
} while (cursor);

Use showMeta=true when your UI needs token names, symbols, images, decimals, or historical prices for the from and to sides.

Treat nextCursor as opaque. Do not decode, modify, or construct cursors in application code.

Real-time Datastream

Connect to:

wss://datastream.solanatracker.io/{YOUR_API_KEY}

Whale watch

Join a tier room to receive new qualifying trades:

const ws = new WebSocket(
  "wss://datastream.solanatracker.io/YOUR_API_KEY"
);

ws.addEventListener("open", () => {
  ws.send(JSON.stringify({
    type: "join",
    room: "transaction:whale:10000",
  }));
});

ws.addEventListener("message", (event) => {
  const message = JSON.parse(event.data);
  if (message.type !== "message") return;

  for (const trade of message.data) {
    const label = trade.type === "buy" ? "WHALE BUY" : "WHALE SELL";
    console.log(
      `${label} $${trade.volume.toLocaleString()} ` +
      `${trade.token?.to?.symbol ?? "token"} by ${trade.wallet}`
    );
  }
});

Available whale rooms:

transaction:whale:1000
transaction:whale:2500
transaction:whale:5000
transaction:whale:10000

Rooms are cumulative. A $12,000 trade is delivered to the 1000, 2500, 5000, and 10000 rooms. Join only the tiers your application needs.

KOL tracker

transaction:kol receives every eligible KOL trade, including trades below the $1,000 tier threshold:

ws.send(JSON.stringify({
  type: "join",
  room: "transaction:kol",
}));

ws.addEventListener("message", (event) => {
  const message = JSON.parse(event.data);
  if (message.type !== "message" || message.room !== "transaction:kol") {
    return;
  }

  const trade = message.data[0];
  const identity = trade.identity?.twitter || trade.identity?.name || trade.wallet;
  console.log(
    `${identity}: ${trade.type} $${trade.volume.toLocaleString()} ` +
    `on ${trade.token?.to?.symbol ?? trade.token?.from?.symbol ?? "token"}`
  );
});

For high-value KOL alerts, use cumulative tier rooms:

ws.send(JSON.stringify({
  type: "join",
  room: "transaction:kol:5000",
}));

KOL signal pipeline

Apply a size filter to incoming KOL trades before sending an alert:

function handleKolTrade(message) {
  if (message.type !== "message") return;

  for (const trade of message.data) {
    const identity = trade.identity;
    const token = trade.token?.to?.symbol || trade.token?.from?.symbol;

    if (trade.type === "buy" && trade.volume >= 5000) {
      console.log({
        event: "kol_buy_signal",
        wallet: trade.wallet,
        name: identity?.name,
        twitter: identity?.twitter,
        token,
        volumeUsd: trade.volume,
        signature: trade.tx,
      });
    }
  }
}

ws.addEventListener("message", (event) => {
  handleKolTrade(JSON.parse(event.data));
});

Keep raw trades separate from alerts derived from them. An alert is an application event; it does not submit a swap.

Message shape

Whale and KOL Datastream messages contain one enriched trade in a one-item data array:

{
  "type": "message",
  "room": "transaction:whale:10000",
  "data": [
    {
      "tx": "TRANSACTION_SIGNATURE",
      "amount": 125000.5,
      "priceUsd": 0.00012,
      "solVolume": 12.5,
      "volume": 12500,
      "type": "buy",
      "wallet": "WALLET_ADDRESS",
      "time": 1786470000000,
      "program": "raydium",
      "token": {
        "from": { "symbol": "SOL", "amount": 12.5 },
        "to": { "symbol": "MEME", "amount": 125000.5 }
      },
      "identity": {
        "name": "Example KOL",
        "twitter": "@example"
      }
    }
  ]
}

identity is present when the trading wallet is on the shared KOL roster. time is a Unix timestamp in milliseconds. volume is absolute USD volume; use type to determine buy or sell direction.

Production checklist

1. Deduplicate by transaction signature plus wallet, token, and side if your consumer reconnects.
2. Persist the last REST nextCursor when backfilling.
3. Reconnect WebSocket clients with exponential backoff.
4. Join only the required rooms to avoid duplicate cumulative events.
5. Store the raw trade and your derived alert separately.
6. Apply your own risk and execution checks before copy trading.

Whale & KOL REST API

Browse endpoint parameters, response schemas, and pagination.

Whale & KOL Datastream

Browse rooms, join messages, and live trade payloads.

Live swaps

Subscribe to every swap for a token.

KOL performance

Analyze wallet performance and KOL activity.