Pump.fun WebSocket Trading Bot: Track Launches and Trades

Pump.fun is where chaos meets opportunity. Every few minutes a new memecoin hits the feed; some moon, most vanish. This guide shows you how to listen to that feed in real time over WebSockets, catch launches the moment they happen, and automate buy, take-profit, and stop-loss logic around them.

That's the whole agenda.

Degen trader, memecoin explorer, or someone launching a coin of your own: by the end you'll have moved from watching Pump.fun to acting on it.

Tools You'll Need for a Pump.fun WebSocket Bot

• Python 3.x (upgrade if you haven't yet)
• Terminal or IDE (VSCode, PyCharm, dealer's choice)
• A free API Key from NoLimitNodes

What We're Building with the Pump.fun WebSocket

You'll learn how to:

Listen to new token launches on Pump.fun in real time
Stream live transactions across all Pump.fun memecoins
Automatically buy, take profit, or stop loss using logic
Build the foundation of a trading bot that works while you sleep

How Pump.fun Memecoins Work

A quick breakdown of the token lifecycle on Pump.fun:

1. Token launches with full price, so there are no early flippers.
2. As people buy, the price reduces incrementally.
3. When the market cap hits $69K, the token auto-launches on Raydium and the liquidity is burned.
4. Early entries can win big, but many tokens never make it to Raydium, aka "rugged".

Bonus Insight:

Step 1: Real-Time Pump.fun Token Launches via WebSocket

Connect to the live token stream:

url = "wss://api.nolimitnodes.com/pump-fun?api_key=YOUR_API_KEY"

Subscribe to token creation events:

{
  "method": "pumpFunCreateEventSubscribe",
  "params": {
    "eventType": "coin",
    "referenceId": "launch-sub"
  }
}

Each launch arrives in real time with data like:

• Token name & symbol
• Mint address
• Creator wallet
• IPFS metadata (if available)

Step 2: Listen to Pump.fun Trades over WebSocket

To monitor buy/sell actions across every memecoin, subscribe like this:

{
  "method": "pumpFunTradeSubscribe",
  "params": {
    "coinAddress": "all",
    "referenceId": "tx-sub"
  }
}

Sample trade notification:

{
  "method": "tradeEventNotification",
  "result": {
    "type": "Buy",
    "price": { "sol": "0.000000045" },
    "wallet": { "address": "trader-wallet" },
    "token_out": { "token": "coinMintAddress", "amount": 10000000 }
  }
}

Build Your Pump.fun WebSocket Trading Bot

Install the dependency:

pip install websocket-client

Then paste in the bot script:

import websocket, json, threading

buyPrice        = float(0.0000000500)
takeProfitPrice = float(0.0000000900)
stopLossPrice   = float(0.0000000300)

buyDict, sellDict = {}, {}

def on_new_coin(ws, msg):
    data = json.loads(msg)
    if data.get("method") == "createEventNotification":
        coin = data["result"]
        mint = coin["mint"]
        name = coin["name"]
        symbol = coin["symbol"]
        buyDict[mint] = {"name": name, "symbol": symbol}
        print(f"🟢 NEW COIN: {name} ({symbol}) - Mint: {mint}")

def on_trade(ws, msg):
    data = json.loads(msg)
    if data.get("method") == "tradeEventNotification":
        trade = data["result"]
        mint = trade["token_out"]["token"]
        price = float(trade["price"]["sol"])
        if mint in buyDict and buyPrice <= price < takeProfitPrice:
            print(f"🛒 BUY: {buyDict[mint]['symbol']} @ {price}")
            sellDict[mint] = buyDict.pop(mint)
        elif mint in sellDict:
            if price >= takeProfitPrice:
                print(f"💰 SELL (TP): {sellDict[mint]['symbol']} @ {price}")
                del sellDict[mint]
            elif price <= stopLossPrice:
                print(f"🛑 SELL (SL): {sellDict[mint]['symbol']} @ {price}")
                del sellDict[mint]

def run_socket():
    ws = websocket.WebSocketApp(
        "wss://api.nolimitnodes.com/pump-fun?api_key=YOUR_API_KEY",
        on_message=on_trade
    )
    ws.on_open = lambda ws: ws.send(json.dumps({
        "method": "pumpFunTradeSubscribe",
        "params": {"coinAddress": "all", "referenceId": "tx-sub"}
    }))
    ws.run_forever()

def run_new_coin_socket():
    ws = websocket.WebSocketApp(
        "wss://api.nolimitnodes.com/pump-fun?api_key=YOUR_API_KEY",
        on_message=on_new_coin
    )
    ws.on_open = lambda ws: ws.send(json.dumps({
        "method": "pumpFunCreateEventSubscribe",
        "params": {"eventType": "coin", "referenceId": "launch-sub"}
    }))
    ws.run_forever()

threading.Thread(target=run_socket).start()
threading.Thread(target=run_new_coin_socket).start()

Winning Strategies That Actually Work

• Catch early: Snipe coins under $10k market cap
• Track creators: Favor wallets with past wins
• Set exits: Define TP/SL logic clearly
• Avoid rugs: Check if the creator is active on Telegram/X

Is Pump.fun Just Gambling?

Not if you add data + discipline.

Most tokens fail.
Bots help you catch trends, limit loss, and exit before hype dies.

With tools like NoLimitNodes and WebSockets, it stops being pure degenerate gambling and becomes calculated chaos.

Bonus Tips for Creators

Planning to launch your own token? Here's how to stand out:

• Build a Telegram + Twitter presence before launch
• Upload a meme-based litepaper or whitepaper on IPFS
• Highlight real or meme utility in metadata
• Add creator vesting or community wallets for credibility

Useful Links

For the core Pump.fun WebSocket API guide, start with the main NoLimitNodes reference.

• NoLimitNodes – Free API & tooling
• Pump.fun – Where memecoins are born
• Raydium – Where tokens go if they make it