pumpdev3
pumpdev3
pumpdev.io

Pumpfun API - The Complete Pump.fun Developer SDK. Build trading bots, snipers, token launchers, automated tools

Last updated Jun 30, 2026
26
Stars
0
Forks
0
Issues
0
Stars/day
Attention Score
57
View on GitHub โ†— Open in github.dev
Topics
#memecoins#pumpdotfun#pumpfun#solana#solana-memecoin-sniper-bot
Language breakdown
No language data available.
โ–ธ Files click to expand
README

PumpFun API

The Fastest Pump.fun & PumpSwap API โ€” Lightning Trading & Token Creation

Website Docs Telegram Twitter

What is PumpDev?

PumpDev is the fastest way to trade and create tokens on pump.fun and PumpSwap. Our Lightning API lets you buy, sell, and launch tokens with one HTTP call โ€” no wallet setup, no RPC management, no client-side signing.

  • โšก Lightning API โ€” One HTTP call = trade done, server signs + sends
  • โšก Lightning Bundle โ€” One HTTP call = Jito bundle, server signs + sends via Jito
  • ๐Ÿ“ฆ Jito Bundle Support โ€” Atomic pump.fun token creation + multiple buys in one block
  • ๐Ÿ’ฐ 0.25% Commission โ€” Lowest fees in the market
  • ๐Ÿ” Client-Side Signing โ€” Alternative mode: your private keys never leave your machine
  • ๐Ÿ› ๏ธ Developer-First โ€” Clean REST API with JavaScript/TypeScript examples

โšก Lightning API โ€” One Call Trading

The Lightning API is the easiest and fastest way to trade on pump.fun. One HTTP call and you're done โ€” no client-side signing, no RPC management.

Step 1: Create a Lightning Wallet

const res = await fetch('https://pumpdev.io/api/wallet/create', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ label: 'my-bot' })
});
const { apiKey, publicKey, privateKey } = await res.json();

Step 2: Fund It & Trade

// Buy token โ€” one call, server signs + sends
const res = await fetch('https://pumpdev.io/api/trade-lightning?api-key=YOUR_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    action: 'buy',
    mint: 'TokenMintAddress',
    amount: 0.1,
    denominatedInSol: 'true',
    slippage: 15
  })
});

const { signature } = await res.json(); console.log('Done!', signature);

Sell with Lightning

// Sell 100% of tokens โ€” one call
// Token account is automatically closed after sell to reclaim ~0.002 SOL rent
const res = await fetch('https://pumpdev.io/api/trade-lightning?api-key=YOUR_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    action: 'sell',
    mint: 'TokenMintAddress',
    amount: '100%',
    denominatedInSol: 'false',
    slippage: 15,
    // closeTokenAccount: false  // Set to false to keep token account open
  })
});

const { signature } = await res.json(); console.log('Sold!', signature);

โšก Lightning Token Creation

Create tokens on pump.fun instantly with one HTTP call. No IPFS roundtrip โ€” PumpDev stores metadata locally for fastest launches.

const res = await fetch('https://pumpdev.io/api/create-lightning?api-key=YOUR_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: 'My Token',
    symbol: 'MTK',
    image: 'https://example.com/logo.png',
    buyAmountSol: 0.5
  })
});

const { mint, signature, pumpfun } = await res.json(); console.log('Token launched!', pumpfun);

Full Lightning documentation: Lightning Setup | Lightning Trade | Lightning Create | Lightning Bundle

โšก Lightning Bundle โ€” Jito Protected One-Call Trading

Lightning Bundle combines the simplicity of Lightning with Jito's MEV protection. One HTTP call โ€” server signs and sends up to 4 transactions atomically via Jito. Mix buy, sell, and create in a single bundle.

// Multi-wallet buy via Jito bundle โ€” one call, MEV protected
const res = await fetch('https://pumpdev.io/api/bundle-lightning', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    accounts: [
      { apiKey: 'WALLET1_KEY', type: 'buy', amount: 0.1, denominatedInSol: 'true' },
      { apiKey: 'WALLET2_KEY', type: 'buy', amount: 0.2, denominatedInSol: 'true' },
    ],
    mint: 'TokenMintAddress',
    jitoTip: 0.01
  })
});
const { results, mint } = await res.json();
console.log(${results.filter(r => r.signature).length}/${results.length} ok);
// Create token + dev buy atomically โ€” one call
const res = await fetch('https://pumpdev.io/api/bundle-lightning', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    accounts: [
      { apiKey: 'YOUR_KEY', type: 'create', name: 'My Token', symbol: 'MTK',
        image: 'https://example.com/logo.png' },
      { apiKey: 'YOUR_KEY', type: 'buy', amount: 0.5, denominatedInSol: 'true' },
      { apiKey: 'SNIPER_KEY', type: 'buy', amount: 1.0, denominatedInSol: 'true' },
    ],
    jitoTip: 0.01
  })
});
const { results, mint } = await res.json();
console.log(Token launched via Jito: https://pump.fun/${mint});
Full Lightning Bundle documentation: Lightning Bundle

Local-Sign Bundle โ€” Client-Side Signing + Jito

POST /api/bundle builds the same Jito bundle as bundle-lightning but returns unsigned transactions. You sign with your own private keys and send to Jito yourself. Uses publicKey per account โ€” no wallet import or API key needed.

import { VersionedTransaction, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const wallet = Keypair.fromSecretKey(bs58.decode('YOURPRIVATEKEY'));


// 1. Build unsigned bundle const res = await fetch('https://pumpdev.io/api/bundle', {   method: 'POST',   headers: { 'Content-Type': 'application/json' },   body: JSON.stringify({     accounts: [       { publicKey: wallet.publicKey.toBase58(), type: 'buy', amount: 0.1, denominatedInSol: 'true' }     ],     mint: 'TokenMintAddress',     jitoTip: 0.01   }) }); const data = await res.json();


// 2. Sign locally const signedTxs = data.transactions.map((entry) => {   const tx = VersionedTransaction.deserialize(bs58.decode(entry.transaction));   tx.sign([wallet]);   return bs58.encode(tx.serialize()); });


// 3. Send to Jito await fetch('https://mainnet.block-engine.jito.wtf/api/v1/bundles', {   method: 'POST',   headers: { 'Content-Type': 'application/json' },   body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'sendBundle', params: [signedTxs] }) });

Full documentation: Local-Sign Bundle

Key Features

| Feature | Description | |---------|-------------| | โšก Lightning Trading | One HTTP call buy/sell โ€” server signs + sends | | โšก Lightning Token Creation | One HTTP call token launch with built-in metadata storage | | โšก Lightning Bundle | One HTTP call Jito bundle โ€” MEV-protected trades and launches | | Pump.fun Token Creation | Create token on pump.fun with custom metadata and socials | | Pump.fun Jito Bundle | Launch token + dev buy + multiple buyers atomically | | Trading API | Generate buy/sell transactions for any pump.fun token | | Real-Time WebSocket | Stream live trades, launches, migrations, and wallet activity (bonding curve + PumpSwap AMM) | | Fee Claiming | Automate creator royalty collection | | Cashback Rewards | Create cashback-enabled tokens and claim trader cashback | | Auto Close ATA | Automatically closes token accounts after sell to reclaim ~0.002 SOL rent | | SOL Transfers | Build transfer transactions for wallet management |

Client Side Quick Start

Installation

npm install @solana/web3.js bs58

Step 1: Upload Metadata to Pump.fun IPFS

async function uploadMetadata() {
  const formData = new FormData();
  
  // Add token image
  const imageResponse = await fetch('https://example.com/your-logo.jpg');
  const imageBuffer = await imageResponse.arrayBuffer();
  formData.append('file', new Blob([imageBuffer], { type: 'image/jpeg' }), 'logo.jpg');
  
  // Add token info
  formData.append('name', 'PUMP FUN API');
  formData.append('symbol', 'pumpdev.io');
  formData.append('description', 'Your token description');
  formData.append('twitter', 'https://x.com/YourTwitter');
  formData.append('telegram', 'https://t.me/YourTelegram');
  formData.append('website', 'https://yourwebsite.com');
  formData.append('showName', 'true');

const res = await fetch('https://pump.fun/api/ipfs', { method: 'POST', body: formData });   const { metadataUri } = await res.json();      console.log('Metadata URI:', metadataUri);   return metadataUri; }

Step 2: Create Token (With Dev Buy)

import { VersionedTransaction, Connection, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const API_URL = 'https://pumpdev.io';


async function createToken() {   const creator = Keypair.fromSecretKey(bs58.decode('YOURPRIVATEKEY'));      const response = await fetch(${API_URL}/api/create, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({       publicKey: creator.publicKey.toBase58(),       name: 'PUMP FUN API',       symbol: 'pumpdev.io',       uri: metadataUri,  // From Step 1       buyAmountSol: 0.1, // Dev buy amount in SOL       slippage: 30,      // Slippage % for buy (default: 30)       // mintKeypair: 'OPTIONALMINTSECRETKEYBASE58', // Optional: custom mint keypair     })   });


const result = await response.json();   const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));


// Sign transaction (create + dev buy in single tx)   const tx = VersionedTransaction.deserialize(bs58.decode(result.transaction));   tx.sign([creator, mintKeypair]);


// Send transaction   const connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed');   const signature = await connection.sendTransaction(tx);


console.log(โœ… Token: https://pump.fun/${result.mint});   console.log('Signature:', signature); }

Buy Tokens on Pump.fun

async function buyToken(privateKey, mint, amountSol) {
  const keypair = Keypair.fromSecretKey(bs58.decode(privateKey));
  
  const response = await fetch(${API_URL}/api/trade-local, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: keypair.publicKey.toBase58(),
      action: 'buy',
      mint: mint,
      amount: amountSol,
      slippage: 99,
    })
  });

const data = await response.arrayBuffer();   const tx = VersionedTransaction.deserialize(new Uint8Array(data));   tx.sign([keypair]);


const connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed');   const signature = await connection.sendTransaction(tx);      console.log('Signature:', signature); }

Sell Tokens on Pump.fun

// Sell 100% of tokens
// Token account is automatically closed after sell to reclaim ~0.002 SOL rent
const response = await fetch(${API_URL}/api/trade-local, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: 'YourPublicKey',
    action: 'sell',
    mint: 'TokenMintAddress',
    amount: '100%',           // Supports: '100%', '50%', or exact amount
    slippage: 99,
    // closeTokenAccount: false  // Set to false to keep token account open
  })
});

const data = await response.arrayBuffer(); const tx = VersionedTransaction.deserialize(new Uint8Array(data)); tx.sign([keypair]);


const connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed'); const signature = await connection.sendTransaction(tx);


console.log('Signature:', signature);

โšก Jito Bundles - Advanced

Jito bundles execute multiple transactions atomically in the same block. Use bundles for:

  • Token creation with dev buy
  • Multi-wallet coordinated launches
  • Fast batch sell operations

Why Use Jito Bundles?

  • โœ… Atomic Execution โ€” All transactions succeed or fail together
  • โœ… No Front-Running โ€” Everything lands in the same block
  • โœ… Multiple Wallets โ€” Creator + up to 3 additional buyers
  • โœ… Speed โ€” Single API call for multiple transactions

Create Token with Dev Buy (Bundle)

import { VersionedTransaction, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const API_URL = 'https://pumpdev.io';


async function createTokenWithDevBuy() {   const creator = Keypair.fromSecretKey(bs58.decode('YOURPRIVATEKEY'));


const response = await fetch(${API_URL}/api/create, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({       publicKey: creator.publicKey.toBase58(),       name: 'PUMP FUN API',       symbol: 'pumpdev.io',       uri: 'https://ipfs.io/ipfs/...',       buyAmountSol: 0.5,      // Dev buy amount       slippage: 30,       jitoTip: 0.01     })   });


const result = await response.json();   const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));


// Sign all transactions (create + dev buy)   const signedTxs = result.transactions.map((txInfo) => {     const tx = VersionedTransaction.deserialize(bs58.decode(txInfo.transaction));     const signers = txInfo.signers.includes('mint') ? [creator, mintKeypair] : [creator];     tx.sign(signers);     return bs58.encode(tx.serialize());   });


// Send via Jito bundle   await fetch('https://mainnet.block-engine.jito.wtf/api/v1/bundles', {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'sendBundle', params: [signedTxs] })   });


console.log(โœ… Token: https://pump.fun/${result.mint}); }

Multi-Buyer Bundle Launch

Create token + multiple wallets buy atomically:

async function createMultiBuyerBundle() {
  const creator = Keypair.fromSecretKey(bs58.decode('CREATOR_KEY'));
  const buyer1 = Keypair.fromSecretKey(bs58.decode('BUYER1_KEY'));
  const buyer2 = Keypair.fromSecretKey(bs58.decode('BUYER2_KEY'));

const response = await fetch(${API_URL}/api/create-bundle, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({       publicKey: creator.publicKey.toBase58(),       name: 'PUMP FUN API',       symbol: 'pumpdev.io',       uri: 'https://ipfs.io/ipfs/...',       buyAmountSol: 0.5,          // Creator dev buy       slippage: 30,       jitoTip: 0.01,       additionalBuyers: [         { publicKey: buyer1.publicKey.toBase58(), amountSol: 1.0 },         { publicKey: buyer2.publicKey.toBase58(), amountSol: 0.5 }       ]     })   });


const result = await response.json();   const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));   const wallets = { creator, buyer1, buyer2 };


// Sign each transaction with appropriate signers   const signedTxs = result.transactions.map((txInfo) => {     const tx = VersionedTransaction.deserialize(bs58.decode(txInfo.transaction));     const signers = txInfo.signers.map(s => s === 'mint' ? mintKeypair : wallets[s]).filter(Boolean);     tx.sign(signers);     return bs58.encode(tx.serialize());   });


// Send Jito bundle   await fetch('https://mainnet.block-engine.jito.wtf/api/v1/bundles', {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'sendBundle', params: [signedTxs] })   });


console.log(โœ… Token: https://pump.fun/${result.mint}); }

๐Ÿš€ FAST Bundle Sell - Multiple Accounts in ONE Request

Build sell transactions for multiple wallets in a single API call. This is 3-4x faster than making individual /api/trade-local calls!

Why Use Bundle Sell?

| Individual Calls | Bundle Call | |-----------------|-------------| | N HTTP round-trips | 1 HTTP round-trip | | N blockhash fetches | 1 shared blockhash | | N bonding curve lookups | 1 shared lookup | | ~400-800ms for 4 accounts | ~100-200ms for 4 accounts |

Bundle Sell Example

import { VersionedTransaction, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const API_URL = 'https://pumpdev.io';


async function sellBundleFast(mint, accounts, creatorPublicKey) {   // 1. Build ALL transactions in ONE API call   const response = await fetch(${API_URL}/api/trade-bundle, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({       accounts: accounts.map(acc => ({         publicKey: acc.keypair.publicKey.toBase58(),         name: acc.name,       })),       action: 'sell',       mint: mint,       amount: '100%',       slippage: 99,       priorityFee: 0.005,       creator: creatorPublicKey, // SPEED: skip bonding curve lookup     }),   });


const result = await response.json();   console.log(Built ${result.stats.success}/${result.stats.total} in ${result.stats.durationMs}ms);


// 2. Sign and send each transaction   for (const txInfo of result.transactions) {     if (!txInfo.transaction) continue;          const account = accounts.find(a => a.name === txInfo.name);     const tx = VersionedTransaction.deserialize(bs58.decode(txInfo.transaction));     tx.sign([account.keypair]);          const signature = await connection.sendTransaction(tx, { skipPreflight: true });     console.log(${txInfo.name} sent: ${signature});   } }


// Usage const accounts = [   { name: 'creator', keypair: Keypair.fromSecretKey(bs58.decode('...')) },   { name: 'bundle1', keypair: Keypair.fromSecretKey(bs58.decode('...')) },   { name: 'bundle2', keypair: Keypair.fromSecretKey(bs58.decode('...')) }, ];


await sellBundleFast('TokenMint', accounts, accounts[0].keypair.publicKey.toBase58());

Bundle Sell Response

{
  transactions: [
    { name: 'creator', transaction: 'base58encodedtx', error: null },
    { name: 'bundle1', transaction: 'base58encodedtx', error: null },
    { name: 'bundle2', transaction: null, error: 'No token balance found' },
  ],
  stats: {
    total: 3,
    success: 2,
    failed: 1,
    durationMs: 150
  }
}

Claim Creator Fees (Fee Sharing Support)

Check claimable balance and claim creator fees. Same URL โ€” GET reads the balance, POST builds the claim transaction. Full support for pump.fun's fee sharing feature.

// 1. Check claimable balance (read-only โ€” no transaction built)
const params = new URLSearchParams({ publicKey: 'YourPublicKey', mint: 'TokenMint' });
const balanceRes = await fetch(${API_URL}/api/claim-account?${params});
const balance = await balanceRes.json();

console.log(Claimable: ${balance.totalClaimable} ${balance.isNativeQuote ? 'SOL' : balance.quoteMint}); console.log(  Pump: ${balance.pumpBalance}, PumpSwap: ${balance.pumpSwapBalance}); console.log(  Graduated: ${balance.graduated}, Fee sharing: ${balance.hasFeeSharing});


// 2. Build and send claim transaction if (balance.totalClaimable > 0) {   const body = { publicKey: 'YourPublicKey', mint: 'TokenMint' };


const response = await fetch(${API_URL}/api/claim-account, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify(body)   });


const data = await response.arrayBuffer();   const tx = VersionedTransaction.deserialize(new Uint8Array(data));   tx.sign([keypair]);


const signature = await connection.sendTransaction(tx, { skipPreflight: false });   console.log('Claimed:', signature); }

Important: Include the mint parameter for fee sharing, graduated tokens, and non-SOL quote mints. Without it, the API defaults to a wrapped-SOL creator vault sweep.

Cashback Rewards

Pump.fun's cashback feature redirects creator fees back to traders. Create cashback-enabled tokens and let users claim their accumulated rewards.

Create a Cashback-Enabled Token

const response = await fetch(${API_URL}/api/create, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: creator.publicKey.toBase58(),
    name: 'My Token',
    symbol: 'MTK',
    uri: metadataUri,
    cashbackEnabled: true,  // Enable cashback for traders
    buyAmountSol: 0.5,
    slippage: 30
  })
});

Check & Claim Cashback

Same pattern โ€” GET checks balance, POST claims:

// 1. Check claimable cashback (read-only)
const params = new URLSearchParams({ publicKey: 'YourPublicKey', program: 'both' });
const balanceRes = await fetch(${API_URL}/api/claim-cashback?${params});
const balance = await balanceRes.json();

console.log(Claimable cashback: ${balance.totalCashback} SOL); console.log(  Pump: ${balance.pumpCashback}, PumpSwap: ${balance.pumpSwapCashback});


// 2. Claim if available if (balance.totalCashback > 0) {   const response = await fetch(${API_URL}/api/claim-cashback, {     method: 'POST',     headers: { 'Content-Type': 'application/json' },     body: JSON.stringify({       publicKey: 'YourPublicKey',       program: 'both'  // 'both' | 'pump' | 'pumpswap'     })   });


const data = await response.arrayBuffer();   const tx = VersionedTransaction.deserialize(new Uint8Array(data));   tx.sign([keypair]);


const signature = await connection.sendTransaction(tx);   console.log('Cashback claimed:', signature); }

Real-Time WebSocket โ€” Pump.fun & PumpSwap Data

Stream live trades, new token launches, migrations, and wallet activity from both Pump.fun bonding curves and PumpSwap AMM pools. Subscriptions automatically follow tokens across migration โ€” no re-subscribe needed.

import WebSocket from 'ws';

const ws = new WebSocket('wss://pumpdev.io/ws');


ws.on('open', () => {   // Subscribe to new pump.fun token launches   ws.send(JSON.stringify({ method: 'subscribeNewToken' }));


// Subscribe to specific token trades (bonding curve + PumpSwap AMM)   ws.send(JSON.stringify({     method: 'subscribeTokenTrade',     keys: ['TokenMint1', 'TokenMint2']   }));


// Track whale wallets   ws.send(JSON.stringify({     method: 'subscribeAccountTrade',     keys: ['WhaleWallet1', 'WhaleWallet2']   })); });


ws.on('message', (data) => {   const event = JSON.parse(data.toString());


if (event.txType === 'create') {     console.log(๐Ÿ†• New Token: ${event.name} (${event.symbol}));     console.log(   Mint: ${event.mint});     console.log(   Market Cap: ${event.marketCapSol} SOL);   }


if (event.txType === 'buy' || event.txType === 'sell') {     const src = event.source ?  [${event.source}] : '';     console.log(๐Ÿ“Š ${event.txType.toUpperCase()}${src}: ${event.solAmount} SOL);     if (event.pool) console.log(   Pool: ${event.pool});   }


if (event.txType === 'complete') {     console.log(๐Ÿ”„ MIGRATION: ${event.mint} bonding curve completed);   }


if (event.txType === 'create_pool') {     console.log(๐ŸŠ POOL CREATED: ${event.mint} -> ${event.pool});   } });

API Endpoints

| Endpoint | Method | Description | |----------|--------|-------------| | /api/wallet/create | POST | โšก Lightning โ€” Create wallet + API key | | /api/wallet/import | POST | โšก Lightning โ€” Import existing key + get API key | | /api/trade-lightning | POST | โšก Lightning โ€” Server-side sign + send trade | | /api/create-lightning | POST | โšก Lightning โ€” Server-side token creation | | /api/bundle-lightning | POST | โšก Lightning Bundle โ€” Up to 4 txs (buy/sell/create) โ€” sends via Jito | | /api/bundle | POST | Local-Sign Bundle โ€” Returns unsigned txs, you sign + send to Jito | | /api/create | POST | Create token on pump.fun (with optional dev buy) | | /api/create-bundle | POST | Pump.fun Jito bundle - create + multiple buyers | | /api/trade-local | POST | Generate buy/sell transactions | | /api/trade-bundle | POST | FAST - Build multiple sell txs in ONE request | | /api/claim-account | GET | Check claimable creator fee balance (read-only) | | /api/claim-account | POST | Claim creator fees (standard) | | /api/claim-distribute | POST | Distribute creator fees (fee sharing / reward split) | | /api/claim-cashback | GET | Check claimable cashback balance (read-only) | | /api/claim-cashback | POST | Claim cashback rewards from trading | | /api/transfer | POST | Transfer specific SOL amount | | /api/transfer-all | POST | Transfer entire wallet balance | | /ws | WebSocket | Real-time market data streaming |

WebSocket Subscriptions

| Method | Description | |--------|-------------| | subscribeNewToken | New token launches | | subscribeTokenTrade | Trades for specific tokens (bonding curve + PumpSwap, auto-follows migration) | | subscribeAccountTrade | Trades from specific wallets | | unsubscribeNewToken | Unsubscribe from new tokens | | unsubscribeTokenTrade | Unsubscribe from token trades | | unsubscribeAccountTrade | Unsubscribe from wallet trades |

Pricing

| Operation | Fee | |-----------|-----| | Create Token on Pump.fun | FREE | | Pump.fun Token Launch Bundle | 0.25% of buys | | Buy Tokens (client-side) | 0.25% | | Sell Tokens (client-side) | 0.25% | | Create + Dev Buy | 0.25% of dev buy | | Lightning Trading | 0.5% | | SOL Transfers | FREE | | WebSocket Data | FREE |

Compare: Most competitors charge 1% per trade.

Why PumpDev?

| Feature | PumpDev | Others | |---------|---------|--------| | โšก Lightning API | Yes โ€” one call trading | No | | โšก Lightning Bundle | Yes โ€” one call Jito trading | No | | Jito Bundle Support | Yes | Limited | | Commission | 0.25% | 1% | | Fast Execution | Optimized | Standard | | Private Key Security | Local signing available | Some require managed wallets | | Multiple Buyers Bundle | Up to 4 wallets | Often just 1 | | PumpSwap AMM Support | Full โ€” trading + WebSocket | Limited | | Auto Close Token Accounts | Yes โ€” reclaims rent | No | | WebSocket Data | Free, unlimited | Often paid |

Use Cases

  • ๐Ÿš€ Pump.fun Token Creator โ€” Launch memecoins with dev buys
  • ๐ŸŽฏ Sniper Bots โ€” Instant buys on new token launches
  • ๐Ÿ“ฆ Jito Bundle Launchers โ€” Atomic multi-wallet token launches
  • ๐Ÿค– Trading Bots โ€” Automated buy/sell strategies
  • ๐Ÿ“Š Analytics Dashboards โ€” Real-time market monitoring
  • ๐Ÿ‹ Whale Trackers โ€” Follow smart money movements
  • ๐Ÿš€ Token Launchers โ€” Automated token deployment systems
  • ๐Ÿ’ผ Portfolio Managers โ€” Multi-wallet trading operations

Examples

Working code examples in the /examples folder:

| File | Description | |------|-------------| | buy-sell.js | Buy and sell tokens on Pump.fun | | websocket.js | Real-time trade data and new token alerts | | create-token.js | Launch new tokens with optional dev buy | | sniper-bot.js | Automated new token sniper (educational) | | claim-fees.js | Check balances & claim creator fees and cashback | | transfer.js | SOL transfer transactions | | lightning.js | Lightning API: server-side wallet, trade, and token creation | | lightning-bundle.js | Lightning Bundle: Jito-protected atomic bundles (buy/sell/create) | | bundle.js | Local-Sign Bundle: build unsigned txs, sign locally, send to Jito |

# Run any example
cd examples
npm install @solana/web3.js bs58 ws dotenv
node buy-sell.js

Documentation

Full documentation with detailed examples:

Community & Support

Keywords

pump.fun pump.fun api pumpswap pumpswap api pump.fun trading bot solana trading api solana memecoin pump.fun sniper pump.fun sdk solana dex api memecoin api pump.fun automation solana websocket pump.fun developer solana token trading bonding curve pump.fun integration

Copyright ยฉ 2026 PumpDev. All rights reserved.
pumpdev.io

๐Ÿ”— More in this category
anoma
anoma/anoma
Reference implementation of Anoma
โ˜… 33.7k
 argotorg
argotorg/solidity
Solidity, the Smart Contract Programming Language
โ˜… 25.7k
 slymnoyann
bigint/hey
Hey is a decentralized and permissionless social media app built with Lens Protocol ๐ŸŒฟ
โ˜… 29.4k
 ethereumbook
ethereumbook/ethereumbook
Mastering Ethereum: 2nd Edition, by Andreas M. Antonopoulos, Gavin Wood, Carlo Parisi, Alessandro Mazza, Niccolรฒ Pozzolini
โ˜… 21.5k
 ethereum-lists
ethereum-lists/chains
provides metadata for chains
โ˜… 9.8k
 MetaMask
MetaMask/metamask-extension
:globe_with_meridians: :electric_plug: The MetaMask browser extension enables browsing Ethereum blockchain enabled websites
โ˜… 13.2k
 saadansha
saadansha/crypto-trading-bot-v2
Cryptocurrency Trading Bot: For Binance, Bybit, Bitfinex, BitMEX... (Production Version)
โ˜… 226
 AmazingAng
AmazingAng/WTF-Solidity
WTF Solidity ๆž็ฎ€ๅ…ฅ้—จๆ•™็จ‹๏ผŒไพ›ๅฐ็™ฝไปฌไฝฟ็”จใ€‚Now supports English! ๅฎ˜็ฝ‘: https://wtf.academy
โ˜… 14.0k
 ethereum
ethereum/ethereum-org-website
Ethereum.org is a primary online resource for the Ethereum community.
โ˜… 5.9k
 Uniswap
Uniswap/interface
๐Ÿฆ„ Open source interfaces for the Uniswap protocol
โ˜… 5.5k
 UFund-Me
UFund-Me/Qbot
[๐Ÿ”ฅupdating ...] AI ่‡ชๅŠจ้‡ๅŒ–ไบคๆ˜“ๆœบๅ™จไบบ(ๅฎŒๅ…จๆœฌๅœฐ้ƒจ็ฝฒ) AI-powered Quantitative Investment Research Platform. ๐Ÿ“ƒ online docs: https://ufund-me.github.io/Qbot โœจ :news: qbot-mini: https://github.com/Charmve/iQuant
โ˜… 18.0k
 egametang
egametang/ET
Unity3D Client And C# Server Framework
โ˜… 9.9k

ยฉ 2026 GitRepoTrend ยท pumpdev3/pumpdev.io ยท Updated daily from GitHub