Pump.fun Trade Monitor

Real-Time Solana Meme Token Tracking via WebSocket

A high-performance Apify Standby Actor that streams meme token and new transaction events from the Pump.fun platform. Connect via WebSocket to capture market movements and fresh liquidity instantly.

🚀 Overview

This Standby-only Actor provides real-time access to Solana-based token transactions on the Pump.fun platform. The service operates as a lightweight, always-on web server delivering instant trade notifications. Events are pushed to your client as they happen via a single WebSocket connection, ensuring you capture every critical market movement and new token opportunity faster than ever before.

✨ Key Features

• 🔄 Apify Standby Mode: Always-on, fast-responding web server optimized for real-time streaming
• 🔴 Real-Time Event Streaming: Instant delivery of trades via high-performance WebSocket
• 🎯 Dynamic Filtering: Subscribe to specific token mint addresses dynamically without reopening the connection
• ⚡ High Performance: Sub-second trade delivery, connecting directly to Pump.fun's internal streams
• 💪 Scalable: Supports up to 1000 concurrent client connections with automatic cleanup
• 🛡️ Production Ready: Advanced health monitoring, disconnect detection, and automatic reconnection handling

🌐 Available Endpoints

Endpoint	Type	Description
/	WebSocket	Main real-time stream endpoint. Connect here via wss://
/health	HTTP GET	Monitor service health, active tokens, and connection stats

🔧 Quick Start

Standby Mode Only

This Actor only works in Standby mode. It cannot be run in normal mode. When you run it normally, it will only display a message and exit.

Connecting via WebSocket

Connect to the Actor's Standby URL using the wss:// protocol. Authentication is required using your Apify API Token.

You can authenticate by either:

1. Passing it in the header: Authorization: Bearer YOUR_APIFY_TOKEN (Recommended for server-side clients)
2. Appending it as a query parameter: ?token=YOUR_APIFY_TOKEN (For browser websockets where custom headers aren't supported)

Endpoint: wss://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/

1. Establish Connection

Connect to the WebSocket server. You will immediately receive a connected event containing your connection ID and current token subscriptions.

2. Manage Token Subscriptions

Send a JSON message to subscribe to specific token mint addresses. You will only receive trade events for the tokens you are subscribed to. You can pass multiple tokens in the array.

Important Notes:

• Scope: Subscriptions are managed per connection. If you connect via WebSocket Client A and Client B, their filtered token lists are completely independent.
• Limits: You can send a maximum of 200 tokens in a single tokens array per WebSocket message. This is not a limit on total tokens monitored per connection, but a safety limit per individual JSON payload. To monitor 500 tokens, simply send three separate subscribe messages.

Subscribe Request:

{
    "action": "subscribe",
    "tokens": [
        "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
        "8hMpgQGzin64DpoVqeFFyaHmZYzFTVVFHLLHzAo9pump"
    ]
}

Available Actions

• subscribe: Adds the provided list of tokens to your current connection's monitoring list.
• unsubscribe: Removes the provided list of tokens from your current connection's monitoring list. If you stop tracking a token, you will no longer receive trades for it.
• set: Fully replaces your connection's monitoring list with the newly provided tokens. Any tokens you were monitoring before that are not in the new set list are automatically removed.

Example set Action:

{
    "action": "set",
    "tokens": ["TokenA", "TokenB"] 
}
// Even if you were tracking TokenC before, you are now ONLY tracking TokenA and TokenB.

Example Client (Node.js)

1. Install dependencies:

$npm install ws

2. Create client.js and run:

import WebSocket from 'ws';
import https from 'https';

// Configuration
const CONFIG = {
    APIFY_TOKEN: process.env.APIFY_TOKEN || 'YOUR_APIFY_TOKEN', // 👈 Add your token here
    ACTOR_URL: 'wss://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/',
    HEALTH_URL: 'https://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/health',
    RECONNECT_BASE_DELAY: 1000,
    RECONNECT_MAX_DELAY: 30000,
    HEALTH_CHECK_INTERVAL: 4 * 60 * 1000 // 4 minutes
};

let reconnectDelay = CONFIG.RECONNECT_BASE_DELAY;
let ws;
let healthCheckInterval;

function connect() {
    ws = new WebSocket(CONFIG.ACTOR_URL, {
        headers: {
            'Authorization': `Bearer ${CONFIG.APIFY_TOKEN}`
        }
    });

    ws.on('open', () => {
        console.log('✅ Connected to Pump.fun Trade Monitor');
        
        reconnectDelay = CONFIG.RECONNECT_BASE_DELAY;

        // Subscribe to specific tokens
        ws.send(JSON.stringify({
            action: 'subscribe',
            tokens: [
                '9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump',
                '8hMpgQGzin64DpoVqeFFyaHmZYzFTVVFHLLHzAo9pump'
            ]
        }));
    });

    ws.on('message', (data) => {
        try {
            const event = JSON.parse(data);
            console.log('📩 Received:', event.event_type);
            
            if (event.event_type === 'trade') {
                const details = event.data.trade_details;
                console.log(`Trade: ${details.type} ${details.sol_amount} SOL for token ${details.mint_address}`);
            } else if (event.event_type === 'subscriptions_updated') {
                console.log('Subscriptions Updated:', event.data.current_tokens);
            }
        } catch (e) {
            console.error('⚠️ Failed to parse message:', e.message);
        }
    });

    ws.on('close', (code) => {
        console.log(`⚠️ Disconnected (Code: ${code}). Reconnecting in ${reconnectDelay}ms...`);
        scheduleReconnect();
    });

    ws.on('error', (err) => {
        console.error('❌ WebSocket error:', err.message);
    });
}

function scheduleReconnect() {
    setTimeout(() => {
        connect();
        reconnectDelay = Math.min(reconnectDelay * 2, CONFIG.RECONNECT_MAX_DELAY);
    }, reconnectDelay);
}

function startHealthCheck() {
    healthCheckInterval = setInterval(() => {
        const req = https.get(CONFIG.HEALTH_URL, {
            headers: { 'Authorization': `Bearer ${CONFIG.APIFY_TOKEN}` }
        }, (res) => {
            console.log(`💓 Health Check: ${res.statusCode}`);
            res.resume();
        });
        
        req.on('error', (e) => console.error(`💓 Health Check Failed: ${e.message}`));
    }, CONFIG.HEALTH_CHECK_INTERVAL);
}

process.on('SIGINT', () => {
    console.log('🛑 Shutting down client...');
    clearInterval(healthCheckInterval);
    if (ws) ws.close();
    process.exit(0);
});

console.log('🚀 Starting Pump.fun Monitor Client...');
connect();
startHealthCheck();

Example Client (Python)

1. Install dependencies:

$pip install websockets aiohttp

2. Create client.py and run:

import asyncio
import websockets
import json
import aiohttp
import logging
import sys
import os

# Configuration
APIFY_TOKEN = os.getenv("APIFY_TOKEN", "YOUR_APIFY_TOKEN") # 👈 Add your token here
ACTOR_WSS_URL = "wss://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/"
HEALTH_URL = "https://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/health"
RECONNECT_BASE_DELAY = 1.0
RECONNECT_MAX_DELAY = 30.0
HEALTH_CHECK_INTERVAL = 240

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%H:%M:%S')
logger = logging.getLogger("PumpFunMonitor")

async def monitor_health():
    async with aiohttp.ClientSession() as session:
        while True:
            try:
                await asyncio.sleep(HEALTH_CHECK_INTERVAL)
                headers = {"Authorization": f"Bearer {APIFY_TOKEN}"}
                async with session.get(HEALTH_URL, headers=headers, timeout=10) as response:
                    logger.info(f"💓 Health Check: {response.status}")
            except Exception as e:
                logger.error(f"💓 Health Check Failed: {e}")

async def listen():
    reconnect_delay = RECONNECT_BASE_DELAY
    
    while True:
        try:
            logger.info(f"🔌 Connecting to {ACTOR_WSS_URL}...")
            headers = {"Authorization": f"Bearer {APIFY_TOKEN}"}
            async with websockets.connect(ACTOR_WSS_URL, additional_headers=headers) as websocket:
                logger.info("✅ Connected!")
                reconnect_delay = RECONNECT_BASE_DELAY
                
                subscribe_msg = {
                    "action": "subscribe",
                    "tokens": [
                        "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
                        "8hMpgQGzin64DpoVqeFFyaHmZYzFTVVFHLLHzAo9pump"
                    ]
                }
                await websocket.send(json.dumps(subscribe_msg))
                logger.info("📡 Subscribed to tokens")
                
                async for message in websocket:
                    try:
                        event = json.loads(message)
                        logger.info(f"📩 Received: {event.get('event_type')}")
                        
                        if event.get('event_type') == 'trade':
                            trade_data = event.get('data', {}).get('trade_details', {})
                            logger.info(f"Trade: {trade_data.get('type')} {trade_data.get('sol_amount')} SOL for {trade_data.get('mint_address')}")
                        elif event.get('event_type') == 'subscriptions_updated':
                            logger.info(f"Subscriptions Updated: {event.get('data', {}).get('current_tokens')}")
                            
                    except json.JSONDecodeError:
                        logger.warning("Received invalid JSON message")
                        
        except (websockets.ConnectionClosed, OSError) as e:
            logger.warning(f"⚠️ Connection lost: {e}")
        except Exception as e:
            logger.error(f"❌ Unexpected error: {e}")
        
        logger.info(f"⏳ Reconnecting in {reconnect_delay}s...")
        await asyncio.sleep(reconnect_delay)
        reconnect_delay = min(reconnect_delay * 2, RECONNECT_MAX_DELAY)

async def main():
    try:
        await asyncio.gather(listen(), monitor_health())
    except asyncio.CancelledError:
        logger.info("🛑 Task cancelled, exiting...")

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("🛑 Exiting due to user interrupt...")
        sys.exit(0)

HTTP Endpoints Usage

# Set your Apify API token
export APIFY_TOKEN="YOUR_APIFY_TOKEN"

# Check service health and connection stats
curl -H "Authorization: Bearer $APIFY_TOKEN" https://muhammetakkurtt--pump-fun-trade-monitor.apify.actor/health

🔍 Health Monitoring & Service Status

Health Endpoint Response (GET /health)

{
  "status": "ok",
  "timestamp": "2026-03-13T10:30:45.000Z",
  "connections": 42,
  "active_tokens": 15,
  "messages_processed": 125847
}

📊 Event Data Structure

Trade Event (trade)

{
  "event_type": "trade",
  "timestamp": "2026-03-13T13:46:38.551547268Z",
  "data": {
      "bonding_curve": {
          "address": "5rCKLmjkeF5KpUnsyo1VPVANPifWVr6fHj5DAYCp3Kfb",
          "base_reserves": 423650879.446129,
          "is_bonding_curve": false,
          "quote_reserves": 0.077840965,
          "virtual_sol_reserves": 0,
          "virtual_token_reserves": 0
      },
      "creator_details": {
          "address": "7H8FsaJLyL4mhphsxHjjykiTbaPwf61whPxPoFTJFX5g",
          "created_at": "",
          "fee_sol": 0.000040055,
          "fee_usd": 0.0036957912336276198
      },
      "market_details": {
          "market_cap_usd": 16.953165195582816,
          "price_sol": 1.8373847140779552e-10,
          "price_usd": 1.695316519558282e-8,
          "program": "pump_amm",
          "sol_price_usd": 92.26791246105654
      },
      "media": {
          "metadata_uri": ""
      },
      "social_links": {},
      "token_details": {
          "metadata_uri": "",
          "mint_address": "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
          "name": "",
          "program": "pump_amm",
          "quote_mint_address": "So11111111111111111111111111111111111111112",
          "supply": 1000000000,
          "symbol": ""
      },
      "trade_details": {
          "is_buy": false,
          "mint_address": "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
          "pool_address": "5rCKLmjkeF5KpUnsyo1VPVANPifWVr6fHj5DAYCp3Kfb",
          "price_sol": 1.8373847140779552e-10,
          "price_usd": 1.695316519558282e-8,
          "signature": "4522ERGq398Mt8SJ3HpFVWRoZjFJCyKZEjgwtHwZvhVBcv6PvSpymPNRBc3LPKZKF7sBmKysjBScVVQvyJmSu4AV",
          "slot_index_id": "0004061475000008520406",
          "sol_amount": 0.013184441,
          "timestamp": "2026-03-13T13:46:37Z",
          "token_amount": 62027939.95407,
          "type": "sell",
          "usd_amount": 1.2165008480359647,
          "user_address": "C7xAvB1bJ1F7q3nzKq43vB16uqNrwbzhjmoLdi7M9c3d"
      },
      "user_profile": {
          "address": "C7xAvB1bJ1F7q3nzKq43vB16uqNrwbzhjmoLdi7M9c3d"
      }
  }
}

Connection Event (connected)

Sent immediately upon successful connection.

{
  "event_type": "connected",
  "timestamp": "2026-03-13T10:30:45.000Z",
  "data": {
    "connection_id": "ws_1643849162000",
    "tokens": [],
    "token_count": 0,
    "endpoint": "/"
  }
}

Subscriptions Updated Event (subscriptions_updated)

Sent after confirming a subscribe, unsubscribe, or set action.

{
  "event_type": "subscriptions_updated",
  "timestamp": "2026-03-13T10:30:45.000Z",
  "data": {
    "action": "subscribe",
    "requested_tokens": [
        "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
        "8hMpgQGzin64DpoVqeFFyaHmZYzFTVVFHLLHzAo9pump"
    ],
    "current_tokens": [
        "9TfTHrnXsA8fvVCAjnKph5LjGPe4jckZ76tmMXm3pump",
        "8hMpgQGzin64DpoVqeFFyaHmZYzFTVVFHLLHzAo9pump"
    ],
    "total_tokens": 2
  }
}

Error Event (error)

Sent when an error occurs (e.g., invalid JSON or action).

{
    "event_type": "error",
    "timestamp": "2026-03-13T10:30:45.000Z",
    "data": {
        "code": "invalid_action",
        "message": "Supported actions are subscribe, unsubscribe, and set."
    }
}

🎯 Use Cases

💹 Trading & Investment

• Algorithmic Trading Bots: Feed real-time trade execution data directly into your trading algorithms.
• Sniper Bots: Detect large buys or sells instantly to execute rapid trades.
• Copy Trading: Monitor specific token movements triggered by notable wallets based on real-time activity.
• Volume Analysis: Monitor buy/sell pressure and track sudden volume spikes.

📊 Analytics & Research

• Market Sentiment Analysis: Track the momentum and adoption rate of new meme coins.
• Whale Tracking: Monitor large SOL movements across different token pairs to predict market shifts.
• Liquidity Tracking: Analyze virtual reserves and bonding curve states in real-time.

🔔 Monitoring & Alerts

• Custom Price Alerts: Get instant notifications when highly active tokens reach specific targets.
• Discord/Telegram Bots: Build community tools that broadcast major trades or new market trends.
• Portfolio Tracking: Receive real-time updates regarding movements in assets you hold.