Pump.fun

Pump.fun is Solana's memecoin launchpad. The Pump.fun node supports token discovery, price checks, on-chain buy/sell, new token launches, and creator-fee / cashback claims.

Prerequisites

• Read operations: No credential required
• All on-chain operations (buy, sell, createToken, claimFees, claimCashback): Connected Privy wallet (transactions are signed through your embedded wallet)

Operations

All discovery ops return a normalized token list - each entry has at least mint, name, symbol, priceSol, and bondingProgressPct so downstream nodes can reference {pumpfunResponse.data[0].name} regardless of which op produced the list. priceSol / bondingProgressPct may be null when the upstream endpoint doesn't include reserve data.

bondingProgressPct is derived from the curve itself: SOL raised so far divided by SOL raised plus SOL still needed to complete the curve. Pump.fun no longer uses one fixed curve size. The classic launch needs about 85 SOL, but live curves needing several thousand SOL exist, so a token holding 1,400 SOL can still be a third of the way to graduating. Every discovery row also carries graduationSolTotal, the SOL that particular curve collects before it graduates, so a workflow can tell a small curve from a large one.

Only SOL-quoted curves are returned. Pump.fun also launches curves quoted in other tokens such as USDC. Those rows are dropped from every discovery list, getTokenInfo refuses them, and buy / sell fail before building a transaction, because every price and reserve field in this node is denominated in SOL.

getMovers is a beta operation. It reads the movers board from Pump.fun's advanced indexer, the same feed the pump.fun site polls, which Pump.fun does not document. Rows keep the normalized discovery shape (mint, name, symbol, bondingProgressPct, complete) so screening built for other discovery ops works unchanged, and add what only this feed carries: usd_market_cap, athMarketCapUsd, volume in SOL and USD over 5 minute, 15 minute, 1 hour and 24 hour windows (volumeUsd5m, volumeSol1h, and so on), txCount5m, txCount, buyCount, sellCount, ageSeconds, kolCount, sniperCount, program and the hasTwitter / hasWebsite / hasTelegram flags. The board has no reserve data, so priceSol and graduationSolTotal are null, and bondingProgressPct is the indexer's own figure. Unlike getGraduating, the board mixes bonding-curve and graduated tokens, so gate on complete before a bonding-curve buy. Field names are Solaris AI's reading of the indexer's terse keys; keys whose meaning was not clear are not surfaced. Rows come back in the indexer's order, and the board tops out at roughly 100 to 150 rows whatever limit asks for.

getRecommended, getNew, getGraduating, and search (plus the padding half of getTrending) read Pump.fun's paginated coin list. That list returns at most 70 rows per request, so a limit above 70 is assembled from several sequential pages and takes proportionally longer. getGraduating and search always scan a 300-row pool before filtering, whatever limit you set.

getGraduating additionally verifies its candidates on-chain, in batched RPC calls of up to 100 curves, walking down the ranking until it has limit live curves or the pool is exhausted, and drops curves that have already completed, because the Pump.fun index can keep reporting a graduated token as still bonding. Small limits need one call; a limit near 300 can take three. If an RPC call fails the operation fails rather than returning stale rows.

Automatic routing

Buy and sell operations transparently route based on the token's state:

• Bonding curve - while the token is still on the Pump.fun bonding curve
• PumpSwap AMM - once the token has graduated from the bonding curve

You don't need to configure the route; the node detects it at run time.

Reliability

The Pump.fun frontend API can return transient 429, 5xx, or timeout errors under load. Read operations (the discovery feeds, getCoin/getTokenInfo lookups, and getSolPrice) retry automatically with backoff, so a brief blip no longer fails your run. Trades and other on-chain operations (buy, sell, createToken, claimFees, claimCashback) never auto-retry - retrying after an ambiguous broadcast could place a duplicate order or spend twice, so they surface the error instead. To keep a failing feed from stopping a whole scheduled run, set the node to Continue on failure. See Automatic retries for the full policy.

Configuration

Every numeric and boolean field below accepts either a literal value or a {varName.path} template resolved at run time against upstream node outputs - e.g. solAmount: "{trigger.amount}", slippageBps: "{aiDecision.bps}", or dryRun: "{gate.simulate}". Boolean templates resolve true/false, 1/0, and yes/no (case-insensitive) after substitution. Each boolean field in the config UI has a "Use {template}" toggle that swaps the checkbox for a template input. Literal values are bounds-checked in the config UI; templates are validated at run time after substitution.

Output (getCoin)

{
  "success": true,
  "operation": "getCoin",
  "mint": "TokenMintAddress123...",
  "data": {
    "mint": "TokenMintAddress123...",
    "name": "Example Token",
    "symbol": "EXT",
    "market_cap": 125000,
    "usd_market_cap": 125000
  }
}

Output (getTokenInfo)

On-chain protocol state. When the token has graduated, priceSol switches from bonding-curve spot to PumpSwap pool spot, and pool fields are populated. If the PumpSwap pool lookup fails on a graduated token, the bonding-curve snapshot is returned with pumpswapWarning / pumpswapError attached.

{
  "success": true,
  "operation": "getTokenInfo",
  "mint": "TokenMintAddress123...",
  "data": {
    "mint": "TokenMintAddress123...",
    "bondingCurve": "BondingCurvePda...",
    "priceSol": 0.00003,
    "bondingProgressPct": 23.5,
    "graduated": false,
    "graduationSolTotal": 85.005,
    "realSolReserves": 20.0,
    "virtualSolReserves": 50.0,
    "virtualTokenReserves": "1000000000000",
    "creator": "CreatorPubkey...",
    "isMayhemMode": false,
    "isCashbackEnabled": false
  }
}

Output shape - all operations

Every Pump.fun operation (reads and trades) returns the same outer envelope:

{ success, operation, mint?, data }

Downstream nodes always reference fields via {responseName.data.<field>} - e.g. {pumpfunResponse.data.txHash} on a trade, {pumpfunResponse.data.name} on getCoin. mint is omitted on operations that don't take one (getTopRunners, getSolPrice, getRecommended, getCurrentlyLive).

Output (buy)

{
  "success": true,
  "operation": "buy",
  "mint": "TokenMintAddress123...",
  "data": {
    "venue": "bonding_curve",
    "walletAddress": "UserWallet...",
    "solAmount": 0.1,
    "estimatedTokens": 3250.4,
    "minTokens": 2762.9,
    "slippageBps": 1500,
    "priceSol": 0.00003,
    "bondingProgressPct": 23.5,
    "confirmed": true,
    "txHash": "5Lbm..."
  }
}

For a graduated token, venue becomes "pumpswap" and bondingProgressPct is replaced by poolPrice. bondingProgressPct is a 0–100 percent (one decimal), matching getTokenInfo. Dry-run results additionally include dryRun: true, simulated: true, unitsConsumed, logs, error, and balanceWarning.

Output (sell)

{
  "success": true,
  "operation": "sell",
  "mint": "TokenMintAddress123...",
  "data": {
    "venue": "pumpswap",
    "walletAddress": "UserWallet...",
    "tokensSold": 1000,
    "estimatedSol": 0.0312,
    "minSol": 0.0265,
    "slippageBps": 1500,
    "confirmed": true,
    "txHash": "5Lbm..."
  }
}

Preflight failures

Both buy and sell preflight the wallet's SOL balance before broadcasting. A live trade with insufficient SOL throws before spending any funds - Insufficient SOL for sell fees. Have X SOL, need ~Y SOL. (or the buy equivalent). A dry-run attaches the same information as data.balanceWarning instead of throwing so the workflow can inspect it.

Output (createToken)

{
  "success": true,
  "operation": "createToken",
  "mint": "NewMintAddress...",
  "data": {
    "mint": "NewMintAddress...",
    "bondingCurve": "BondingCurvePda...",
    "name": "Example Coin",
    "symbol": "EXM",
    "metadataUri": "https://...",
    "uploadedMetadata": true,
    "isMayhem": false,
    "isCashback": false,
    "initialBuySol": 0.01,
    "walletAddress": "UserWallet...",
    "templateHint": "Use {pumpfunResponse.mint} in downstream nodes. Explorer: https://solscan.io/token/...",
    "pumpUrl": "https://pump.fun/coin/...",
    "explorer": "https://solscan.io/token/...",
    "confirmed": true,
    "bondingCurveVerified": true,
    "txHash": "5Lbm...",
    "txExplorer": "https://solscan.io/tx/..."
  }
}

mint is surfaced at the top level so downstream nodes can reference it as {pumpfunResponse.mint} - the canonical way to chain follow-up work after a launch (e.g. post to Telegram, set an alert, auto-buy more). uploadedMetadata is true when we uploaded to pump.fun IPFS and false when you supplied a pre-hosted metadataUri. On a dry run, metadataUriPlaceholder: true and a metadataNote indicate a synthetic URI was used - IPFS is not touched during dry-run, and balance/validation failures in live mode also skip the upload.

Signing + integrity

createToken requires two signers: your Privy wallet (fee payer) and a fresh mint keypair. The mint keypair is generated in-memory for one transaction and never persisted. To avoid undocumented mutations to the transaction message, the node calls Privy's signTransaction (not signAndSendTransaction), then performs a byte-level integrity check on Privy's response before broadcasting: serialized message bytes must be unchanged, the mint signature must survive the round-trip, and Privy must have added at least one user signature. Any discrepancy aborts before broadcast.

Output (claimFees)

Collects accrued creator fees from both vaults (skips either when empty). When neither vault has a balance, returns success: false with error: "no_fees" so downstream conditions can branch cleanly.

{
  "success": true,
  "operation": "claimFees",
  "data": {
    "walletAddress": "UserWallet...",
    "pumpRecoveredSol": 0.123,
    "pumpswapRecoveredSol": 0.045,
    "totalRecoveredSol": 0.168,
    "wsolNote": "PumpSwap fees land as WSOL in your Wrapped SOL ATA. Unwrap manually or via Jupiter to get native SOL.",
    "createdWsolAta": true,
    "confirmed": true,
    "txHash": "5Lbm...",
    "txExplorer": "https://solscan.io/tx/..."
  }
}

PumpSwap fees land as WSOL in your creator WSOL ATA - the node does not auto-unwrap because that would require closing the ATA and could nuke any pre-existing WSOL balance. Use the Jupiter node or any Solana wallet to unwrap when you're ready.

Output (claimCashback)

Claims accrued volume-based cashback. When the user's volume-accumulator PDA doesn't exist, returns success: false with error: "no_accumulator". Note: an existing accumulator with zero claimable cashback is NOT detected client-side - the on-chain program is the authoritative source and the tx will revert at runtime if there's nothing to claim.

{
  "success": true,
  "operation": "claimCashback",
  "data": {
    "walletAddress": "UserWallet...",
    "accumulator": "UserVolAccumulatorPda...",
    "confirmed": true,
    "txHash": "5Lbm...",
    "txExplorer": "https://solscan.io/tx/..."
  }
}

Common use cases

• Monitor new token launches and filter by market cap
• Automate memecoin buys when conditions are met (combine with AI or Condition node)
• Track top runners and send alerts via Telegram

Next steps

• Jupiter - swap on established tokens
• Birdeye - deeper token analytics