How to Build a Solana Dip-Buying Bot with Sub-Second Price Alerts (2026)

Step 3: Execute the Buy

When a dip event arrives, swap SOL for the token via Jupiter:

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

const connection = new Connection(process.env.RPC_URL!);
const wallet = Keypair.fromSecretKey(bs58.decode(process.env.PRIVATE_KEY!));
const SOL_MINT = "So11111111111111111111111111111111111111112";
const BUY_AMOUNT_LAMPORTS = "200000000"; // 0.2 SOL

export async function executeBuy(tokenMint: string): Promise<string> {
  // Get Jupiter quote
  const quoteUrl = new URL("https://quote-api.jup.ag/v6/quote");
  quoteUrl.searchParams.set("inputMint", SOL_MINT);
  quoteUrl.searchParams.set("outputMint", tokenMint);
  quoteUrl.searchParams.set("amount", BUY_AMOUNT_LAMPORTS);
  quoteUrl.searchParams.set("slippageBps", "500");

  const quote = await fetch(quoteUrl.toString()).then(r => r.json());

  // Get swap transaction
  const { swapTransaction } = 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: 200000,
    }),
  }).then(r => r.json());

  // Sign and send
  const tx = VersionedTransaction.deserialize(Buffer.from(swapTransaction, "base64"));
  tx.sign([wallet]);

  const sig = await connection.sendRawTransaction(tx.serialize(), {
    skipPreflight: true,
    maxRetries: 3,
  });

  await connection.confirmTransaction(sig, "confirmed");
  return sig;
}

Set slippage higher than normal (5-10%) for dip buys. During sharp drops, liquidity thins out and tight slippage will cause transaction failures.

Step 4: Recovery Tracking

If you set recovery_pct when creating the alert, the system tracks the dip low (lowest MC after the dip fires) and sends a price_alert:recovery event when the token bounces back by that percentage from the bottom.

This is useful for two things:

Profit-taking signal: you bought the dip, now the recovery confirms the bounce is real
Logging: track which dip buys actually recovered vs. which kept falling

The recovery payload includes dip_low_mc_usd — the absolute bottom the token hit after your dip alert fired. Compare that to current_mc_usd to see exactly how much of the bounce you captured.

Running Multiple Alerts

A realistic setup tracks 5-25 tokens simultaneously. Each alert is independent — you can set different drop thresholds per token based on its volatility profile:

// Tight threshold for blue-chip memecoins (less volatile)
await client.priceAlerts.create({
  token_mint: WIF_MINT,
  drop_pct: 15,
  recovery_pct: 10,
  delivery_mode: "webhook",
  webhook_url: "https://your-server.com/webhook/dip",
});

// Wide threshold for micro-cap tokens (more volatile)
await client.priceAlerts.create({
  token_mint: MICROCAP_MINT,
  drop_pct: 40,
  recovery_pct: 25,
  delivery_mode: "webhook",
  webhook_url: "https://your-server.com/webhook/dip",
});

Architecture Overview

The bot has four components:

Alert creation — register a token + drop threshold via the API

Webhook receiver — HTTP server that receives price_alert:dip events

Buy execution — swap SOL for the dipped token via Jupiter

Recovery tracking — optionally get notified when the token bounces back

No polling loops. No WebSocket connections to maintain. The alert system pushes to you — we cover this push-vs-poll tradeoff in depth in our guide to automated dip buying with webhooks.

Prerequisites

Node.js 18+ and TypeScript

A MadeOnSol API key (PRO tier for up to 5 alerts, ULTRA for 25) — get one at madeonsol.com/pricing

A Solana wallet with SOL for trading

A publicly accessible HTTP endpoint for webhook delivery (use ngrok for development)

Install the SDK:

npm install madeonsol @solana/web3.js bs58 dotenv express npm install -D typescript @types/node @types/express ts-node

Step 1: Create a Price Alert

A price alert captures the token's current market cap as the baseline when you create it. You set a drop_pct — when the MC falls below baseline * (1 - drop_pct / 100), the alert fires.

// src/create-alert.ts import MadeOnSol from "madeonsol"; const client = new MadeOnSol({ apiKey: process.env.MADEONSOL_API_KEY! }); async function createDipAlert(tokenMint: string) { const alert = await client.priceAlerts.create({ token_mint: tokenMint, drop_pct: 25, // fire when MC drops 25% from current recovery_pct: 15, // then fire again when MC recovers 15% from the dip low name: "Dip buy alert", delivery_mode: "webhook", webhook_url: "https://your-server.com/webhook/dip", }); console.log("Alert created:", alert.id); console.log("Baseline MC:", alert.baseline_mc_usd); console.log("Webhook secret:", alert.webhook_secret); // Store the webhook_secret — you need it to verify signatures return alert; } createDipAlert("TOKEN_MINT_HERE").catch(console.error);

The API returns a webhook_secret on creation — shown once only. Store it securely. Every webhook payload is signed with HMAC-SHA256 so you can verify it came from MadeOnSol and not an attacker.

Alert Lifecycle

Each alert is one-shot: watching then dipped then optionally recovered. After it fires, create a new one to re-track. This is intentional — it forces you to reassess the baseline rather than blindly re-entering at old levels.

Step 2: Webhook Receiver

When the price drops past your threshold, MadeOnSol POSTs a price_alert:dip event to your webhook URL. The payload includes the baseline MC, current MC, and the actual drop percentage.

// src/webhook-server.ts import express from "express"; import crypto from "crypto"; import { executeBuy } from "./buy"; const app = express(); app.use(express.json()); const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET!; function verifySignature(body: string, timestamp: string, signature: string): boolean { const expected = crypto .createHmac("sha256", WEBHOOK_SECRET) .update(`${timestamp}.${body}`) .digest("hex"); return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected)); } app.post("/webhook/dip", async (req, res) => { const rawBody = JSON.stringify(req.body); const timestamp = req.headers["x-madeonsol-timestamp"] as string; const signature = req.headers["x-madeonsol-signature"] as string; if (!verifySignature(rawBody, timestamp, signature)) { return res.status(401).send("Invalid signature"); } const event = req.body; console.log(`DIP DETECTED on ${event.token_mint}`); console.log(`Baseline MC: $${event.baseline_mc_usd}`); console.log(`Current MC: $${event.current_mc_usd}`); console.log(`Drop: ${event.drop_pct_actual.toFixed(1)}%`); // Execute the buy try { const sig = await executeBuy(event.token_mint); console.log(`Buy executed: ${sig}`); } catch (err) { console.error("Buy failed:", err); } res.status(200).send("OK"); }); app.listen(4000, () => console.log("Webhook server running on :4000"));

The signature verification is not optional. Without it, anyone who discovers your webhook URL can trigger fake buy signals.

How to Build a Solana Dip-Buying Bot with Sub-Second Price Alerts (2026)

Compare features and read reviews.

Seer

Cambrian

Noves

More from the blog.

How to Set Up Automated Solana Dip Buying with Webhooks — No Polling Required (2026)

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

Explore the live data.

Step 3: Execute the Buy

Step 4: Recovery Tracking

Running Multiple Alerts

Raiku

GetBlock

The Data Layer for a Telegram Trading Bot or Terminal SaaS (2026)

Solana Memecoin Data API for Builders: Embed Real-Time Intelligence in Your Product (2026)

Find Tokens Before They Moon: Scout Leaderboard, KOL Consensus, and Peak History (2026)

BonkBot vs Trojan: Which Solana Telegram Bot Should You Use in 2026?

Architecture Overview

Prerequisites

Step 1: Create a Price Alert

Alert Lifecycle

Step 2: Webhook Receiver

No-Code Alternative: Telegram Bot

Risks and Limitations

What to Build Next