Alpha Signals API

Receive scored Pump.fun token observations and updates through a persistent WebSocket. Alpha access uses your existing PumpFunData account, API key, and credit balance.

See Alpha Signals pricing and performance or follow the Python integration guide.

Alpha alerts do not guarantee bonding or profits; past performance does not guarantee future results.

One WebSocket connection per subscription. A second connection returns HTTP 409.

1. Get your key and activate access

Activate and renew Alpha on the website's account page. Then use your existing API key to connect your bot, or generate one on that page if needed. No auto-renewal.

Your WebSocket connection closes when access expires.

2. Connect over WebSocket

Connect to wss://api.pumpfundata.com/alpha/alerts and pass your customer API key in the X-API-Key handshake header. Keep the key server-side. Ordinary HTTP requests to this endpoint return 426.

Optionally use wss://api.pumpfundata.com/alpha/alerts?replay=100 to replay up to 100 recent messages, oldest first, then continue live. Deduplicate with alert_id. Max 5 replay connections per minute per account.

For Python 3.10+, install websockets 14 or newer and set PUMPFUNDATA_API_KEY in your shell environment. A .env file requires loading into the process environment; Python does not load it automatically.

pip install "websockets>=14"
export PUMPFUNDATA_API_KEY="pfd_your_customer_key"
python alpha_client.py

Save this as alpha_client.py:

import asyncio
import json
import os
from collections import deque

from websockets.asyncio.client import connect
from websockets.exceptions import ConnectionClosed, InvalidStatus

URL = "wss://api.pumpfundata.com/alpha/alerts"
# Append "?replay=100" to URL for recent updates on each connection.
API_KEY = os.environ["PUMPFUNDATA_API_KEY"]

async def main():
    seen = deque(maxlen=100)
    try:
        async for ws in connect(
            URL,
            additional_headers={"X-API-Key": API_KEY},
            ping_interval=20,
            ping_timeout=20,
        ):
            try:
                async for message in ws:
                    alert = json.loads(message)
                    if alert["alert_id"] in seen:
                        continue
                    print(alert["token_mint"], alert["score"], flush=True)
                    # Pass the alert to your own analysis here.
                    seen.append(alert["alert_id"])
            except ConnectionClosed:
                # Reconnect using the same URL, including optional replay.
                continue
    except InvalidStatus as error:
        print(f"Connection rejected: HTTP {error.response.status_code}")
        print("Check your API key, access expiry, and existing connection.")

asyncio.run(main())

This uses the library's reconnection support for transient failures. Invalid credentials, expired access, or an existing connection require correction. WebSocket protocol pings are supported; the text heartbeat ping receives pong. Other client messages close this receive-only connection.

3. Schema reference

Each WebSocket message is one JSON object. A token can have multiple observations, including updates in the same second. Use alert_id as identity; version only describes the schema. The example below uses illustrative values and placeholder addresses.

{
  "alert_id": "example-observation-01",
  "token_mint": "<token_mint>",
  "pool_address": "<pool_address>",
  "name": "Example",
  "symbol": "EX",
  "uri": "https://example.com/token.json",
  "first_alerted": 1791326400,
  "last_alerted": 1791326460,
  "score": 1.819,
  "score_timestamp": 1791326460,
  "bonded_at": null,
  "version": 1
}

Field	Type	Description
alert_id	string	Unique observation ID. Repeated delivery can be identified using this field.
token_mint	string	Token mint address.
pool_address	string	Pool address associated with this observation.
name	string	Token name, with a fallback when unavailable.
symbol / uri	string or null	Token symbol and metadata URI if available; otherwise null.
first_alerted	integer	Original first-alert time for this token, in Unix seconds.
last_alerted	integer	Most recent alert time reported for this token, in Unix seconds.
score	number	Our algorithm's numeric assessment at score_timestamp. It is not a probability but you can use it as an input feature.
score_timestamp	integer	Time of the score assessment, in Unix seconds.
bonded_at	integer or null	Reported bonding time in Unix seconds, or null when not reported.
version	integer	Packet schema version. Not a timestamp or observation sequence number.

A null bonded_at means that this observation does not report a bonding time. It does not erase a bonding time reported by an earlier observation. Store received messages in your application if you need your own history.

4. Connection errors

401: Missing or invalid customer authentication.
400: Invalid replay count; use an integer from 1 to 100.
403: No active Alpha access, or a disallowed browser origin.
409: This account already has an open WebSocket. Close it before connecting another.
426: Use a WebSocket client instead of a regular HTTP request to /alpha/alerts.
429: Request rate limit exceeded. Slow down connection or API retries.

A close code of 1008 can mean expired access, a regenerated API key, or an unsupported client message. Reconnect with your new key after regeneration, or renew access when expired. Add the replay parameter on each connection when using catch-up.

Ready to receive alerts?

Activate access with your existing credits and use your customer API key.

Open Alpha access in your account →