Build a Solana Memecoin Sniper Bot with the DEX Firehose (2026 Guide)

End-to-end walkthrough for building a Solana memecoin sniper bot that detects fresh Pump.fun launches in real time, filters by token age and deployer reputation, and fires execution within seconds. Uses the MadeOnSol DEX Firehose WebSocket.

MadeOnSol·April 16, 2026· 8 min read

Build a Solana Memecoin Sniper Bot with the DEX Firehose (2026 Guide)

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.

FrogLabs Terminal

Serverless, non-custodial desktop terminal for launching and bundling Solana memecoins — private keys never leave your machine.

Jupiter Terminal

Embeddable swap widget powered by Jupiter for any Solana dApp

Foxify

Peer-to-peer perpetual futures DEX on Solana with customizable trading pairs

Build your own trading bot

KOL copy-trading, deployer sniping, and DEX trade streaming — all via API.

New customers try Pro free for 5 days — card, cancel anytime.

Start free

import { MadeOnSol } from "madeonsol";

const client = new MadeOnSol({ apiKey: "msk_your_key" });

// Mirror KOL trades in real-time
const { trades } = await client.kol.feed({ action: "buy" });

// Set up webhooks for instant alerts
const webhook = await client.webhooks.create({
  url: "https://your-bot.com/hook",
  events: ["kol:trade", "deployer:alert"],
});

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 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.

Keep reading

More from the blog.

All Guides

Guides

How to Use DEXScreener for Solana Trading: Complete Guide (2026)

Master DEXScreener for Solana trading. Learn how to find new tokens, read charts, set alerts, filter by liquidity, and spot opportunities before others. Step-by-step guide with pro tips. Updated May 2026.

13 minMay 5, 2026

Guides

How to Build Solana Trading Tools with the MadeOnSol SDK

Use the MadeOnSol TypeScript SDK to build KOL trade alerts, deployer reputation checkers, and multi-wallet convergence scanners — with real code examples.

Enjoyed this article?

Explore the live data.

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

Open the KOL Tracker

API reference Start free Browse all articles

Explore more

Top 10 Trading Bots Top 10 DEXs & Swaps Deployer Hunter KOL Tracker Compare Yields Solana Glossary

Execution: from signal to swap

The Firehose handles the signal. Execution is a separate problem and you have options:

Jupiter Swap API — straightforward, single endpoint, slippage-aware
Direct DEX program — lower latency, more code, requires you to handle pool state
Existing aggregator SDK — fastest to ship, less control

Below is a minimal Jupiter integration. It assumes you already have a Solana keypair loaded; in production you would want a hot wallet with a small float, separate from your main treasury.

import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js";
import bs58 from "bs58";

const conn = new Connection(process.env.RPC_URL, "confirmed");
const wallet = Keypair.fromSecretKey(bs58.decode(process.env.HOT_WALLET_SECRET));
const SOL = "So11111111111111111111111111111111111111112";

async function snipeJupiter(mint, solAmount) {
  const lamports = Math.floor(solAmount * 1e9);

  // 1. Quote
  const quote = await fetch(
    `https://quote-api.jup.ag/v6/quote?inputMint=${SOL}&outputMint=${mint}` +
    `&amount=${lamports}&slippageBps=500`
  ).then(r => r.json());

  // 2. Swap tx
  const swap = await fetch("https://quote-api.jup.ag/v6/swap", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      quoteResponse: quote,
      userPublicKey: wallet.publicKey.toBase58(),
      wrapAndUnwrapSol: true,
      prioritizationFeeLamports: 50_000,
    }),
  }).then(r => r.json());

  // 3. Sign + send
  const tx = VersionedTransaction.deserialize(Buffer.from(swap.swapTransaction, "base64"));
  tx.sign([wallet]);
  const sig = await conn.sendTransaction(tx, { skipPreflight: true, maxRetries: 0 });
  return sig;
}

Wired into the firehose handler:

const SNIPE_AMOUNT_SOL = 0.1;
const seenMints = new Set();

async function onTrade(t, isReplay) {
  if (isReplay) return;                    // never act on backfilled trades
  if (seenMints.has(t.mint)) return;       // one snipe per mint
  seenMints.add(t.mint);

  console.log(`SNIPING ${t.mint} (signal: ${t.sol_amount} SOL buy by ${t.wallet.slice(0,8)}…)`);
  try {
    const sig = await snipeJupiter(t.mint, SNIPE_AMOUNT_SOL);
    console.log(`  → tx ${sig}`);
  } catch (err) {
    console.error(`  → snipe failed: ${err.message}`);
  }
}

That is a complete, working sniper. Hardening it for production is largely about exit logic, position sizing, and safety rails — none of which are unique to this stack.

Operational notes that will save you hours

Reconnect on disconnect. The server may close your connection on slow consumers (1MB buffer threshold), token expiry (5-minute check), or network issues. Wrap the WebSocket in an exponential-backoff reconnect.

The signal: what counts as "fresh"?

A "fresh" launch is one where the bonding curve has been live for some short window (often 30 seconds to 5 minutes) and you have not missed the initial run-up. The DEX Firehose exposes this directly via the token_age_max_seconds filter, which uses a persisted first-seen lookup so the value is consistent across our deploy cycles — you do not get a false flood of "new" tokens after every restart.

A subscription that gets you fresh Pump.fun buys looks like this:

import WebSocket from "ws"; const API_KEY = process.env.MADEONSOL_KEY; // Step 1: get a short-lived stream token const tokenRes = await fetch("https://madeonsol.com/api/v1/stream/token", { method: "POST", headers: { "Authorization": `Bearer ${API_KEY}` }, }); const { token } = await tokenRes.json(); // Step 2: connect to the firehose const ws = new WebSocket(`wss://madeonsol.com/ws/v1/dex-stream?token=${token}`); ws.on("open", () => { ws.send(JSON.stringify({ type: "subscribe", sub_id: "fresh-pumpfun", replay: 50, // get the last 50 matching trades on connect filters: { dex: "pumpfun", token_age_max_seconds: 300, // first seen within last 5 minutes action: "buy", min_sol: 0.5, // ignore dust }, })); }); ws.on("message", (raw) => { const msg = JSON.parse(raw); if (msg.type === "connected") console.log("connected, capabilities:", msg.capabilities); else if (msg.type === "subscribed") console.log("filter active:", msg.filters); else if (msg.channel === "dex:trades") { onTrade(msg.data, msg.replay === true); } }); function onTrade(t, isReplay) { const tag = isReplay ? "[replay]" : "[live] "; console.log(`${tag} ${t.dex} buy ${t.sol_amount} SOL → ${t.mint.slice(0, 8)}… by ${t.wallet.slice(0, 8)}…`); }

Run that and you will start receiving candidate launches within seconds. The replay: 50 flag immediately backfills the last 50 matching trades from our in-memory ring buffer so your bot has live context the moment it boots.

Filtering for quality, not quantity

Catching every fresh launch is easy. Catching the ones that are actually worth sniping is the entire game. The Firehose lets you stack filters server-side so your bot only wakes up on signals worth acting on.

Three filter dimensions matter:

1. Deployer tier

Most Pump.fun tokens are launched by wallets with no track record (unranked). A small minority are launched by wallets we have classified as elite or good — meaning they have deployed multiple tokens and consistently bonded them above some MC threshold. Tier classification is updated daily by our Deployer Hunter pipeline.

Filter on it like this:

ws.send(JSON.stringify({ type: "subscribe", sub_id: "elite-launches", filters: { dex: "pumpfun", token_age_max_seconds: 300, deployer_tier: ["elite", "good"], action: "buy", min_sol: 0.5, }, }));

Across a 24-hour window this typically reduces the firehose by 95%+ while keeping the signals with the highest historical bond rates. If you want to query that classification directly rather than stream it, our Solana deployer API for tracking token creators covers the REST surface behind these tiers.

2. Trade-size cohort

A token that is getting only 0.05 SOL trades is noise. A token with multiple ≥1 SOL buys in its first minute is showing real interest — though be aware that coordinated multi-wallet buying can fake this, which we unpack in our breakdown of how token launches use bundle buys. Use min_sol aggressively (1.0 SOL+) for higher-quality signals, lower (0.3–0.5 SOL) if you want broader coverage.

3. Multiple subs for tiered alerts

Run a primary "act on it" subscription with strict filters and a secondary "watch it" subscription with looser filters — on the same connection:

// High-confidence: act ws.send(JSON.stringify({ type: "subscribe", sub_id: "act", filters: { dex: "pumpfun", token_age_max_seconds: 120, deployer_tier: ["elite"], min_sol: 1.0, action: "buy" }, })); // Lower-confidence: log + dashboard ws.send(JSON.stringify({ type: "subscribe", sub_id: "watch", filters: { dex: "pumpfun", token_age_max_seconds: 600, deployer_tier: ["elite", "good", "moderate"], min_sol: 0.3 }, }));

Each matched trade carries the sub_id so you route them locally with no ambiguity.