Skip to main content

Pump.fun Token API Documentation: Trades, Prices, OHLCV

Pump.fun does not run a hosted data API. It publishes program documentation and IDLs for its on-chain programs on GitHub (pump-public-docs), and the hosts its web app calls are undocumented, so there is no supported endpoint for trades, prices, candles or new launches. This page is the query reference for the Bitquery Pump.fun API, which reads that activity from the chain: live trades, new token launches, prices and OHLCV, bonding curve progress, graduations to PumpSwap, holders and top traders, over GraphQL, WebSocket, gRPC and Kafka, filtered by the Pump.fun program address 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Every query runs as written in the Bitquery IDE. Queries on the archive or combined dataset need an archive add-on; the free trial is real-time only. Delivery options, latency and pricing are on the Pump.fun API product page.

Want structured trades, OHLC and market cap? Start with the Trading API

The Trading API is the fastest path to clean Pump.fun market data. Trading.Trades returns MEV-filtered swaps with USD price, market cap and supply on every row, across 10 chains in one API, and Trading.Tokens gives pre-aggregated OHLC down to one second, so you never build candles yourself. Worked Pump.fun examples are in Trader-Focused Trade APIs below.

Reach for the raw chain-level queries on this page when you need what the Trading API deliberately does not carry: history older than the Trading window, bonding-curve internals, per-instruction detail, or call / event context.

For data points not covered here, ask support.

Try Our PumpFun Token Sniffer

Want to screen Pump.fun mints for phishing risk? Check out our PumpFun Token Sniffer, a proof-of-concept tool that helps identify suspicious token behavior by analyzing transfers and trades.

Need zero-latency Pump.fun data? Read about our Shred Streams and contact us for a trial. For gRPC streaming, see Pump.fun gRPC Streams →.

You may also be interested in:

note

To query or stream data via graphQL outside the Bitquery IDE, you need to generate an API access token.

Follow the steps here to create one: How to generate Bitquery API token ➤

What is the Program Address for Pump.fun on Solana?​

The Pump.fun program address on Solana mainnet is 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Use Bitquery's GraphQL API to filter DEX trades, mintn creation, and bonding curve data by this program ID.

6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P

Use this program ID when filtering Solana instructions or supply updates for Pump.fun mints. All examples below reference this program. For bonding curve data, token creation, and migration tracking, use the queries in this guide with Program: { Address: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" } }.

Mints that complete the bonding curve graduate to PumpSwap, pump.fun's own AMM, at program address pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA (see the PumpSwap API page). In the trade cubes the two venues appear as Dex.ProtocolName pump for the bonding curve and pump_amm for PumpSwap (family Pumpswap). Curve mints trade for hours, not months, so the examples here that need a market still alive when you read them use PUMP (pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn), pump.fun's own token, which trades on PumpSwap. For a token still on the curve, switch the filter to pump and take a live mint from tokens traded in the last hour.

Token Creation & Metadata​

How do I get newly created Pump.fun tokens?​

Subscribe to TokenSupplyUpdates filtered by the Pump.fun program's create or create_v2 method for metadata, supply and dev address as each mint appears. New Pump.fun mints: run it ➤

Show the GraphQL
subscription {
  Solana {
    TokenSupplyUpdates(
      where: {
        Instruction: {
          Program: {
            Address: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
            Method: { in: ["create", "create_v2"] }
          }
        }
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Signer
      }
      TokenSupplyUpdate {
        Amount
        Currency {
          Symbol
          ProgramAddress
          PrimarySaleHappened
          Native
          Name
          MintAddress
          MetadataAddress
          Key
          IsMutable
          Fungible
          EditionNonce
          Decimals
          Wrapped
          VerifiedCollection
          Uri
          UpdateAuthority
          TokenStandard
        }
        PostBalance
      }
    }
  }
}

How do I get creation time and dev address of a Pump.fun token?​

Try Pump.Fun Dev Address & Creation Time Query ➤

Show the GraphQL
query MyQuery {
  Solana(network: solana) {
    Instructions(
      where: {
        Instruction: {
          Accounts: { includes: { Address: { is: "token mint address" } } }
          Program: {
            Name: { is: "pump" }
            Method: { in: ["create", "create_v2"] }
          }
        }
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Signer
        Signature
      }
      Instruction {
        Accounts {
          Address
        }
      }
    }
  }
}

How do I monitor Pump.fun new token launches in real time?​

Use Bitquery's GraphQL subscription on Instructions filtered by the Pump.fun program and create/create_v2 methods. This returns creation events with mint address, bonding curve, metadata, creator, name, symbol, and URI.

Track launches in realtime: stream it ➤

Show the GraphQL
subscription {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Method: { in: ["create", "create_v2"] }
            Name: { is: "pump" }
          }
        }
      }
    ) {
      Instruction {
        Accounts {
          Address
          IsWritable
          Token {
            Mint
            Owner
            ProgramId
          }
        }
        Logs
        Program {
          AccountNames
          Address
          Arguments {
            Name
            Type
            Value {
              ... on Solana_ABI_Json_Value_Arg {
                json
              }
              ... on Solana_ABI_Float_Value_Arg {
                float
              }
              ... on Solana_ABI_Boolean_Value_Arg {
                bool
              }
              ... on Solana_ABI_Bytes_Value_Arg {
                hex
              }
              ... on Solana_ABI_BigInt_Value_Arg {
                bigInteger
              }
              ... on Solana_ABI_Address_Value_Arg {
                address
              }
              ... on Solana_ABI_String_Value_Arg {
                string
              }
              ... on Solana_ABI_Integer_Value_Arg {
                integer
              }
            }
          }
          Method
          Name
        }
      }
      Transaction {
        Signature
      }
    }
  }
}

How do I get all Pump.fun tokens created by a specific address?​

Everything created by an address: run it ➤

tip

Want to analyze the funding history and transaction patterns of a creator? Connect the Bitquery MCP server and ask an AI agent to trace the creator's funding in plain English (AI Investigations), or use our Money Flow API to query fund movements directly.

Show the GraphQL
query MyQuery {
  Solana {
    TokenSupplyUpdates(
      where: {
        Transaction: {
          Result: { Success: true }
          Signer: { is: "ADD CREATOR ADDRESS HERE" }
        }
        Instruction: {
          Program: {
            Address: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
            Method: { in: ["create", "create_v2"] }
          }
        }
      }
    ) {
      Block {
        Time
      }
      TokenSupplyUpdate {
        Amount
        Currency {
          Uri
          UpdateAuthority
          Symbol
          Name
          MintAddress
          MetadataAddress
          Fungible
          Decimals
        }
        PostBalance
      }
      Transaction {
        Signature
        Signer
      }
    }
  }
}

How do I get Pump.fun tokens created by a wallet from historical data?​

Use the v1 Solana transfers API to list what a wallet created on Pump.fun over a date range.

Replace the signer value and the date range in the query with your target wallet and desired window. For aggregates (e.g. total count of mints created by a wallet), use the dedicated count query below.

Show the GraphQL
{
  solana {
    transfers(
      options: { limit: 100, desc: "block.height" }
      date: { since: "2025-02-08", till: "2025-06-08" }
      externalProgramId: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
      transferType: { is: mint }
      signer: { is: "Ddu1xqgNHBRBiJrissrpLtevq2A7KAHjgiDzECoNL8HG" }
    ) {
      block {
        height
        timestamp {
          iso8601
        }
      }
      instruction {
        action {
          name
        }
        callPath
        external
        externalAction {
          name
          type
        }
        program {
          name
          id
        }
        externalProgram {
          id
          name
        }
      }
      currency {
        name
        symbol
        address
      }
      date {
        date
      }
      amount
      receiver {
        address
        mintAccount
        type
      }
      transaction {
        signature
        signer
      }
      transferType
    }
  }
}

How do I get token metadata, dev address, and creation time for a specific Pump.fun token?​

Each new launch arrives with its dev address, metadata and supply. PostBalance carries the current supply. New mints with dev and metadata: stream it ➤

Show the GraphQL
subscription {
  Solana {
    TokenSupplyUpdates(
      where: {Instruction: {Program: {Address: {is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}, Method: {in: ["create","create_v2"]}}}}
    ) {
      Block{
        Time
      }
      Transaction{
        Signer
      }
      TokenSupplyUpdate {
        Amount
        Currency {
          Symbol
          ProgramAddress
          PrimarySaleHappened
          Native
          Name
          MintAddress
          MetadataAddress
          Key
          IsMutable
          Fungible
          EditionNonce
          Decimals
          Wrapped
          VerifiedCollection
          Uri
          UpdateAuthority
          TokenStandard
        }
        PostBalance
      }
    }
  }
}

Pump.fun Mayhem Mode Tokens​

Below APIs are related to Pump.fun tokens which were launched within Mayhem mode.

To check whether an older mint was created with Mayhem mode true or false, use this Bitquery Solana v1 API, in v1 we have all the solana transfers data so we check for the 1 Billion token transfer to Mayhem Autonomous AI agent if theres a transfer we can say that the token was a Mayhem token.

How do I track Mayhem mode enabled Pump.fun tokens in real time?​

Streams mints created with Mayhem mode enabled, as they launch. Try the API here.

Show the GraphQL
subscription MyQuery {
  Solana {
    Instructions(
      where: {Instruction: {Program: {Address: {is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}, Method: {in: ["create", "create_v2"]}, Arguments: {includes: {Value: {Boolean: true}}}}}, Transaction: {Result: {Success: true}}}
    ) {
      Instruction {
        Program {
          Method
          Arguments {
            Name
            Type
            Value {
              ... on Solana_ABI_Integer_Value_Arg {
                integer
              }
              ... on Solana_ABI_String_Value_Arg {
                string
              }
              ... on Solana_ABI_Address_Value_Arg {
                address
              }
              ... on Solana_ABI_BigInt_Value_Arg {
                bigInteger
              }
              ... on Solana_ABI_Bytes_Value_Arg {
                hex
              }
              ... on Solana_ABI_Boolean_Value_Arg {
                bool
              }
              ... on Solana_ABI_Float_Value_Arg {
                float
              }
              ... on Solana_ABI_Json_Value_Arg {
                json
              }
            }
          }
        }
      }
      Transaction {
        Signature
      }
    }
  }
}

How do I check Mayhem mode of a Pump.fun token?​

Now you can check if a pump fun token is in Mayhem mode or not, we will be checking if it was launched with the is_mayhem_mode as true or false. Check Mayhem mode: run it ➤

Show the GraphQL
query MyQuery {
  Solana {
    Instructions(
      where: {Instruction: {Program: {Address: {is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}, Method: {in: ["create", "create_v2"]}}, Accounts: {includes: {Address: {is: "TOKEN_ADDRESS_TO_CHECK"}}}}, Transaction: {Result: {Success: true}}}
    ) {
      Instruction {
        Program {
          Method
          Arguments {
            Name
            Type
            Value {
              ... on Solana_ABI_Integer_Value_Arg {
                integer
              }
              ... on Solana_ABI_String_Value_Arg {
                string
              }
              ... on Solana_ABI_Address_Value_Arg {
                address
              }
              ... on Solana_ABI_BigInt_Value_Arg {
                bigInteger
              }
              ... on Solana_ABI_Bytes_Value_Arg {
                hex
              }
              ... on Solana_ABI_Boolean_Value_Arg {
                bool
              }
              ... on Solana_ABI_Float_Value_Arg {
                float
              }
              ... on Solana_ABI_Json_Value_Arg {
                json
              }
            }
          }
        }
      }
      Transaction {
        Signature
      }
    }
  }
}

How do I check if a Pump.fun token was launched in Mayhem mode? (Historical)​

To determine if a Pump.fun token was launched in Mayhem mode, we use the Solana v1 Transfers API. The following query checks transfers of exactly 1,000,000,000,000,000 units (which equals 1 billion tokens when adjusted for 6 decimal places).

  • If the resulting count is 2, the token was launched in Mayhem mode.
  • If the count is 1, the token was launched in standard mode.

This method reliably identifies whether a token's initial mint followed the Mayhem mode process.

Try out the API

Show the GraphQL
{
  solana {
    transfers(
      date: { since: "2025-01-01" }
      amount: { is: 1000000000000000 }
      currency: { is: "EEhQvi54Rwme2z84gG6qQmuaWjnZ6b9AMgq5aGkKpump" }
    ) {
      count
    }
  }
}

Token Pricing & Market Data​

How do I get the latest price of a Pump.fun token?​

We launched the Price Index in August 2025, allowing you to track price of any token trading onchain.

Here's an example of tracking prices. It uses PUMP on PumpSwap; for a mint still on the bonding curve, filter Market.Program to 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P instead.

PumpFun Token prices against SOL Stream Latest price in USD: run it ➤

Show the GraphQL
{
  Trading {
    Pairs(
      where: {
        Market: { Network: { is: "Solana" } }
        Token: {
          Address: { is: "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn" }
        }
        Interval: { Time: { Duration: { eq: 60 } } }
      }
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
    ) {
      Market {
        Address
        Network
        Program
        Protocol
        ProtocolFamily
      }
      Price {
        IsQuotedInUsd
        Average {
          ExponentialMoving
          Mean
          SimpleMoving
          WeightedSimpleMoving
        }
        Ohlc {
          Close
          High
          Low
          Open
        }
      }
      Token {
        Address
        Name
        Symbol
      }
      QuoteToken {
        Address
        Name
        Symbol
      }
      Volume {
        Base
        Usd
      }
    }
  }
}

How do I track the price of a Pump.fun token in real time?​

Live stream of token price updates on Pump.fun

Track price in real time: stream it ➤

Show the GraphQL
subscription {
  Trading {
    Pairs(
      where: {
        Token: {
          Address: { is: "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn" }
        }
        Price: { IsQuotedInUsd: true }
        Market: {
          Network: { is: "Solana" }
          Program: { is: "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA" }
        }
      }
    ) {
      Market {
        Address
        Network
        Program
        Protocol
        ProtocolFamily
      }
      Price {
        Average {
          ExponentialMoving
          Mean
          SimpleMoving
          WeightedSimpleMoving
        }
        Ohlc {
          Close
          High
          Low
          Open
        }
      }
      Token {
        Address
        Name
        Symbol
      }
      QuoteToken {
        Address
        Name
        Symbol
      }
      Volume {
        Base
        Usd
      }
    }
  }
}

How do I get top 10 Pump.fun tokens by price change in the last 5 minutes?​

Returns the ten biggest price moves on Pump.fun over the last 5 minutes. Open it in the Bitquery IDE: biggest 5-minute movers.

Show the GraphQL
{
  Trading {
    Pairs(
      limit: {count: 10}
      limitBy: {count: 1, by: Token_Address}
      orderBy: {descendingByField: "Price_Change_5min"}
      where: {Interval: {Time: {Duration: {eq: 1}}}, Block: {Time: {since_relative: {minutes_ago: 5}}}, Price: {IsQuotedInUsd: true}, Market: {Network: {is: "Solana"}, Program: {is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}}}
    ) {
      Market {
        Address
        Network
        Program
        Protocol
        ProtocolFamily
      }
      Price {
        Average {
          currentPrice: Mean(maximum: Block_Time)
          min5Ago: Mean(
            minimum: Block_Time
            if: {Block: {Time: {since_relative: {minutes_ago: 5}}}}
          )
        }
      }
      Price_Change_5min: calculate(expression: "(( $Price_Average_currentPrice - $Price_Average_min5Ago ) / $Price_Average_min5Ago) * 100")
      Token {
        Address
        Name
        Symbol
      }
      Market{
        Address
      }
      QuoteToken {
        Address
        Name
        Symbol
      }
    }
  }
}

How do I get Pump.fun token OHLCV data historically?​

Use Bitquery's DEXTradeByTokens with Block.Time(interval: minutes, count: 1) to fetch open-high-low-close (OHLC) data. Filter by token mint and Pump.fun program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. For history, use dataset: archive; some fields such as Trade_Side are not served there. OHLC on Pump.fun: run it ➤

note

Trade Side Account field will not be available for aggregate queries in Archive and Combined Datasets

Show the GraphQL
{
  Solana(dataset: archive) {
    DEXTradeByTokens(
      limit: { count: 10 }
      orderBy: { descendingByField: "Block_Timefield" }
      where: {
        Trade: {
          Currency: {
            MintAddress: { is: "66VR6bjEV5DPSDhYSQyPAxNsY3dgmH6Lwgi5cyf2pump" }
          }
          Dex: {
            ProgramAddress: {
              is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
            }
          }
        }
      }
    ) {
      Block {
        Timefield: Time(interval: { in: minutes, count: 1 })
      }
      volume: sum(of: Trade_Amount)
      Trade {
        high: Price(maximum: Trade_Price)
        low: Price(minimum: Trade_Price)
        open: Price(minimum: Block_Slot)
        close: Price(maximum: Block_Slot)
      }
      count
    }
  }
}

How do I get a token's all-time high (ATH) price on Pump.fun?​

Use Bitquery's DEXTradeByTokens with dataset: archive, Trade.PriceInUSD(maximum: Trade_PriceInUSD), and quantile(of: Trade_PriceInUSD, level: 0.98) to get ATH price. Market cap = ATH price × 1 billion (Pump.fun tokens have 1B supply). Pass token mint addresses in Trade.Currency.MintAddress.in. ATH price and market cap in timeframe: run it ➤

Show the GraphQL
{
  Solana(dataset: archive) {
    DEXTradeByTokens(
      limitBy: { by: Trade_Currency_MintAddress, count: 1 }
      where: {
        Trade: {
          Currency: {
            MintAddress: {
              in: [
                "639g7XEn1fMf7ZpHhKWUiHywY4PpQ5QPm6VMsw8Cpump"
                "FXMCWau8etMkKZnyn4pi9qMM3NVfrCHFM4KKnJvNpump"
              ]
            }
          }
          Side: {
            Currency: {
              MintAddress: {
                in: [
                  "11111111111111111111111111111111"
                  "So11111111111111111111111111111111111111112"
                ]
              }
            }
          }
        }
        Block: { Time: { since: "2025-05-03T06:37:00Z" } }
      }
    ) {
      Trade {
        Currency {
          MintAddress
          Name
          Symbol
        }
        PriceInUSD(maximum: Trade_PriceInUSD)
        Side {
          Currency {
            Symbol
          }
        }
      }
      max: quantile(of: Trade_PriceInUSD, level: 0.98)
      ATH_Marketcap: calculate(expression: "$max * 1000000000")
    }
  }
}

How do I get token price change over time (delta from X minutes back)?​

Useful for tracking % change by comparing first/last prices Price change over time: run it ➤

Show the GraphQL
query PumpFunRecentTrades {
  Solana {
    DEXTradeByTokens(
      where: {
        Block: { Time: { since_relative: { minutes_ago: 60 } } }
        Trade: {
          Currency: {
            MintAddress: { is: "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn" }
          }
          Dex: { ProtocolName: { is: "pump_amm" } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Trade {
        Market {
          MarketAddress
        }
        Currency {
          Symbol
          Name
          MintAddress
        }
        lastPrice: Price(maximum: Block_Slot)
        prePrice: Price(minimum: Block_Slot)
      }
      Price_change: calculate(
        expression: "(( $Trade_lastPrice - $Trade_prePrice ) / $Trade_prePrice) * 100"
      )
    }
  }
}

How do I get a wallet's PnL on Pump.fun tokens?​

Bitquery does not return a single “PnL” field for Pump.fun: derive it from historical buys and sells for that wallet and mint. Query Solana.DEXTrades or DEXTradeByTokens with Dex.ProtocolName: pump, the token MintAddress, Transaction.Signer or buy/sell accounts, and a time window; then compute realized PnL from USD volumes (see the Realised PnL example on Solana DEX Trades). Use the Crypto Price API if you need mark-to-market for open positions.

Trade Activity & Volume​

How do I get live trades from Pump.fun using Bitquery?​

Use Bitquery's DEXTrades GraphQL subscription filtered by ProtocolName: "pump" to stream live Pump.fun trades including buy/sell sides, amounts, accounts, and methods. For gRPC or Kafka, see Pump.fun gRPC Streams. Pump.fun real-time trades: stream it ➤

Show the GraphQL
subscription MyQuery {
  Solana {
    DEXTrades(
      where: {
        Trade: { Dex: { ProtocolName: { is: "pump" } } }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Instruction {
        Program {
          Method
        }
      }
      Trade {
        Dex {
          ProtocolFamily
          ProtocolName
        }
        Buy {
          Amount
          Account {
            Address
          }
          Currency {
            Name
            Symbol
            MintAddress
            Decimals
            Fungible
            Uri
          }
          Price
        }
        Sell {
          Amount
          Account {
            Address
          }
          Currency {
            Name
            Symbol
            MintAddress
            Decimals
            Fungible
            Uri
          }
          PriceInUSD
          Price
        }
      }
      Transaction {
        Signature
      }
    }
  }
}

How do I get the latest trades for a Pump.fun token?​

Retrieves recent trades with detailed price, amount, and sides Latest trades for one mint: run it ➤

Show the GraphQL
query pumpfunTokenLatestTrades($token: String) {
  Solana {
    DEXTradeByTokens(
      orderBy: { descending: Block_Time }
      limit: { count: 50 }
      where: {
        Trade: {
          Currency: { MintAddress: { is: $token } }
          Price: { gt: 0 }
          Dex: { ProtocolName: { is: "pump_amm" } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        allTime: Time
      }
      Trade {
        Account {
          Address
          Owner
        }
        Side {
          Type
        }
        Price
        Amount
        Side {
          AmountInUSD
          Amount
        }
      }
    }
  }
}
{
  "token": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
}

How do I get the volume of a Pump.fun token for the last 7 days?​

Use Bitquery's DEXTradeByTokens with sum(of: Trade_Amount) and a Block.Time.since filter (e.g. 7 days ago) to aggregate trading volume. Filter by token mint address and ProtocolName (pump_amm for PumpSwap, as in the PUMP example, or pump for the bonding curve). Trading volume for one mint: run it ➤

Show the GraphQL
query MyQuery {
  Solana(dataset: archive) {
    DEXTradeByTokens(
      where: {
        Trade: {
          Currency: {
            MintAddress: { is: "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn" }
          }
          Dex: { ProtocolName: { is: "pump_amm" } }
        }
        Block: { Time: { since_relative: { days_ago: 7 } } }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          MintAddress
        }
        Dex {
          ProtocolName
          ProtocolFamily
        }
      }
      TradeVolumeRaw: sum(of: Trade_Amount)
      TradeVolumeUSD: sum(of: Trade_Side_AmountInUSD)
    }
  }
}

In addition, you can get the last 7 days of trading volume using the Crypto Price API. Example:

Last 7 days of volume: run it ➤

{
  Trading {
    Tokens(
      where: {
        Block: { Date: { since_relative: { days_ago: 7 } } }
        Interval: { Time: { Duration: { eq: 3600 } } }
        Token: {
          Address: { is: "cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij" }
        }
      }
    ) {
      sum(of: Volume_Usd)
    }
  }
}

How do I get all tokens traded on Pump.fun in the last 1 hour?​

To list everything traded on Pump.fun in the last hour, filter trades by the protocol and a block time inside that window. This provides a list of tokens that have had at least one trade during this window, along with associated token and market details. Each token record includes its mint address, name, symbol, and network. The sample GraphQL query below retrieves all Pump.fun tokens traded in the last hour on Solana:

Everything traded in the last hour: run it ➤

Show the GraphQL
{
  Trading {
    Pairs(
      limitBy: { by: Token_Address, count: 1 }
      where: {
        Market: {
          Program: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
        }
        Token: { Network: { is: "Solana" } }
        Block: { Time: { since_relative: { minutes_ago: 60 } } }
        Interval: { Time: { Duration: { eq: 1 } } }
      }
    ) {
      Token {
        Address
        Id
        IsNative
        Name
        Network
        Symbol
        TokenId
      }
      Market {
        Address
        Program
        Name
      }
    }
  }
}

How do I get tokens that reached a specific market cap on Pump.fun?​

To find mints that crossed a market-cap threshold, use the following example. It filters for tokens with a market cap greater than or equal to a provided value (for example, $10,000) on Solana within the last minute. Adjust the ge value in MarketCap to your chosen threshold.

Mints that reached a market cap: run it ➤

Show the GraphQL
{
  Trading {
    Pairs(
      limitBy: { by: Token_Address, count: 1 }
      where: {
        Market: {
          Program: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
        }
        Token: { Network: { is: "Solana" } }
        Supply: { MarketCap: { ge: 10000 } }
        Block: { Time: { since_relative: { minutes_ago: 1 } } }
        Interval: { Time: { Duration: { eq: 1 } } }
      }
    ) {
      Token {
        Address
        Id
        IsNative
        Name
        Network
        Symbol
        TokenId
      }
      Price {
        Average {
          Mean
          ExponentialMoving
          SimpleMoving
          WeightedSimpleMoving
        }
      }
      Supply {
        MarketCap
        FullyDilutedValuationUsd
        TotalSupply
      }
      Market {
        Address
        Program
        Name
      }
    }
  }
}

How do I get detailed trade stats (volume, buys, sells, makers, buyers, sellers)?​

Includes 5-minute and 1-hour metrics for deep token analytics. The windows use since_relative and after_relative, so they roll forward with no date to update; the example pair is the PUMP/USDC PumpSwap pool. Detailed trade stats: run it ➤

Show the GraphQL
query PairStats($token: String!, $pair_address: String!) {
  Solana(dataset: realtime) {
    DEXTradeByTokens(
      where: {
        Transaction: { Result: { Success: true } }
        Trade: {
          Currency: { MintAddress: { is: $token } }
          Market: { MarketAddress: { is: $pair_address } }
        }
        Block: { Time: { since_relative: { hours_ago: 1 } } }
      }
    ) {
      Trade {
        Currency {
          Name
          MintAddress
          Symbol
        }
        start: PriceInUSD(minimum: Block_Time)
        min5: PriceInUSD(
          minimum: Block_Time
          if: { Block: { Time: { after_relative: { minutes_ago: 5 } } } }
        )
        end: PriceInUSD(maximum: Block_Time)
        Dex {
          ProtocolName
          ProtocolFamily
          ProgramAddress
        }
        Market {
          MarketAddress
        }
        Side {
          Currency {
            Symbol
            Name
            MintAddress
          }
        }
      }
      makers: count(distinct: Transaction_Signer)
      makers_5min: count(
        distinct: Transaction_Signer
        if: { Block: { Time: { after_relative: { minutes_ago: 5 } } } }
      )
      buyers: count(
        distinct: Transaction_Signer
        if: { Trade: { Side: { Type: { is: buy } } } }
      )
      buyers_5min: count(
        distinct: Transaction_Signer
        if: {
          Trade: { Side: { Type: { is: buy } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
      sellers: count(
        distinct: Transaction_Signer
        if: { Trade: { Side: { Type: { is: sell } } } }
      )
      sellers_5min: count(
        distinct: Transaction_Signer
        if: {
          Trade: { Side: { Type: { is: sell } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
      trades: count
      trades_5min: count(if: { Block: { Time: { after_relative: { minutes_ago: 5 } } } })
      traded_volume: sum(of: Trade_Side_AmountInUSD)
      traded_volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { after_relative: { minutes_ago: 5 } } } }
      )
      buy_volume: sum(
        of: Trade_Side_AmountInUSD
        if: { Trade: { Side: { Type: { is: buy } } } }
      )
      buy_volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: {
          Trade: { Side: { Type: { is: buy } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
      sell_volume: sum(
        of: Trade_Side_AmountInUSD
        if: { Trade: { Side: { Type: { is: sell } } } }
      )
      sell_volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: {
          Trade: { Side: { Type: { is: sell } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
      buys: count(if: { Trade: { Side: { Type: { is: buy } } } })
      buys_5min: count(
        if: {
          Trade: { Side: { Type: { is: buy } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
      sells: count(if: { Trade: { Side: { Type: { is: sell } } } })
      sells_5min: count(
        if: {
          Trade: { Side: { Type: { is: sell } } }
          Block: { Time: { after_relative: { minutes_ago: 5 } } }
        }
      )
    }
  }
}
{
  "token": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "pair_address": "2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd"
}

How do I get the first 100 buyers of a Pump.fun token?​

Gets the first 100 wallets that bought. DEXTrades on Solana keeps only the recent window, so pick a mint launched inside it. First 100 buyers: run it ➤

Show the GraphQL
query MyQuery {
  Solana {
    DEXTrades(
      where: {
        Trade: {
          Buy: {
            Currency: {
              MintAddress: {
                is: "token mint address"
              }
            }
          }
        }
      }
      limit: { count: 100 }
      orderBy: { ascending: Block_Time }
    ) {
      Trade {
        Buy {
          Amount
          Account {
            Token {
              Owner
            }
          }
        }
      }
    }
  }
}

How do I check if the first 100 buyers are still holding?​

Pass the owner addresses from the query above. Each row is the latest balance of one token account, picked by slot and then by transaction index, so two balance changes in the same slot are read in the right order. A balance of 0 means the wallet sold or moved everything. A wallet with no row had no balance change in the real-time window (about 8 hours); for a token launched inside that window, every buyer has a row.

Show the GraphQL
query StillHolding($token: String!, $owners: [String!]!) {
  Solana(dataset: realtime) {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Account: { Owner: { in: $owners, not: "" } }
          Currency: { MintAddress: { is: $token, not: "" } }
        }
        Transaction: { Result: { Success: true } }
      }
      orderBy: [{ descending: Block_Slot }, { descending: Transaction_Index }]
      limitBy: { by: BalanceUpdate_Account_Address, count: 1 }
    ) {
      Block {
        Time
      }
      BalanceUpdate {
        Account {
          Owner
          Address
        }
        balance: PostBalance
      }
    }
  }
}
{
  "token": "token mint address",
  "owners": [
    "ApRJBQEKfmcrViQkH94BkzRFUGWtA8uC71DXu6USdd3n",
    "9nG4zw1jVJFpEtSLmbGQpTnpG2TiKfLXWkkTyyRvxTt6"
  ]
}

Token Liquidity, Pools & Pairs​

How do I get all trading pairs of a Pump.fun token?​

Lists all markets where the token is traded, including pair addresses All trading pairs for one mint: run it ➤

Show the GraphQL
{
  Solana {
    DEXTradeByTokens(
      where: {
        Trade: { Currency: { MintAddress: { is: "token mint address" } } }
      }
    ) {
      count
      Trade {
        Market {
          MarketAddress
        }
        Dex {
          ProgramAddress
          ProtocolName
          ProtocolFamily
        }
        Currency {
          MintAddress
          Symbol
        }
      }
    }
  }
}

How do I get liquidity of Pump.fun tokens?​

Returns the current balance of each token vault of the pools you pass, one row per vault. A PumpSwap pool has two vaults: the token and the quote token, usually WSOL. A bonding curve priced in SOL has one, the token, because it keeps its SOL as plain SOL, which Native: false leaves out. Pass the MarketAddress values from the trading-pairs query above. Each row is the vault's latest balance, picked by slot and then by transaction index. A pool with no trade in the real-time window (about 8 hours) returns no row.

Show the GraphQL
query PoolLiquidity($pools: [String!]!) {
  Solana(dataset: realtime) {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Currency: { Native: false }
          Account: { Owner: { in: $pools, not: "" } }
        }
        Transaction: { Result: { Success: true } }
      }
      orderBy: [{ descending: Block_Slot }, { descending: Transaction_Index }]
      limitBy: { by: BalanceUpdate_Account_Address, count: 1 }
    ) {
      Block {
        Time
      }
      BalanceUpdate {
        Account {
          Owner
          Address
        }
        Currency {
          MintAddress
          Symbol
        }
        Liquidity: PostBalance
      }
    }
  }
}
{
  "pools": ["pool address"]
}

How do I get bonding curve progress for a Pump.fun token?​

Use Bitquery's DEXPools with Pump.fun market address to get pool balances. Bonding curve progress = 100 - (((base_balance - 206900000) × 100) / 793100000). Combine with DEXTradeByTokens for volume and TokenSupplyUpdates for market cap. Please change the timestamp in the query to recent ones; the saved query might have outdated numbers. Market cap, liquidity, bonding curve, volume: run it ➤

Show the GraphQL
query MyQuery($time_1h_ago: DateTime, $token: String, $pairAddress: String) {
  Solana {
    volume: DEXTradeByTokens(
      where: {
        Trade: {
          Currency: { MintAddress: { is: $token } }
          Market: { MarketAddress: { is: $pairAddress } }
        }
        Block: { Time: { since: $time_1h_ago } }
        Transaction: { Result: { Success: true } }
      }
    ) {
      VolumeInUSD: sum(of: Trade_Side_AmountInUSD)
    }
    liquidity_and_BondingCurve: DEXPools(
      where: {
        Pool: { Market: { MarketAddress: { is: $pairAddress } } }
        Transaction: { Result: { Success: true } }
      }
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
    ) {
      Pool {
        Market {
          BaseCurrency {
            Name
            Symbol
          }
          QuoteCurrency {
            Name
            Symbol
          }
        }
        Base {
          Balance: PostAmount
          PostAmountInUSD
        }
        Quote {
          PostAmount
          PostAmountInUSD
        }
      }
    }
    marketcap_and_supply: TokenSupplyUpdates(
      where: {
        TokenSupplyUpdate: { Currency: { MintAddress: { is: $token } } }
        Transaction: { Result: { Success: true } }
      }
      limitBy: { by: TokenSupplyUpdate_Currency_MintAddress, count: 1 }
      orderBy: { descending: Block_Time }
    ) {
      TokenSupplyUpdate {
        MarketCap: PostBalanceInUSD
        Supply: PostBalance
        Currency {
          Name
          MintAddress
          Symbol
        }
      }
    }
    Price: DEXTradeByTokens(
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
      where: {
        Transaction: { Result: { Success: true } }
        Trade: {
          Currency: { MintAddress: { is: $token } }
          Market: { MarketAddress: { is: $pairAddress } }
        }
      }
    ) {
      Trade {
        Price
        PriceInUSD
      }
    }
  }
}
{
  "time_1h_ago": "2025-06-01T11:00:00Z",
  "token": "EskuW9PhydSiMTxnWbvYBLVvwWV9pKhG4yYM9SwFPump",
  "pairAddress": "BkivJgUrXRQtJyePt5MzJJe9Y2JXhUaFhpCJcgxkisD"
}

How do I get the last Pump.fun trade before a token graduates to PumpSwap AMM?​

Finds the final pool trade before a mint moves to PumpSwap. DEXPools keeps only the recent window, so it must have graduated inside it; drop the Market filter to list every recent graduation. Last Pump.fun trade before PumpSwap: run it ➤

Show the GraphQL
{
  Solana {
    DEXPools(
      where: {
        Pool: {
          Dex: { ProtocolName: { is: "pump" } }
          Base: { PostAmount: { eq: "206900000" } }
          Market: {
            BaseCurrency: {
              MintAddress: {
                is: "token mint address"
              }
            }
          }
        }
        Transaction: { Result: { Success: true } }
      }
      orderBy: { descending: Block_Time }
    ) {
      Transaction {
        Signer
        Signature
      }
      Instruction {
        Program {
          Method
        }
      }
      Pool {
        Base {
          ChangeAmount
          PostAmount
        }
        Quote {
          ChangeAmount
          ChangeAmountInUSD
          PostAmount
          PostAmountInUSD
          Price
          PriceInUSD
        }
        Dex {
          ProgramAddress
          ProtocolFamily
          ProtocolName
        }
        Market {
          BaseCurrency {
            Name
            Symbol
            MintAddress
          }
          MarketAddress
          QuoteCurrency {
            Name
            Symbol
            MintAddress
          }
        }
      }
    }
  }
}

Token Holder & Trader Insights​

How do I get dev's holdings of a Pump.fun token?​

Returns the developer's current balance of the token. Each row is the latest balance of one of the developer's token accounts, picked by slot and then by transaction index; add the rows if there is more than one. No row means the balance did not change in the real-time window (about 8 hours). The same query works for any other wallet.

Show the GraphQL
query DevHoldings($dev: String!, $token: String!) {
  Solana(dataset: realtime) {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Account: { Owner: { is: $dev, not: "" } }
          Currency: { MintAddress: { is: $token, not: "" } }
        }
        Transaction: { Result: { Success: true } }
      }
      orderBy: [{ descending: Block_Slot }, { descending: Transaction_Index }]
      limitBy: { by: BalanceUpdate_Account_Address, count: 1 }
    ) {
      Block {
        Time
      }
      BalanceUpdate {
        Account {
          Address
        }
        balance: PostBalance
      }
    }
  }
}
{
  "dev": "8oTWME5BPpudMksqEKfn562pGobrtnEpNsG66hBBgx92",
  "token": "token mint address"
}

How do I get top 10 token holders of a Pump.fun token?​

Returns the 10 wallets that hold the most of a token. A wallet's holding is the sum of all its balance changes for that mint, so the result equals current balances only for a token launched within the real-time window (about 8 hours). For an older token, use the V1 method on the Solana Token Holders API page. The bonding curve before graduation, and the PumpSwap pool after it, appear in the list as holders; drop those owners to see wallets only.

Do not rank holders with PostBalance(maximum: Block_Slot). When an account changes twice in one slot, that pick can return the older balance. At graduation a SOL-paired bonding curve goes from 206,900,000 tokens to 0 in one slot, and a wallet can sell out in several transactions in one slot. In both cases that query can return the old, nonzero balance, so the empty curve or the sold-out wallet shows up as a top holder.

Show the GraphQL
query TopHolders($token: String!) {
  Solana(dataset: realtime) {
    BalanceUpdates(
      limit: { count: 10 }
      orderBy: { descendingByField: "Holding" }
      where: {
        BalanceUpdate: { Currency: { MintAddress: { is: $token, not: "" } } }
        Transaction: { Result: { Success: true } }
      }
    ) {
      BalanceUpdate {
        Account {
          Owner
        }
      }
      Holding: sum(of: BalanceUpdate_Amount)
    }
  }
}
{
  "token": "token mint address"
}

How do I get top traders of a Pump.fun token?​

Use Bitquery's DEXTradeByTokens with orderBy: descendingByField: "volumeUsd", limit: 100, and sum(of: Trade_Side_AmountInUSD) grouped by Trade.Account.Owner to rank top wallets by USD volume for a Pump.fun token. Top traders: run it ➤

Show the GraphQL
query TopTraders($token: String) {
  Solana {
    DEXTradeByTokens(
      orderBy: { descendingByField: "volumeUsd" }
      limit: { count: 100 }
      where: {
        Trade: { Currency: { MintAddress: { is: $token } } }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Trade {
        Account {
          Owner
        }
      }
      bought: sum(
        of: Trade_Amount
        if: { Trade: { Side: { Type: { is: buy } } } }
      )
      sold: sum(
        of: Trade_Amount
        if: { Trade: { Side: { Type: { is: sell } } } }
      )
      volume: sum(of: Trade_Amount)
      volumeUsd: sum(of: Trade_Side_AmountInUSD)
    }
  }
}
{
  "token": "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
  "pool": "5Ezr4oK1vTV4m8f7g8P1Be1uwtzczhf21AztwNxWcmwM"
}

How do I get top Pump.fun token creators?​

Find wallet addresses of top creators by number of tokens launched Top creators: run it ➤

tip

Want to dive deeper into a creator's background? Ask an AI agent via the Bitquery MCP server to trace the source of funds for any Pump.fun creator (AI Investigations), or use our Money Flow API to analyze funding history directly.

Show the GraphQL
query MyQuery {
  Solana(network: solana) {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Name: { is: "pump" }
            Method: { in: ["create", "create_v2"] }
          }
        }
      }
      orderBy: { descendingByField: "tokens_count" }
    ) {
      tokens_count: count
      Transaction {
        Signer
      }
    }
  }
}

Token Security & Analysis​

How do I check if a Pump.fun token is phishy?​

This uses two queries to flag a possibly phishy mint, by comparing transfers against trades. It surfaces wallets that received a balance without ever buying, a common pattern in phishing and airdrop scams.

How It Works​

The detection method works by:

  1. First Query: get the first transfers to each address, giving the timestamp when each wallet first received a balance.
  2. Second Query: Check if those addresses ever bought the token and when - pass the address list from the first query as a variable to check their purchase history.
  3. Analysis: Compare transfer times and trade times in your code:

    • If an address never bought the token, it's suspicious.

    • If an address's first buy time is later than the first transfer time, it indicates the token was received before being purchased, which is a red flag for phishing behavior.

      That pattern means someone else sent them the balance, which is suspicious: devs often push supply to well-known accounts in crypto space to misguide traders.

Pick a token launched within the recent window, since the Transfers and DEXTrades cubes on Solana keep no archive. Whether it is phishy is not decided here, as we are not running the timestamp comparison. Here we are just demonstrating that how you can get data from Bitquery and later run basic analysis on it.

Query 1: Get First Transfers of a Token to Addresses​

This retrieves the first transfer to each address, with the timestamp when that wallet first received a balance.

Run Query

Show the GraphQL
query MyQuery($token: String, $bonding_curve: String) {
  Solana {
    Transfers(
      limit: { count: 1000 }
      orderBy: { ascendingByField: "Block_first_transfer" }
      where: {
        Transfer: {
          Receiver: { Token: { Owner: { not: $bonding_curve } } }
          Currency: { MintAddress: { is: $token } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Transfer {
        Receiver {
          Token {
            Owner
          }
        }
      }
      Block {
        first_transfer: Time(minimum: Block_Time)
      }
      total_transferred_amount: sum(of: Transfer_Amount)
    }
  }
}
{
  "token": "token mint address",
  "bonding_curve": "bonding curve address"
}

Query 2: Get First Buys of an Address List for a Specific Token​

This query checks if the addresses from Query 1 ever bought the token and when. Pass the address array from Query 1 as a variable to this query.

Run Query

Show the GraphQL
query MyQuery($token: String!, $buyersList: [String!]) {
  Solana {
    DEXTradeByTokens(
      orderBy: { ascendingByField: "Block_first_buy" }
      where: {
        Trade: {
          Account: { Token: { Owner: { in: $buyersList } } }
          Currency: { MintAddress: { is: $token } }
          Dex: {
            ProgramAddress: {
              is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
            }
          }
          Side: { Type: { is: buy } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Trade {
        Account {
          Token {
            Owner
          }
        }
        Currency {
          Name
          Symbol
          MintAddress
        }
        Side {
          Type
        }
      }
      Block {
        first_buy: Time(minimum: Block_Time)
      }
      total_bought_amount: sum(of: Trade_Amount)
    }
  }
}
{
  "token": "token mint address",
  "buyersList": [ PASS THE ADDRESS LIST YOU GOT FROM QUERY 1 HERE ]
}

Implementation Notes​

  • Extract the address list and first transfer timestamps from Query 1
  • Pass the address array as a variable to Query 2
  • Compare the timestamps for all addresses:
    • If firstTransferTime < firstBuyTime or firstBuyTime is null → Phishy indicator
    • If firstBuyTime <= firstTransferTime → Normal behavior
  • You can implement this logic in your application code to automatically flag suspicious tokens

Token Rankings & Filters​

How do I get top Pump.fun tokens by market cap?​

Use Trading API Pairs: rank by Supply.MarketCap over the last 24 hours, 1s interval, Market.ProtocolFamily Pumpfun, Volume.Usd > 1000, Solana tokens, limitBy one row per Token_Id, up to 50 results.

Top mints by market cap: run it ➤

Show the GraphQL
{
  Trading {
    Pairs(
      limit: { count: 50 }
      limitBy: { count: 1, by: Token_Id }
      orderBy: { descending: Supply_MarketCap }
      where: {
        Block: { Time: { since_relative: { hours_ago: 24 } } }
        Interval: { Time: { Duration: { eq: 1 } } }
        Market: { ProtocolFamily: { is: "Pumpfun" } }
        Volume: { Usd: { gt: 1000 } }
        Token: { Network: { is: "Solana" } }
      }
    ) {
      Currency {
        Id
        Name
        Symbol
      }
      Price {
        Average {
          Mean(maximum: Block_Time)
        }
      }
      Volume {
        Base(maximum: Block_Time)
        Quote(maximum: Block_Time)
        Usd(maximum: Block_Time)
      }
      Token {
        Network
        Symbol
        Address
      }
      Supply {
        MarketCap(maximum: Block_Time)
        FullyDilutedValuationUsd(maximum: Block_Time)
        TotalSupply(maximum: Block_Time)
      }
    }
  }
}

How do I get all Pump.fun tokens above 10K market cap?​

Subscribe to Trading Pairs when the token is on Solana, Market.ProtocolFamily is Pumpfun, Supply.MarketCap > 10,000 (USD), and interval duration > 1 second.

Mints above 10K market cap: stream it ➤

Show the subscription
subscription {
  Trading {
    Pairs(
      where: {
        Token: { Id: { includesCaseInsensitive: "solana" } }
        Interval: { Time: { Duration: { gt: 1 } } }
        Supply: { MarketCap: { gt: 10000 } }
        Market: { ProtocolFamily: { is: "Pumpfun" } }
      }
    ) {
      Currency {
        Name
        Id
        Symbol
      }
      Token {
        Name
        Symbol
        Id
        Address
        Network
      }
      Market {
        Protocol
        ProtocolFamily
      }
      Supply {
        TotalSupply
        FullyDilutedValuationUsd
        MarketCap
      }
    }
  }
}

How do I track "King of the Hill" Pump.fun tokens (30K–35K market cap)?​

Tokens in the $30K–$35K Supply.MarketCap band on Pumpfun (see Pump.fun on King of the Hill). Subscribe to Trading Pairs with MarketCap between 30,000 and 35,000 USD.

“King of the Hill” mints: stream it ➤

Show the subscription
subscription {
  Trading {
    Pairs(
      where: {
        Token: { Id: { includesCaseInsensitive: "solana" } }
        Interval: { Time: { Duration: { gt: 1 } } }
        Supply: { MarketCap: { gt: 30000, lt: 35000 } }
        Market: { ProtocolFamily: { is: "Pumpfun" } }
      }
    ) {
      Currency {
        Name
        Id
        Symbol
      }
      Token {
        Name
        Symbol
        Id
        Address
        Network
      }
      Market {
        Protocol
        ProtocolFamily
      }
      Supply {
        TotalSupply
        FullyDilutedValuationUsd
        MarketCap
      }
    }
  }
}

Trader-Focused Trade APIs (with USD Price, Market Cap & Supply)​

The queries below use the Trades cube (Trading { Trades }) which is trader-focused and provides reliable USD prices including for all tokens. See DEXTrades vs DEXTradeByTokens vs Trades cube for when to use which.

Get All DEX Trades on PumpFun With Price, Market Cap, and Supply​

Stream all PumpFun DEX trades in real time with USD price, market cap, FDV, circulating supply, and transaction fee data. Filter by Pair.Market.ProtocolFamily: Pumpfun to capture every swap across Pumpfun in a single subscription.

You can run this subscription in the Bitquery IDE.

Show the GraphQL
subscription {
  Trading {
    Trades(where: { Pair: { Market: { ProtocolFamily: { is: "Pumpfun" } } } }) {
      Side
      Supply {
        MaxSupply
        TotalSupply
        FullyDilutedValuationUsd
        CirculatingSupply
        MarketCap
      }
      Trader {
        Address
      }
      TransactionHeader {
        Fee
        FeePayer
        Sender
        To
        Hash
        Index
      }
      Amounts {
        Base
        Quote
      }
      AmountsInUsd {
        Base
        Quote
      }
      Block {
        Date
        Time
        Timestamp
      }
      Pair {
        Currency {
          Id
          Name
          Symbol
        }
        Market {
          Address
          Program
          Network
        }
        Currency {
          Symbol
          Id
          Name
        }
        QuoteCurrency {
          Id
          Name
          Symbol
        }
        Token {
          Address
          Id
          IsNative
          Symbol
          TokenId
          Network
        }
        QuoteToken {
          Address
          Id
          IsNative
          Symbol
          TokenId
          Network
        }
      }
      Price
      PriceInUsd
    }
  }
}

Top Traders by PnL for a Specific PumpFun Token (Last 30 Minutes)​

Rank traders by PnL on one pool: filter Pair.Market.Address, last 30 minutes, limit: 10, and orderBy PnL descending. Useful for leaderboards, smart-money screens, and pool-specific trader analytics. The example pool is the PUMP/USDC PumpSwap pool; for a bonding curve, use the curve's market address from the latest trades query.

You can run this query in the Bitquery IDE.

Show the GraphQL
{
  Trading {
    Trades(
      limit: { count: 10 }
      orderBy: { descendingByField: "PnL" }
      where: {
        Block: { Time: { since_relative: { minutes_ago: 30 } } }
        Pair: {
          Market: {
            Address: { is: "2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd" }
          }
        }
      }
    ) {
      Trader {
        Address
      }
      Amount_Bought: sum(of: AmountsInUsd_Base, if: { Side: { is: "Buy" } })
      Amount_Sold: sum(of: AmountsInUsd_Base, if: { Side: { is: "Sell" } })
      Amount_Bought_native: sum(of: Amounts_Base, if: { Side: { is: "Buy" } })
      Amount_Sold_native: sum(of: Amounts_Base, if: { Side: { is: "Sell" } })
      PnL: calculate(expression: "$Amount_Sold - $Amount_Bought")
      buys: count(if: { Side: { is: "Buy" } })
      sells: count(if: { Side: { is: "Sell" } })
    }
  }
}

Get Latest Creator Fee Transfers on Pump.fun​

Retrieve the 10 most recent creator fee collections on the Pump.fun bonding curve program. Filter Instruction.Program.Method: "collect_creator_fee" and Instruction.Program.Address: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" to get balance updates showing who collected, how much, and from which token.

You can run this query in the Bitquery IDE.

Show the GraphQL
{
  Solana(network: solana) {
    InstructionBalanceUpdates(
      limit: {count: 10}
      orderBy: {descending: Block_Time}
      where: {Instruction: {Program: {Method: {is: "collect_creator_fee"}, Address: {is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"}}}, Transaction: {Result: {Success: true}}}
    ) {
      Transaction {
        Signer
        Signature
        Result {
          Success
          ErrorMessage
        }
        Index
        Fee
      }
      Block {
        Time
        Hash
      }
      BalanceUpdate {
        Account {
          Address
          Owner
          Token {
            Owner
          }
        }
        Amount
        AmountInUSD
        Currency {
          Name
          MintAddress
          Symbol
        }
        PreBalance
        PostBalance
      }
    }
  }
}

Does pump.fun have an official API?​

Not a hosted one. Pump.fun publishes program documentation and IDLs on GitHub for the bonding curve program, PumpSwap and its fee program, which is what you need to build and sign transactions. It publishes no data API: the hosts its web app calls have no reference, no published rate limits, no schema and no stability promise, so anything built on them can break without notice. The queries on this page read the same on-chain activity through Bitquery, with a documented schema, plan-based rate limits, and streaming over WebSocket, gRPC and Kafka.

Pump.funBitquery Pump.fun API
DocumentationProgram docs and IDLs on GitHub; no data API referenceSchema, examples and IDE links on this page
Trades, prices, candles, launchesServed to the pump.fun web app by undocumented hostsGraphQL queries, WebSocket subscriptions, gRPC and Kafka streams
HistoryNone publishedHistorical datasets for trades and token creation, realtime window for pools and transfers, Parquet exports through cloud datasets
Rate limitsUnpublished30, 90 or 240 requests a minute by plan, custom on Enterprise
AccessNo key or documented third-party accessAccess token, seven-day free trial

API key, free trial and pricing​

Create an access token at account.bitquery.io and follow how to generate a token; there is no approval step. The free trial runs for seven days and includes 1,000 API points, 100 MCP credits and two simultaneous streams. Request rate limits by plan are 30 a minute on Personal, 90 on Pro and 240 on Scale, with custom limits on Enterprise; see rate limits. Points and streams are explained on how billing works, and plan prices are on the Pump.fun API product page and the pricing page.

Video Tutorials​

Pump.Fun API | Get Live Prices, Metadata, OHLCV, Trading Pair Stats, Charts​

Video Tutorial on Getting Pump.fun Trades​

Video Tutorial | How to Get the OHLC Data & Price of a Token on Pump.fun DEX in Realtime​

Video Tutorial | How to get Top Token Holders and Trading Volume for a Pump.fun Token​

Video Tutorial | How to get Top Traders of a Token on Solana Pump.fun DEX​

Video Tutorial | How to get first 100 Buyers of a Pump.fun Token​

Video Tutorial | How to get Top Token Creators on Pump.fun​

Video Tutorial | How to get Newly Created Pump.fun Tokens, Dev Address, Creation Time, Metadata​

Video Tutorial | How to get all Pump.fun Tokens created by a Dev​

Video Tutorial | How to get Liquidity of a Pump.fun Token​

Video Tutorial | Pump.fun Mayhem Mode API​

Why does my Pump.fun query return "columns not available in combined dataset"?​

Fields like Trade.Side are only available with dataset: realtime. For historical queries use dataset: archive (or combined, which adds the realtime tail) and avoid Trade_Side, Trade_Side_Type, and similar realtime-only fields.

Frequently Asked Questions

Does pump.fun have an official API?

Not a hosted one. Pump.fun publishes program docs and IDLs on GitHub for building transactions, but no data API for trades, prices, candles or launches. Bitquery reads that activity from the chain and serves it over GraphQL, WebSocket, gRPC and Kafka.

What is the Pump.fun program address on Solana?

The bonding curve program is 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Graduated tokens trade on PumpSwap at pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA. In Bitquery trade data the venues appear as ProtocolName pump and pump_amm.

Do I need an API key, and is there a free tier?

Yes, an access token from account.bitquery.io, generated without an approval step. The seven-day trial includes 1,000 API points, 100 MCP credits and two simultaneous streams; paid plans are listed on the pricing page.

Can I stream new Pump.fun token launches in real time?

Yes. Subscribe to TokenSupplyUpdates or Instructions filtered by the Pump.fun program and the create methods, as shown in the launches section, or use the gRPC and Kafka streams for lower latency.

How do I get Pump.fun OHLCV candles?

Use Trading.Tokens or Trading.Pairs with an Interval duration in seconds for pre-built candles, or aggregate DEXTradeByTokens by time as shown in the OHLCV section. Both return open, high, low, close and volume.

How do I get a Pump.fun token's all-time high price?

Query DEXTradeByTokens with dataset archive and PriceInUSD(maximum: Trade_PriceInUSD) for the token since its launch, as shown in the ATH section; a 0.98 quantile alongside it filters one-off outlier prints.

How do I get Pump.fun creator fee data?

Query InstructionBalanceUpdates for collect_creator_fee instructions on the Pump.fun program, as shown in the creator fee section; each row carries the signer, signature and the balance changes of the fee collection.

How do I get the current price of a Pump.fun token?

Query DEXTrades or Trading.Trades filtered by the mint and Pump.fun program address 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Trading.Trades includes USD price on every row for the last ~30 days.

How do I track new Pump.fun token launches?

Subscribe to creation or pool events filtered by the Pump.fun program, or poll DEXPools for new pairs. Examples on this page include real-time subscription queries.

Does Bitquery have historical Pump.fun data?

Yes. Use dataset: archive for older trades and bonding-curve history, and dataset: realtime for the latest window. On Solana, combined returns the same rows as archive rather than merging the realtime tail.

How do I know when a token graduated to PumpSwap?

Tokens that hit the bonding curve target appear in PumpSwap pools. Filter DEXPools with Base.PostAmount equal to 206900000 or follow the Pump Fun to PumpSwap guide.

Build with Bitquery

Ready to run this in production?

Get an API key and run these queries in minutes, or talk to us about plans and enterprise delivery.

Get your API keyBuy Pump.fun history as filesSee pricingTry the MCP serverSubscribe to newsletter
Talk to the teamTelegramEmail

On this page