Historical Token Deployments API

What you'll learn

• How to fetch historical token deployment data
• Query deployments by wallet address
• Implement pagination for large datasets
• Analyze deployment patterns and metadata

Introduction

The Historical Token Deployments API enables you to retrieve and analyze past token deployment data. This API is specifically designed for historical analysis - for real-time deployment notifications, please refer to our WebSocket Streams API.

Access Requirements

• Valid API key (visit https://app.callstatic.com for tier information)
• Rate limits and data access vary by subscription tier

Authentication

All requests require a Bearer token in UUID format:

Authorization: Bearer your-api-key-here

Base URL

https://api.callstaticrpc.com/pumpfun/v1

Data Structure

The API returns detailed information about token deployments:

Response Structure

{
    "success": true,
    "data": [
        {
            "id": "550e8400-e29b-41d4-a716-446655440000",
            "deployer": "AaA2aA5aA8aA4aA7aA1aA9aAa3aA6aA2aA8aA5aA1a",
            "deploy_timestamp": 1679616000000,
            "mint": "BbB3bB7bB2bB9bB4bB8bB1bBb5bB2bB6bB3bB9bB4bB",
            "name": "Sample Token",
            "symbol": "SMPL",
            "decimals": 9,
            "initial_supply": 1000000000000,
            "total_supply": 1000000000000,
            "description": "A sample token deployment",
            "mint_authority": "AaA9aA3aA6aA2aA8aA4aA7aAa1aA5aA9aA3aA6aA2a",
            "freeze_authority": "AaA7aA1aA4aA8aA2aA6aA9aAa3aA7aA1aA4aA8aA5a",
            "twitter": "@sample_token",
            "telegram": "t.me/sample_token",
            "website": "https://sample-token.com",
            "uri": "https://arweave.net/sample-token-metadata",
            "image_uri": "https://arweave.net/sample-token-image",
            "is_complete": true,
            "complete_timestamp": 1679616100000
        }
    ],
    "has_more": false,
    "total": 1
}

TypeScript

import axios from 'axios';

interface TokenDeployment {
id: string;
deployer: string;
deploy_timestamp: number;
mint: string;
name: string;
symbol: string;
decimals: number;
initial_supply: number;
total_supply: number;
description: string;
mint_authority: string;
freeze_authority: string;
twitter?: string;
telegram?: string;
website?: string;
uri: string;
image_uri: string;
is_complete: boolean;
complete_timestamp?: number;
}

interface PaginatedResponse {
success: boolean;
data: TokenDeployment[];
has_more: boolean;
total: number;
}

class TokenHistoricalClient {
private readonly baseUrl = 'https://api.callstaticrpc.com/pumpfun/v1';

    constructor(private readonly apiKey: string) {}

    async getWalletDeployments(params: {
        wallet: string;
        limit?: number;
        offset?: number;
    }): Promise<PaginatedResponse> {
        const response = await axios.get(`${this.baseUrl}/historical/deployments`, {
            headers: {
                Authorization: `Bearer ${this.apiKey}`,
                'Content-Type': 'application/json'
            },
            params: {
                wallet: params.wallet,
                limit: params.limit,
                offset: params.offset
            }
        });

        return response.data;
    }

    async getAllDeployments(wallet: string): Promise<TokenDeployment[]> {
        let allDeployments: TokenDeployment[] = [];
        let offset = 0;
        const limit = 100;

        while (true) {
            const response = await this.getWalletDeployments({
                wallet,
                limit,
                offset
            });

            allDeployments = [...allDeployments, ...response.data];

            if (!response.has_more) break;
            offset += limit;
        }

        return allDeployments;
    }

}

JavaScript

const axios = require('axios');

class TokenHistoricalClient {
    constructor(apiKey) {
        this.baseUrl = 'https://api.callstaticrpc.com/pumpfun/v1';
        this.apiKey = apiKey;
    }

    async getWalletDeployments({ wallet, limit, offset }) {
        const response = await axios.get(`${this.baseUrl}/historical/deployments`, {
            headers: {
                Authorization: `Bearer ${this.apiKey}`,
                'Content-Type': 'application/json'
            },
            params: {
                wallet,
                limit,
                offset
            }
        });

        return response.data;
    }

    async getAllDeployments(wallet) {
        let allDeployments = [];
        let offset = 0;
        const limit = 100;

        while (true) {
            const response = await this.getWalletDeployments({
                wallet,
                limit,
                offset
            });

            allDeployments = [...allDeployments, ...response.data];

            if (!response.has_more) break;
            offset += limit;
        }

        return allDeployments;
    }
}

Python

from typing import List, Dict, Any
import requests

class TokenHistoricalClient:
def **init**(self, api_key: str):
self.base_url = "https://api.callstaticrpc.com/pumpfun/v1"
self.api_key = api_key

    def get_wallet_deployments(
        self,
        wallet: str,
        limit: int = None,
        offset: int = None
    ) -> Dict[str, Any]:
        response = requests.get(
            f"{self.base_url}/historical/deployments",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            params={
                "wallet": wallet,
                "limit": limit,
                "offset": offset
            }
        )
        response.raise_for_status()
        return response.json()

    def get_all_deployments(self, wallet: str) -> List[Dict[str, Any]]:
        all_deployments = []
        offset = 0
        limit = 100

        while True:
            response = self.get_wallet_deployments(
                wallet=wallet,
                limit=limit,
                offset=offset
            )

            all_deployments.extend(response["data"])

            if not response["has_more"]:
                break

            offset += limit

        return all_deployments

[Analysis scenarios section with properly indented code...]

TypeScript

async function analyzeDeploymentTimeline(wallet: string) {
    const client = new TokenHistoricalClient('your-api-key');
    const deployments = await client.getAllDeployments(wallet);

    // Group deployments by month
    const monthlyDeployments = deployments.reduce((acc, dep) => {
        const month = new Date(dep.deploy_timestamp).toISOString().slice(0, 7);
        acc[month] = (acc[month] || 0) + 1;
        return acc;
    }, {});

    return {
        totalDeployments: deployments.length,
        deploymentsByMonth: monthlyDeployments,
        firstDeployment: new Date(Math.min(...deployments.map(d => d.deploy_timestamp))),
        lastDeployment: new Date(Math.max(...deployments.map(d => d.deploy_timestamp))),
        completionRate: deployments.filter(d => d.is_complete).length / deployments.length
    };
}

TypeScript

async function analyzeSocialPresence(wallet: string) {
    const client = new TokenHistoricalClient('your-api-key');
    const deployments = await client.getAllDeployments(wallet);
  
    return {
        totalTokens: deployments.length,
        withTwitter: deployments.filter(d => d.twitter).length,
        withTelegram: deployments.filter(d => d.telegram).length,
        withWebsite: deployments.filter(d => d.website).length,
        withAllSocial: deployments.filter(d => 
            d.twitter && d.telegram && d.website
        ).length,
        socialUrls: deployments.map(d => ({
            name: d.name,
            twitter: d.twitter,
            telegram: d.telegram,
            website: d.website
        }))
    };
}

Error Handling

The API returns standard HTTP status codes:

Status Code	Description
200	Successful response
400	Bad request
401	Unauthorized - Invalid or missing bearer token
500	Internal server error

Best Practices

1. Implement Pagination

   • Use the limit and offset parameters for large datasets
   • Default to reasonable page sizes (e.g., 100 records)
   • Handle the has_more flag to determine if more data is available

2. Error Handling

   try {
     const deployments = await client.getWalletDeployments({
       wallet: "AaA2...",
     });
   } catch (error) {
     if (error.response?.status === 401) {
       console.error("Invalid API key");
     } else if (error.response?.status === 400) {
       console.error("Invalid parameters");
     }
   }

Next Steps

Now that you understand how to analyze historical token deployment data, you can:

1. 📊 Build deployment analytics dashboards
2. 🔍 Track wallet deployment patterns
3. 📈 Create token metadata analysis tools
4. 🏷️ Monitor social media presence

Real-time Data

For real-time token deployment notifications, check out our WebSocket Streams API documentation.

Need Help?

For additional support:

• Email us at [email protected]
• Visit our Support Portal