Meteora Dynamic Bonding Curve API

The Meteora Dynamic Bonding Curve (DBC) is Meteora's launch program on Solana, at dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN. A team configures a curve, buyers trade against it, and once the quote threshold is met the token graduates into a DAMM pool. Launchpads including Jupiter Studio and Believe run on it. Bitquery reads that whole lifecycle: new launches, every curve trade with a USD price and market cap, graduations, top traders and migrations, over GraphQL, WebSocket, Kafka and gRPC.

Meteora publishes REST data APIs for DLMM, DAMM v1 and DAMM v2, but none for the Dynamic Bonding Curve. There is an SDK and an IDL for building transactions, and nothing that serves launches, trades or curve state. That gap is what this page fills.

Start with the Trading API

DBC tokens live and die in hours, so the fastest path is the Trading API. Trading.Trades returns MEV-filtered curve trades with USD price, market cap and supply on every row, and Trading.Pairs gives OHLC and market cap per curve down to one second. Filter either with Market: { Protocol: { is: "dynamic_bonding_curve" } }.

Use the chain-level Instructions cube further down for the events the Trading cubes do not model: launches, graduations and migration checks.

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 Meteora DBC program ID on Solana?

The Dynamic Bonding Curve program is dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN on Solana mainnet, and Meteora uses the same address on devnet. Its pool authority PDA is FhVo3mqL8PW5pH5U2CN4XE33DokiyZnUwuGpH2hmHLuM.

dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN

In the Trading cubes DBC is Market.Protocol dynamic_bonding_curve. In the Solana chain-level cubes the rows carry Dex.ProtocolName dynamic_bonding_curve and Dex.ProtocolFamily Meteora. DBC method names keep the IDL's snake_case spelling. Rows whose method starts with Evt, such as EvtSwap and EvtCurveComplete, are event logs emitted beside the real instruction.

Meteora runs four trading programs on Solana, each with its own Bitquery page:

Meteora program	Program ID	Protocol name	Bitquery page
Dynamic Bonding Curve, launches that graduate to a DAMM pool	`dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN`	`dynamic_bonding_curve`	This page
DAMM v2, constant-product pools with position NFTs	`cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG`	`cp_amm`	Meteora DAMM v2 API
DLMM, concentrated liquidity in price bins	`LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo`	`lb_clmm`	Meteora DLMM API
DAMM v1, the legacy Dynamic AMM	`Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB`	`amm`	Meteora DAMM v1 API

Picking an example token

Every query below that takes a mint uses a placeholder, because a bonding curve that is busy this hour is usually empty tomorrow. Run this first and paste one of the mints it returns into the examples.

{
  Trading {
    Trades(
      limit: { count: 10 }
      orderBy: { descendingByField: "usd" }
      where: {
        Pair: {
          Market: {
            Protocol: { is: "dynamic_bonding_curve" }
            Network: { is: "Solana" }
          }
        }
        Block: { Time: { since_relative: { minutes_ago: 10 } } }
      }
    ) {
      Pair {
        Token {
          Symbol
          Address
        }
        QuoteToken {
          Symbol
        }
        Market {
          Address
        }
      }
      usd: sum(of: AmountsInUsd_Base)
      trades: count
    }
  }
}

Pair.Token.Address is the mint and Pair.Market.Address the curve.

Meteora DBC trades in real time

Stream every decoded curve trade with the trader, both amounts, the USD price and the token's market cap. This one subscription covers all DBC launches at once, so it is the usual starting point for launch bots and screeners.

subscription {
  Trading {
    Trades(
      where: {
        Pair: {
          Market: {
            Protocol: { is: "dynamic_bonding_curve" }
            Network: { is: "Solana" }
          }
        }
      }
    ) {
      Block {
        Time
      }
      Side
      Price
      PriceInUsd
      Trader {
        Address
      }
      Amounts {
        Base
        Quote
      }
      AmountsInUsd {
        Base
        Quote
      }
      Supply {
        MarketCap
        CirculatingSupply
        TotalSupply
      }
      TransactionHeader {
        Hash
        FeePayer
      }
      Pair {
        Market {
          Address
          Protocol
        }
        Token {
          Symbol
          Name
          Address
        }
        QuoteToken {
          Symbol
          Address
        }
      }
    }
  }
}

Add AmountsInUsd: { Base: { gt: 1000 } } to watch only meaningful size, or Pair: { Token: { Address: { is: "<mint>" } } } to follow one curve.

Market cap and price of a Meteora DBC token

Trading.Pairs carries market cap, fully diluted valuation, supply, OHLC and volume per curve, already computed. Replace the mint with one from the example query above.

Price: { IsQuotedInUsd: true } matters: every market publishes each interval twice, once in USD and once in the quote token. DBC curves are quoted in SOL, USDC, JUP and other tokens, so without that filter you may read a price in the wrong unit.

{
  Trading {
    Pairs(
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
      where: {
        Token: { Address: { is: "<mint>" } }
        Market: {
          Protocol: { is: "dynamic_bonding_curve" }
          Network: { is: "Solana" }
        }
        Price: { IsQuotedInUsd: true }
        Interval: { Time: { Duration: { eq: 60 } } }
      }
    ) {
      Block {
        Time
      }
      Token {
        Symbol
        Name
        Address
      }
      QuoteToken {
        Symbol
      }
      Market {
        Address
      }
      Price {
        Ohlc {
          Open
          High
          Low
          Close
        }
        Average {
          Mean
        }
      }
      Volume {
        Usd
        Base
      }
      Supply {
        MarketCap
        FullyDilutedValuationUsd
        TotalSupply
      }
    }
  }
}

Stream Meteora DBC tokens above a market cap threshold

The screener query: every DBC curve whose market cap crosses your floor, live. Change gt to move the threshold.

subscription {
  Trading {
    Pairs(
      where: {
        Market: {
          Protocol: { is: "dynamic_bonding_curve" }
          Network: { is: "Solana" }
        }
        Price: { IsQuotedInUsd: true }
        Supply: { MarketCap: { gt: 10000 } }
        Interval: { Time: { Duration: { eq: 60 } } }
      }
    ) {
      Block {
        Time
      }
      Token {
        Symbol
        Name
        Address
      }
      QuoteToken {
        Symbol
      }
      Market {
        Address
      }
      Supply {
        MarketCap
        FullyDilutedValuationUsd
        TotalSupply
      }
      Price {
        Ohlc {
          Close
        }
      }
      Volume {
        Usd
      }
    }
  }
}

Meteora DBC OHLC API

Trading.Pairs serves candles at whatever interval you ask for, so there is nothing to aggregate. Set Interval.Time.Duration in seconds: 1 for one-second candles, 60 for one-minute. One-second candles matter on a bonding curve, where a token's whole life can be shorter than an hour.

{
  Trading {
    Pairs(
      limit: { count: 30 }
      orderBy: { descending: Block_Time }
      where: {
        Token: { Address: { is: "<mint>" } }
        Market: {
          Protocol: { is: "dynamic_bonding_curve" }
          Network: { is: "Solana" }
        }
        Price: { IsQuotedInUsd: true }
        Interval: { Time: { Duration: { eq: 1 } } }
      }
    ) {
      Block {
        Time
      }
      Market {
        Address
      }
      QuoteToken {
        Symbol
      }
      Price {
        Ohlc {
          Open
          High
          Low
          Close
        }
      }
      Volume {
        Usd
        Base
      }
    }
  }
}

Top traders of a Meteora DBC token

Ranks wallets on one curve by USD volume, one row per wallet, with the USD each bought and sold and a realised PnL for the window. Trading.Trades reports Side from the trader's own point of view, so no field gymnastics are needed.

note

Run this as a query, not a subscription. Aggregates over WebSocket return partial results.

query TopTraders($token: String) {
  Trading {
    Trades(
      limit: { count: 100 }
      orderBy: { descendingByField: "pnl" }
      where: {
        Pair: {
          Market: {
            Protocol: { is: "dynamic_bonding_curve" }
            Network: { is: "Solana" }
          }
          Token: { Address: { is: $token } }
        }
      }
    ) {
      Trader {
        Address
      }
      bought: sum(of: AmountsInUsd_Base, if: { Side: { is: "Buy" } })
      sold: sum(of: AmountsInUsd_Base, if: { Side: { is: "Sell" } })
      pnl: calculate(expression: "$sold - $bought")
      buys: count(if: { Side: { is: "Buy" } })
      sells: count(if: { Side: { is: "Sell" } })
      volumeUsd: sum(of: AmountsInUsd_Base)
    }
  }
}
{
  "token": "<mint>"
}

pnl here is realised in the window only: a wallet still holding its bag shows a negative number. The wallet PnL guide covers unrealised positions.

Track new Meteora DBC launches

Launches are per-instruction detail, so this uses the chain-level Instructions cube. A curve is created by one of two instructions, and you need both: initialize_virtual_pool_with_spl_token for standard SPL tokens and initialize_virtual_pool_with_token2022 for Token-2022 mints. Token-2022 launches are a large minority of DBC traffic, so filtering only the SPL variant silently hides a third of new tokens.

Program.AccountNames names each entry of Instruction.Accounts in order: base_mint is the new token, quote_mint the token the curve is priced in, pool the curve address, creator the launching wallet, and base_vault and quote_vault the reserves.

subscription {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Address: { is: "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN" }
            Method: {
              in: [
                "initialize_virtual_pool_with_spl_token"
                "initialize_virtual_pool_with_token2022"
              ]
            }
          }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        Time
      }
      Instruction {
        Accounts {
          Address
          IsWritable
          Token {
            Mint
            Owner
            ProgramId
          }
        }
        Program {
          AccountNames
          Address
          Method
          Name
        }
      }
      Transaction {
        Signature
        Signer
        FeePayer
      }
    }
  }
}

Track Meteora DBC graduations

When a curve completes, a keeper migrates the liquidity into a DAMM pool. migration_damm_v2 is the instruction in use today; migrate_meteora_damm is the older path into DAMM v1 and still appears in historical data, so keep both when querying the archive.

subscription {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Address: { is: "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN" }
            Method: { in: ["migration_damm_v2", "migrate_meteora_damm"] }
          }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        Time
      }
      Instruction {
        Accounts {
          Address
          IsWritable
          Token {
            Mint
            Owner
            ProgramId
          }
        }
        Program {
          AccountNames
          Address
          Method
          Name
        }
      }
      Transaction {
        Signature
        Signer
      }
    }
  }
}

Meteora runs the migration keepers itself, so the signer is usually a Meteora address rather than the token creator. Graduation thresholds are set per curve config; Meteora's published keeper Asi5DTGEeiso6k7ya6ndDabEZ7DRCgfTpCBLPH5E3aQs handles configs with a threshold of 10 SOL, 750 USDC or 1500 JUP.

Track migrations across DBC, LetsBonk.fun, Raydium LaunchLab, Boop.fun and Moonit

One subscription covering graduations on five launchpads. Each branch matches that program's own migration method, and the LetsBonk.fun branch is identified by its platform config address appearing in the accounts of a Raydium LaunchLab migration.

subscription {
  Solana {
    Instructions(
      where: {
        any: [
          {
            Instruction: {
              Program: {
                Address: { is: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj" }
                Method: { is: "initialize_v2" }
              }
            }
          }
          {
            Instruction: {
              Program: {
                Address: { is: "boop8hVGQGqehUK2iVEMEnMrL5RbjywRzHKBmBE7ry4" }
                Method: { is: "graduate" }
              }
            }
          }
          {
            Instruction: {
              Program: {
                Address: { is: "MoonCVVNZFSYkqNXP6bxHLPL6QQJiMagDL3qcqUQTrG" }
                Method: { is: "migrateFunds" }
              }
            }
          }
          {
            Instruction: {
              Program: {
                Address: { is: "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN" }
                Method: { in: ["migrate_meteora_damm", "migration_damm_v2"] }
              }
            }
          }
          {
            Instruction: {
              Program: {
                Address: { is: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj" }
                Method: { in: ["migrate_to_amm", "migrate_to_cpswap"] }
              }
              Accounts: {
                includes: {
                  Address: { is: "FfYek5vEz23cMkWsdJwG2oa6EphsvXSHrGpdALN4g6W1" }
                }
              }
            }
          }
        ]
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        Time
      }
      Instruction {
        Accounts {
          Address
          IsWritable
          Token {
            Mint
            Owner
            ProgramId
          }
        }
        Program {
          AccountNames
          Address
          Method
          Name
        }
      }
      Transaction {
        Signature
        Signer
      }
    }
  }
}

Read the program address on each row to tell the launchpads apart: dbcij3… is Meteora DBC, LanMV9… is Raydium LaunchLab, boop8h… is Boop.fun, MoonCV… is Moonit, and a LaunchLab row carrying FfYek5vEz23cMkWsdJwG2oa6EphsvXSHrGpdALN4g6W1 in its accounts is a LetsBonk.fun graduation.

Check whether a list of tokens has graduated from Meteora DBC

Pass up to a few hundred mints and get back a row for each one that has migrated. Tokens with no row have not graduated. Add Block: { Time: { since_relative: { days_ago: 7 } } } to bound the scan.

query MyQuery($tokenAddresses: [String!]) {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Address: { is: "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN" }
            Method: { in: ["migration_damm_v2", "migrate_meteora_damm"] }
          }
          Accounts: { includes: { Address: { in: $tokenAddresses } } }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        Time
      }
      Instruction {
        Accounts {
          Address
          Token {
            Mint
          }
        }
        Program {
          AccountNames
          Method
        }
      }
      Transaction {
        Signature
      }
    }
  }
}
{
  "tokenAddresses": ["<mint-1>", "<mint-2>", "<mint-3>"]
}

Latest price of a token on Meteora DBC

If you want a single price rather than a candle, read the last trade from Trading.Trades. PriceInUsd is the USD price of that print and Supply.MarketCap the market cap at that moment.

{
  Trading {
    Trades(
      limit: { count: 1 }
      orderBy: { descending: Block_Time }
      where: {
        Pair: {
          Market: {
            Protocol: { is: "dynamic_bonding_curve" }
            Network: { is: "Solana" }
          }
          Token: { Address: { is: "<mint>" } }
        }
      }
    ) {
      Block {
        Time
      }
      Price
      PriceInUsd
      Side
      Supply {
        MarketCap
      }
      Pair {
        Token {
          Symbol
        }
        QuoteToken {
          Symbol
        }
        Market {
          Address
        }
      }
    }
  }
}

Raw curve trades and history

The chain-level cubes carry per-swap detail the Trading cubes leave out, such as the exact instruction behind a trade and the token accounts on each side. Solana.DEXTrades keeps roughly 12 hours; Solana.DEXTradeByTokens keeps about 7 days on realtime and reaches back to mid-2024 on archive.

subscription {
  Solana {
    DEXTrades(
      where: {
        Trade: {
          Dex: {
            ProgramAddress: { is: "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN" }
          }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Signature
        Signer
      }
      Trade {
        Dex {
          ProgramAddress
          ProtocolName
          ProtocolFamily
        }
        Market {
          MarketAddress
        }
        Buy {
          Currency {
            Name
            Symbol
            MintAddress
          }
          Amount
          AmountInUSD
          Account {
            Address
            Owner
          }
          Price
          PriceInUSD
        }
        Sell {
          Currency {
            Name
            Symbol
            MintAddress
          }
          Amount
          AmountInUSD
          Account {
            Address
            Owner
          }
          Price
          PriceInUSD
        }
      }
    }
  }
}

Aggregate in native amounts on archive and combined, not USD

Summing Trade_Side_AmountInUSD on the Solana archive and combined datasets does not aggregate cleanly: adding it to a grouped query shatters one row into many partial rows, and combined also returns fewer trades than realtime over the same window. Aggregate Trade_Amount instead, and take USD figures from the Trading cubes, where every row carries a vetted USD price.

API key, free trial and pricing

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

Frequently Asked Questions

Does Meteora have an API for the Dynamic Bonding Curve?

No. Meteora publishes REST data APIs for DLMM, DAMM v1 and DAMM v2, but none for the Dynamic Bonding Curve. It ships an SDK and IDL for building transactions only. Bitquery reads DBC launches, trades, market caps and graduations from the chain and serves them over GraphQL, WebSocket, Kafka and gRPC.

What is the Meteora DBC program ID on Solana?

dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN, the same on mainnet and devnet, with pool authority FhVo3mqL8PW5pH5U2CN4XE33DokiyZnUwuGpH2hmHLuM. In Bitquery data it is Market.Protocol dynamic_bonding_curve in the Trading cubes and ProtocolName dynamic_bonding_curve, family Meteora, in the Solana cubes.

How do I track new Meteora DBC token launches?

Subscribe to Solana.Instructions on the DBC program with both initialize_virtual_pool_with_spl_token and initialize_virtual_pool_with_token2022. Filtering only the SPL variant hides every Token-2022 launch, which is a large minority of DBC traffic. AccountNames identifies base_mint as the new token and pool as the curve.

How do I know when a Meteora DBC token graduates?

Watch the migration instructions on the DBC program: migration_damm_v2 is the current path into DAMM v2, and migrate_meteora_damm is the older path into DAMM v1 that still appears in historical data. Meteora runs the keepers, so the signer is usually a Meteora address.

How do I get the market cap of a Meteora DBC token?

Query Trading.Pairs filtered by Market.Protocol dynamic_bonding_curve with Price.IsQuotedInUsd true. Supply.MarketCap, FullyDilutedValuationUsd and TotalSupply come back on the row, already computed. A subscription with Supply.MarketCap gt your threshold turns it into a screener.

Why do the examples use placeholder mints?

Bonding curve tokens are short lived, so any mint hardcoded into a docs page stops returning rows within days. Run the example query at the top of this page to get mints trading right now and paste one in.

How do I get OHLC candles for a Meteora DBC token?

Query Trading.Pairs with Interval.Time.Duration in seconds and Price.IsQuotedInUsd true. One-second candles are available, which matters on a curve whose whole life can be under an hour.

Which launchpads run on Meteora DBC?

Jupiter Studio and Believe both launch on the Dynamic Bonding Curve, and their tokens appear in the queries on this page alongside every other DBC launch. Bitquery has dedicated pages for each if you want to filter to one launchpad.

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

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

Meteora DAMM v2 API, where graduated DBC tokens land
Meteora DLMM API
Meteora DAMM v1 API
Jupiter Studio API and Believe API, launchpads built on DBC
Trading API overview, Trades cube and Pairs cube
Wallet PnL
Solana DEX Trades API
Data coverage and retention
gRPC DEX trades topic and real-time Solana streams over Kafka
API Authorization

Support

For technical support and questions contact our support team via telegram or create a ticket here

Build with Bitquery

Ready to run this in production?

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

Get your API key See pricing Try the MCP server Subscribe to newsletter

Talk to the teamTelegram Email

What is the Meteora DBC program ID on Solana?​

Picking an example token​

Meteora DBC trades in real time​

Market cap and price of a Meteora DBC token​

Stream Meteora DBC tokens above a market cap threshold​

Meteora DBC OHLC API​

Top traders of a Meteora DBC token​

Track new Meteora DBC launches​

Track Meteora DBC graduations​

Track migrations across DBC, LetsBonk.fun, Raydium LaunchLab, Boop.fun and Moonit​

Check whether a list of tokens has graduated from Meteora DBC​

Latest price of a token on Meteora DBC​

Raw curve trades and history​

API key, free trial and pricing​

Frequently Asked Questions

Related documentation​

Support​

What is the Meteora DBC program ID on Solana?

Picking an example token

Meteora DBC trades in real time

Market cap and price of a Meteora DBC token

Stream Meteora DBC tokens above a market cap threshold

Meteora DBC OHLC API

Top traders of a Meteora DBC token

Track new Meteora DBC launches

Track Meteora DBC graduations

Track migrations across DBC, LetsBonk.fun, Raydium LaunchLab, Boop.fun and Moonit

Check whether a list of tokens has graduated from Meteora DBC

Latest price of a token on Meteora DBC

Raw curve trades and history

API key, free trial and pricing

Related documentation

Support