Is the Meteora DLMM API free, and what is the rate limit?

The official REST API at dlmm-api.meteora.ag is free with a 30 RPS rate limit. No WebSocket, no gRPC. That works for a dashboard refreshing every few seconds. It does not work for trading bots, LP rebalancers, or anything where bin-level freshness matters. We run parsed real-time DLMM streams over gRPC from $49/month (Pro, 2 streams). No per-event surcharge, no rate limit on the gRPC payload.

Does Meteora DLMM have a WebSocket or gRPC API?

Meteora's official surface is REST-only. The real-time path goes through Solana directly: WebSocket logsSubscribe filtered on the DLMM program ID gives raw program logs you parse yourself, and Yellowstone gRPC gives multiplexed transaction + account streams. We pre-decode the DLMM events over gRPC, so you receive typed swap and position updates instead of base64 logs.

How do I get OHLCV data from Meteora DLMM?

Two ways. The official /pool_pair/{address}/ohlcv endpoint returns pre-aggregated candles, but lags the chain by 5-30 seconds. Or you bucket the parsed swap stream yourself. Each decoded swap carries the active bin id, in/out amounts, and the bin step, enough to compute price-per-bin without rounding error. The stream version is sub-second; the REST version is whatever Meteora's batch interval happens to be that day.

How do I detect new DLMM pools as they launch?

Filter on initialize_lb_pair. The instruction payload includes both mint addresses, the initial active bin id, and the bin step (which determines the fee tier). Our parsed stream emits a typed PoolCreated event for this. Useful for sniper bots tracking new memecoin pairs that migrate into DLMM after Pump.fun graduation.

What's the difference between Meteora DLMM and DAMM?

DLMM is bin-based. Liquidity is split across discrete price bins with deterministic price-per-bin. Feels like an order book; settles like an AMM. DAMM is the older Meteora pool style: constant-product with dynamic fee logic, simpler accounts, no bins. Two separate programs, two separate IDLs. Most current Meteora volume goes through DLMM; DAMM is still active for legacy pairs and some stable pools.

How do bin arrays work in Meteora DLMM?

A BinArray is a fixed-size on-chain account holding 70 contiguous bins. Each bin has its own X-token / Y-token reserves and an LP-token supply. When a swap moves price across bins, the program walks adjacent BinArrays sequentially. The active_id field on the LbPair tells you which bin is currently inside the spread; tracking it together with the surrounding BinArrays is how an LP rebalancer knows its range is about to fall out of position.

How does NoLimitNodes compare to Bitquery for Meteora data?

Bitquery's GraphQL is excellent for historical analytics and JOINed queries across DEXes. If you want post-hoc dashboards or research, they're a solid pick. We ship parsed real-time gRPC streams sized for sub-second decisioning. Different jobs. Many teams use both: Bitquery for backfill, us for the live edge.

Enhanced Stream

The Meteora DLMM API: real-time bin-level liquidity data for Solana's top DEX

Meteora's DLMM became the highest-volume DEX on Solana through 2025. Tens of billions in monthly swap volume, all bin-by-bin. The official API at dlmm-api.meteora.ag is REST with a 30 RPS cap and no WebSocket or gRPC. Fine for a chart on a dashboard. Useless for an LP rebalancer that has to react when the active bin moves out of range, or a sniper watching for new pool launches. We watch the DLMM program directly and ship parsed events: every swap, add_liquidity, remove_liquidity, position update, and active-bin shift, decoded as it lands. 14ms p50 from slot to socket.

Bin-level decodingNo 30 RPS capgRPC + WebSocketActive-bin trackingSub-50ms latency

On-chain programs

Meteora DLMMLBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo, Bin-based dynamic liquidity market maker. Meteora's flagship pool program
Meteora DAMM (legacy dynamic AMM)Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB, Older constant-product Meteora pools (verify if streaming both)

Try it live: Meteora streams

decoded solana events over grpc · click Run to see live data

2 streamslive

Meteora DLMM

Meteora dynamic liquidity market maker swaps

1grpcurl -H "x-api-key: YOUR_API_KEY" \
2  -d '{"topic":"prod.mat.solana.program.swaps.meteora_dlmm","format":"JSON"}' \
3  stream-1.nln.clr3.org:443 nln.stream.v1.StreamService/Subscribe

Live Output

See real data

Click Run to stream 5 live Meteora DLMM messages

Pro: 2 streams $49/mo · Ultra: 20 streams $199/mo · pre-parsed, zero infra

The Meteora DLMM events you can stream

every decoded instruction across LbPair, BinArray, and Position accounts

Event	Type	Description	Frequency	Latency
swap	instruction	DLMM exact-in swap. Decoded with active-bin id, amount in/out, price impact, and the bin array touched.	Very high	14ms
swap_exact_out	instruction	DLMM exact-out swap. Same decoding shape with the output amount fixed and input computed from bin liquidity.	High	14ms
add_liquidity	instruction	LP deposit into a specific bin range. Surfaces position NFT mint plus the per-bin liquidity distribution.	High	14ms
add_liquidity_by_strategy	instruction	Deposit using one of Meteora's built-in distribution strategies (Spot, Curve, BidAsk). Decoded with strategy parameters.	Medium	14ms
remove_liquidity	instruction	LP withdrawal, bin-by-bin liquidity reduction with the resulting token payouts.	High	14ms
initialize_lb_pair	instruction	New DLMM pool launch. Includes base/quote mints, initial active bin, and bin step (fee tier).	Medium	14ms
initialize_position	instruction	Mint a new Position NFT for a given bin range, the canonical LP entry signal.	High	14ms
claim_fee	instruction	LP claims accrued trading fees. Use to compute realized yield per position.	Medium	14ms
claim_reward	instruction	LP claims pool reward emissions (LP incentives, dual-asset rewards).	Medium	14ms
update_position_lock_release_point	instruction	Locked-position lifecycle. Useful for tracking time-locked liquidity programs.	Low	14ms

DLMM streaming performance

last reviewed 2026-04-28

DLMM swap latency

14ms

p50 from slot landing to your socket

Verified 2026-04-28

Active LbPairs tracked

5,000+

Live DLMM pools we decode in real time

Verified 2026-04-28

Daily DLMM instructions

3-8M

Across swap, add_liquidity, claim_fee variants, peak memecoin cycles

Stream uptime SLO

99.95%

Pro and Ultra plans, monthly rolling

What DLMM is, and why bins matter

DLMM stands for Dynamic Liquidity Market Maker. Instead of pricing liquidity along a smooth curve (Raydium AMM v4) or as continuous ranges (CLMM), DLMM splits the price axis into discrete bins. Each bin is a small price band that holds its own X / Y reserves. A swap walks bins from the active one outward until the input is filled, at deterministic prices. It feels like an order book and settles like an AMM. That hybrid is the whole reason it took off in 2025.

On chain, four account types do all the work. LbPair holds the pair config: base mint, quote mint, bin step, active bin id, fees. BinArray accounts each store 70 contiguous bins of liquidity; a busy pool spans many of them. Position and PositionV2 represent individual LP entries with a tick range and per-bin liquidity. Oracle stores the price-history ring buffer for TWAPs.

Subscribing to “Meteora data” means watching three things. Instruction calls into the DLMM program (swaps, deposits, withdrawals, claims). Account writes to LbPair (active bin shifts). And account writes to specific BinArrays you care about (granular liquidity distribution). All three drop into one feed if you set it up right.

The official Meteora API: what it gives you, what it doesn't

The official Meteora API at dlmm-api.meteora.ag is REST. Seven main endpoints: pool list, pool detail, OHLCV history, swap volume, fee accruals, group listings, and protocol-wide metrics. The hard limits: 30 requests per second, polling-only, aggregates updated on a 5 to 30 second cadence behind the chain.

That's genuinely fine for an analytics dashboard refreshing every 30 seconds, or a backfill job pulling pool history into a notebook. We'd use it ourselves for either.

What it doesn't do: catch new pool launches as they happen. Tell an LP rebalancer that the active bin just moved out of its range. Power a sniper that needs to sit in the slot after a token migrates into DLMM. Anything where freshness matters in seconds, not in the next polling cycle, has to subscribe to the program directly.

Decoding bin arrays and active-bin price changes

The single most important field for monitoring a DLMM pool live is the LbPair's active_id: the integer id of the bin currently inside the spread. Every swap that crosses a bin boundary increments or decrements it. Subscribing to LbPair account writes (rather than only transactions) gives you a tight signal that price moved with no decoder overhead. The active_id sits at a fixed byte offset.

For deeper analytics, per-bin liquidity, slippage estimates, execution-price prediction, you also need the surrounding BinArray accounts. A typical SOL/USDC DLMM pool spans dozens of them. Our parsed stream flags which BinArrays were touched by each swap, so your decoder refreshes its cached liquidity map only for the ones that changed instead of polling the whole program every block.

Bin step is the other key parameter. It defines the geometric ratio between adjacent bin prices. A 100-bps bin step means each bin is 1% wider than the previous one. Bin step is set at pool creation and emitted in the initialize_lb_pair instruction, which is useful for sniper bots that filter for tighter (low-slippage) or looser (memecoin-volatile) pools at launch.

What teams build with this

Sniper bots

Filter on initialize_lb_pair to catch new DLMM pools at launch. Bin step + initial active bin tell you whether you're looking at a tight stable-style pool or a memecoin breakout. Pair with the Pump.fun graduation stream and you catch DLMM-bound migrations ahead of any aggregator.

LP rebalancers

Watch active_id on the LbPair plus your Position bin range. When the active bin drifts out of range, the position stops earning fees. Fire a rebalance. 14ms p50 means you avoid leaving stale liquidity during a memecoin pump.

OHLC dashboards

Bucket the swap stream into time intervals per LbPair. Bin id plus bin step gives you exact price; you skip the rounding errors REST aggregates leak. Cleaner candles, faster freshness.

MEV & arb

Cross-DEX arb engines treat DLMM as one input. The parsed swap event lets you compute the post-trade price instantly, before the next slot lands. Fast enough to bundle a counter-trade through Jito.

Pricing, and where we sit vs the rest

The Meteora DLMM data market splits cleanly. Official REST is free but rate-limited. Bitquery sells GraphQL access; if you want JOINed historical analytics across DEXes they're genuinely better at that than we are. Direct on-chain subscription via Yellowstone gRPC is the only real-time option. Bitquery shines for post-hoc work; we shine for sub-second decisioning and predictable pricing.

We charge flat. Pro ($49/month) gives you two parsed streams. DLMM is one option among ten-plus DEXes and program families. Ultra ($199/month) bumps that to twenty plus 30 hours of custom dev time per month. No per-event surcharges, no DLMM-specific add-ons. Full breakdown is on the pricing page.

Frequently asked questions

LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo. It owns every LbPair, BinArray, and Position account that backs DLMM trading. Filter your stream on this ID to capture every swap, deposit, withdrawal, and position update across DLMM in one feed.