How to Stream Real-Time Solana DEX Trades with WebSockets

Build a real-time Solana DEX trade monitor using MadeOnSol's WebSocket streaming API. Filter trades by token, wallet, program, or size — covers Pump.fun, Raydium, Jupiter, and Orca.

MadeOnSol·April 5, 2026· 9 min read

How to Stream Real-Time Solana DEX Trades with WebSockets

Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.

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.

See Business pricing

Tools mentioned

Compare features and read reviews.

Live health scores, average ratings, and direct links on MadeOnSol.

Dexsport

Licensed Web3 sports betting with 40+ crypto tokens across 20+ chains

Dexrank

Expert DEX reviews, real-time rankings, and security ratings for Solana exchanges

Dexlab

No-code Solana token minting with DEX swaps, a Telegram bot, and an API

Build a deployer sniper bot

Access deployer alerts, bonding stats, and tier data via API. Free tier: 200 requests/day.

Start free

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" });

npm install madeonsolFull API docs

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.

Keep reading

More from the blog.

All Developer Tools

DeFi

How to Swap Crypto Without KYC: ChangeNOW, DEXs, and What Actually Works

A practical guide to swapping crypto without KYC in 2026. Covers ChangeNOW for cross-chain instant swaps, on-chain DEXs like Jupiter and Raydium, THORChain, and when each option makes sense.

12 minMay 23, 2026

Developer Tools

Building a Solana Portfolio Alert System: Price Drops, KOL Exits, and Recovery Signals (2026)

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.

Enjoyed this article?

Explore the live data.

Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana & Robinhood Chain tools — free to explore.

Open the KOL Tracker

API reference Start free Browse all articles

Explore more

Top 10 Developer Tools Top 10 RPC Deployer Hunter KOL Tracker Compare Yields Solana Glossary

Step 5: Build a Pump.fun launch sniping monitor

Here's a practical example — monitor all new Pump.fun trades and flag tokens with high buy volume:

// src/pumpfun-monitor.ts
import WebSocket from "ws";
import { MadeOnSol } from "madeonsol";

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

interface TokenStats {
  buys: number;
  sells: number;
  totalSol: number;
  uniqueBuyers: Set<string>;
  firstSeen: number;
}

const tokens = new Map<string, TokenStats>();

async function monitor() {
  const { dex_ws_url } = await client.stream.getToken();
  if (!dex_ws_url) throw new Error("Ultra subscription required");

  const ws = new WebSocket(dex_ws_url);

  ws.on("open", () => {
    ws.send(JSON.stringify({
      type: "subscribe",
      filters: {
        program: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P",
        min_sol: 0.1,
      },
    }));
    console.log("Monitoring Pump.fun trades...");
  });

  ws.on("message", (raw) => {
    const msg = JSON.parse(raw.toString());
    if (msg.type !== "dex:trade") return;

    const { token_mint, action, sol_amount, wallet } = msg.data;

    if (!tokens.has(token_mint)) {
      tokens.set(token_mint, {
        buys: 0, sells: 0, totalSol: 0,
        uniqueBuyers: new Set(),
        firstSeen: Date.now(),
      });
    }

    const stats = tokens.get(token_mint)!;
    if (action === "buy") {
      stats.buys++;
      stats.uniqueBuyers.add(wallet);
    } else {
      stats.sells++;
    }
    stats.totalSol += sol_amount;

    // Alert on tokens with 5+ unique buyers in the first 2 minutes
    const age = (Date.now() - stats.firstSeen) / 1000;
    if (stats.uniqueBuyers.size >= 5 && age < 120 && stats.buys === 5) {
      console.log(
        `[ALERT] ${token_mint.slice(0, 8)}... — ` +
        `${stats.uniqueBuyers.size} buyers, ${stats.totalSol.toFixed(1)} SOL in ${age.toFixed(0)}s`
      );
    }
  });

  ws.on("close", () => setTimeout(monitor, 5000));
}

monitor();

Step 6: Combine with KOL data

The real power comes from combining the DEX stream with KOL intelligence. When a KOL buys a token you're monitoring:

// Periodically fetch KOL feed to cross-reference
setInterval(async () => {
  const { trades } = await client.kol.feed({ limit: 20, action: "buy" });

  for (const trade of trades) {
    if (tokens.has(trade.mint)) {
      const stats = tokens.get(trade.mint)!;
      console.log(
        `[KOL BUY] ${trade.kol_name} bought a token you're watching — ` +
        `${stats.uniqueBuyers.size} unique buyers, ${stats.totalSol.toFixed(1)} SOL volume`
      );
    }
  }
}, 30_000);

Step 7: Add KOL momentum detection

Instead of only checking the feed, use the momentum endpoint to find tokens where KOL buy interest is accelerating — before full coordination kicks in:

// Check momentum tokens every 2 minutes
setInterval(async () => {
  const { hot_tokens } = await client.kol.hotTokens({
    period: "1h",
    min_kols: 2,
    limit: 10,
  });

  for (const token of hot_tokens) {
    if (token.acceleration > 2.0) {
      const tracked = tokens.get(token.token_mint);
      console.log(
        `[MOMENTUM] ${token.token_symbol}: ${token.kols_total} KOLs, ` +
        `${token.acceleration}x acceleration` +
        (tracked ? `, ${tracked.uniqueBuyers.size} unique buyers on-chain` : "")
      );
    }
  }
}, 120_000);

Supported DEX programs

The stream covers 9 Solana DEX programs:

DEX	What's covered
Pump.fun	Token launches, bonding curve swaps
PumpSwap	Post-bond AMM trades
Raydium AMM v4	Legacy pool swaps
Raydium CPMM	Concentrated pools
Raydium CLMM	Concentrated liquidity
Jupiter (DCA)	Dollar-cost averaging orders
Orca Whirlpool	Concentrated liquidity trades
Moonshot	Token launch trades
Meteora DLMM	Dynamic liquidity trades

DEX

What's covered

Pump.fun

Token launches, bonding curve swaps

PumpSwap

Post-bond AMM trades

Raydium AMM v4

Legacy pool swaps

Raydium CPMM

Concentrated pools

Raydium CLMM

Concentrated liquidity

Jupiter (DCA)

Dollar-cost averaging orders

Orca Whirlpool

Concentrated liquidity trades

Moonshot

Token launch trades

Meteora DLMM

Dynamic liquidity trades

Step 1: Get a streaming token

The WebSocket URL requires a 24-hour token. Generate one via the REST API:

// src/get-token.ts import { MadeOnSol } from "madeonsol"; const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY!, }); async function getStreamToken() { const token = await client.stream.getToken(); console.log("WebSocket URL:", token.ws_url); console.log("DEX Stream URL:", token.dex_ws_url); // Ultra only console.log("Expires:", token.expires_at); return token; }

The response includes:

ws_url — KOL/deployer event stream (Pro/Ultra)

dex_ws_url — all-DEX trade stream (Ultra only)

token — JWT valid for 24 hours

Step 2: Connect to the DEX stream

// src/stream.ts import WebSocket from "ws"; import { MadeOnSol } from "madeonsol"; const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY!, }); async function connectDexStream() { const { dex_ws_url } = await client.stream.getToken(); if (!dex_ws_url) { console.error("DEX stream requires Ultra subscription"); return; } const ws = new WebSocket(dex_ws_url); ws.on("open", () => { console.log("Connected to DEX stream"); // Subscribe with filters (at least one required) ws.send(JSON.stringify({ type: "subscribe", filters: { program: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P", // Pump.fun min_sol: 0.5, }, })); }); ws.on("message", (data) => { const trade = JSON.parse(data.toString()); if (trade.type === "dex:trade") { console.log( `[${trade.data.dex}] ${trade.data.action} ${trade.data.token_symbol || trade.data.token_mint.slice(0, 8)} — ` + `${trade.data.sol_amount.toFixed(2)} SOL` ); } }); ws.on("close", () => { console.log("Disconnected — reconnecting in 5s..."); setTimeout(connectDexStream, 5000); }); ws.on("error", (err) => { console.error("WebSocket error:", err.message); }); } connectDexStream();

Step 3: Filter options

The subscribe message requires at least one targeting filter:

// Track a specific token ws.send(JSON.stringify({ type: "subscribe", filters: { token_mint: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", // BONK }, })); // Track multiple tokens (max 50) ws.send(JSON.stringify({ type: "subscribe", filters: { token_mints: ["mint1...", "mint2...", "mint3..."], min_sol: 1, // Only trades > 1 SOL }, })); // Track a specific wallet across all DEXes ws.send(JSON.stringify({ type: "subscribe", filters: { wallet: "7xKXqmq...", }, })); // Track all Pump.fun trades above 2 SOL ws.send(JSON.stringify({ type: "subscribe", filters: { program: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P", min_sol: 2, action: "buy", // Only buys }, }));

Available filter fields

Filter	Type	Description
`token_mint`	string	Single token mint address
`token_mints`	string[]	Up to 50 token mints
`wallet`	string	Single wallet address
`wallets`	string[]	Up to 50 wallet addresses
`program`	string	DEX program ID
`min_sol`	number	Minimum trade size in SOL
`max_sol`	number	Maximum trade size in SOL
`action`	"buy" \| "sell"	Filter by trade direction

Filter

Type

Description

token_mint

string

Single token mint address

token_mints

string[]

Up to 50 token mints

wallet

string

Single wallet address

wallets

string[]

Up to 50 wallet addresses

program

string

DEX program ID

min_sol

number

Minimum trade size in SOL

max_sol

number

Maximum trade size in SOL

action

"buy" | "sell"

Filter by trade direction

Step 4: Trade data format

Each trade message looks like:

{ "type": "dex:trade", "data": { "signature": "5xYz...", "wallet": "7xKX...", "token_mint": "DezX...", "token_symbol": null, "action": "buy", "sol_amount": 2.5, "token_amount": 1500000, "dex": "pumpfun", "program_id": "6EF8...", "slot": 312456789, "timestamp": "2026-04-05T10:30:15Z" } }

Note: token_symbol and token_name are not included in the stream for performance. Resolve token metadata separately using a service like Helius DAS API or your own cache.

Feature	Pro (€43/mo, ≈ $49)	Ultra (€131/mo, ≈ $149)
KOL/Deployer WebSocket	2 connections	3 connections
DEX Trade Stream	No	2 connections
REST API	10K req/day	100K req/day
Webhooks	3	10

How to Stream Real-Time Solana DEX Trades with WebSockets

Compare features and read reviews.

Dexsport

Dexrank

Dexlab

More from the blog.

How to Swap Crypto Without KYC: ChangeNOW, DEXs, and What Actually Works

Building a Solana Portfolio Alert System: Price Drops, KOL Exits, and Recovery Signals (2026)

Explore the live data.

Step 5: Build a Pump.fun launch sniping monitor

Step 6: Combine with KOL data

Step 7: Add KOL momentum detection

DexVault

Soldex AI

Pump.fun Surge Alerts, Day 1: 138 Fires and What Happened an Hour Later

Pump.fun Deployer Stats — August 2026: 1.03M Launches, 18,202 Graduations, a 1.8% Bond Rate

How AI Agents Pay for Robinhood Chain Data in USDG (x402, No API Key)

Buy vs Build: What a Solana Deployer-Reputation Dataset Costs

What you'll build

Prerequisites

Supported DEX programs

Step 1: Get a streaming token

Step 2: Connect to the DEX stream

Step 3: Filter options

Available filter fields

Step 4: Trade data format

Step 8: Check deployer quality for new tokens

Pricing

FAQ

What's the latency of the DEX stream?

Can I subscribe to multiple filters at once?

How does this compare to running my own Yellowstone gRPC?

Does the stream include token names and symbols?

How can I combine the DEX stream with KOL analytics?

What are KOL momentum tokens?