Skip to main content

Four Meme API

Need real-time Four.meme data or anything from the last ~30 days?

For real-time + last ~30 days, use the Trading cube — Trading.Trades gives you clean, MEV-filtered swaps with USD price, market cap, and supply on every row across 8 chains in one API. Four.meme examples using Trading.Trades are also shown in the "Trader-Focused Trade APIs" section below. Use the raw chain-level queries on this page when you need historical Four.meme data older than ~30 days or call / event context.

Bitquery exposes four.meme (Four Meme) on BNB Chain through GraphQL: live trades (fourmeme_v1), TokenCreate events on the exchange proxy, bonding curve math from proxy balances, migrations to PancakeSwap, OHLCV, liquidity events, and leaderboards. Use subscriptions for real-time streams and dataset: combined for history. The Four Meme exchange proxy used in examples is 0x5c952063c7fc8610ffdb798152d69f0b9550762b (see below).

The sections below are example queries and streams. For other fields, contact support.

Need low-latency BSC data? See Streams and contact us for a trial. For mempool (pre-confirmation) Four Meme data, see the dedicated Four Meme Mempool API page.

For live DEX prices and 24h volume across Four.meme tokens, see DEXrabbit's Four.meme category.

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 Four Meme exchange contract address on BSC?​

The Four Meme / four.meme exchange proxy on BNB Chain is:

0x5c952063c7fc8610ffdb798152d69f0b9550762b

Use it in Transaction.To, LogHeader.Address, or BalanceUpdate.Address filters when you listen for TokenCreate, LiquidityAdded, or migration-related logs. DEXTrades for the launchpad use Dex.ProtocolName: { is: "fourmeme_v1" }.

Table of Contents​

1. Four Meme Trading & Market Data (BSC)​

2. Token Lifecycle, Liquidity & Migrations​

3. Trader Insights​

4. Top Tokens & Getting Started​

5. Frequently asked questions (AEO)​

6. Video Tutorials​

7. Real World Projects​

Bitquery DEX Data Access Options​

  • GraphQL APIs: Query historical and real-time EVM data with flexible filtering and aggregation
  • Real-time Streams: Subscribe to live EVM blockchain events via WebSocket subscriptions
  • Cloud Solutions: Access EVM data through AWS, GCP, and Snowflake integrations
  • Kafka Streams: High-throughput data streaming for enterprise applications

Getting Started with Bitquery:​

How do I detect Four Meme token migrations to PancakeSwap?​

This query tracks four meme token migrations to Pancakeswap in realtime by monitoring transactions sent to the Four Meme factory address (0x5c952063c7fc8610ffdb798152d69f0b9550762b) and filtering for PairCreated and PoolCreated events. These events are emitted when a token graduates from Four Meme and migrates to Pancakeswap. Test it here.

Click to expand GraphQL query
subscription {
  EVM(network: bsc) {
    Events(
      where: {
        Log: { Signature: { Name: { in: ["PairCreated"] } } }
        Transaction: {
          To: { is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b" }
        }
      }
    ) {
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
        }
      }
      Transaction {
        Hash
      }
    }
  }
}

Check if a four meme token has migrated or not​

Below query will only show response if a the mentioned four meme tokens have migrated to Pancakeswap. Note: Please use a Block{Date} filter to minimize the data processing and hence the query processing time and get fast responses. Try the query here.

Click to expand GraphQL query
{
  EVM(network: bsc, dataset: combined) {
    DEXTradeByTokens(
      where: {Block: {Date: {since: "2025-10-10"}}, Trade: {Dex: {OwnerAddress: {in: ["0xca143ce32fe78f1f7019d7d551a6402fc5350c73"]}}, Currency: {SmartContract: {in: ["0xfe9936abb3c0659733ff0d03cf41d17b04c84444", "0x9cb5ae8ec79c72bd70b415efb7ff936e707f4444"]}}}}
    ) {
      count
      Trade {
        Currency {
          SmartContract
        }
      }
    }
  }
}

How do I get bonding curve progress for a Four Meme token?​

Below query will give you amount of left tokens put it in the below given simplied formulae and you will get Bonding Curve progress for the token.

Bonding Curve Progress Formula​

  • Formula: BondingCurveProgress = 100 - ((leftTokens * 100) / initialRealTokenReserves)

Where:

  • leftTokens = realTokenReserves - reservedTokens

  • initialRealTokenReserves = totalSupply - reservedTokens

  • Definitions:

    • initialRealTokenReserves = totalSupply - reservedTokens
      • totalSupply: 1,000,000,000 (Four meme Token)
      • reservedTokens: 200,000,000
      • Therefore, initialRealTokenReserves: 800,000,000
    • leftTokens = realTokenReserves - reservedTokens
      • realTokenReserves: Token balance at the market address.
note

Simplified Formula: BondingCurveProgress = 100 - (((balance - 200000000) * 100) / 800000000)

Additional Notes​

  • Balance Retrieval:
    • The balance is the four meme token balance at this Four Meme: Proxy address (0x5c952063c7fc8610FFDB798152D69F0B9550762b).
    • Use this query to fetch the balance: Query Link.
Click to expand GraphQL query
query MyQuery($token: String) {
  EVM(dataset: combined, network: bsc) {
    BalanceUpdates(
      where: {BalanceUpdate: {Address: {is: "0x5c952063c7fc8610FFDB798152D69F0B9550762b"}}, Currency: {SmartContract: {is: $token}}}
      orderBy: {descendingByField: "balance"}
    ) {
      Currency {
        Name
      }
      balance: sum(of: BalanceUpdate_Amount)
      BalanceUpdate {
        Address
      }
    }
  }
}
Click to expand Query Varibles (Paste this in variables section on IDE)
{
  "token": "0x13378bcbbc386eea99f09bc716f2c80979484444"
}

Get Four Meme Tokens which are above 95% Bonding Curve Progress​

Using the above Bonding Curve formula, we can calculate the token balances for the Four Meme Proxy contract (0x5c952063c7fc8610FFDB798152D69F0B9550762b) corresponding to approximately 95% to 100% progress along the bonding curve, that comes out to be 200,000,000 to 240,000,000. The tokens in the response are arranged in the ascending order of Bonding Curve Percentage, i.e., 95% to 100%. You can run and test the saved query here.

Click to expand GraphQL query
query MyQuery {
  EVM(dataset: combined, network: bsc) {
    BalanceUpdates(
      limit: { count: 100 }
      where: {
        BalanceUpdate: {
          Address: { is: "0x5c952063c7fc8610FFDB798152D69F0B9550762b" }
        }
      }
      orderBy: { descendingByField: "Bonding_Curve_Progress_precentage" }
    ) {
      Currency {
        SmartContract
        Name
      }
      balance: sum(
        of: BalanceUpdate_Amount
        selectWhere: { ge: "200000000", le: "240000000" }
      )
      BalanceUpdate {
        Address
      }
      Bonding_Curve_Progress_precentage: calculate(
        expression: "100 - ((($balance - 200000000) * 100) / 800000000)"
      )
    }
  }
}

How do I get newly created tokens on Four Meme?​

Run Query

This query retrieves newly created tokens on Four Meme by listening to the TokenCreate event. The response provides:

Token Information:

  • creator: Wallet address of the token creator
  • token: Contract address of the newly created token
  • name: Token name
  • symbol: Token symbol/ticker
  • totalSupply: Total supply

Launch Details:

  • requestId: Unique identifier for the token creation
  • launchTime: Unix timestamp of when the token launched
  • launchFee: Fee paid
Click to expand GraphQL query
{
  EVM(dataset: realtime, network: bsc) {
    Events(
      where: {
        Transaction: {
          To: { is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b" }
        }
        Log: { Signature: { Name: { is: "TokenCreate" } } }
      }
      limit: { count: 10 }
      orderBy: { descending: Block_Time }
    ) {
      Log {
        Signature {
          Name
          Signature
        }
      }
      Arguments {
        Value {
          ... on EVM_ABI_Integer_Value_Arg {
            integer
          }
          ... on EVM_ABI_Boolean_Value_Arg {
            bool
          }
          ... on EVM_ABI_Bytes_Value_Arg {
            hex
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
        }
        Name
        Type
      }
      Transaction {
        Hash
        To
        From
      }
    }
  }
}

How do I stream Four Meme token creation events in real time?​

Use a GraphQL subscription on EVM(network: bsc) with the same TokenCreate filter as the query above. Each matching log is pushed as it appears. You can start from the same saved query in the IDE and change the operation type to subscription: Token creation (IDE).

Click to expand GraphQL subscription
subscription {
  EVM(network: bsc) {
    Events(
      where: {
        Transaction: {
          To: { is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b" }
        }
        Log: { Signature: { Name: { is: "TokenCreate" } } }
      }
    ) {
      Log {
        Signature {
          Name
          Signature
        }
      }
      Arguments {
        Value {
          ... on EVM_ABI_Integer_Value_Arg {
            integer
          }
          ... on EVM_ABI_Boolean_Value_Arg {
            bool
          }
          ... on EVM_ABI_Bytes_Value_Arg {
            hex
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
        }
        Name
        Type
      }
      Transaction {
        Hash
        To
        From
      }
    }
  }
}

You can refer to this example to track latest trades of a token on other particular DEX's such as Pancake Swap.

Get Four.Meme Tokens created by a specific Dev​

This API fetches Four.Meme tokens created by a specific dev on BSC by tracking token minting transfers signed by a particular dev. Dev Address here in example is 0x9c75588640605d46b42f2d64c5c2e993de251210. Use a date filter based on your needs — shorter time ranges mean faster execution and reduced query time.

Run Query

Click to expand GraphQL query
{
  EVM(network: bsc, dataset: combined) {
    Transfers(
      where: {
        Block: { Date: { since: "2025-08-01" } }
        Transfer: {
          Sender: { is: "0x0000000000000000000000000000000000000000" }
        }
        Transaction: {
          From: { in: ["0x9c75588640605d46b42f2d64c5c2e993de251210"] }
        }
      }
    ) {
      Transaction {
        From
        To
      }
      Transfer {
        Sender
        Receiver
        Amount
        Currency {
          Name
          Symbol
          SmartContract
        }
      }
    }
  }
}

Get Dev Address of a Four.meme token​

Fetches the developer address that created a specific Four.Meme token on BSC by tracing the minting transfer (from the zero address) of that token’s smart contract. Use a date filter based on your needs — shorter time ranges make the query execute faster and return results more efficiently. Token Address in this example is 0xd284aa8910fe1dcac70f3e28ddd8cc61dac94444.

Run Query

Click to expand GraphQL query
{
  EVM(network: bsc, dataset: combined) {
    Transfers(
      where: {
        Block: { Date: { since: "2025-08-01" } }
        Transfer: {
          Currency: {
            SmartContract: { is: "0xd284aa8910fe1dcac70f3e28ddd8cc61dac94444" }
          }
          Sender: { is: "0x0000000000000000000000000000000000000000" }
        }
      }
    ) {
      Transaction {
        From
        To
      }
      Transfer {
        Sender
        Receiver
        Amount
        Currency {
          Name
          Symbol
          SmartContract
        }
      }
    }
  }
}

Get Dev Token Holding percentage​

Calculates what percentage of total token supply is held by the developer address for a specified Four Meme token.

Run Query

Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc) {
    TransactionBalances(
      where: {
        TokenBalance: {
          Address: { is: "0x749ca8e9fcfaf40796e8654ae7624b738c0b9a9d" }
          Currency: {
            SmartContract: { is: "0x4dE1486E27237F170Cd92fF1Efb17eF4c2C74444" }
          }
        }
        TransactionStatus: { Success: true }
      }
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
    ) {
      TokenBalance {
        Address
        Currency {
          Name
          Symbol
          SmartContract
        }
        Balance: PostBalance
        PostBalanceInUSD
        TotalSupply
        TotalSupplyInUSD
      }
      holding_percentage: calculate(
        expression: "$TokenBalance_Balance / 10000000"
      )
    }
  }
}

Get Top 10 Holders percentages​

Calculates the percentage of total supply held by the top 10 holders of a specific Four Meme token on BSC.

Run Query

Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc) {
    TransactionBalances(
      where: {
        TokenBalance: {
          Currency: {
            SmartContract: { is: "0x4dE1486E27237F170Cd92fF1Efb17eF4c2C74444" }
          }
        }
        TransactionStatus: { Success: true }
      }
      limit: { count: 10 }
      orderBy: { descendingByField: "holding_percentage" }
    ) {
      TokenBalance {
        Address
        Currency {
          Name
          Symbol
          SmartContract
        }
        Balance: PostBalance(maximum: Block_Time)
      }
      holding_percentage: calculate(
        expression: "$TokenBalance_Balance / 10000000"
      )
    }
  }
}

How do I get live Four Meme trades using Bitquery?​

Using subscriptions you can subscribe to the latest trades on Four Meme as shown in this example. The subscription returns latest trade info such as buyers and sellers, buy and sell currency details and amount of currency.

Click to expand GraphQL query
subscription {
  EVM(network: bsc) {
    DEXTrades(
      where: { Trade: { Dex: { ProtocolName: { is: "fourmeme_v1" } } } }
    ) {
      Trade {
        Buy {
          Buyer
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
        }
        Sell {
          Seller
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
        }
      }
      Transaction {
        Hash
      }
    }
  }
}

Get Latest Buys and Sells for a Four Meme Token​

This query retrieves the most recent token buy and sell trades of a specific token on Four Meme Exchange.

Click to expand GraphQL query
query MyQuery($currency: String) {
  EVM(network: bsc, dataset: combined) {
    buys: DEXTrades(
      where: {
        Trade: {
          Buy: { Currency: { SmartContract: { is: $currency } } }
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
        }
      }
      orderBy: { descending: Block_Time }
    ) {
      Block {
        Time
      }
      Trade {
        Buy {
          Amount
          Buyer
          Price
          PriceInUSD
          Seller
        }
        Sell {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
      }
    }
    sells: DEXTrades(
      where: {
        Trade: {
          Sell: { Currency: { SmartContract: { is: $currency } } }
          Success: true
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
        }
      }
      orderBy: { descending: Block_Time }
    ) {
      Block {
        Time
      }
      Trade {
        Buy {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
        Sell {
          Amount
          Buyer
          Price
          PriceInUSD
          Seller
        }
      }
    }
  }
}
{
  "currency": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40"
}

You can also check if the token is listed on other DEX using this example.

Get Trade Metrics of a Four Meme Token​

Use the below query to get trade metrics like volume and trades for a token in different time frames, such as 24 hours, 1 hour and 5 minutes. Test it here.

Click to expand GraphQL query
query MyQuery($currency: String) {
  EVM(network: bsc) {
    DEXTradeByTokens(
      where: {
        Trade: { Currency: { SmartContract: { is: $currency } }, Success: true }
        Block: { Time: { since_relative: { hours_ago: 24 } } }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
      }
      volume_24hr: sum(of: Trade_Side_AmountInUSD)
      volume_1hr: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { since_relative: { hours_ago: 1 } } } }
      )
      volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { since_relative: { minutes_ago: 5 } } } }
      )
      trades_24hr: count
      trades_1hr: count(
        if: { Block: { Time: { since_relative: { hours_ago: 1 } } } }
      )
      trades_5min: count(
        if: { Block: { Time: { since_relative: { minutes_ago: 5 } } } }
      )
    }
  }
}
{
  "currency": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40"
}

Get latest price of a Four.meme 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 Four.meme token prices.

Click to expand GraphQL query
{
  Trading {
    Pairs(
      where: {Price: {IsQuotedInUsd: false}, Market: {Network: {is: "Binance Smart Chain"}, Program: {is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b"}}, Token: {Address: {is: "0x2157de505dfaa51676d6d22c0424551fbeaf4444"}}, Interval: {Time: {Duration: {eq: 60}}}}
      limit: {count: 1}
      orderBy: {descending: Block_Time}
    ) {
      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
      }
    }
  }
}

Get ATH price of a Four Meme Token​

Fetches the All-Time High (ATH) price of a specific Four.Meme token on BSC, using the DEXTradeByTokens dataset to calculate the 98th percentile of trade prices (approximate ATH). Try the API here.

Tune the parameters level: 0.98 and Date as necessary to filter outliers.

Click to expand GraphQL query
query tradingView(
  $network: evm_network
  $dataset: dataset_arg_enum
  $token: String
) {
  EVM(network: $network, dataset: $dataset) {
    DEXTradeByTokens(
      limit: { count: 1 }
      where: {
        Block: { Date: { since: "2025-10-10" } }
        TransactionStatus: { Success: true }
        Trade: {
          Side: { Currency: { SmartContract: { is: "0x" } } }
          Currency: { SmartContract: { is: $token } }
        }
      }
    ) {
      max: quantile(of: Trade_PriceInUSD, level: 0.98)
      Block {
        Time
      }
    }
  }
}
{
  "network": "bsc",
  "token": "0xe59ecb01d56a7f1e66276c1bc885d64c92614444",
  "dataset": "combined",
  "local": "EVM",
  "interval": 60
}

Get Price Change Percentage for a Four Meme Token​

Use the below query to get the price change in percentage for various time fields including 24 hours, 1 hour and 5 minutes. Try it here.

Click to expand GraphQL query
query MyQuery($currency: String) {
  EVM(network: bsc) {
    DEXTradeByTokens(
      where: {
        Trade: { Currency: { SmartContract: { is: $currency } } }
        Block: { Time: { since_relative: { hours_ago: 24 } } }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
        price_24hr: PriceInUSD(minimum: Block_Time)
        price_1hr: PriceInUSD(
          if: { Block: { Time: { is_relative: { hours_ago: 1 } } } }
        )
        price_5min: PriceInUSD(
          if: { Block: { Time: { is_relative: { minutes_ago: 1 } } } }
        )
        current: PriceInUSD
      }
      change_24hr: calculate(
        expression: "( $Trade_current - $Trade_price_24hr ) / $Trade_price_24hr * 100"
      )
      change_1hr: calculate(
        expression: "( $Trade_current - $Trade_price_1hr ) / $Trade_price_1hr * 100"
      )
      change_5min: calculate(
        expression: "( $Trade_current - $Trade_price_5min ) / $Trade_price_5min * 100"
      )
    }
  }
}
{
  "currency": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40"
}

How do I get Four Meme OHLCV data for a token?​

Use the below query to get four meme token OHLCV data. Test it here.

Click to expand GraphQL query
query tradingView($network: evm_network, $token: String) {
  EVM(network: $network, dataset: combined) {
    DEXTradeByTokens(
      limit: { count: 10 }
      orderBy: { descendingByField: "Block_Time" }
      where: {
        Trade: {
          Currency: { SmartContract: { is: $token } }
          PriceAsymmetry: { lt: 0.1 }
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
        }
      }
    ) {
      Block {
        Time(interval: { count: 5, in: minutes })
      }
      Trade {
        open: PriceInUSD(minimum: Block_Number)
        close: PriceInUSD(maximum: Block_Number)
        max: PriceInUSD(maximum: Trade_PriceInUSD)
        min: PriceInUSD(minimum: Trade_PriceInUSD)
      }
      volumeUSD: sum(of: Trade_Side_AmountInUSD, selectWhere: { gt: "0" })
    }
  }
}
{
  "network": "bsc",
  "token": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40"
}

Monitor trades of traders on Four meme​

You can use our streams to monitor real time trades of a trader on Four Meme, for example run this stream.

Click to expand GraphQL query
subscription {
  EVM(network: bsc) {
    DEXTrades(
      where: {
        Trade: { Dex: { ProtocolName: { is: "fourmeme_v1" } } }
        Transaction: {
          From: { is: "0x7db00d1f5b8855d40827f34bb17f95d31990306e" }
        }
      }
    ) {
      Trade {
        Buy {
          Buyer
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
          Price
          PriceInUSD
        }
        Sell {
          Seller
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
        }
      }
      Transaction {
        Hash
      }
    }
  }
}

You can also get the trade activities of a user on Pancake Swap using our Pancake Swap APIs.

Track Four Meme Tokens in 14k to 18k Marketcap​

Tracks live Four Meme tokens on BSC with a market cap between $14K–$18K, filtered by 14k to 18k Marketcap. Useful for spotting emerging small-cap meme tokens in real time. Try the query here.

Click to expand GraphQL query
subscription {
  Trading {
    Pairs(
      where: {
        Interval: { Time: { Duration: { eq: 1 } } }
        Price: {
          IsQuotedInUsd: true
          Average: { Mean: { gt: 0.000014, le: 0.000018 } }
        }
        Market: {
          Protocol: { is: "fourmeme_v1" }
          Network: { is: "Binance Smart Chain" }
        }
        Volume: { Usd: { gt: 5 } }
      }
    ) {
      Token {
        Name
        Symbol
        Address
      }
      Market {
        Protocol
        Program
        Network
        Name
        Address
      }
      Block {
        Date
        Time
        Timestamp
      }
      Interval {
        Time {
          Start
          Duration
          End
        }
      }
      Volume {
        Base
        Quote
        Usd
      }
      marketcap: calculate(expression: "Price_Average_Mean * 1000000000")
      Price {
        Average {
          Mean
        }
        Ohlc {
          Close
          High
          Low
          Open
        }
      }
    }
  }
}

Track Latest and Historical Trades of a Four Meme User​

You can use DEX Trades API with combined dataset to get latest and historic trades of a user. Run this query for example.

Click to expand GraphQL query
query MyQuery($address: String) {
  EVM(dataset: combined, network: bsc) {
    DEXTrades(
      where: {
        Trade: { Dex: { ProtocolName: { is: "fourmeme_v1" } } }
        Transaction: { From: { is: $address } }
      }
      orderBy: { descending: Block_Time }
    ) {
      Block {
        Time
      }
      Trade {
        Buy {
          Buyer
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
          Price
          PriceInUSD
        }
        Sell {
          Seller
          Currency {
            Name
            Symbol
            SmartContract
          }
          Amount
        }
      }
      Transaction {
        Hash
      }
    }
  }
}
{
  "address": "0x7db00d1f5b8855d40827f34bb17f95d31990306e"
}

Top Buyers for a Token on Four Meme​

This query returns top buyers of a particular token on Four Meme, with currency smart contract as 0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40 for this example.

Click to expand GraphQL query
query MyQuery($currency: String) {
  EVM(network: bsc, dataset: combined) {
    DEXTrades(
      where: {
        Trade: {
          Buy: { Currency: { SmartContract: { is: $currency } } }
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
        }
      }
      limit: { count: 100 }
    ) {
      Trade {
        Buy {
          Buyer
        }
      }
      trades: count
      bought: sum(of: Trade_Buy_Amount)
    }
  }
}
{
  "currency": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40"
}

Get Trade Volume and Number of Trades for a Four Meme Token​

This query returns the traded volume and number of trades for a particular Four Meme token in different time frames, namely 24 hours, 1 hour and 5 minutes.

Click to expand GraphQL query
query MyQuery(
  $currency: String
  $time_24hr_ago: DateTime
  $time_1hr_ago: DateTime
  $time_5min_ago: DateTime
) {
  EVM(network: bsc) {
    DEXTradeByTokens(
      where: {
        Trade: { Currency: { SmartContract: { is: $currency } } }
        Block: { Time: { since: $time_24hr_ago } }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
      }
      volume_24hr: sum(of: Trade_Side_AmountInUSD)
      volume_1hr: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { since: $time_1hr_ago } } }
      )
      volume_5min: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { since: $time_5min_ago } } }
      )
      trades_24hr: count
      trades_1hr: count(if: { Block: { Time: { since: $time_1hr_ago } } })
      trades_5min: count(if: { Block: { Time: { since: $time_5min_ago } } })
    }
  }
}
{
  "currency": "0x9b48a54bcce09e59b0479060e9328ab7dbdb0d40",
  "time_24hr_ago": "2024-03-23T15:00:00Z",
  "time_1hr_ago": "2024-03-24T14:00:00Z",
  "time_5min_ago": "2024-03-24T15:55:00Z"
}

Get Realtime Market Cap and Price of a Four Meme Token​

To get the market cap of a token we need two things, the latest PriceInUSD and total supply of the token. Total Supply is 1,000,000,000 (1B) for four meme tokens so we just need to get price and multiply it with 1B. This query helps with getting the latest USD price of a token and hence its latest Marketcap.

Market Cap = Total Supply * PriceInUSD
Click to expand GraphQL query
subscription {
  Trading {
    Pairs(
      where: {
        Interval: { Time: { Duration: { eq: 1 } } }
        Price: { IsQuotedInUsd: true }
        Market: {
          Protocol: { is: "fourmeme_v1" }
          Network: { is: "Binance Smart Chain" }
        }
        Volume: { Usd: { gt: 5 } }
        Token: { Address: { is: "0xf5bc78c8c762e4003742dacc31f3ba7091be4444" } }
      }
    ) {
      Token {
        Name
        Symbol
        Address
      }
      Market {
        Protocol
        Program
        Network
        Name
        Address
      }
      Block {
        Date
        Time
        Timestamp
      }
      Interval {
        Time {
          Start
          Duration
          End
        }
      }
      Volume {
        Base
        Quote
        Usd
      }
      marketcap: calculate(expression: "Price_Average_Mean * 1000000000")
      Price {
        Average {
          Mean
        }
        Ohlc {
          Close
          High
          Low
          Open
        }
      }
    }
  }
}

Top Tokens by marketcap​

Below API can be used to get top four meme tokens by marketcap. You can get all the data through us and create a min and max marketcap filter in your application. Try the API here.

Market Cap = Total Supply * PriceInUSD
Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc, dataset: realtime) {
    DEXTradeByTokens(
      limit: { count: 100 }
      orderBy: { descendingByField: "Marketcap" }
      where: {
        TransactionStatus: { Success: true }
        Trade: {
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
          Side: {
            AmountInUSD: { gt: "20" }
            Currency: {
              SmartContract: {
                in: [
                  "0x"
                  "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
                  "0x55d398326f99059fF775485246999027B3197955"
                  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
                  "0x17EAfd08994305D8AcE37EfB82F1523177eC70EE"
                  "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d"
                ]
              }
            }
          }
        }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
        PriceInUSD(maximum: Block_Time)
        Side {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
      }
      Transaction {
        Hash(maximum: Block_Time)
      }
      Marketcap: calculate(expression: "$Trade_PriceInUSD * 1000000000")
    }
  }
}

Top Tokens by launch marketcap​

Below API can be used to get top four meme tokens by launch marketcap (marketcap at the time of launching). You can get all the data through us and create a min and max marketcap filter in your application. Try the API here.

Market Cap = Total Supply * PriceInUSD
Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc, dataset: realtime) {
    DEXTradeByTokens(
      limit: { count: 100 }
      orderBy: { descendingByField: "Marketcap" }
      where: {
        TransactionStatus: { Success: true }
        Trade: {
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
          Side: {
            AmountInUSD: { gt: "20" }
            Currency: {
              SmartContract: {
                in: [
                  "0x"
                  "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
                  "0x55d398326f99059fF775485246999027B3197955"
                  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
                  "0x17EAfd08994305D8AcE37EfB82F1523177eC70EE"
                  "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d"
                ]
              }
            }
          }
        }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
        PriceInUSD(minimum: Block_Time)
        Side {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
      }
      Transaction {
        Hash(minimum: Block_Time)
      }
      Marketcap: calculate(expression: "$Trade_PriceInUSD * 1000000000")
    }
  }
}

How do I get top tokens by volume on Four Meme?​

Below API can be used to get top Four Meme tokens by buys, sells, volume, price change, buyers, and sellers over rolling windows (for example 1h / 24h). You can apply min/max market cap filters in your application on top of this data. Try the API here.

Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc, dataset: combined) {
    DEXTradeByTokens(
      limit: { count: 100 }
      orderBy: { descendingByField: "buys_1hr" }
      where: {
        Block: { Time: { since_relative: { hours_ago: 24 } } }
        TransactionStatus: { Success: true }
        Trade: {
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
          Side: {
            Currency: {
              SmartContract: {
                in: [
                  "0x"
                  "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
                  "0x55d398326f99059fF775485246999027B3197955"
                  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
                  "0x17EAfd08994305D8AcE37EfB82F1523177eC70EE"
                  "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d"
                ]
              }
            }
          }
        }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
        price_24hr: Price(minimum: Block_Time)
        price_1hr: Price(
          maximum: Block_Time
          if: { Block: { Time: { till_relative: { hours_ago: 1 } } } }
        )
        price_5min: Price(
          maximum: Block_Time
          if: { Block: { Time: { till_relative: { minutes_ago: 5 } } } }
        )
        current: Price(maximum: Block_Time)
        Side {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
      }
      buyers_24hr: count(
        distinct: Transaction_From
        if: { Trade: { Side: { Type: { is: buy } } } }
      )
      sellers_24hr: count(
        distinct: Transaction_From
        if: { Trade: { Side: { Type: { is: sell } } } }
      )
      buys_1hr: count(
        if: {
          Trade: { Side: { Type: { is: buy } } }
          Block: { Time: { till_relative: { hours_ago: 1 } } }
        }
      )
      buys_24hr: count(if: { Trade: { Side: { Type: { is: buy } } } })
      sells_1hr: count(
        if: {
          Trade: { Side: { Type: { is: sell } } }
          Block: { Time: { till_relative: { hours_ago: 1 } } }
        }
      )
      sells_24hr: count(if: { Trade: { Side: { Type: { is: sell } } } })
      volume_1hr: sum(
        of: Trade_Side_AmountInUSD
        if: { Block: { Time: { till_relative: { hours_ago: 1 } } } }
      )
      volume_24hr: sum(of: Trade_Side_AmountInUSD)
      change_24hr: calculate(
        expression: "( $Trade_current - $Trade_price_24hr ) / $Trade_price_24hr * 100"
      )
      change_1hr: calculate(
        expression: "( $Trade_current - $Trade_price_1hr ) / $Trade_price_1hr * 100"
      )
      change_5min: calculate(
        expression: "( $Trade_current - $Trade_price_5min ) / $Trade_price_5min * 100"
      )
    }
  }
}

Top Four Meme tokens by realtime market cap (activity filter)​

This query uses dataset: realtime and DEXTradeByTokens ordered by a calculated marketcap field, with a minimum trade size in USD on the filter. Use it when you want a live-oriented leaderboard; for volume / buy-sell breakdowns use the previous section. Try the API here.

Click to expand GraphQL query
query MyQuery {
  EVM(network: bsc, dataset: realtime) {
    DEXTradeByTokens(
      limit: { count: 100 }
      orderBy: { descendingByField: "Marketcap" }
      where: {
        TransactionStatus: { Success: true }
        Trade: {
          Dex: { ProtocolName: { is: "fourmeme_v1" } }
          Side: {
            AmountInUSD: { gt: "20" }
            Currency: {
              SmartContract: {
                in: [
                  "0x"
                  "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
                  "0x55d398326f99059fF775485246999027B3197955"
                  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
                  "0x17EAfd08994305D8AcE37EfB82F1523177eC70EE"
                  "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d"
                ]
              }
            }
          }
        }
      }
    ) {
      Trade {
        Currency {
          Name
          Symbol
          SmartContract
        }
        PriceInUSD(minimum: Block_Time)
        Side {
          Currency {
            Name
            Symbol
            SmartContract
          }
        }
      }
      Transaction {
        Hash(minimum: Block_Time)
      }
      Marketcap: calculate(expression: "$Trade_PriceInUSD * 1000000000")
    }
  }
}

Top Tokens by liquidity​

Below API can be used to get top four meme tokens by liquidity between 800M and 900M token liquqidity. You can create a min and max liquidity filter in your application using this API. Try the API here.

Click to expand GraphQL query
query MyQuery {
  EVM(dataset: combined, network: bsc) {
    BalanceUpdates(
      where: {
        BalanceUpdate: {
          Address: { is: "0x5c952063c7fc8610FFDB798152D69F0B9550762b" }
        }
      }
      orderBy: { descendingByField: "balance" }
    ) {
      Currency {
        Name
        Symbol
        SmartContract
      }
      balance: sum(
        of: BalanceUpdate_Amount
        selectWhere: { gt: "800000000", le: "900000000" }
      )
      BalanceUpdate {
        Address
      }
    }
  }
}

Track Liquidity Add Events for All Tokens on Four Meme​

This query tracks all liquidity addition events on the Four Meme Exchange. It listens for LiquidityAdded events emitted from the four meme exchange's smart contract (0x5c952063c7fc8610ffdb798152d69f0b9550762b)

You can run the query here

Click to expand GraphQL query
{
  EVM(dataset: realtime, network: bsc) {
    Events(
      limit: {count: 20}
      where: {LogHeader: {Address: {is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b"}},
        Log: {Signature: {Name: {is: "LiquidityAdded"}}}}
    ) {
      Block {
        Time
        Number
        Hash
      }
      Receipt {
        ContractAddress
      }
      Topics {
        Hash
      }
      TransactionStatus {
        Success
      }
      LogHeader {
        Address
        Index
        Data
      }
      Transaction {
        Hash
        From
        To
      }
      Log {
        EnterIndex
        ExitIndex
        Index
        LogAfterCallIndex
        Pc
        SmartContract
        Signature {
          Name
          Signature
        }
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Integer_Value_Arg {
            integer
          }
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
          ... on EVM_ABI_Bytes_Value_Arg {
            hex
          }
          ... on EVM_ABI_Boolean_Value_Arg {
            bool
          }
        }
      }
    }
  }
}

Track Liquidity Add Events for a Token on Four Meme​

This query tracks liquidity addition events for a specific token on the Four Meme Exchange. It listens for LiquidityAdded events emitted from the exchange's smart contract (0x5c952063c7fc8610ffdb798152d69f0b9550762b) BNB network

In this example, the query monitors liquidity events for a specific token (0x5a49ce64a1e44f6fce07e9ff38f54dde8a8a0e94) by filtering the event arguments to only include actions related to this token.

You can run the query here

Click to expand GraphQL query
{
  EVM(dataset: realtime, network: bsc) {
    Events(
      limit: {count: 20}
      where: {LogHeader: {Address: {is: "0x5c952063c7fc8610ffdb798152d69f0b9550762b"}}, Log: {Signature: {Name: {is: "LiquidityAdded"}}}, Arguments: {includes: {Name: {is: "token1"}, Value: {Address: {is: "0x5a49ce64a1e44f6fce07e9ff38f54dde8a8a0e94"}}}}}
    ) {
      Block {
        Time
        Number
        Hash
      }
      Receipt {
        ContractAddress
      }
      Topics {
        Hash
      }
      TransactionStatus {
        Success
      }
      LogHeader {
        Address
        Index
        Data
      }
      Transaction {
        Hash
        From
        To
      }
      Log {
        EnterIndex
        ExitIndex
        Index
        LogAfterCallIndex
        Pc
        SmartContract
        Signature {
          Name
          Signature
        }
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Integer_Value_Arg {
            integer
          }
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
          ... on EVM_ABI_Bytes_Value_Arg {
            hex
          }
          ... on EVM_ABI_Boolean_Value_Arg {
            bool
          }
        }
      }
    }
  }
}

Check if a Four.meme Token is Phishy​

This elaborative API approach uses two queries to detect if a Four Meme 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 0x35a7bb282d8caafe71617c9d52ee30f1adfe4444 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) {
  EVM(network: bsc, dataset: combined) {
    Transfers(
      limit: { count: 1000 }
      orderBy: { ascendingByField: "Block_first_transfer" }
      where: {
        TransactionStatus: { Success: true }
        Transfer: {
          Receiver: {
            notIn: [
              "0x5c952063c7fc8610ffdb798152d69f0b9550762b"
              "0x757eba15a64468e6535532fcF093Cef90e226F85"
            ]
          }
          Currency: { SmartContract: { is: $token } }
        }
      }
    ) {
      Transfer {
        Receiver
      }
      Block {
        first_transfer: Time(minimum: Block_Time)
      }
      total_transferred_amount: sum(of: Transfer_Amount)
    }
  }
}
{
  "token": "0x35a7bb282d8caafe71617c9d52ee30f1adfe4444"
}

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!]) {
  EVM(network: bsc, dataset: combined) {
    DEXTradeByTokens(
      orderBy: { ascendingByField: "Block_first_buy" }
      where: {
        Trade: {
          Currency: { SmartContract: { is: $token } }
          Dex: { ProtocolFamily: { is: "FourMeme" } }
          Side: { Type: { is: buy } }
          Buyer: { in: $buyersList }
        }
        TransactionStatus: { Success: true }
      }
    ) {
      Trade {
        Buyer
        Currency {
          Name
          Symbol
          SmartContract
        }
        Side {
          Type
        }
      }
      Block {
        first_buy: Time(minimum: Block_Time)
      }
      total_bought_amount: sum(of: Trade_Amount)
    }
  }
}
{
  "token": "0x35a7BB282d8CAAFe71617c9d52EE30F1adFe4444",
  "buyersList" : [Pass the Address list you getting in Query 1]
}

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

Metadata for a Newly Created Token​

This query will fetch you trade metrics, such as marketcap, trade volume, token holders and creation time for a newly created Four Meme token on BSC network. You can test the query here.

Click to expand GraphQL query
query MyQuery($token: String!) {
  EVM(network: bsc) {
    DEXTradeByTokens(
      where: { Trade: { Currency: { SmartContract: { is: $token } } } }
    ) {
      Block {
        createdAt: Time(minimum: Block_Time)
      }
      volume: sum(of: Trade_Side_AmountInUSD)
    }
    BalanceUpdates(where: { Currency: { SmartContract: { is: $token } } }) {
      holders: uniq(of: BalanceUpdate_Address, selectWhere: { gt: "0" })
    }
  }
  marketCap: Trading {
    Pairs(
      where: {
        Interval: { Time: { Duration: { eq: 1 } } }
        Market: { Network: { is: "Binance Smart Chain" } }
        Volume: { Usd: { gt: 5 } }
        Token: { Address: { is: $token } }
      }
      orderBy: { descending: Interval_Time_Start }
      limit: { count: 1 }
    ) {
      Price {
        Average {
          Mean
        }
      }
      marketcap: calculate(expression: "Price_Average_Mean * 1000000000")
    }
  }
}

Top Traders of a token​

This query will fetch you top traders of a Four Meme token for the BSC network. You can test the query here.

Click to expand GraphQL query
query topTraders($network: evm_network, $token: String) {
  EVM(network: $network, dataset: combined) {
    DEXTradeByTokens(
      orderBy: {descendingByField: "volumeUsd"}
      limit: {count: 100}
      where: {Trade: {Currency: {SmartContract: {is: $token}}, Dex: {ProtocolName: {is: "fourmeme_v1"}}}}
    ) {
      Trade {
        Buyer
        Dex {
          OwnerAddress
          ProtocolFamily
          ProtocolName
        }
      }
      buyVolume: sum(of: Trade_Amount, if: {Trade: {Side: {Type: {is: buy}}}})
      sellVolume: sum(of: Trade_Amount, if: {Trade: {Side: {Type: {is: sell}}}})
      volume: sum(of: Trade_Amount)
      volumeUsd: sum(of: Trade_Side_AmountInUSD)
    }
  }
}
{
  "network": "bsc",
  "token": "0x37e3a59843b056e063780402ef25e12dca394444"
}

Get liquidity of a Four Meme token​

Using below API you can get the liquidity of a four meme token. Subtract 200000000 from the Balance that this query returns because 200M tokens are reserved which gets transferred to pancakeswap when this fourmeme token graduates. Test the API here.

Click to expand GraphQL query
query MyQuery {
  EVM(dataset: combined, network: bsc) {
    BalanceUpdates(
      where: {BalanceUpdate: {Address: {is: "0x5c952063c7fc8610FFDB798152D69F0B9550762b"}}, Currency: {SmartContract: {is: "0x87c5b3da05b062480b55c2dbf374ccd084f74444"}}}
      orderBy: {descendingByField: "balance"}
    ) {
      Currency {
        Name
      }
      balance: sum(of: BalanceUpdate_Amount)
      BalanceUpdate {
        Address
      }
    }
  }
}

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 FourMeme With Price, Market Cap, and Supply​

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

You can run this subscription in the Bitquery IDE.

Click to expand GraphQL query
subscription {
  Trading {
    Trades(
      where: { Pair: { Market: { ProtocolFamily: { is: "FourMeme" } } } }
    ) {
      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 FourMeme Token (Last 30 Minutes)​

Rank traders by PnL on specific bonding curve: filter Pair.Market.Address, last 30 minutes, limit: 10, and orderBy PnL descending. Useful for leaderboards, smart-money screens, and curve-specific trader analytics.

You can run this query in the Bitquery IDE.

Click to expand GraphQL query
{
  Trading {
    Trades(
      limit: { count: 10 }
      orderBy: { descendingByField: "PnL" }
      where: {
        Block: { Time: { since_relative: { minutes_ago: 30 } } }
        Pair: {
          Token: {
            Address: { is: "0x1f60df4bf4f08498ee4a111058c99774b81e4444" }
          }
        }
      }
    ) {
      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" } })
    }
  }
}

Frequently asked questions (Four Meme + Bitquery)​

These mirror common “answer engine” questions. Each item points to the section on this page unless noted.

QuestionWhere it is answered
How do I get live Four Meme trades using Bitquery?Live trades subscription (fourmeme_v1 + DEXTrades)
How do I detect Four Meme token migrations to PancakeSwap?Migration subscription and check if migrated
How do I get bonding curve progress for a Four Meme token?Bonding curve formula + balance query
What is the Four Meme exchange contract address on BSC?Contract address
How do I get newly created tokens on Four Meme?TokenCreate query
How do I stream Four Meme token creation events in real time?TokenCreate subscription
How do I get top tokens by volume on Four Meme?Top tokens by volume / activity and realtime market cap leaderboard
Can I monitor Four Meme transactions in the BSC mempool before confirmation?Separate guide: Four Meme Mempool API (not duplicated on this page)
How do I get Four Meme OHLCV data for a token?OHLCV query
Can the API return four.meme token volume changes every second?Not documented on this page yet — add minimum interval, aggregation options, and any rate or streaming limits you want to communicate publicly.

Video Tutorial | How to get Bonding Curve Progress of any Four Meme Token​

Video Tutorial | How to track the Four Meme Tokens which are about to Graduate in Realtime​

Video Tutorial | How to get Liquidity of a Four Meme Token​

Video Tutorial | How to get Top Traders of a Four Meme Token on Solana Four Meme DEX​

Video Tutorial | How to Get the OHLCV Data of a token on Four Meme DEX​

Real World Projects with Four Meme API​

Building a Four Meme Dashboard​

Four Meme Sniper Bot​

Frequently Asked Questions

How do I get Four Meme token trades on BSC?

Query EVM.DEXTrades on network bsc filtered to the Four Meme protocol. Examples cover new launches, OHLC, and top traders.

Can I stream Four Meme trades before they confirm?

Use the Four Meme Mempool API for pre-confirmation monitoring, or Kafka streams for confirmed trades at scale.

How do I get OHLC for a Four Meme token?

Use DEXTradeByTokens with interval aggregation on network bsc, or see the OHLC examples on this page.