Skip to main content

Four Meme API

Get ultra low latency Four Meme memecoin data on BNB Chain: live trades, bonding curve progress, newly created tokens, prices, OHLC, liquidity, migrations, top traders and more.

The below GraphQL APIs and Streams are examples of data points you can get with Bitquery. If you have questions on other data points, reach out to support.

Need zero-latency BSC data? Read about our Streams and contact us for a trial: https://docs.bitquery.io/docs/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: https://docs.bitquery.io/docs/authorisation/how-to-generate/

Table of Contents​

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

2. Token Lifecycle, Liquidity & Migrations​

3. Trader Insights​

4. Top Tokens & Getting Started​

5. Video Tutorials​

6. 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:​

Track All Four Meme Tokens That Have Migrated 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
        }
      }
    }
  }
}

Bonding Curve Progress API for FourMeme 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)"
      )
    }
  }
}

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
      }
    }
  }
}

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
        }
      }
    }
  }
}

Subscribe the Latest Trades on Four Meme​

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). Use a date filter suited to your needs — a shorter duration will make the query run faster and return results more efficiently. Try the API here.

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"
}

Get OHLCV data of a Four Meme 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")
    }
  }
}

Top Tokens by buys, sells, volume, price change, buyers, sellers​

Below API can be used to get top four meme tokens by buys, sells, volume, price change, buyers, sellers. You can get all the data through us and create a min and max marketcap filter in your application. 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 Tokens by buys, sells, volume, price change, buyers, sellers​

Below API can be used to get top four meme tokens by buys, sells, volume, price change, buyers, sellers. You can get all the data through us and create a min and max buys, sells, volume, price change filter in your application. 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
          }
        }
      }
    }
  }
}

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
      }
    }
  }
}

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​