Pump.fun Real Time Monitor — Live Solana & EVM Token Streams

Real-time Pump.fun event streaming API. Stream new token launches, graduations, buy/sell trades, holder and rug-risk metrics, price ticks, market caps, liquidity moves, livestreams and wallet activity — across Solana and seven EVM chains (Base, BNB Chain, Ethereum, HyperEVM, Ink and more), over WebSocket (WSS).

🚀 Overview

This Standby-only Actor is an always-on web server that pushes Pump.fun events to you the moment they happen. No polling, no dataset, no rate limits to manage — open one connection and records arrive sub-second.

Pump.fun is no longer a Solana-only platform, and neither is this monitor: alongside bonding-curve and PumpSwap activity you get live EVM trades, liquidity and token launches across 15 DEX protocols (Uniswap V2/V3/V4, PancakeSwap, Aerodrome, Velodrome, Ramses and others).

22 streams, each on its own endpoint, each filterable on the server.

✨ Key Features

• 🔄 Apify Standby Mode: always-on, fast-responding web server
• 🔴 Real-Time Streaming: sub-second delivery over WebSocket (WSS)
• 🌐 Solana + 7 EVM chains: Base, BNB Chain, Ethereum, HyperEVM, Ink and two more
• 🏭 Every launchpad: token creations carry the launch platform and program, not just pump's own
• 🛡️ Rug-risk metrics live: holder count, developer / top-10 / sniper / bundler holdings as they change
• 🎯 Server-side filtering: narrow by mint, chain, wallet, trade side, size, market cap or DEX protocol — filtered-out records never cross the wire, so you are not charged for them
• 👛 Wallet tracking: every trade and balance change for the wallets you name — copy-trading ready
• 💱 Price & market-cap feeds: per-token price ticks on every chain, plus a batched market-cap ticker
• ⚡ Built for throughput: records are forwarded without being decoded and re-encoded, so the open stream stays fast and stable
• 🔌 Shared upstream: many subscribers on the same stream cost one upstream subscription

🌐 Available Streams

GET /feeds returns this table live, with the filters each stream accepts.

Tokens

Endpoint	Event	What it carries
/events/tokens/created	token_created	Every new token, any launchpad — name, symbol, creator, platform, program, bonding curve, supply
/events/tokens/new	new_coin	New pump.fun tokens, minimal record
/events/tokens/new/detailed	new_coin_detailed	New tokens with the complete metadata record
/events/tokens/graduated	graduated	Tokens graduating off their bonding curve, with their new pool
/events/tokens/holders	holder_update	Holder count, dev / top-10 / sniper / bundler holdings
/events/tokens/lifecycle	coin_lifecycle	State changes with the full before/after record

Trades

Endpoint	Event	What it carries
/events/trades/unified	unified_trade	Every Solana trade — bonding curve and AMM — with market cap and fees in USD
/events/trades/pump	trade	Solana bonding-curve trades
/events/trades/pumpswap	pump_trade	PumpSwap trades
/events/mayhem	mayhem_trade, mayhem_state	Mayhem-mode trades and state changes

Market data

Endpoint	Event	What it carries
/events/prices	price	Per-token price ticks in USD and the chain's native asset
/events/marketcaps	marketcap	Batched market-cap ticker, ~100 token updates a second

EVM chains

Endpoint	Event	What it carries
/events/evm/trades	evm_trade	EVM trades with protocol, price, market cap, pool and trader
/events/evm/liquidity	evm_liquidity	Liquidity added or removed, with pool reserves
/events/evm/pools	evm_pool	New pools
/events/evm/tokens/created	evm_token_created	New EVM tokens
/events/evm/lifecycle	evm_lifecycle	EVM token state changes
/events/bridge	bridge_trade	Cross-chain swaps

Other

Endpoint	Event	What it carries
/events/livestreams	livestream	Livestreams starting, updating and ending, with viewer counts
/events/home-feed	home_feed	Influencer callouts, per chain

Wallets — require ?wallet=

Endpoint	Event	What it carries
/events/wallets/trades	wallet_trade	Every trade by the wallets you name
/events/wallets/balances	wallet_balance	Balance changes for those wallets

tokens/new, tokens/new/detailed, trades/pump and trades/pumpswap carry the same events as tokens/created and trades/unified, in pump.fun's own record formats — pick whichever shape suits you.

Everything

/events/all carries every event once: every stream above except the wallet streams, the four alternative formats just mentioned, and tokens/graduated, whose records tokens/lifecycle already carries. Nothing arrives, or is charged, twice.

Service endpoints

Endpoint	Type	Description
/feeds	HTTP GET	Every stream, its event type and accepted filters
/health	HTTP GET	Upstream status, subscriber count, throughput

🔧 Quick Start

This Actor only works in Standby mode. It cannot be run in normal mode.

Connecting via WebSocket

Every stream is a WebSocket endpoint: wss://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor/events/<stream>. Authentication is required with your Apify API token, either:

1. as a header: Authorization: Bearer <APIFY_TOKEN> (recommended for server-side clients), or
2. as a query parameter: ?token=<APIFY_TOKEN> (for browser WebSockets, which cannot set headers).

A plain HTTP GET on a stream path returns 426 Upgrade Required with the WebSocket URL to use.

Try it from the terminal

$npx wscat -c "wss://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor/events/tokens/created?token=<APIFY_TOKEN>"

< {"connection_id":"c1","endpoint":"tokens/created","event_type":"connected"}
< {"event_type":"token_created","feed":"tokens_created","data":{"mint":"7mxCuKWMrCdFK3U9byEEtbo835Bw4VtzfL3RUdqDpump","name":"DICE","symbol":"DICE",...}}

WebSocket (Node.js)

import WebSocket from 'ws';

const TOKEN = process.env.APIFY_TOKEN;
const ws = new WebSocket(
  'wss://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor/events/evm/trades?chain=base&minUsd=1000',
  { headers: { Authorization: `Bearer ${TOKEN}` } },
);

ws.on('open', () => console.log('connected'));

ws.on('message', (raw) => {
  const { event_type, feed, data } = JSON.parse(raw.toString());
  if (event_type === 'connected') return;

  const { trade } = data;
  console.log(`${trade.type} ${data.token_address} $${trade.amount_usd} on ${trade.protocol}`);
});

ws.on('close', (code) => {
  // 4002: the run reached its Max total charge — reconnecting would start a new run.
  if (code === 4002) return console.log('charge limit reached, not reconnecting');
  console.log(`closed (${code}), reconnect with a backoff`);
});

WebSocket (Python)

import asyncio, json, os
import aiohttp

URL = ("wss://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor"
       "/events/trades/unified?minMarketCap=50000")

async def main():
    headers = {"Authorization": f"Bearer {os.environ['APIFY_TOKEN']}"}
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.ws_connect(URL, heartbeat=30) as ws:
            async for message in ws:
                if message.type != aiohttp.WSMsgType.TEXT:
                    continue
                payload = json.loads(message.data)
                if payload.get("event_type") == "connected":
                    continue
                trade = payload["data"]
                print(trade["type"], trade["mintAddress"], trade["amountUsd"])

asyncio.run(main())

Follow a wallet (copy-trading)

npx wscat -c "wss://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor/events/wallets/trades\
?wallet=7nU6wgiAWLpf8vnMdPrUZrRXFAUKEbYWDpeX9CyhV3Ea&token=<APIFY_TOKEN>"

🎛️ Filters

Query parameters, freely combined. Each stream accepts the filters its records carry the data for — GET /feeds lists them per stream. A filter the stream cannot apply, or a parameter it does not know, is refused with a 400 instead of being silently ignored.

mint, chain and wallet narrow the upstream subscription wherever the stream allows it; every other filter is applied on the server. Either way you receive — and pay for — only the records that pass. A record passes only when every filter you set holds for it: with minUsd, a record that has no USD value does not pass.

Filter	Example	Notes
mint	?mint=ByL5…pump,8EK8…pump	Token addresses, comma separated. Up to 300 addresses per connection, mints and wallets together — about as many as a URL can carry; to follow more, split them over several connections (the Python client does this for you)
chain	?chain=base,bsc	solana, ethereum, base, bsc, hyperevm, ink, or a CAIP-2 id such as eip155:4663
wallet	?wallet=7nU6…V3Ea	Wallet streams only, where it is required
type	?type=buy	buy or sell on trade streams; add or remove on evm/liquidity
minUsd / maxUsd	?minUsd=1000	Trade, liquidity or swap size in USD
minMarketCap / maxMarketCap	?minMarketCap=50000	Token market cap in USD
protocol	?protocol=UNISWAP_V4	DEX protocol, on the EVM streams

Examples

# Large Base-chain trades only (on /events/evm/trades)
?chain=base&minUsd=5000

# Buys on tokens above $50k market cap
?type=buy&minMarketCap=50000

# Two specific tokens
?mint=ByL5zhWG6Q4abqQkJZgyWC4Kj7hSaWXyUwezAwYDpump,8EK8dTQcpqupDVYM8jE2avebpHFgqWw25VojBWxpump

🐍 Ready-made Client

For a terminal-ready setup, use the Pump.fun Monitor Client — a Python client that handles the connection, reconnection, filtering and output for you.

🔗 pumpfun-monitor-client

Features:

• 💻 CLI: python main.py -e evm/trades --chain base --min-usd 1000
• 📡 Multi-stream: follow several streams at once, each with its own connection
• 🔄 Auto-reconnect: backoff that widens on repeated failure
• 🛑 Respects your budget: stops at the charge limit instead of reconnecting into a new run
• 📄 JSONL output: append-only, one record per line
• 🎨 Readable output: every record type formatted for the terminal
• 📊 Live statistics: uptime, per-type counts, throughput

⚡ Performance & Scaling

This Actor runs on 512 MB in Standby, and that is enough for everything it serves. The unfiltered /events/all stream, around 1,500 records a second at busy times, keeps up comfortably; in testing a single run served every stream at once — about 2,700 records a second over 26 connections — with room to spare.

On Apify, memory also sets the CPU share, and you pay for it, so there is normally no reason to raise it. If you hold a very large number of connections on one run and want more headroom, you can.

How to increase memory (Standby mode)

Standby uses pre-configured instances, so memory cannot be set per request. Create a Task instead:

1. Go to Apify Console → Actors → pump-fun-real-time-monitor
2. Click Create Task
3. Name it (e.g. pumpfun-monitor-1gb)
4. In the Task configuration open the Standby tab
5. Set Memory higher (up to 1024 MB)
6. Enable Standby and copy the Task Standby URL
7. Use that URL in your application

Tip: more memory means more CPU and a higher platform cost on your side; the default is sized so that you should not need it.

🔍 Health Monitoring

$curl "https://muhammetakkurtt--pump-fun-real-time-monitor.apify.actor/health?token=<APIFY_TOKEN>"

{
  "status": "ok",
  "liveData": true,
  "uptimeSec": 3162,
  "subscribers": 4,
  "activeStreams": { "evm_trades": 2, "trades_unified": 1, "prices": 1 },
  "eventsDelivered": 2841903
}

status is ok while live data is flowing and reconnecting during a brief interruption — the streams stay open and resume by themselves.

📊 Event Data Structures

token_created — new token, any launchpad

{
  "mint": "7mxCuKWMrCdFK3U9byEEtbo835Bw4VtzfL3RUdqDpump",
  "name": "DICE", "symbol": "DICE",
  "creator": "HgocuDwYvUMkgfn7NefAV2C7LBTDuBCSHiCTHwGhSsVA",
  "program": "pump", "platform": null,
  "bonding_curve": "6LfbVTy5rENW7d51SoNByKeETZWUtmXfLeV1yWcjqUJ8",
  "metadata_uri": "https://ipfs.io/ipfs/QmXDf6z4qQNSMwB4V9PMt9A9aTF5Mk2fXVW2XCLLBwUKzn",
  "created_timestamp": "2026-09-22T20:00:59+00:00",
  "complete": false, "supply": 1000000000000000
}

graduated — a token leaving its bonding curve for its PumpSwap pool. before and after are the full coin record; the pool appears in after.

{
  "mint": "2AfUkX9kj6xWMaTAJGygjZ2rGymeSE7j2n3UVxxbpump",
  "eventType": "COIN_LIFECYCLE_EVENT_TYPE_COIN_MIGRATED",
  "before": { "pumpSwapPool": null, "…": "…" },
  "after": {
    "mint": "2AfUkX9kj6xWMaTAJGygjZ2rGymeSE7j2n3UVxxbpump",
    "name": "doggi", "symbol": "doge",
    "creator": "7iFZwiffvkXvR4MPhVDkxkUGBXZPFDprj9erf7wWnENq",
    "bondingCurve": "4r1RQqZaPaEAqEtpWsamExiSq9vHRZNdUb1RGmQFgcrB",
    "complete": true,
    "pumpSwapPool": "5pPGkGGL77yC4pRF9pkELkkZNDNjifQukSGqGoFzuqee",
    "createdTimestamp": "1789658500000", "updatedAt": "1790162620"
  }
}

holder_update — rug-risk metrics

{
  "mintId": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "numHolders": "415928",
  "devHoldingAmount": "0",
  "topTenHoldersOwnedAmount": "2428983344.0177",
  "snipersOwnedAmount": "0",
  "bundlersOwnedAmount": "0"
}

unified_trade — Solana trade

{
  "mintAddress": "Ge87EtsjwRQbHaqQmKRno69RFTwh9bfSsm99XNxTpump",
  "type": "sell", "program": "pump_amm", "isBondingCurve": false,
  "amountSol": "0.421467868", "amountUsd": "49.800144722638392648",
  "priceUsd": "0.0050168173272614963840834541",
  "marketCapUsd": "5016817.3272614963840834541335",
  "userAddress": "4EJcnEqBsfCEbJAgHJHkgAy7NADp7Gs5ZS1KKZkuVngY",
  "poolAddress": "5PGhKctym6odbHGo2tKMST2AjmJsb2uZBQrKkn4ZuFT5",
  "lpFeeUsd": "0.100251966515433786",
  "protocolFeeUsd": "0.025063021168562718",
  "timestamp": "2026-09-22T20:01:58+00:00"
}

evm_trade — EVM trade

{
  "token_address": "0x29cC30f9D113B356Ce408667aa6433589CeCBDcA",
  "chain_id": "eip155:8453", "chain_family": "EVM",
  "block_timestamp": "2026-09-22T20:01:43Z",
  "identity": { "tx_hash": "0xdd7f2ea2…d8d646", "block_id": 51658978 },
  "trade": {
    "type": "BUY", "protocol": "PANCAKESWAP_V3",
    "price_usd": "0.0573733528860813",
    "amount_usd": "12.17397",
    "market_cap_usd": "13137350.343854895",
    "pool_address": "0x83f3ACa29Bc79B048B99C56013475570acc97ccF",
    "trader_address": "0xE6B82c6EcCDfB2d6BC55bb11A61bAE5AB2c3f807"
  }
}

evm_liquidity — liquidity move

{
  "token_address": "0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82",
  "chain_id": "eip155:8453",
  "liquidity": {
    "type": "REMOVE", "protocol": "AERODROME_SLIPSTREAM",
    "amount_usd": "782.234242397039",
    "provider_address": "0xac7EA8c517B826Ff1512252d3A90e88CD26e69bd",
    "pool": {
      "liquidity_usd": "373957.65470956534",
      "reserve_base_usd": "123620.04840286082",
      "reserve_quote_usd": "250337.60630670452"
    }
  }
}

price and marketcap

{ "kind": "token", "chain": "solana",
  "token": "8Byg9wi43TNzgJpYta6UXxPz3LPe8v6ZwvmWWoWQpump",
  "priceUsd": 9.480512255151445e-06, "priceNative": 8.020390987220827e-08,
  "nativePriceUsd": 118.20511332,
  "pool": "DbRVBRLni7dk9VQQffn9NEL43LbADf5EJYdJnsiLQWaj",
  "timestamp": "2026-09-22T20:01:30Z" }

A chain's own asset price arrives as "kind": "native" with nativePriceUsd and no token.

{ "mint": "3rGSot1DANawxJYQPhYuNPxrLwX3wjLqnqfRWQSPF7FE",
  "marketCapUsd": 4569.8053019634235, "updatedAt": "2026-09-22T20:01:36Z" }

🚨 Connection Management

Frames. One JSON object per WebSocket message. The first is the handshake:

{ "event_type": "connected", "connection_id": "c1", "endpoint": "evm/trades" }

Every record after it:

{ "event_type": "evm_trade", "feed": "evm_trades", "data": { "…": "…" } }

Keep-alive. The server sends standard WebSocket ping frames; any WebSocket library answers them for you. A connection that stops answering is closed after two minutes, so a client that vanished without closing — a laptop gone to sleep — does not keep the run going.

Close codes

Code	Reason	What to do
4002	charge limit reached	Stop. The run hit its Max total charge; reconnecting starts a new run with a new budget.
1009	Backpressure limit reached	Reconnect. Your client fell behind the stream and records were piling up unread — read faster or narrow the stream with filters.
1001	server restarting or stream interrupted	Reconnect.
4003	billing unavailable	Reconnect after a short wait.

Rejected connections get a regular HTTP response with a JSON error before any upgrade: 404 for an unknown stream; 400 for an unknown parameter, a filter the stream cannot apply, a value that cannot be read (a malformed address, more than 300 addresses, minUsd above maxUsd) or a wallet stream without wallet; 503 while the service is starting, closing or at its subscriber limit.

Behaviour

• Streams are opened upstream when the first subscriber asks for them and closed when the last one leaves
• A brief upstream interruption is recovered automatically with the subscriptions restored; your connection stays open
• Reconnect with a backoff on any close other than 4002

💰 Cost

Two events are charged:

• Actor start — once per run. A Standby run starts with your first connection and stops after five idle minutes; a connection after that starts, and is charged for, a new run.
• Record — one per record sent to you. The handshake and keepalives are free. A record counts when it leaves the server, so records still in flight when a connection drops have been paid for.

Filters are the lever. Filtered-out records are never sent and never charged, so a narrowed stream costs only what you asked for. /events/all unfiltered carries roughly 1,500 records a second; a stream narrowed to a handful of tokens carries a few.

Set Max total charge on the run. The Actor stops sending at exactly that budget and closes the streams with code 4002, so a firehose left open overnight cannot surprise you.

🎯 Use Cases

💹 Trading & Sniping

• New launch detection: catch tokens seconds after creation, on every launchpad, on Solana and EVM
• Rug-risk screening: developer, sniper, bundler and top-10 holdings as they change
• Copy-trading: follow specific wallets' trades in real time
• Graduation plays: know the moment a token completes its bonding curve

📊 Analytics & Research

• Cross-chain market data: Solana and seven EVM chains from one stream
• Liquidity analysis: additions and removals with pool reserves
• Price databases: per-token ticks and a batched market-cap feed
• Launchpad comparison: token creations carry their platform and program

🔔 Monitoring & Alerts

• Whale alerts: minUsd on any trade stream
• Liquidity-pull alerts: evm/liquidity with type=REMOVE
• Mayhem tracking: mode trades and state changes
• Dashboards: feed a live view without polling

🛠️ Development & Integration

• Trading bots: sub-second event delivery with source-side filtering
• Telegram / Discord bots: pipe filtered streams straight into alerts
• Indexers: one connection instead of a polling loop