Skip to main content

Pump.fun API - Live Prices, OHLCV, ATH, MarketCap

The Bitquery Pump.fun API provides real-time and historical data for Pump.fun memecoin trades on Solana via GraphQL. Use Bitquery to get live trades, new token launches, OHLCV, bonding curve progress, top traders, and tokens migrated to PumpSwap. Access via REST, WebSocket subscriptions, gRPC streams, or Kafka. Filter by program address 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. For other data points, reach out to support.

Try Our PumpFun Token Sniffer

Want to analyze Pump.fun tokens for potential phishing risks? 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 Pumpfun data? Read about our Shred Streams and Contact us for a Trial. For gRPC streaming: 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 ➤

Table of Contents​

1. Token Creation and Metadata​

2. Pump.fun Mayhem Mode Tokens​

3. Token Pricing & Market Data​

4. Trade Activity & Volume​

5. Token Liquidity, Pools & Pairs​

6. Token Holder & Trader Insights​

7. Token Security & Analysis​

8. Token Rankings & Filters​

9. Frequently Asked Questions​

10. Video Tutorials​

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, token creation, and bonding curve data by this program ID.

6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P

Use this program ID when filtering Solana instructions or token supply updates for Pump.fun tokens. 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" } }.

Token Creation & Metadata​

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

Use Bitquery's TokenSupplyUpdates subscription filtered by the Pump.fun program create or create_v2 method to get metadata, supply, and dev address of newly created tokens in real time. Try New Pump.fun Tokens Query ➤

Click to expand GraphQL query
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 ➤

Click to expand GraphQL query
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 token creation events with mint address, bonding curve, metadata, creator, name, symbol, and URI.

Track Pump.fun token launches in realtime — Stream ➤

Click to expand GraphQL query
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?​

All Pump.fun tokens created by an address — Query ➤

tip

Want to analyze the funding history and transaction patterns of a creator? Check out our Money Flow API to track fund movements and understand creator behavior.

Click to expand GraphQL query
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 Pump.fun tokens created by a specific wallet 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 tokens created by a wallet), use the dedicated count query below.

Click to expand GraphQL query
{
  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?​

Now you can track the newly created Pump.fun Tokens along with their dev address, metadata and supply. PostBalance will give you the current supply for the token. Newly created Pump.fun tokens with dev, metadata — Stream ➤

Click to expand GraphQL query
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.

If you need to check for a old pump.fun token if it was created with Mayhem mode true or false then 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?​

Track Pump.fun tokens created in real time with Mayhem mode enabled. This API lets you monitor all new tokens launched with Mayhem set to true. Try the API here.

Click to expand GraphQL query
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 of a Pump Fun Token — Query ➤

Click to expand GraphQL query
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 utilize 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

Click to expand GraphQL query
{
  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 PumpFun token prices.

PumpFun Token prices against SOL Stream Pump.fun token latest price in USD — Query ➤

Click to expand GraphQL query
{
  Trading {
    Pairs(
      where: {
        Market: { Network: { is: "Solana" } }
        Token: {
          Address: { is: "FXm5giasijiQEjR9isXSyW3TXiFGsR7unows3gvzpump" }
        }
        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 Pump.fun token price in real time — Stream ➤

Click to expand GraphQL query
subscription {
  Trading {
    Pairs(
      where: {
        Token: {
          Address: { is: "BUWg5Fhzvwn2xm4EYoaSFGNZXFRk8ThYe9h5R5GaXipE" }
        }
        Price: { IsQuotedInUsd: true }
        Market: {
          Network: { is: "Solana" }
          Program: { is: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P" }
        }
      }
    ) {
      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?​

Use the below query to get top 10 Pump.fun tokens by price change in the last 5 minutes. Test the query here.

Click to expand GraphQL query
{
  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 dataset: combined, some fields like Trade_Side may be limited. OHLC for a token on Pump.fun — Query ➤

note

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

Click to expand GraphQL query
{
  Solana(dataset: combined) {
    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: combined, 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 — Pump.fun Query ➤

Click to expand GraphQL query
{
  Solana(dataset: combined) {
    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 Pump.fun token price change over time — Query ➤

Click to expand GraphQL query
query PumpFunRecentTrades {
  Solana {
    DEXTradeByTokens(
      where: {
        Block: { Time: { since_relative: { minutes_ago: 60 } } }
        Trade: {
          Currency: {
            MintAddress: { is: "EEaSCMNk1aZxZmT7rXTP2gNWmEeyTVq99yeCEjNfRzbz" }
          }
          Dex: { ProtocolName: { is: "pump" } }
        }
        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 and starter PnL queries). 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 ➤

Click to expand GraphQL query
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 a Pump.fun token — Query ➤

Click to expand GraphQL query
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" } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        allTime: Time
      }
      Trade {
        Account {
          Address
          Owner
        }
        Side {
          Type
        }
        Price
        Amount
        Side {
          AmountInUSD
          Amount
        }
      }
    }
  }
}
{
  "token": "FbhypAF9LL93bCZy9atRRfbdBMyJAwBarULfCK3roP93"
}

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". Trading volume of a Pump.fun token — Query ➤

Click to expand GraphQL query
query MyQuery {
  Solana(dataset: combined) {
    DEXTradeByTokens(
      where: {
        Trade: {
          Currency: {
            MintAddress: { is: "EEaSCMNk1aZxZmT7rXTP2gNWmEeyTVq99yeCEjNfRzbz" }
          }
          Dex: { ProtocolName: { is: "pump" } }
        }
        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 for any token — Query ➤

{
  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 get all tokens traded on Pump.fun in the last 1 hour, use a query that filters trades by the Pump.fun protocol and a block time within the past hour. 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:

All Pumpfun Tokens traded in last 1 hour — Query ➤

Click to expand GraphQL query
{
  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 tokens on Pump.fun that have reached a specific market capitalization threshold, you can use the following Bitquery GraphQL example. This query 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.

View Pump.fun tokens that reached a specific market cap — Query ➤

Click to expand GraphQL query
{
  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 Pump.fun token detailed trade stats — Query ➤

Click to expand GraphQL query
query MyQuery(
  $token: String!
  $pair_address: String!
  $time_5min_ago: DateTime!
  $time_1h_ago: DateTime!
) {
  Solana(dataset: realtime) {
    DEXTradeByTokens(
      where: {
        Transaction: { Result: { Success: true } }
        Trade: {
          Currency: { MintAddress: { is: $token } }
          Market: { MarketAddress: { is: $pair_address } }
        }
        Block: { Time: { since: $time_1h_ago } }
      }
    ) {
      Trade {
        Currency {
          Name
          MintAddress
          Symbol
        }
        start: PriceInUSD(minimum: Block_Time)
        min5: PriceInUSD(
          minimum: Block_Time
          if: { Block: { Time: { after: $time_5min_ago } } }
        )
        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: $time_5min_ago } } }
      )
      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: $time_5min_ago } }
        }
      )
      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: $time_5min_ago } }
        }
      )
      trades: count
      trades_5min: count(if: { Block: { Time: { after: $time_5min_ago } } })
      traded_volume: sum(of: Trade_Side_AmountInUSD)
      traded_volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { after: $time_5min_ago } } }
      )
      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: $time_5min_ago } }
        }
      )
      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: $time_5min_ago } }
        }
      )
      buys: count(if: { Trade: { Side: { Type: { is: buy } } } })
      buys_5min: count(
        if: {
          Trade: { Side: { Type: { is: buy } } }
          Block: { Time: { after: $time_5min_ago } }
        }
      )
      sells: count(if: { Trade: { Side: { Type: { is: sell } } } })
      sells_5min: count(
        if: {
          Trade: { Side: { Type: { is: sell } } }
          Block: { Time: { after: $time_5min_ago } }
        }
      )
    }
  }
}
{
  "token": "3se1Bd46JqPiobyxtnwKWaLVnQK8RaAKHVtuCq4rRiog",
  "pair_address": "7NhN7yzHkuttbA8JBqboRXTXmMi3DkJ61MN3SgEPg5VZ",
  "time_5min_ago": "2025-02-18T10:10:00Z",
  "time_1h_ago": "2025-02-18T09:15:00Z"
}

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

Get wallet addresses of first 100 accounts who bought a token First 100 buyers of a Pump.fun token — Query ➤

Click to expand GraphQL query
query MyQuery {
  Solana {
    DEXTrades(
      where: {
        Trade: {
          Buy: {
            Currency: {
              MintAddress: {
                is: "2Z4FzKBcw48KBD2PaR4wtxo4sYGbS7QqTQCLoQnUpump"
              }
            }
          }
        }
      }
      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 above query to evaluate holdings Holdings of first 100 buyers — Pump.fun Query ➤

Click to expand GraphQL query
query MyQuery {
  Solana {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Account: {
            Token: {
              Owner: {
                in: [
                  "ApRJBQEKfmcrViQkH94BkzRFUGWtA8uC71DXu6USdd3n"
                  "9nG4zw1jVJFpEtSLmbGQpTnpG2TiKfLXWkkTyyRvxTt6"
                ]
              }
            }
          }
          Currency: { MintAddress: { is: "token mint address" } }
        }
      }
    ) {
      BalanceUpdate {
        Account {
          Token {
            Owner
          }
        }
        balance: PostBalance(maximum: Block_Slot)
      }
    }
  }
}

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 of a Pump.fun token — Query ➤

Click to expand GraphQL query
{
  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?​

Gets pool token balances for liquidity estimation across multiple known pool accounts Pump.fun pools and token balances — Query ➤

Click to expand GraphQL query
{
  Solana {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Currency: { Native: false }
          PostBalance: { gt: "0" }
          Account: {
            Owner: {
              in: [
                "7jVYY8nUjbt5gzLt3tZJaHD9NSMyaTuvPhJLfazmjjyy"
                "7iDwUGUDLccKdWN5hUppoqxLeUMjw7BieQAFdTwj3F5V"
              ]
            }
          }
        }
      } # add pool address here
      limit: { count: 10 }
      orderBy: { descending: Block_Time }
    ) {
      BalanceUpdate {
        Account {
          Token {
            Owner
          }
          Owner
          Address
        }
        Currency {
          MintAddress
          Native
        }
        Liquidity: PostBalance(maximum: Block_Slot)
      }
    }
  }
}

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 — Pump.fun Query ➤

Click to expand GraphQL query
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 token transitions to PumpSwap Last Pump.fun trade before PumpSwap — Query ➤

Click to expand GraphQL query
{
  Solana {
    DEXPools(
      where: {
        Pool: {
          Dex: { ProtocolName: { is: "pump" } }
          Base: { PostAmount: { eq: "206900000" } }
          Market: {
            BaseCurrency: {
              MintAddress: {
                is: "3Tf4ZSdJ6vvFY2ob9DDYFgFRGSgCxDm6MfBViY8ppump"
              }
            }
          }
        }
        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 token holdings Developer holdings of a Pump.fun token — Query ➤

Click to expand GraphQL query
query MyQuery($dev: String, $token: String) {
  Solana {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Account: { Owner: { is: $dev } }
          Currency: { MintAddress: { is: $token } }
        }
      }
    ) {
      BalanceUpdate {
        balance: PostBalance(maximum: Block_Slot)
      }
    }
  }
}
{
  "dev": "8oTWME5BPpudMksqEKfn562pGobrtnEpNsG66hBBgx92",
  "token": "token mint address"
}

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

Returns wallet addresses and holdings of top 10 token holders Top 10 holders of a Pump.fun token — Query ➤

Click to expand GraphQL query
query MyQuery {
  Solana(dataset: realtime) {
    BalanceUpdates(
      limit: { count: 10 }
      orderBy: { descendingByField: "BalanceUpdate_Holding_maximum" }
      where: {
        BalanceUpdate: {
          Currency: { MintAddress: { is: "token mint address" } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      BalanceUpdate {
        Currency {
          Name
          MintAddress
          Symbol
        }
        Account {
          Address
        }
        Holding: PostBalance(maximum: Block_Slot)
      }
    }
  }
}

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 of a Pump.fun token — Query ➤

Click to expand GraphQL query
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": "FbhypAF9LL93bCZy9atRRfbdBMyJAwBarULfCK3roP93",
  "pool": "5Ezr4oK1vTV4m8f7g8P1Be1uwtzczhf21AztwNxWcmwM"
}

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

Find wallet addresses of top creators by number of tokens launched Top Pump.fun token creators — Query ➤

tip

Want to dive deeper into a creator's background? Use our Money Flow API to analyze funding history and trace the source of funds for any Pump.fun creator.

Click to expand GraphQL query
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 elaborative API approach uses two queries to detect if a Pump.fun token is potentially phishy by analyzing the relationship between token transfers and trades. This approach helps identify tokens where recipients received tokens without purchasing them, which is a common pattern in phishing or airdrop scams.

How It Works​

The detection method works by:

  1. First Query: Get the first transfers of a token to addresses - this provides the timestamp of when each address first received the token.
  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.

      Above analysis means someone else transferred the token to them which is phishy because devs often send token to famous KOLs or Influential People in crypto space to misguide traders.

We are taking here example of 3Fymji2JPhhbKuCzNPKEyjdEuF9cyFuQ8HksyjRGpump token, this may or may not be phishy as we are not running the further comparison between timestamps. 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 query retrieves the first transfer of a token to each address, providing the timestamp when each address first received the token.

Run Query

Click to expand GraphQL query
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": "3Fymji2JPhhbKuCzNPKEyjdEuF9cyFuQ8HksyjRGpump",
  "bonding_curve": "6AMeqEdepfKKmTQAwcMvbrwugcaJaXtt3MsJGy7WdXpk"
}

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

Click to expand GraphQL query
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": "3Fymji2JPhhbKuCzNPKEyjdEuF9cyFuQ8HksyjRGpump",
  "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 Pump.fun tokens by market cap — Query ➤

Click to expand GraphQL query
{
  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.

Pump.fun tokens above 10K market cap — Stream ➤

Click to expand GraphQL 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.

Pump.fun “King of the Hill” tokens — Stream ➤

Click to expand GraphQL 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
      }
    }
  }
}

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​

Frequently Asked Questions​

Can I get Pump.fun token trade data via gRPC or Kafka stream?​

Yes. Bitquery offers gRPC streams and Kafka for Pump.fun trades. Contact sales for a trial of zero-latency Pumpfun data Streams.

What is the rate limit for the Pump.fun API?​

Rate limits depend on your Bitquery plan. See authorisation for API token limits and upgrade options.

Does Bitquery support historical Pump.fun data?​

Yes. Use dataset: combined in your GraphQL query for historical data. For real-time only (last ~8 hours on PumpSwap), use dataset: realtime. See historical aggregate data for details.

How do I get tokens that migrated from Pump.fun to PumpSwap?​

Use the Pump Fun to Pump Swap guide. Filter DEXPools by Base.PostAmount: { eq: "206900000" } to find tokens that graduated, or subscribe to pool creation events.

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

The Trade.Side and some other fields are only available with dataset: realtime. For historical queries with dataset: combined, avoid Trade_Side, Trade_Side_Type, and similar realtime-only fields. Use DEXTradeByTokens fields that work in both datasets.