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?

Doing this yourself against a raw Solana RPC node means running or renting infrastructure, subscribing to program logs, decoding instruction data for the pump.fun program, and handling reconnects and backfills. You pay for compute units or credits, and you maintain a decoder every time the program changes.

Anaxer removes that entire layer. It watches the chain, parses pump.fun and PumpSwap activity, and emits the same clean event shape over streams and REST. You consume JSON and focus on your strategy.

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.

What does a launch event look like?

Every new token produces a created event. Amounts and supplies are strings (never floats), timestamps are ISO 8601 UTC, and every event carries a Solana slot for sequencing.

PUMP

pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn

🎉 Just now

WebsiteSocial

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",
  "platform": "pumpfun",
  "mint": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "name": "Pump",
  "symbol": "PUMP",
  "tokenSupply": "1000000000",
  "socials": {
    "website": "https://pump.fun",
    "x": "https://x.com/pumpfun"
  },
  "creator": "7BvK3nF2HxR8mP5qW9tL4sY6jC1dA8eU3gN2fM5A1zXY",
  "slot": 309812345,
  "timestamp": "2026-06-27T07:21:04Z"
}

The mint, name, symbol, and socials above are from the real PUMP token. creator, slot, and timestamp are illustrative - your stream will carry the actual on-chain values for each launch.

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?

The server sends { "type": "ping" } roughly every 30 seconds. Reply with { "type": "pong" } within 10 seconds or the connection closes. Most production clients also implement exponential-backoff reconnects. The official SDKs handle heartbeats, reconnection, and gap recovery for you - see SDKs.

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 watch launches and act in plain English via the Anaxer MCP server.

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, 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.