Anaxer vs Birdeye: which is better for pump.fun data?

Quick answer

Anaxer and Birdeye solve different problems that happen to overlap on pump.fun.

Birdeye is a broad, multi-chain market-data and analytics platform - 17+ chains, deep OHLCV history, holder analytics, wallet PnL, token security scoring. Its REST API is metered in compute units, and its WebSocket streams are billed per byte delivered. Its free tier includes no streaming at all, and real-time access starts at $125-$199/mo.

Anaxer is a Solana-only real-time event API. It streams pre-parsed launches, graduations, trades, and prices over WebSocket on flat plans - $0 for live creation and graduation streams, $39/mo for all stream types - and never meters stream volume.

If you are building a pump.fun bot, dashboard, or alerting system and you want a bill that does not move when volume spikes, Anaxer is the cheaper and simpler option by a wide margin. If you need price history, holder breakdowns, wallet PnL, or anything outside Solana, Anaxer does not cover that and Birdeye does. The two are complements rather than rivals, and pairing them is usually the cheapest arrangement of all: run the high-volume real-time streams on Anaxer, where they are not metered, and keep Birdeye for the historical and analytical queries it is built for.

Who is this comparison for?

This is for developers who need real-time Solana event data, specifically:

• pump.fun bots (snipers, copy-trading, trading automation)
• Launch and graduation alerting
• Trading dashboards that need live trades and prices
• PumpSwap monitoring

If you need historical charts, holder distribution, rug-risk scoring, wallet portfolio tracking, or coverage of Ethereum, Base, BSC, Sui, or Hyperliquid, Birdeye covers ground Anaxer does not, and the rest of this page says so plainly - including where running both beats running either alone.

What is the difference between Anaxer and Birdeye?

Birdeye is a full-spectrum market-data platform. It covers prices, OHLCV, liquidity, transaction flow, holder analytics, token and pair overviews, wallet portfolio and PnL, smart-money tracking, token security, and perps - across Solana plus Ethereum, Base, BSC, Arbitrum, Sui, Aptos, Monad, HyperEVM and more. Most developers meet Birdeye through birdeye.so the terminal; the API is a separate product billed in compute units.

Anaxer is narrower on purpose. It watches a small set of high-value Solana events - token launches, graduations, DEX trades, and prices (wallet transfers coming soon) - parses them, and emits structured JSON with identical shapes over WebSocket and REST. pump.fun and PumpSwap are its native dataset.

The cleanest way to hold the distinction: Birdeye is an analytics platform you query; Anaxer is an event pipe you subscribe to. Birdeye answers "what happened to this token over the last six months." Anaxer answers "tell me the instant something happens." Those are different products, and the pricing models follow from that difference.

Anaxer vs Birdeye: head-to-head

How do Anaxer and Birdeye pricing compare?

Verified 20 September 2026 against the public Birdeye pricing page and the Anaxer pricing page. Both change - confirm current numbers before deciding.

Birdeye's plans

Two things are worth pointing out plainly, because they are easy to miss.

The free tier cannot stream, and barely queries. 30,000 compute units is about 10,000 calls to the 3-CU price endpoint, or 2,000 calls to the 15-CU token-overview endpoint, for the entire month. The rate limit is 1 request per second. It is a trial, not a tier you can prototype a live product on.

Streaming is not in the advertised entry plans. The Birdeye pricing grid shows Lite at $39 and Starter at $99, and neither includes WebSocket access. A small toggle labelled "Turn on to enable WebSocket access" converts Starter into Starter Plus at $125/mo with 100 concurrent connections. Meanwhile Birdeye's own data accessibility by package table lists all WebSocket features - price, transactions, new listings, new pairs, large trades, wallet transactions, token stats - as beginning at Premium ($199). Budget for $199 and treat $125 as a discovery.

Anaxer's plans

There are no compute units, no credits, and no per-event or per-byte charge. What your plan limits is how many concurrent connections you can hold on any one stream - 1 on Free, 1 on Starter, 2 on Pro, counted across your whole account. A quiet stream and a full firehose cost exactly the same.

Birdeye bills WebSocket streaming by the byte

This is the single most important thing to understand before you build a real-time product on Birdeye, and it is documented rather than inferred. From Birdeye's compute unit cost reference:

"Websocket subscriptions are billed by bytes (CUPB)."

CUPB is compute units per byte. The rate depends on which subscription you open:

Note the spread: the new-listing stream costs 267x more per byte than the trades stream. That matters, because new listings are exactly what a pump.fun product subscribes to.

A worked example: streaming pump.fun launches

Let us price the most common pump.fun workload on Birdeye - a live feed of every new token - using real launch volume and stated assumptions you can check.

pump.fun is currently producing roughly 32,000 token creations per day (measured on the Anaxer creations stream over a rolling 24 hours), which is about 960,000 events per month. Birdeye covers these: SUBSCRIBE_TOKEN_NEW_LISTING accepts meme_platform_enabled: true and a sources filter that includes pump_dot_fun.

Because billing is per byte, the cost depends on payload size. A new-listing payload carries an address, decimals, name, symbol, liquidity, a timestamp, a logoURI, and the source - so a few hundred bytes to about a kilobyte. Here is the range:

The pump.fun launch feed on its own consumes roughly the entire 20M compute-unit allowance of the $199 Premium plan - and at the upper end nearly doubles it, before you have made a single REST call, opened a price stream, or watched a single trade.

The same stream on Anaxer is on the free plan.

Why per-byte billing is hard to budget

The deeper problem is not the rate, it is the shape. With per-byte billing, your bill is a function of on-chain activity you do not control. A quiet week costs less; a memecoin mania costs more, at exactly the moment your product is under load and you least want to be reasoning about overage brackets.

Birdeye does not cut you off at the allowance - overage is post-paid, and your card is charged automatically once accrued overage crosses a threshold ($100 on Starter and Premium, $300 on Business). That is friendlier than a hard stop, but it means the ceiling is set by chain activity rather than by you.

Anaxer inverts this: stream volume is never metered, so the busiest day of the cycle costs precisely what the quietest day costs.

The limit that pricing pages do not show: 100 addresses

Cost is one constraint. There is a second one that no amount of budget removes.

Birdeye's SUBSCRIBE_TXS subscription is address-scoped, not chain-scoped. You name the tokens or pairs you want, and the documentation caps that at 100 addresses per subscription. Each WebSocket connection also holds one active subscription per message type - sending a second SUBSCRIBE_TXS overwrites the first rather than adding to it. So the real ceiling is 100 addresses per connection, multiplied by your plan's connection count.

For most analytics products that is fine. For pump.fun it is a structural mismatch, because you do not know in advance which of the day's ~32,000 new tokens will matter. Watching the ecosystem means either maintaining a rolling address list, evicting tokens to make room, and re-subscribing continuously - or accepting that you will miss the token that mattered.

Anaxer's trades stream is chain-scoped. On Pro ($99/mo) you subscribe once and receive trades across all tokens, with no address list to maintain and nothing to evict.

Graduations: a first-class event vs an inference

pump.fun graduation - a bonding curve completing and liquidity migrating to PumpSwap - is one of the highest-signal events in the ecosystem. At current rates roughly 1,131 of 31,948 daily launches graduate, about 3.5%.

Anaxer emits graduation as its own event type, on the free plan, with the graduating mint, the pool, and the timestamp already resolved.

Birdeye has no graduation primitive. The closest proxy is SUBSCRIBE_NEW_PAIR, which reports newly created trading pairs; Birdeye's documentation describes it as useful for "tracking new tokens being added" and does not address migrations between platforms. To derive graduations you would correlate new-pair events against tokens you had previously seen launch - state you have to keep yourself - and pay 0.03 CU/byte for the stream while you do it.

If you need to know the moment a token graduates, that is a meaningful difference in both engineering effort and cost. We wrote up what a pump.fun graduation actually is and how to detect them if you want the mechanics.

How much work is each to integrate?

Both are WebSocket APIs authenticated with an API key, so the difference is not protocol - it is how much you have to reason about before the first event arrives.

Anaxer: open a connection, subscribe to a channel by name.

const ws = new WebSocket("wss://api.anaxer.com/v1/stream?apiKey=YOUR_KEY");
ws.addEventListener("open", () => ws.send(JSON.stringify({
  type: "subscribe",
  id: "launches",
  channel: "creations",
})));

Birdeye: connect to the chain-specific socket with an echo-protocol subprotocol, then send a typed subscription with its own parameter set.

const ws = new WebSocket(
  "wss://public-api.birdeye.so/socket/solana?x-api-key=YOUR_KEY",
  "echo-protocol",
);
ws.addEventListener("open", () => ws.send(JSON.stringify({
  type: "SUBSCRIBE_TOKEN_NEW_LISTING",
  data: { meme_platform_enabled: true, sources: ["pump_dot_fun"] },
})));

The code is comparable. The surrounding work is not. On Birdeye you also need to decide which plan unlocks WebSocket, estimate compute-unit burn per subscription, track per-API rate limits that differ by endpoint group (wallet endpoints run at 30 requests per minute, not per second), keep subscriptions under the 100-address cap, remember that one connection holds one subscription per type, and monitor overage thresholds so you are not surprised by an automatic charge.

On Anaxer there is one rate limit, one connection cap per stream, and no usage metering to model. That is the whole of it.

Which should you choose?

A comparison is only useful if it tells you when not to buy. Here is the honest split.

Choose Birdeye when you need:

• Historical data. Deep OHLCV across arbitrary timeframes. This is Birdeye's clearest advantage - Anaxer's retention is deliberately short (7 days of trade history, 90 days of creations and graduations, current prices only), because it is an event pipe rather than a data warehouse. If you need to chart six months, Anaxer cannot do it at any price.
• Multi-chain coverage. 17+ chains including Ethereum, Base, BSC, Arbitrum, Sui, Aptos, Monad, and HyperEVM. Anaxer is Solana-only.
• Analytics depth. Holder distribution, first buyers, wallet net worth and PnL, smart-money tracking, trader leaderboards, token security scoring, perps data. Anaxer offers none of these.
• A fixed watchlist. If you track a known basket of tokens and want rich metrics on each, Birdeye's model fits well and the 100-address cap never binds.

Choose Anaxer when you need:

• Real-time pump.fun data at a predictable price. Flat monthly billing with no per-byte or per-event metering, starting free.
• The whole ecosystem, not a watchlist. Chain-wide trades with no address list to maintain.
• Launches and graduations as first-class events, pre-parsed, with graduation resolved for you.
• A short path from key to stream. One connection, one subscribe message, no usage model to reason about.

Running both is reasonable. Use Anaxer for the real-time firehose - the part that would be metered per byte elsewhere - and Birdeye for the historical and analytical queries that Anaxer does not serve. That split plays to each product's actual strength, and keeps the high-volume portion of your spend flat.

Summary

Birdeye is a strong, mature analytics platform, and for historical market data, holder analytics, and multi-chain coverage it does things Anaxer simply does not do. But its economics are built around querying stored data, not consuming live firehoses: streaming is excluded from the free tier, gated behind a $125-$199/mo plan, billed per byte delivered, and capped at 100 addresses for trades.

For real-time pump.fun and PumpSwap data specifically, Anaxer is materially cheaper and simpler - live creation and graduation streams on the free plan, every stream type at $39/mo, chain-wide trades at $99/mo, and a bill that does not move when volume does.

Next steps

Test it against your own workload before deciding anything. The creations and graduations streams are free, so you can measure latency, payload shape, and data quality without spending. If you are also weighing general-purpose RPC providers, read Anaxer vs Helius. For production connection handling, see the Solana streaming guide. When you are ready, explore the pump.fun API or get a key.