PumpFun Token Creation

Real-time notifications when new tokens are created on the PumpFun platform.

Overview

The PumpFun token creation stream provides instant alerts for new token launches on the PumpFun platform.

Connection

WebSocket Endpoint:

wss://api.nolimitnodes.com/socket?apikey=YOUR_API_KEY

Subscription

Subscribe Request

{
    "method": "dataSubscribe",
    "params": {
        "referenceId": "PUMPFUN_CREATE_TOKENS",
        "streams": [
            {
                "stream": "pumpFunCreateTokensSubscribe",
                "params": {
                    "event_type": "create_coin",
                    "creator": "optional_creator_address"
                }
            }
        ]
    },
    "id": 1
}

Filter Parameters

Parameter	Type	Required	Description
name	string	No	Filter by token name
symbol	string	No	Filter by token symbol
mint	string	No	Filter by token mint address
user	string	No	Filter by user/creator wallet address
creator	string	No	Filter by creator wallet address

Response Messages

Subscription Confirmation

{
    "status": "Subscribed to pumpFunCreateTokens",
    "subscription_id": "07c97c5d-ab7c-4b93-973e-1355bd73db65",
    "stream": "pumpFunCreateTokensSubscribe",
    "reference_id": "PUMPFUN_CREATE_TOKENS"
}

Token Creation Event

{
    "method": "pumpFunCreateTokensSubscribe",
    "subscription_id": "eec5aebb-2184-44e8-aea8-3b2971666a8f",
    "result": {
        "name": "Recap Rewards",
        "symbol": "RR",
        "uri": "https://ipfs.io/ipfs/QmdbQP3FP1nNpoBhk2YGcGCitr1byLCJn7WcZUByWyigr8",
        "mint": "6WauKcRdemKpxPS94cb7xWK6KTWHjpFcA5XLQUXKpump",
        "bondingCurve": "63R7cGgbbvC8ty5CsTYY8yisw81JKVFwC5xMBmF73yba",
        "user": "2MN1hF8iy9fHUsPizmwLaswWc5dEFZfMmUCiRchNxwgh",
        "creator": "2MN1hF8iy9fHUsPizmwLaswWc5dEFZfMmUCiRchNxwgh",
        "timestamp": "1757905029",
        "virtualTokenReserves": "1073000000000000",
        "virtualSolReserves": "30000000000",
        "realTokenReserves": "793100000000000",
        "tokenTotalSupply": "1000000000000000",
        "block_num": "366897920",
        "block_time": "1757905029",
        "program_id": "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P",
        "type": "create_token"
    }
}

Field Descriptions

• name: Token name
• symbol: Token symbol
• uri: Metadata URI (IPFS link)
• mint: Token mint address
• bondingCurve: Bonding curve address
• user: User wallet address
• creator: Creator wallet address
• timestamp: Unix timestamp
• virtualTokenReserves: Virtual token reserves
• virtualSolReserves: Virtual SOL reserves
• realTokenReserves: Real token reserves
• tokenTotalSupply: Total token supply
• block_num: Block number
• block_time: Block timestamp
• program_id: PumpFun program ID
• type: Event type ("create_token")

Unsubscribe

To stop receiving token creation events, use the dataUnsubscribe method with the subscription ID:

Unsubscribe Request

{
    "method": "dataUnsubscribe",
    "params": {
        "subscriptionIds": ["your_subscription_id_here"],
        "referenceId": "UNSUB_REF"
    }
}

Unsubscribe Response

{
    "status": "Unsubscribed from pumpFunCreateTokens",
    "subscription_id": "your_subscription_id_here",
    "stream": "pumpFunCreateTokensSubscribe",
    "reference_id": "UNSUB_REF"
}

Code Examples

JavaScript/Node.js

const WebSocket = require('ws');

class TokenLaunchMonitor {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.ws = null;
    }

    connect() {
        this.ws = new WebSocket(`wss://api.nolimitnodes.com/socket?apikey=${this.apiKey}`);

        this.ws.on('open', () => {
            console.log('Connected to token creation stream');
            this.subscribe();
        });

        this.ws.on('message', (data) => {
            const message = JSON.parse(data);
            if (message.method === 'pumpFunCreateTokensSubscribe') {
                this.processNewToken(message.result);
            }
        });
    }

    subscribe() {
        this.ws.send(JSON.stringify({
            method: 'dataSubscribe',
            params: {
                referenceId: 'PUMP_CREATE',
                streams: [{
                    stream: 'pumpFunCreateTokensSubscribe',
                    params: {}
                }]
            }
        }));
    }

    processNewToken(token) {
        console.log('\n🚀 NEW TOKEN CREATED');
        console.log('═══════════════════════════════════');
        console.log(`Name: ${token.name}`);
        console.log(`Symbol: ${token.symbol}`);
        console.log(`Mint: ${token.mint}`);
        console.log(`Creator: ${token.creator.slice(0, 8)}...`);
        console.log(`Bonding Curve: ${token.bondingCurve.slice(0, 8)}...`);
        console.log(`Block: ${token.block_num}`);

        const virtualSol = parseInt(token.virtualSolReserves) / 1e9;
        const realTokens = parseInt(token.realTokenReserves) / 1e9;

        console.log(`\nReserves:`);
        console.log(`  Virtual SOL: ${virtualSol.toFixed(2)} SOL`);
        console.log(`  Real Tokens: ${realTokens.toLocaleString()}`);

        if (token.uri) {
            console.log(`\nMetadata: ${token.uri}`);
        }
    }
}

// Usage
const monitor = new TokenLaunchMonitor('YOUR_API_KEY');
monitor.connect();

Python

import json
import asyncio
import websockets
from datetime import datetime

class TokenLaunchMonitor:
    def __init__(self, api_key):
        self.api_key = api_key
        self.uri = f"wss://api.nolimitnodes.com/socket?apikey={api_key}"

    async def connect(self):
        self.websocket = await websockets.connect(self.uri)
        print("Connected to token creation stream")

    async def subscribe(self):
        subscription = {
            "method": "dataSubscribe",
            "params": {
                "referenceId": "PUMP_CREATE",
                "streams": [{
                    "stream": "pumpFunCreateTokensSubscribe",
                    "params": {}
                }]
            }
        }
        await self.websocket.send(json.dumps(subscription))

    async def listen(self):
        async for message in self.websocket:
            data = json.loads(message)
            if data.get('method') == 'pumpFunCreateTokensSubscribe':
                await self.process_token_creation(data['result'])

    async def process_token_creation(self, token):
        print(f"\n{'='*50}")
        print(f"🚀 NEW TOKEN: {token['name']} ({token['symbol']})")
        print(f"{'='*50}")

        print(f"\n📋 Token Details:")
        print(f"  Mint: {token['mint'][:10]}...")
        print(f"  Creator: {token['creator'][:8]}...")
        print(f"  Bonding Curve: {token['bondingCurve'][:8]}...")
        print(f"  Block: {token['block_num']}")
        print(f"  Timestamp: {token['timestamp']}")

        # Calculate reserves
        virtual_sol = int(token['virtualSolReserves']) / 1e9
        real_tokens = int(token['realTokenReserves']) / 1e9
        total_supply = int(token['tokenTotalSupply']) / 1e9

        print(f"\n💰 Token Economics:")
        print(f"  Total Supply: {total_supply:,.0f}")
        print(f"  Virtual SOL: {virtual_sol:.2f} SOL")
        print(f"  Real Tokens: {real_tokens:,.0f}")

        if token.get('uri'):
            print(f"\n🔗 Metadata URI: {token['uri']}")

async def main():
    monitor = TokenLaunchMonitor("YOUR_API_KEY")
    await monitor.connect()
    await monitor.subscribe()
    await monitor.listen()

if __name__ == "__main__":
    asyncio.run(main())

Best Practices

1. Token Due Diligence

• Verify Metadata: Immediately fetch and validate token metadata from the IPFS URI
• Analyze Bonding Curve: Check virtual/real reserves and initial liquidity (flag if <10 SOL)
• Creator Background: Track creator wallet history and previous token launches for patterns

2. Risk Assessment

• Authority Status: Monitor mint and freeze authority settings for security risks
• Reserve Analysis: Calculate liquidity ratios and flag suspicious bonding curve setups
• Launch Patterns: Identify prolific creators or unusual launch timing as potential red flags

3. Performance Optimization

• Filter Strategically: Use creator or liquidity filters to focus on relevant tokens
• Cache Metadata: Store frequently accessed token data and creator statistics locally
• Batch Processing: Group multiple token analysis operations for efficiency

Related Documentation

• PumpFun Trade Events
• Token Creations
• Liquidity Pools