How to track pump.fun token launches in real time

Tracking pump.fun token launches in real time means subscribing to a live feed of new-token events instead of polling the chain. With Anaxer you open one WebSocket, subscribe to the creations channel, and receive a structured JSON event the moment any pump.fun token is minted - no RPC nodes, Geyser plugins, program IDs, or log decoding.

Who is this guide for?

This guide is for developers who need new pump.fun tokens the instant they launch:

• Sniper and trading bots that must act in the first seconds
• Launch dashboards and token explorers
• Alerting and notification systems
• Analytics and research platforms
• Copy-trading and wallet-tracking tools

If you only need occasional snapshots rather than a live feed, the REST creations endpoint is simpler than a WebSocket. If you need a live feed with zero infrastructure, read on.

Why is tracking pump.fun launches hard with raw RPC?

Against a raw Solana RPC you run or rent infrastructure, subscribe to program logs, decode the pump.fun instruction data, and maintain that decoder every time the program changes - all metered by compute units or credits. Anaxer removes that layer: it parses pump.fun and PumpSwap activity and emits a clean event over streams and REST, so you consume JSON and focus on your strategy. For how this compares to decoding a raw Yellowstone gRPC firehose yourself, see raw gRPC or parsed events.

How do I connect to the creations stream?

Open a WebSocket to the stream endpoint with your API key, then send a subscribe message for the creations channel.

const ws = new WebSocket("wss://api.anaxer.com/v1/stream?key=YOUR_KEY");

ws.addEventListener("open", () => {
  ws.send(JSON.stringify({ subscribe: "creations" }));
});

ws.addEventListener("message", (event) => {
  const msg = JSON.parse(event.data);
  if (msg.type === "created") {
    console.log("New launch:", msg.symbol, msg.mint);
  }
});

The server acknowledges your subscription with { "type": "subscribed", "channel": "creations" }, then begins streaming events.

To receive socials with the launch event, subscribe in enrichment mode (and optionally skip Mayhem-mode creates):

ws.send(JSON.stringify({
  subscribe: "creations",
  filters: { enriched: true, excludeMayhem: true }
}));

Fast mode (omit enriched or set it false) delivers immediately — often with socials still null. Enriched mode delivers the same created event type only after off-chain metadata fetch succeeds; failed or missing metadata never produces an enriched frame. uri is the on-chain metadata URI in both modes.

What does a launch event look like?

Every new token produces a created event. Timestamps are epoch milliseconds, and every event carries a Solana slot for sequencing plus a transaction signature.

PUMP

pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn

🎉 Just now

WebsiteSocialTelegram

Here is the same event as raw JSON — a real example from the official PUMP token (pumpCmXq...9Dfn), the pump.fun platform token:

{
  "type": "created",
  "source": "pump_fun",
  "mint": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "name": "Pump",
  "symbol": "PUMP",
  "creator": "7BvK3nF2HxR8mP5qW9tL4sY6jC1dA8eU3gN2fM5A1zXY",
  "uri": "https://ipfs.io/ipfs/QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG",
  "mayhemMode": false,
  "socials": {
    "website": "https://pump.fun",
    "twitter": "https://x.com/pumpfun",
    "telegram": "https://t.me/pumpfun"
  },
  "signature": "3Nk7pT2xQeB8mVdR4wLc9fJhY6zS1nGtK5uA3oXvW7qE2mCpH8dRzL4nJb9FgKtR5zXvY2mNc8hAeQ",
  "slot": 309812345,
  "timestamp": 1751008864000
}

The mint, name, symbol, and socials above are from the real PUMP token (enriched-mode shape). creator, uri, slot, signature, and timestamp are illustrative - your stream will carry the actual on-chain values for each launch. In fast mode, expect socials fields to often be null.

How do I recover missed launches after a disconnect?

WebSocket connections drop - Wi-Fi blips, deploys, server restarts. The pattern is: remember the last slot you saw, and after reconnecting, backfill the gap with a single REST call before trusting the live stream again.

curl "https://api.anaxer.com/v1/creations?since=309812345&limit=100" \
  -H "Authorization: Bearer YOUR_KEY"

The REST endpoint returns the same event shape as the stream, plus a nextCursor for pagination. Because streams and REST share one data model, your parsing code does not change between live and backfill paths. See the creations stream reference and the REST creations endpoint for the full parameter list.

How do I keep the connection alive?

Reply to the server's ping with a pong within 10 seconds and use backoff reconnects - the Solana WebSocket streams guide covers heartbeats, close codes, and reconnection in full, and the official SDKs handle all of it for you.

Troubleshooting: why am I not seeing launches?

A few issues account for almost every "no events" report:

• No events after connecting. Send the { subscribe: "creations" } message inside the open handler, not before the socket is ready, and confirm you received the { "type": "subscribed" } acknowledgement.
• Connection closes after ~40 seconds. You are not answering heartbeats. Reply to every ping with a pong within 10 seconds.
• Duplicate events after a reconnect. Deduplicate by mint plus slot, and backfill with since set to the last slot you processed rather than replaying from scratch.
• Falling behind under heavy launch volume. Do not do slow work in the message handler. Push events onto a queue and process them off the socket thread so a slow consumer never stalls the connection.

What can I build with launch data?

• Sniper and trading bots that evaluate a token the instant it launches.
• Launch dashboards and alerts that surface new tokens by creator, name, or socials.
• AI agents that screen launches in plain English via the Anaxer MCP server - see how to build a Solana trading agent with Claude and Cursor.

Because the creations stream is included on the free plan, you can prototype any of these without a card. The pump.fun API covers the full ecosystem - launches, graduations, PumpSwap trades, and prices — each on its own stream. When you are ready for trades and prices (wallet transfers coming soon), compare options on the pricing page.

Next steps

Open a free key, connect to creations, and log your first launch event. Then layer in graduations to catch tokens moving to PumpSwap, and read the Solana streaming guide for production-grade connection handling.