- Mobula
- Codex
- Birdeye
Mobula’s market-data surfaces map below, on our chains;
the main ones that do not carry over are listed at the end of this tab. A Mobula
integration moves with minimal relearning: auth is the same convention (raw
API key in the
The holder fields of pulse rows map to the row fields of the same names as
Pricing: 1 credit per trigger sent to your URL; managing webhooks and triggers is free. Mobula’s REST webhooks of swaps and
transfers (
Authorization header) and the credit model is aligned: pay as
you go, or a monthly Growth plan with credits included.Conventions that differ
| Mobula | Serialized | Why |
|---|---|---|
blockchain/chainId mixed (evm:56, solana:solana, names) | chain param, always evm:<id> or solana (solana:solana accepted on input) | one format everywhere |
priceUSD, marketCapUSD (USD-suffix) | priceUsd, marketCapUsd (camelCase) | consistent casing |
athUSD (token details, token filters) | priceUsdAth, on /v1/token and on every Pulse, Screener and search row (REST and streams), with filters and sorts on the lists: on Solana the USD price at the time of the peak; on EVM chains priceNativeAth × the native coin’s current USD price. marketCapAthUsd = priceUsdAth × the circulating supply | a high counts only when its market’s liquidity could back it |
athDate (token details) | on Solana, priceUsdAthAt on /v1/token; priceNativeAthAt dates the native high priceNativeAth | ms epoch instead of an ISO date; null on EVM chains |
circulatingSupply, marketCapUSD, marketCapDilutedUSD | circulatingSupply (total supply minus the tokens held by burn addresses; the asset’s for majors, stablecoins and native coins), marketCapUsd = circulatingSupply × price, fdvUsd = totalSupply × price | one basis on every endpoint and stream, from the token page to wallet positions |
A token’s liquidityUSD | liquidityUsd (and liquidityNative): the token’s most traded markets summed, each counted on its smaller side, on /v1/token, /v1/token/price, the Screener and Pulse token rows and the token-updates, pulse and screener streams; the main market’s own liquidity is pool.liquidityUsd on /v1/token, every pool row shows its own, and a search row shows its pool’s | one liquidity measure on every token surface |
| A token’s volume, transactions and traders | every market of the token counts, order books and proprietary AMMs (Solana) included, so the figures can differ from the ones you show today | every trade of the token is in its volume |
| A token’s price, price change and chart | one market, the token’s main market (its launch curve before graduation), for the price, the price change, the candles and the sparklines; pools= on the candles merges the markets you list | the price you show and the chart always agree |
Missing data: some fields default to 0 (transferFeePercentage on Solana), security fields left out when unknown | null when unknown, a 0 is always a measured zero | you can trust a zero |
| Parameter checks | an unknown or malformed param is a 400 with a machine-readable error.code | fail loud |
GET {data}, batch POST {payload} (or {data}, depending on the endpoint) | always { data, meta } | one envelope |
Batch: an error string in the slot of an item that failed (token/price, token/price-history) | every batch answers 200 with one slot per item, in input order: the item’s data or { error: { code, message } } | one machine-readable error shape on every batch, and a failed item is not billed |
| Timestamps: milliseconds, seconds or ISO strings depending on the endpoint | always unix milliseconds, fields end in At; candles keep the TradingView convention (time, from, endTime in seconds, a millisecond from or endTime is accepted) | no guessing |
| Trade amounts | GROSS on-chain amounts (the exact swapped value), fees in their own fields | matches the chain exactly |
Token balances: balance (a number) next to rawBalance (the raw integer) | a wallet’s amount is its exact on-chain balance, a decimal string at the token’s full precision; token quantities sent as strings never in exponent notation | the exact balance, already scaled |
exchange: { name, logo } on every pair and pulse row | pool.exchange (the venue of the pool) and pool.launchpad (the launchpad of the token), both { name, logo }, on every REST card and every live row; the quote token’s name and logo are pool.quoteName and pool.quoteIconUrl; the full catalog is GET /v1/meta/factories | launchpad and venue told apart |
Wallet labels, insider and locker among them | camelCase names in labels (dev, sniper, bundler, whale, proTrader, smartTrader, freshTrader, kol, and liquidityPool on holders), always in one fixed order; our definitions: freshTrader = a new wallet (Mobula’s fresh traders: funded in the last 24 hours), on EVM first funded at most 7 days ago, on Solana with its first trade at most 7 days before a trade (on the tapes) or its first SOL received at most 7 days before its first buy of the token (on holders, top traders, positions and wallet-filtered tapes), smartTrader = consistently profitable over the last 30 days; insider is served on Solana token holders and top traders (a wallet that received at least 0.01 % of the supply without buying it, tokens created since 2026-10-02); locker is not served (400 when asked for) | every label is defined once, on Wallet labels |
address that names a pool on the market endpoints and in the ohlcv stream’s pool mode | every row names its token and its pool explicitly, tokenAddress and poolAddress, next to address; on input, poolAddress (or address) on /v1/pool/* and pool on the streams | you never guess which address is which (Identity fields) |
Native coin as 0xeeee…eeee | native coin = 0x0000…0000 on EVM (pool.quote.address, token/pools), So11111111111111111111111111111111111111112 on Solana; 0x0000…0000 and 0xeeee…eeee accepted for the native coin on every chain, Solana included (read as the SOL mint), responses use the chain’s own address | the chain’s own convention, no synthetic address |
Endpoint map
| Mobula | Serialized | Notes |
|---|---|---|
POST /api/2/pulse (views[]) | GET /v1/pulse?view=new|bonding|graduated&chains= | one view per call (Mobula’s bonded view is graduated, also accepted as migrated; model accepted in place of view), with the filter tree and the sorts of the pulse stream: includeKeywords is filters={"OR":[{"name":{"contains":"..."}},{"symbol":{"contains":"..."}}]} (one pair per keyword, letter case ignored; excludeKeywords the same under NOT), deployer is {"creator.address":{"equals":"..."}}, holders_count, top_10_holdings_percentage and dev_holdings_percentage are holdersCount, top10HoldersPct and devHoldingsPct with gte / lte, and sortBy takes any numeric card field (holdersCount, marketCapUsd, windows.1h.volumeUsd, …); the flat filters stay (age, liquidity, market cap, bonding, volume, txns, fees, socials, launchpads with factories, labeled creators with labeledDev); bondingProgress is consistent with the token endpoint; every card carries its creator with creator.labeled and the deployer track record (creator.launchedCount, creator.migratedCount), the holders (holdersCount, top10HoldersPct, top25HoldersPct, devHoldingsPct), the taxes and token flags (risk) and every pool of the token (pools); rolling windows on request, 1m included (windows=1m,1h); pool mode is GET /v1/pulse/pools and the pulse-pools stream |
POST /api/2/token/filters (mode: "token") | GET /v1/screener | one row per token, each window summing all its markets (each wallet counted once), shown on its main market; filtered and sorted on our side: any field as sort key, a filter tree, a timeframe, cursor pagination; windowed stats on nine windows, 1m to 24h, with the wallets of each window (unique buyers and sellers, traders, snipers, pro traders, smart traders); every row carries the token’s launchpad and lifecycle, links, creator, holders, all-time high (priceNativeAth, marketCapAthUsd, with filters and sorts), and taxes and flags (risk, with filters and sorts); the view is written like a screener subscription; text filters always ignore letter case and EVM addresses match in any case |
POST /api/2/token/filters (mode: "market") | GET /v1/screener/pools | one row per pool, the same parameters and row fields as GET /v1/screener, the figures of the market itself; the view is written like a screener-pools subscription |
GET /api/1/market/query/token | GET /v1/screener?sortBy=volume | volume is strictly by USD volume of the timeframe (24h by default); the default trending ranks by relevance (wash-penalised); marketCap, createdAt or any numeric field |
GET/POST /api/2/fast-search | GET /v1/search?q= | tokens + pools, cross-chain (a pool address returns its token on that pool, and a row’s liquidityUsd is the liquidity of its pool); input is q, the chains (blockchains in the GET filters, chainId on POST) are chain (a CSV of our chain ids), sortBy keeps its name (volume24h = volume, volume_1h = volume1h, createdAt = newest, holdersCount = holders, liquidity, marketCap, feesPaid24h / feesPaid1h accepted, plus order), and any figure of the row sorts too (all-time high, transactions…); filters takes the Screener’s filter tree and the flat filters (bondedOnly is {"migrated":{"equals":true}}, excludeBonded is {"migrated":{"equals":false}}, poolTypes is {"pool.type":{"in":[...]}}; bonded, bondingPercentage, deployerTokensCount, deployerMigrationsCount, holdersCount work as filter names), with keywords on name and ticker, taxes, holders, top 10 and dev holdings, all-time high; meta.complete says when a filtered or re-sorted list may be missing a token; native coins come back as rows (0xeeee… accepted, served as 0x000…0), socials on every row (website, twitter, telegram, discord, uri, and others is socials.links, the links of /v1/token/metadata); factory is pool.factoryAddress (the address that created the row’s pool; pool.factory names the launchpad) and preBondingFactory / sourceFactory is launchpadFactoryAddress (the address that created the bonding curve); every row also carries holdersCount, top10HoldersPct, top25HoldersPct, devHoldingsPct, bondingProgress (bondingPercentage), migrated (bonded), the 1h and 24h figures in stats (volume, fees, buys, sells, transactions, price change), risk (taxes and token flags), priceNativeAth / marketCapAthUsd and creator with the deployer track record creator.launchedCount / creator.migratedCount (deployerTokensCount / deployerMigrationsCount) |
GET /api/2/token/details | GET /v1/token?chain=&address= | the launchpad block: bondingPercentage is bondingProgress and bondedAt is graduatedAt; deployer keeps its name; deployerTokensCount is creator.launchedCount and deployerMigrationsCount is creator.migratedCount (EVM: every token the deployer created, on a launchpad or not; Solana: its launchpad launches; null when unknown); totalFeesPaidUSD is feesPaidUsd (plus feesPaidNative): fees paid by traders on the main market since its creation, bonding curve included after a graduation; feesPaid24hUSD is stats24h.feesUsd, and feesPaid1minUSD, feesPaid5minUSD, feesPaid1hUSD… are windows.<w>.feesUsd when you pass windows (fees paid by traders in the window, summed over the token’s pools; on EVM chains, network fees only: Mobula adds platform and MEV fees there, so ours read lower); traders24h is stats24h.traders, and traders5min, traders1h… are windows.<w>.traders when you pass windows (unique wallets that bought or sold, each counted once across the token’s pools) |
POST /api/2/token/details (batch) | POST /v1/token (full, 25 tokens) or POST /v1/token/price (lean, 100 tokens) | response array in input order, per-item {error} slots |
GET/POST /api/2/token/price | GET/POST /v1/token/price | priceUSD, marketCapUSD, liquidityUSD are priceUsd, marketCapUsd, liquidityUsd; batch up to 100 tokens per call (Mobula: 500) |
GET/POST /api/2/token/price-at | GET/POST /v1/token/price-at | timestamp in unix seconds, per item in a batch of up to 100; the price is the last trade at or before timestamp on the token’s main market (Mobula served the closest trade, sometimes after it); swapTimestamp (milliseconds) is at (seconds), poolAddress keeps its name, priceUSD is priceUsd with usdBasis; a token that had not traded yet answers NO_PRICE_AT instead of an empty entry |
windowed stats of token/details | GET/POST /v1/token/stats, or windows= on GET/POST /v1/token | batch up to 25 tokens, windows shared and pools per token, one slot per token; the same price either way: 2 credits, 2 per 25 tokens in a batch (on /v1/token, the token details with their windows included); token-wide by default, pools= to restrict; 5m, 1h, 6h, 24h by default, 1m, 15m, 30m, 4h, 12h on request (1min is 1m); per-window txns, buy/sell split (volumeBuy<w>USD / volumeSell<w>USD are buyVolumeUsd / sellVolumeUsd), fees paid (feesPaid<w>USD is feesUsd, plus feesNative) and priceChangePct |
GET /api/1/metadata | GET/POST /v1/token/metadata | socials, icon, description, dex-paid and when it was paid (dexPaidAt, also on every Pulse and Screener card) |
GET/POST /api/2/asset/details | GET/POST /v1/asset | one asset and every token of it on our chains (BTC with WBTC, cbBTC and BTCB; ETH with the native coin of every chain and its WETH; USDC with its bridged copies); id is our asset id (btc, usdc), blockchain + address is chain + address of any of its tokens; every token is listed (no tokensLimit) with its kind (native, wrapped, bridged) and variant (WBTC, cbBTC…); one product across chains with variant: an asset read as one wrapped or bridged copy is id=btc&variant=wbtc (WBTC) or id=usdt&variant=usdt0 (USDT0); staked versions (stETH, LBTC) are their own assets with underlying; prices per token with POST /v1/token/price; batch up to 100 |
GET /api/1/all (fields=contracts,blockchains) | GET /v1/assets | the whole asset table with every token, page by page (up to 250 assets), filterable by category, chain and underlying; cache it and group any token locally |
GET /api/2/token/markets | GET /v1/token/pools | rank 1 = the token’s main market, the pool we price from, then its other markets ranked the way the main market is picked, then the rest by 24h volume and liquidity, each with its own liquidity; liquidityUSD is liquidityUsd (plus liquidityNative); approximateReserveToken / approximateReserveUSD are pooledBase / pooledQuote (token units) with pooledBaseNative / pooledQuoteNative (each side in native); factory is factoryAddress on every row (the pool’s own factory or program); feesPaid24hUSD is fees24hUsd (plus fees24hNative), the pool’s fees paid over 24h; native coins list their USD markets first |
GET/POST /api/2/token/ohlcv-history | GET/POST /v1/token/ohlcv | period is interval (1s to 1M), amount is limit (up to 2,000), to is endTime; pools optional, defaults to the token’s main market followed through migration, or merges up to 100 markets you list (200 across a batch); fill defaults to false (traded buckets only, like Mobula), fill=true adds a flat candle for every empty bucket; quote=usd on every chain except Story (evm:1514); native coins (0xeeee…) are charted in USD from their main USD market; paginate with endTime while meta.hasMore; batch up to 10 tokens |
GET /api/2/token/trades | GET/POST /v1/token/trades | token-wide by default (no mode=pair to unlearn); maker keeps the trades of one trader, and transactionSenderAddresses is makers on the POST twin (up to 2,000 traders); label is labels (one or several, any of them matches; each row’s labels keeps its name); native coins get the feed of their main USD markets, read from the coin’s side (isBuy = coin bought); cursor + fromAt; isWash on Solana; meta.usdBasis; marketAddress is poolAddress on every row; quoteTokenPriceUSD is quotePriceUsd, and quoteToken carries its logo (iconUrl); baseTokenAmountRaw and quoteTokenAmountRaw are amountTokenRaw and amountQuoteRaw (decimal strings, Solana; null on EVM chains); baseTokenMarketCapUSD is fdvUsd, the trade’s price × the token’s total supply as on Mobula, plus fdvNative; the maker’s walletMetadata of /2/token/trades-enriched is on every row, flat: displayName, avatarUrl, twitter; gasFeesUSD, mevFeesUSD, platformFeesUSD, totalFeesUSD are gasFeesUsd, mevFeesUsd, platformFeesUsd, totalFeesUsd (per transaction, at the trade’s rate; on EVM chains mevFeesUsd and platformFeesUsd are null and totalFeesUsd is the gas), plus feesNative |
GET /api/2/token/holder-positions | GET /v1/token/holders | top holders with supply share; limit (up to 1,000) + offset pagination; labels use the wallet label names above, plus liquidityPool; label is labels (one or several, among the top 5,000 holders, each keeping its rank); walletMetadata is flat on the row: entityName, entityType, displayName, avatarUrl (its entityLogo), twitter (its entityTwitter, without @); platform keeps its name and its shape (id, name, logo), the same value as on wallet labels; trading fields are null when unknown; amount is the exact balance as a decimal string and tokenAmountRaw is amountRaw; volumeBuyToken / volumeSellToken are boughtTokens / soldTokens; firstTradeAt / lastTradeAt keep their names; the fees are buyFeesUsd / sellFeesUsd / totalFeesUsd (Solana); fundingInfo is fundingFrom, fundingAt, fundingTxHash, fundingAmountNative, and its fromWalletTag / fromWalletLogo are fundingFromTag / fundingFromLogo; walletAddresses is wallets (up to 100, holders first, then the wallets that traded the token and hold none of it any more, with a zero balance; meta.matched counts the holders among them, meta.exited the others); watchlist keeps the holders among one of your watchlists; past 5,000 holders, page with cursor (meta.nextCursor) |
GET /api/2/token/trader-positions | GET /v1/token/top-traders | ranked by PnL, amount bought or sold, or trade count, lifetime or over 1h to 30d; pools= ranks the traders of the markets you list over a window; open position, average entry, the trader’s labels; walletMetadata is flat on the row: entityName, entityType, displayName, avatarUrl (its entityLogo), twitter; platform as on holders, on every timeframe; fundingInfo as on holders (fundingFrom, fundingAt, fundingTxHash, fundingAmountNative, fundingFromTag, fundingFromLogo); limit up to 1,000 with offset; label is labels (one or several, any of them matches, among the top 1,000 traders, each keeping its rank; meta.matched counts them); walletAddresses is wallets (up to 100); tokenAmountRaw is amountRaw, percentageOfTotalSupply is pctSupply, avgBuyPriceUSD / avgSellPriceUSD are avgBuyPriceUsd / avgSellPriceUsd (at each trade’s rate, null on the EVM lifetime ranking), the fees are buyFeesUsd / sellFeesUsd / totalFeesUsd (Solana lifetime, and both families on a window); GET /v1/pool/top-traders for one pool |
GET/POST /api/2/token/price-history | GET/POST /v1/token/sparklines | one token on GET, a batch of up to 100 tokens on POST, 24 to 30 evenly spaced points per timeframe; timestamps: true returns dated points ({ at, value } for [timestamp, price]); native prices, quote: "usd" on every chain except Story (evm:1514); GET /v1/pool/sparklines and POST /v1/pool/sparklines for pools |
GET /api/2/token/security | GET/POST /v1/token/security | mint/freeze authority, honeypot, taxes, ownership renounced and upgradeable proxy (EVM), Token-2022 controls (Solana), top-10 holder concentration, snipers/bundlers, dex-paid; batch up to 100; field by field in Security fields below; the contract audit (vulnerabilities, source review) is GET /v1/audit/contract |
GET /api/2/wallet/deployer | GET /v1/token/dev-tokens?wallet= | every token of the deployer, newest first, every EVM chain in one list, with a verdict on each (active, migrated, rugged, abandoned) and a risk read; page becomes offset (with meta.hasMore), the deployer’s counts are meta.creator.launchedCount / migratedCount; address= resolves the deployer of a token for you; on each token, factory is pool.factoryAddress, preBondingFactory is launchpadFactoryAddress, priceChange1hPercentage / priceChange24hPercentage are stats.1h.priceChangePct / stats.24h.priceChangePct, socials is metadata (twitterUrl, websiteUrl, telegramUrl, links for the others, uri), security is risk; the deployer’s labels, entity and funding are on meta.creator (flat: displayName, twitter, entityName, labels, fundingFrom, fundingAt); the deployer’s position in each token is devPosition with include=devPosition (2 more credits per call; balance is amount, amountUSD is amountUsd, volumeBuy / volumeSell are boughtUsd / soldUsd, avgBuyPriceUSD / avgSellPriceUSD are entryPriceUsd / exitPriceUsd) |
GET /api/2/market/lighthouse | GET /v1/lighthouse | blockchains is chains (evm = every EVM chain); total, byChain, byDex, byLaunchpad are total, chains[], exchanges[], launchpads[]; each figure is read per window, volumeUSD["15min"] is stats["15m"].volumeUsd and volumeUSDChange is stats["15m"].changePct.volumeUsd; trades is txns (swaps, one per market crossed), with buys and sells; added: buy and sell volumes, distinct traders, tokensCreated, migrations, graduationRate, the previous window, 5m, 30m, 4h and 12h, the brand color of each exchange and launchpad, and limit for the top N of both lists; feesPaidUSD and byPlatform are not served |
GET/POST /api/2/market/details | GET /v1/pool/data, POST /v1/pool/data | price, liquidity, venue and windowed stats of one pool, or of up to 100 pools across chains, one slot per pool; for the price alone, GET/POST /v1/pool/price (price, market cap and the pool’s own liquidity, 1 credit, batch up to 100 pools) |
liquidityBurnPercentage of market/details | GET/POST /v1/pool/security | lpBurnedPct and lpLockedPct of that pool, with lpSource, next to the security sheet of its token; batch up to 100 pools |
the market fields of GET/POST /api/2/market/details (venue, base and quote tokens) | GET/POST /v1/pool | the definition of one market with its live price and liquidity, or of up to 100 markets across chains in one call, one slot per market |
GET/POST /api/2/market/ohlcv-history | GET/POST /v1/pool/ohlcv | the candles of one pool, batch up to 10 pools; same parameters as the token candles |
GET /api/1/market/trades/pair | GET /v1/pool/trades, POST /v1/pool/trades | the trades of one pool, or the tape of up to 200 pools since a timestamp in one call |
GET/POST /api/2/wallet/positions | GET/POST /v1/wallet/positions | entry price + realized/unrealized/total PnL; labels on every position; the token’s main pool and FDV on every position, no /v1/token call per token: token.poolAddress is pool.address, token.type is pool.type, token.exchange is pool.exchange, token.liquidityUSD is pool.liquidityUsd, token.marketCapDilutedUSD is fdvUsd; token.security.isHoneypot is isHoneypot on the row, on Solana too; batch up to 20 wallets; blockchains is chains with our chain ids (evm:1,evm:8453, evm for every EVM chain), omitted = every EVM chain of a hex address |
GET/POST /api/2/wallet/position (single asset) | GET /v1/wallet/positions?tokens=<address> | same per-position fields, scoped to the requested token(s), up to 50 per call |
GET /api/2/wallet/holdings, GET /api/1/wallet/portfolio | GET /v1/wallet/positions?includeNative=true&includeStables=true | every token held, traded or received, valued, plus the native coin and USD stablecoins, each with the pool object of a position (token.liquidityUSD is pool.liquidityUsd on these rows too); the total is meta.summary.totalValueUsd; cross_chain_balances (one line per asset across chains): group the positions by asset with GET /v1/assets |
GET /api/2/wallet/positions-history | GET/POST /v1/wallet/closed-positions | every exited position with its realized PnL, average entry and exit prices (avgBuyPriceUSD / avgSellPriceUSD are entryPriceUsd / exitPriceUsd) and the token amounts bought and sold; tokens= for one token in one call |
GET /api/2/wallet/trades | GET/POST /v1/wallet/trades | multihop-deduplicated (one event per tx, token and side); blockchains is chains with our chain ids (chains=evm:1,evm:8453, chains=evm for every EVM chain): one timeline, one cursor, 2 credits per call whatever the number of chains; baseToken.address and baseTokenAmount are tokenAddress and amountToken, quoteToken keeps its name and shape (address, symbol, name, decimals, plus the logo as iconUrl) and quoteTokenAmount is amountQuote; marketAddress is poolAddress, transactionHash is txHash |
GET /api/2/wallet/activity (swap actions) | GET/POST /v1/wallet/swaps | one row per transaction (batch up to 20 wallets): swapAssetOut is sent[0], swapAssetIn is received[0] (each with its symbol, name, decimals), swapAmountUsd is volumeUsd, swapPlatform is router (Solana); every leg of the route is listed |
GET /api/2/wallet/activity (transfer actions) | GET /v1/wallet/transfers | token movements in and out (deposits, withdrawals, transfers); from / to / order keep their name and meaning (ms, inclusive); cursorHash / offset are one opaque cursor from meta.nextCursor; filterSpam is excludeSpam (same default, true), and every row carries spam (true, false, or null when not judged) |
GET /api/2/wallet/analysis | GET/POST /v1/wallet/pnl | PnL curve + summary (win rate); explicit usdBasis; blockchains is chains (our chain ids), omitted = every EVM chain of a hex address. from / to in unix milliseconds work as is, and meta.from / meta.to state the window the response covers; period is 1d, 7d, 30d or all, 30d when omitted (Mobula’s default is 7d), and period=90d becomes a from. calendarBreakdown[] is history[] (date is at in milliseconds; buys and sells keep their name, volumeBuy / volumeSell are boughtUsd / soldUsd, realizedPnlUSD is realizedPnlUsd); stat.periodBuys / periodSells are summary.buys / sells, periodVolumeBuy / periodVolumeSell are summary.boughtUsd / soldUsd, periodRealizedPnlUSD is summary.realizedPnlUsd, periodTradingTokens and periodActiveTokensCount are summary.tradedTokens. With include=portfolio: stat.holdingTokensCount is portfolio.positions, the unrealized part of periodTotalPnlUSD is portfolio.unrealizedPnlUsd (tradedInWindow=true adds portfolio.traded.unrealizedPnlUsd, limited to the tokens traded inside the window), and stat.totalValue is portfolio.totalValueUsd with includeNative=true&includeStables=true (tokens, native coin and stablecoins; without the two options, the tokens alone). A trade here is one token bought or sold in one transaction: the tokens a swap only routes through are not counted, so on a wallet that trades through multi-hop routes these counts, volumes and number of tokens can be lower than Mobula’s. Added: realizedPnlNative, boughtNative and soldNative in the chain’s native coin when the call covers one chain, and on the batch POST the combined total of its wallets in meta.total |
GET /api/1/wallet/history | GET /v1/wallet/equity/history | total wallet value in USD over a window, one chain per call; from / to in milliseconds |
GET /api/2/wallet/labels | GET/POST /v1/wallet/labels | one call, no chain to name, up to 100 wallets per batch: walletAddress is address; labels keeps its name (proTrader, smartTrader; freshTrader30d is freshTrader, a first funding at most 7 days old; plus kol, dev, and on Solana sniper, bundler, whale, insider); walletMetadata.entityName / entityType / entityLabels / entityLogo are entity.name / type / labels / logo, the socials are in profile.socials; platform keeps its name and its shape (id, name, logo): the trading platform the wallet trades with, on Solana and on every EVM chain, with the same ids for axiom, trojan, padre and phantom, and the same value on holders and top traders; fundingInfo.from / date / chainId are funding.funder.address / fundedAt (milliseconds) / chain; formattedAmount and currency are funding.amount and funding.currency (the native coin under its own address, where Mobula gives the wrapped coin’s), with the raw amountNative beside; fromWalletTag is funding.funder.entity.name and fromWalletLogo is funding.funder.logo; dust fundings are not counted, so the funding chain and date can differ |
| (identity only) | GET/POST /v1/wallet/profile | full identity graph, 18M+ wallets, linkedWallets clusters; the proTrader and smartTrader labels are isProTrader and isSmartTrader |
GET /api/2/wallet/funding | GET/POST /v1/wallet/funding | first funder + entity tag; batch up to 100 wallets, one slot per wallet |
| (no equivalent) | /v1/wallet/watchlist | a list of wallets kept on our side (1,000 wallets per account by default, more on request), changed by adding and removing wallets, free to manage; the holders of a token among its wallets in one call (/v1/token/holders with watchlist), and its balances and trades live on one stream subscription |
GET /api/1/blockchains, GET /api/2/system-metadata | GET /v1/meta/chains, GET /v1/meta/factories | every chain we serve with its family and native coin; every launchpad and venue with its name, logo and brand color |
GET /api/2/usage | GET /v1/usage | the current cycle of the key; per day with /v1/usage/history, per endpoint with /v1/usage/breakdown; free |
token/price on each chain’s native coin | GET /v1/prices/native | the USD price of every chain’s native coin in one call |
Security fields
GET /api/2/token/security field by field, on GET/POST /v1/token/security:| Mobula | Serialized | Notes |
|---|---|---|
isHoneypot | isHoneypot | EVM: true when a sell loses its whole value, false when measured below, null when unknown; Solana: true for a non-transferable mint, false for a transferable mint with no known block, null when unknown (mint not read yet, active transfer hook, paused, accounts frozen by default); exclude honeypots with isHoneypot !== true |
renounced | renounced (EVM) | true when the owner is an address nobody controls, false when an owner is set, null when the contract has no readable owner |
| (no field) | isProxy, implementationAddress (EVM) | the code can be replaced by an administrator, and the code it runs today; read it with renounced |
noMintAuthority, isMintable (Solana) | mintRevoked (= !isMintable), mintAuthority | null when unknown |
isFreezable | freezeRevoked (= !isFreezable), freezeAuthority | null when unknown |
transferPausable | transferPausable, plus isPaused (Solana) | Solana: accounts born frozen or the pausable extension; EVM: transfers or sells can be blocked |
balanceMutable | balanceMutable, plus permanentDelegate (Solana) | Solana: the address that can move or burn any holder’s tokens; EVM: a privileged role can move or change holders’ balances |
modifyableTax | modifiableTax | spelled modifiable; the fees can still be changed |
buyFeePercentage, sellFeePercentage, transferFeePercentage (0-100) | buyTaxBps, sellTaxBps, transferTaxBps | basis points: percent × 100 |
isNotOpenSource, isBlacklisted, selfDestruct, and isMintable on EVM | isNotOpenSource, isBlacklisted, selfDestruct, isMintable (EVM), plus upgradeableProxy | null when not known, never a made-up false; null on Solana, whose equivalents are mintRevoked, freezeRevoked and the Token-2022 controls |
isWhitelisted | not served | the full audit of a contract’s code is GET /v1/audit/contract |
liquidityBurnPercentage (token details) | lpBurnedPct, plus lpLockedPct and lpSource | the LP of the token’s main market on /v1/token/security, and on /v1/token with include=security (tokenSecurity); the LP of any other pool on /v1/pool/security |
top10HoldingsPercentage (token details, Pulse rows) | top10HoldersPct, plus top25HoldersPct | the shares of supply held by the 10 and by the 25 largest holders, on EVM with liquidity pools, burn wallets, CEX custody and launchpad lockers set aside, on Solana with liquidity pools, the mint, burn wallets and the Pump.fun Mayhem agent set aside, then the price pool and known entities; on /v1/token/security and on every Pulse and Screener row (REST and streams), where both can be filtered and sorted on every list, REST and streams |
top50HoldingsPercentage, top100HoldingsPercentage, top200HoldingsPercentage (token details) | top50HoldersPct, top100HoldersPct, top200HoldersPct | the same rule for the 50, 100 and 200 largest holders, on /v1/token/security (GET and POST); /v1/token with include=security carries top100HoldersPct and top200HoldersPct in tokenSecurity; Pulse, Screener and search rows carry top10HoldersPct, top25HoldersPct and, on Solana, top50HoldersPct |
snipersCount, snipersHoldingsPercentage (token details, Pulse rows) | snipersCount, snipersHoldingsPct | wallets that bought in the first blocks after launch and still hold the token, and the share of supply they still hold from their launch buys; the creator counts in devHoldingsPct only; Pulse, Screener and search rows carry snipersHoldingsPct (Solana, null on EVM chains) |
bundlersCount, bundlersHoldingsPercentage (token details, Pulse rows) | bundlersCount, bundlersHoldingsPct | the bundlers still holding the token (on EVM, wallets that bought at least twice within the launch window; on Solana, wallets that bought in a launch bundle: a buy transaction shared by several signing wallets in the token’s first slots, or the bundle of its creation), and the share of supply they hold; Pulse, Screener and search rows carry bundlersHoldingsPct (Solana, null on EVM chains) |
proTradersCount, proTradersHoldingsPercentage (token details, Pulse rows) | proTradersCount, proTradersHoldingsPct | pro traders (our definition: wallets that have traded $50,000 or more through professional trading terminals) currently holding the token, and the share of supply they hold; every pro trader holding the token counts, whatever its rank among the holders, so the figures can differ from the ones you show today; Pulse, Screener and search rows carry proTradersAllTimeCount (Solana, null on EVM chains), the pro traders who ever traded the token, sold or not |
Token details: light security, dates and links
Mobula (token/details) | Serialized (GET/POST /v1/token) | Notes |
|---|---|---|
holdersCount, top10HoldingsPercentage, devHoldingsPercentage | holdersCount, top10HoldersPct, devHoldingsPct | the definitions of /v1/token/security; top100HoldingsPercentage and top200HoldingsPercentage are tokenSecurity.top100HoldersPct and tokenSecurity.top200HoldersPct with include=security (next rows) |
approximateReserveToken, approximateReserveTokenRaw, approximateReserveUSD (the main pool) | pool.pooledBase and pool.pooledQuote (amounts in token units, decimal-adjusted), pool.pooledBaseNative and pool.pooledQuoteNative (each side in native) | what sits in the main pool, base and quote sides; null on a launch curve and when a pool’s indexed reserves are not reliable; the same fields on every row of /v1/token/pools and on /v1/pool; a raw (undivided) amount is not served: multiply by 10^decimals |
| (no field) | deployTxHash | the transaction that created the token, for a token born on a launchpad bonding curve; null otherwise |
snipersHoldingsPercentage, bundlersHoldingsPercentage, insidersHoldingsPercentage | snipersHoldingsPct, bundlersHoldingsPct, insidersHoldingsPct | Solana; null on EVM chains; the other labels are on /v1/token/security |
snipersCount, bundlersCount, insidersCount | snipersCount, bundlersCount, insidersCount | the wallets of each label still holding the token, right after their share; Solana, null on EVM chains (the EVM sniper and bundler figures are on /v1/token/security) |
proTradersCount | proTradersAllTimeCount (Solana) | pro traders who ever traded the token; the pros still holding it are proTradersCount on /v1/token/security |
security.buyTax, sellTax, transferTax, isHoneypot, noMintAuthority, isFreezable | risk.buyTaxBps, risk.sellTaxBps, risk.transferTaxBps (basis points), risk.isHoneypot, risk.mintRevoked, risk.freezeRevoked | the risk block of the Pulse and Screener rows; LP and contract flags: next row |
security.liquidityBurnPercentage, security.locked, security.isMintable, security.isBlacklisted, security.isNotOpenSource, security.selfDestruct, security.isProxy, security.renounced, security.transferPausable, security.balanceMutable, security.modifyableTax, top100HoldingsPercentage, top200HoldingsPercentage | tokenSecurity.lpBurnedPct, tokenSecurity.lpLockedPct, tokenSecurity.isMintable, tokenSecurity.isBlacklisted, tokenSecurity.isNotOpenSource, tokenSecurity.selfDestruct, tokenSecurity.isProxy, tokenSecurity.renounced, tokenSecurity.transferPausable, tokenSecurity.balanceMutable, tokenSecurity.modifiableTax, tokenSecurity.top100HoldersPct, tokenSecurity.top200HoldersPct | add include=security to the call (2 more credits, on a single call and on a batch of 25 alike): the block carries the LP of the main market (shares 0-100, with lpSource), the shares of the 100 and 200 largest holders (null in a response where their deeper read is late) and every contract flag, with the names and values of /v1/token/security; null when unknown; security.isWhitelisted is not served |
latestTradeDate | lastTradeAt | unix ms; on /v1/token the token’s latest swap across its markets; on the Pulse, Screener and search rows the last trade of the row’s pool (on EVM chains a liquidity add or removal moves it too) |
| the token’s creation date | tokenCreatedAt (first market, the same as createdAt), poolCreatedAt (main market) | unix ms |
factory, preBondingFactory / sourceFactory | pool.factoryAddress, launchpad.factoryAddress | on-chain addresses (Solana: the venue’s program); pool.factory names the launchpad |
isMayhemMode, isCashbackCoin | launchpad.isMayhemMode, launchpad.isCashbackCoin | pump.fun only; isAgentMode is not served |
socials.others | metadata.links | every other link of the token’s profile, typed |
socials.uri | metadata.uri (/v1/token), socials.uri (/v1/search) | the metadata URI set at creation, verbatim; the Pulse and Screener rows do not carry it |
dexscreenerBoosted, dexscreenerBoostedDate | metadata.dexscreenerBoosted, metadata.dexscreenerBoostedAt | has been boosted, and the time of its first boost (unix ms); metadata.dexscreenerBoostActive says whether a boost is running now; no boost amount. dexscreenerSocialPaid(Date) is metadata.dexPaid(At) |
dexscreenerAdPaid, dexscreenerAdPaidDate | metadata.dexAdPaid, metadata.dexAdPaidAt | an ad (token ad or trending-bar ad) was paid on DEX Screener, and the time of the first one (unix ms) |
assetListed (the filter on tokens of Mobula’s asset registry) | metadata.listed | a field of the token on GET/POST /v1/token (listed on /v1/token/metadata and on the search rows) and of every Pulse and Screener row (REST and streams), a filter on the lists ({"metadata.listed":{"equals":true}}): true when CoinGecko lists the token, false when it does not, null when unknown; metadata.coingeckoUrl is its CoinGecko page |
dexscreenerListed | metadata.dexscreenerListed | the token has a page on DEX Screener; metadata.listed is the CoinGecko listing |
burnRate | tokenBurnedPct (/v1/token/security) | the share of the supply held by burn addresses |
liquidityMaxUSD | liquidityNativeAth | the main market’s highest liquidity, in the native coin |
| MEV fees on EVM trades | not served |
Security on Pulse and Screener rows
Thesecurity object of pulse rows and screener results, and the security.* filters, map to the risk block of every GET /v1/pulse, GET /v1/screener row and every pulse and screener stream row. Filters and sorts on risk.* are served by the Screener and the Pulse, REST and streams:| Mobula | Serialized | Notes |
|---|---|---|
security.buyTax, security.sellTax (percent as text, "5.0000") | risk.buyTaxBps, risk.sellTaxBps (a number, 500) | basis points: percent × 100; risk.transferTaxBps too; an unknown tax is null and never passes a bound |
security.isHoneypot | risk.isHoneypot | exclude honeypots with { "risk.isHoneypot": { "not": true } }, which keeps the tokens whose flag is unknown |
security.noMintAuthority | risk.mintRevoked (Solana) | |
security.isFreezable | risk.freezeRevoked (Solana, = !isFreezable) | |
security.transferPausable | risk.transferPausable | |
security.balanceMutable | risk.balanceMutable | |
security.modifyableTax | risk.modifiableTax | spelled modifiable |
security.isMintable, security.isBlacklisted, security.isNotOpenSource, security.selfDestruct | risk.isMintable, risk.isBlacklisted, risk.isNotOpenSource, risk.selfDestruct (EVM) | the values of /v1/token/security, plus risk.upgradeableProxy; null when not known: leave flagged contracts out with { "risk.isBlacklisted": { "not": true } }, which keeps the tokens whose flag is not known |
/v1/token/security, on every GET /v1/pulse, GET /v1/screener and GET /v1/search row and every pulse and screener stream row. They filter and sort on the Pulse and the Screener, REST and streams, and filter the search:| Mobula | Serialized | Notes |
|---|---|---|
holdersCount, top10HoldingsPercentage, devHoldingsPercentage | holdersCount, top10HoldersPct, devHoldingsPct, plus top25HoldersPct | every chain |
top50HoldingsPercentage | top50HoldersPct | Solana; null on EVM chains |
snipersHoldingsPercentage, bundlersHoldingsPercentage, insidersHoldingsPercentage | snipersHoldingsPct, bundlersHoldingsPct, insidersHoldingsPct | Solana; null on EVM chains; the counts are on /v1/token/security |
proTradersCount | proTradersAllTimeCount | Solana; null on EVM chains; the pro traders who ever traded the token, sold or not |
Streams
The protocol: onewss endpoint (wss://ws.serialized.xyz/v1/stream),
auth as the first frame, then additive subscriptions with explicit acks and
per-id unsubscribe. Event payloads reuse our REST shapes, so your parser is
already written. Mobula bills 1 credit per minute of connection plus what each
update consumes; here an open connection is free, a live view (Pulse, Screener)
costs 1 credit per message, and the other channels cost 1 credit per element
with on-chain activity in each message: a pool that traded, a token, a candle
series, a wallet on one chain (Streams billing).
maxUpdatesPerMinute is accepted on every subscription, next to our
updatePeriod. Every channel is open to every key.Mobula stream (type) | Serialized channel | Notes |
|---|---|---|
fast-trade | trades | a token (all its pools, or a subset) or one market (pool); labels to receive only the trades of some wallet labels; tokenMarketCapUSD is fdvUsd, the trade’s price × the token’s total supply as on Mobula |
token-details | token-updates | price, mcap, liquidity, bonding, windowed stats |
market-details (and the legacy pair) | pool-updates | the same fields for one market |
ohlcv | ohlcv | the forming candle, then each closed one, 1s to 1M; pool mode (address = a pool) is pool (or poolAddress), the candles of that pool alone; asset mode (asset) is address (or tokenAddress), the token’s main market |
pulse-v2 (token / pool mode) | pulse / pulse-pools | snapshot, then enter / update / leave deltas; on Solana bondingProgress counts the purchases of real traders (the launchpad’s own bots left out), and bonding holds the curves created in the last 7 days that have started to fill and hold at least 0.5 SOL; on EVM chains new also lists the tokens launched directly on a DEX (dexes filter); every row carries the all-time high (priceNativeAth, marketCapAthUsd), each a filter and a sort key; text filters always ignore letter case, so drop mode: 'insensitive' (an unknown operator is refused by name); every rolling window counts the snipers, pro traders and smart traders that traded in it (windows.<w>.snipers, proTraders, smartTraders), each one a filter and a sort key |
token-filters (mode: "token" / "market") | screener / screener-pools | filtered and sorted server-side, the same views as GET /v1/screener / GET /v1/screener/pools; feesToVolumeRatio24h (and fees_to_volume_ratio_24h of pulse-v2) is windows.24h.feesToVolumeRatio, the same ratio, also on every other window; text filters ignore letter case, EVM addresses match in any case |
position / positions | wallet-positions / wallet-portfolio | live PnL and value per position; one subscription per chain on Mobula, here one subscription for a wallet on several chains (chains) or on every EVM chain (chains: "evm"), one summary across them; tradeUpdatesOnly keeps its name and meaning (an update only when the wallet trades; the other changes arrive with the free snapshot of each minute); a watchlist ("params": {"watchlist": "<id>"}) follows each of its wallets as its own view, every message with its wallet, each wallet counted as one subscription |
balance | wallet-balances | the exact token balances of the wallets you follow, one message per transaction and wallet, SPL tokens on Solana and ERC-20 tokens on EVM chains; you follow a wallet (every token it holds), not a (wallet, token) pair: on one chain, on several (chains) or on every EVM chain (chains: "evm"), a list of up to 100, or a watchlist (1,000 wallets per account by default, more on request) in one subscription; balance and rawBalance keep their name, both exact strings; no snapshot: the starting balances come from /v1/wallet/positions or token holders with watchlist=<id>; previousBalance is the last balance you kept for the token; native coin balances are on /v1/wallet/positions?includeNative=true |
stream with events: ["swap"] filtered on swapSenderAddress (one endpoint per chain family, Growth and Enterprise plans) | wallet-trades | every trade of the wallets you follow, one message per transaction; a wallet on one chain, on several (chains, like blockchains on Mobula’s REST) or on every EVM chain (chains: "evm") in one subscription, a list of wallets (wallets), or a watchlist (1,000 wallets per account by default, more on request) |
Price webhooks
Mobula’s GraphQL API (in alpha) sends price webhooks (createWebhooks with a TOKEN_PRICE_EVENT webhook, a level on
priceUsd). Here one price webhook is your endpoint and its secret, and carries your
triggers (1,000 active per account by default, more on request), each one a token and a level in USD or in the chain’s native coin: create it
once, then add and remove triggers.Mobula (GraphQL createWebhooks) | Serialized | Notes |
|---|---|---|
a TOKEN_PRICE_EVENT webhook per level | a trigger (triggers[]) on one price webhook | up to 1,000 triggers per call, on up to 100 distinct tokens |
callbackUrl, securityToken | callbackUrl, secret of the webhook | |
conditions.networkId, conditions.address | chain, address of the trigger | |
conditions.priceUsd gt, gte, lt, lte, eq | priceUsd with the same operators | the same USD level; priceNative sets it in the chain’s native coin instead (USD or native) |
alertRecurrence: ONCE | the only mode | a trigger fires once, then ends |
the signature derived from your securityToken | X-Serialized-Signature: t=<timestamp>,v1=<hmac> (HMAC-SHA256 of <t>.<raw body>), and eventId to process each message once | verify the signature |
| the event’s price and time | data.priceUsd and data.priceNative (text), data.at (milliseconds) | |
| retries with backoff, up to 2 by default | 4 attempts: at once, then 5 seconds, 30 seconds and 2 minutes later | answer a 2xx within 5 seconds |
getWebhooks, deleteWebhooks | list triggers, remove, delete | |
alertRecurrence: INDEFINITE, publishingType: BATCH, market cap, pair and transfer webhooks | not served |
POST /api/1/webhook) are not served as webhooks: follow wallets live on the
wallet-trades and wallet-balances channels.Not carried over: the chains we do not index (Supported chains
lists ours), execution (swaps, bridges, perps), perps and CeFi market data
(funding rates), prediction markets, NFT, wallet DeFi positions, the holders
stream and first buyers. If one of these blocks your migration, tell us.Codex is a GraphQL API (single
Stream billing, side by side. Codex bills compute units: 1 per message on most
subscriptions (0.5 on
Not carried over: the networks we do not index (Polygon, Optimism, Linea, Tron,
Sui, Aptos and Starknet among them; ours are on Supported chains),
prediction markets, token categories, community notes, wallet discovery across
tokens (
POST /graphql); Serialized is REST. You trade
query composition for one-purpose endpoints with fixed response shapes. The
queries below map to a REST endpoint or a stream channel; the main ones
without a counterpart are listed at the end of this tab.Conventions that differ
| Codex | Serialized | Why |
|---|---|---|
| GraphQL queries over one POST endpoint | one REST endpoint per job | cacheable GETs, no query maintenance |
networkId integers (Base 8453, HyperEVM 999, Solana 1399811149) | evm:<networkId> (evm:8453, evm:999) and solana | self-describing ids |
Composite ids address:networkId | chain + address params | no string assembly |
| Unix seconds | unix milliseconds, At suffix (candle time stays seconds) | consistent with JS Date.now() |
USD amounts as strings on most stats fields (priceUSD, volume24; a float on getTokenPrices), changes as decimals (change24: 0.01 = 1%) | numbers, percents as percent values | fewer conversion mistakes |
Casing varies (priceUSD vs priceUsd, change24 vs priceChange24) | camelCase everywhere | one convention |
Pagination: offset on filterTokens and the other filter queries, cursor on events and balances | an opaque cursor (meta.nextCursor) on feeds and long lists (trades, transfers, screener), limit + offset on holders and wallet positions, endTime on candles | meta.hasMore tells when to stop |
Endpoint map
| Codex (GraphQL) | Serialized | Notes |
|---|---|---|
filterTokens (screener/trending) | GET /v1/screener + GET /v1/pulse + GET /v1/search | ranked tokens, one row per token with the figures of all its markets (sortBy=trending or volume), launchpad lifecycle views, and text search; a phrase with filters in one call is GET /v1/search?q=<phrase>&filters=<tree> (the Screener’s filter tree: liquidity, market cap, volume, transactions, holders, taxes, launchpad state, age…), sorted by any figure of the row |
filterPairs | GET /v1/screener/pools | one row per pool, any field as sort key, a filter tree, a timeframe |
filterNetworks | GET /v1/lighthouse (total, chains[]) | volume, buy and sell volume, swaps, distinct traders, tokens created and migrations per chain, 5m to 24h, each window with its previous one and the change |
filterLaunchpads | GET /v1/lighthouse (launchpads[]) | per launchpad: volume, buy and sell volume, swaps, tokens created, migrations and graduation rate, 5m to 24h; limit is limit (top N by volume); the tokens of a launchpad, column by column, are GET /v1/pulse with factories |
token / tokens, and filterTokens with tokens | GET/POST /v1/token, GET /v1/token/metadata | metadata and live pricing in one call, per token or up to 25 (Codex’s token returns metadata only; its filterTokens with tokens combines them) |
createTransactionHash on token | deployTxHash on GET/POST /v1/token | for a token born on a launchpad bonding curve (the launchpad creates the token and its curve in one transaction); null for any other token; createBlockNumber is not served |
socialLinks.coingecko on token | metadata.coingeckoUrl on GET/POST /v1/token, coingeckoUrl on /v1/token/metadata | the token’s CoinGecko page, null when it has none; listed next to it says whether CoinGecko lists the token; socialLinks.coinmarketcap and cmcId are not served |
getTokenPrices (spot) | GET/POST /v1/token/price | the price of the token’s main market, the market its candles follow (Codex weights all valid pools by default, so prices can differ on tokens with several markets); batch twin, per-item error slots |
getTokenPrices with poolAddress | GET/POST /v1/pool/price | the price of that pool alone, with the market cap at that price and the pool’s own liquidity; batch up to 100 pools |
getTokenPrices with timestamp | GET/POST /v1/token/price-at | the same rule, the last trade at or before timestamp (unix seconds), on the token’s main market (its launch curve before the migration); at is the second of that trade, poolAddress the market; priceUsd at the native rate of that minute; NO_PRICE_AT when the token had not traded yet, instead of a missing entry; up to 100 items per call, each with its own timestamp (Codex: 25, extra inputs dropped) |
getDetailedTokenStats | GET/POST /v1/token/stats | windowed stats token-wide, or on the pools you list |
listPairsForToken, listPairsWithMetadataForToken | GET /v1/token/pools | ranked, rank 1 = the pool we price from; liquidity is liquidityUsd, pooled.token0 / pooled.token1 are pooledBase / pooledQuote (by side, base and quote, never token0 / token1) |
getTokenBars (token-aggregated) | GET /v1/token/ohlcv (default) | the token’s main market, curve history stitched in; for one chart across several of the token’s markets, list them in pools= (up to 100) |
getBars (pair) | GET/POST /v1/pool/ohlcv | TradingView-shaped candles, 1s to 1M; batch up to 10 pools |
tokenSparklines | GET/POST /v1/token/sparklines | one token on GET, a batch on POST; the interval adapts to the token’s age like pointCount does; timestamps: true returns the { timestamp, value } points as { at, value } (milliseconds) |
getTokenEvents (pair) | GET /v1/pool/trades, POST /v1/pool/trades | one row per swap event on EVM (the rows of one transaction share txHash), legs aggregated per transaction and side on Solana; trader badges on every row; GET /v1/token/trades for every pool of a token |
getTokenEventsForMaker | GET /v1/wallet/trades | one event per transaction, token and side (Codex lists each hop of a multi-hop swap as its own event); networkId is chain, and several chains share one timeline and one cursor with chains (evm for every EVM chain); the event’s quoteToken (token0 or token1) and the matching amount0 / amount1 are quoteToken (the quote’s address, symbol, name, decimals, iconUrl) and amountQuote, the traded token’s side is tokenAddress and amountToken |
tokenTopTraders | GET /v1/token/top-traders | ranked by PnL, amount bought or sold, or trade count, lifetime or over 1h to 30d; pools= for some of the token’s markets |
holders | GET /v1/token/holders | on every plan (Codex: Growth or Enterprise) |
top10HoldersPercent | top10HoldersPct on GET/POST /v1/token/security and on every Pulse and Screener row | on EVM, liquidity pools, burn wallets, CEX custody and launchpad lockers set aside; on Solana, liquidity pools, the mint, burn wallets and the Pump.fun Mayhem agent set aside, then the price pool and known entities; so the figure can differ; the same figure on every surface |
mintable / freezable (the authority address) on token, token.risk (buyTax, sellTax) | GET/POST /v1/token/security | mintAuthority / freezeAuthority, and mintRevoked / freezeRevoked as true, false or null when unknown; a risk.buyTax of 0.05 is buyTaxBps 500; the contract audit is GET /v1/audit/contract |
tokenWalletStats | GET/POST /v1/token/security | snipersCount, bundlersCount, insidersCount and snipersHoldingsPct, bundlersHoldingsPct, insidersHoldingsPct |
liquidityLocksV2, liquidityMetadataByToken | GET/POST /v1/token/security, GET/POST /v1/pool/security | lpBurnedPct, lpLockedPct and lpSource of the token’s main market, or of any pool |
pairMetadata, getDetailedPairStats | GET /v1/pool/data | price, liquidity, venue and windowed stats of one pool |
getDetailedPairsStats | POST /v1/pool/data | up to 100 pools across chains, one slot per pool |
balances (wallet) | GET /v1/wallet/positions | includes entry price + PnL per position; tokens= scopes to a token list; includeNative and includeStables add the native coin and USD stablecoins |
detailedWalletStats, walletChart | GET /v1/wallet/pnl | PnL curve + summary (buys, sells and their USD volumes), explicit usdBasis |
getNetworks | GET /v1/meta/chains | every chain we serve, with its family and native coin |
getExchanges | GET /v1/meta/factories | every launchpad and venue with its name, logo and brand color |
filterExchanges | GET /v1/lighthouse (exchanges[]) | volume, buy and sell volume and swaps per exchange, 5m to 24h, sorted by volume; limit is limit; iconUrl is logo; active users per exchange are not served |
onTokenEventsCreated, onEventsCreated (pair) | Streams trades channel | REST-shaped events, a token or one market |
onEventsCreatedByMaker | Streams wallet-trades channel | every trade of the wallets you follow; Codex follows one maker on every network, here one subscription takes a wallet on one chain, on several (chains) or on every EVM chain (chains: "evm"), a list of wallets (wallets) or a watchlist |
onTokenBarsUpdated | Streams ohlcv channel with address | the forming candle of the token’s main market, then each closed one; pools to merge the markets you list |
onBarsUpdated (pair) | Streams ohlcv channel with pool | the forming candle of that pair alone (pairId is chain + pool), then each closed one |
onPriceUpdated / onPricesUpdated, onDetailedTokenStatsUpdated | Streams token-updates channel | price + mcap + liquidity + windowed stats together |
onPairMetadataUpdated, onDetailedStatsUpdated | Streams pool-updates channel | price, liquidity and windowed stats of one market |
onLaunchpadTokenEvent, onLaunchpadTokenEventBatch | Streams pulse channel | launchpad columns: snapshot, then enter / update / leave deltas |
onFilterTokensUpdated | Streams screener channel | filtered and sorted server-side |
onBalanceUpdated | Streams wallet-balances channel | the balance of each token a transaction moves, one message per transaction and wallet: balance is rawBalance, shiftedBalance is balance (an exact decimal string), networkId is chain; networks is chains (evm for every EVM chain), and a watchlist (1,000 wallets per account by default, more on request) follows its wallets in one subscription; for positions valued in USD with their PnL, use the wallet-positions channel |
onLaunchpadTokenEvent and onLaunchpadTokenEventBatch),
plus 1 per MB delivered and 0.25 per minute a subscription stays open (1 request
per message on its request-based plans). onEventsCreated sends one message per
pool and per block, onPriceUpdated a token at most once per block,
onFilterTokensUpdated the tokens of its list whose data changed, at most every
updatePeriod (500 ms by default), the list itself re-evaluated every 30
seconds. Here, an open subscription and its bytes
cost nothing, only its messages do. Subscribe with
"updatePeriod": "block" for the same rhythm: one message per chain and per
block, 1 credit per pool that traded on trades, 1 credit per token on
token-updates. The screener channel sends its view at most every 500 ms by
default, 1 credit per message, like onFilterTokensUpdated
(Streams billing).Price webhooks
One price webhook is your endpoint and its secret, and carries your triggers (1,000 active per account by default, more on request), each one a token and a level in USD or in the chain’s native coin: create it once, then add and remove triggers.| Codex | Serialized | Notes |
|---|---|---|
createWebhooks with tokenPriceEventWebhooksInput.webhooks[] | POST /v1/webhook/price with triggers[] | one webhook, up to 1,000 triggers per call, on up to 100 distinct tokens |
callbackUrl, securityToken | callbackUrl, secret of the webhook | |
conditions.networkId.eq, conditions.address.eq | chain, address of the trigger | |
conditions.priceUsd gt, gte, lt, lte, eq | priceUsd with the same operators | the same USD level; priceNative sets it in the chain’s native coin instead (USD or native) |
alertRecurrence: ONCE | the only mode | a trigger fires once, then ends |
bucketKey (bucketId, bucketSortKey) | the webhook id and the trigger id | |
X-Webhook-Timestamp + X-Webhook-Signature (HMAC-SHA256 of {timestamp}.{rawBody}) | X-Serialized-Signature: t=<timestamp>,v1=<hmac> | the same HMAC in one header (verify the signature) |
deduplicationId, data.priceUsd (text), data.timestamp (seconds) | eventId, data.priceUsd and data.priceNative (text), data.at (milliseconds) | |
| a 2xx within 3 seconds, up to 4 retries about 5 seconds apart | a 2xx within 5 seconds, retries 5 seconds, 30 seconds and 2 minutes after the first attempt | |
getWebhooks, deleteWebhooks | list triggers, remove, delete | |
| 2 compute units per successful delivery, failed attempts free (1 request on request-based plans) | 1 credit per trigger sent to your URL, once its first attempt goes out | managing webhooks and triggers is free |
alertRecurrence: INDEFINITE, publishingType: BATCH, market cap, pair, transfer, token launch and prediction webhooks | not served | follow pairs, wallets and launches live on the streams |
filterWallets), the holders stream (onHoldersUpdated) and event
labels (getEventLabels, onEventLabelCreated). If one of these blocks your
migration, tell us.Birdeye is REST like us, so most of the work is renaming. The structural
differences: chain selection moves from the
Not carried over: the chains we do not index (Sui, Aptos, Fogo, Polygon,
Optimism, zkSync Era and Mantle; ours are on Supported chains),
perps, gainers/losers and wallet leaderboards, smart money lists, money flow,
liquidity history and first buyers. If one of these blocks your migration, tell us.
x-chain header (which defaults to
solana when omitted) to a chain param, three coexisting API
generations (v1 camelCase, v2, v3 snake_case) collapse into one consistent
surface, and a short credit grid, never priced by response size, replaces
Compute Units.Conventions that differ
| Birdeye | Serialized | Why |
|---|---|---|
X-API-KEY header + x-chain header (defaults to solana) | Authorization key + chain param (evm:<id> or solana) | one chain id format, in the query |
v1/v2/v3 generations, mixed casing (priceChange24h vs volume_24h_usd) | one camelCase surface | one convention |
{success, data} envelope, items[] + has_next/hasNext | { data, meta } + meta.hasMore | one envelope |
| Unix seconds (+ human-time duplicates) | unix milliseconds, At suffix (candle time stays seconds) | no guessing |
offset+limit capped at 10,000 on most lists, time or block bounds beyond | an opaque cursor (meta.nextCursor) on trades, swaps and transfers, endTime on candles; holders page by offset down to the 5,000th | a trade history pages to its end without an offset cap |
| Compute Units per endpoint (1 to 300 CU per fixed-price call; batches scale with the item count, some vary with response size) | a fixed price per endpoint, never by response size: most calls 1 credit, the heavier 2 to 10, a contract audit 750; a batch costs one call per tranche of items (25 for lookups, token and pool details and stats, 10 for security, 5 for PnL, pool trades and candles), wallet positions, trades and swaps are billed per wallet | predictable billing |
Endpoint map
| Birdeye | Serialized | Notes |
|---|---|---|
GET /defi/v3/token/list, GET /defi/token_trending | GET /v1/screener | ranked tokens, one row per token: sortBy=trending (relevance), volume, marketCap, liquidityUsd or any numeric field, with filters |
GET /defi/v2/tokens/new_listing, GET /defi/v3/token/meme/list | GET /v1/pulse | launchpad lifecycle views (new, bonding, graduated) with bonding progress, filters and sorts on any card field (holders, top 10, dev share, liquidity, market cap, windows) |
GET /defi/v3/search | GET /v1/search | every chain by default, like Birdeye’s chain=all; keyword is q, sort_by / sort_type are sortBy / order |
GET /defi/price, GET/POST /defi/multi_price | GET/POST /v1/token/price | liquidity + mcap included by default |
GET /defi/token_overview | GET /v1/token | one call: price, mcap, FDV, liquidity, best pool, launchpad state, socials |
GET /defi/v3/token/meta-data/* | GET/POST /v1/token/metadata | + dex-paid flag |
GET /defi/v3/token/market-data/* | GET/POST /v1/token/price | price, market cap and liquidity; FDV and supplies are on GET/POST /v1/token, the holder count (holdersCount) on GET/POST /v1/token/security |
GET /defi/v3/token/trade-data/* | GET/POST /v1/token/stats?windows= | raw figures, plus organic (wash-filtered) ones on Solana |
GET /defi/token_creation_info | GET /v1/token (createdAt, deployer) | included in the detail |
GET /defi/v2/markets | GET /v1/token/pools | rank 1 = the pool we price from, then its other markets ranked the way the main market is picked, then the rest by 24h volume and liquidity |
GET /defi/v3/ohlcv, GET /defi/history_price | GET /v1/token/ohlcv | 1s to 1M; the token’s main market by default, or pools=; candles in the native coin by default (Birdeye defaults to USD), quote=usd on every chain except Story (evm:1514) |
GET /defi/txs/token (+ /seek_by_time), GET /defi/v3/token/txs | GET /v1/token/trades | one endpoint for both, a cursor that never skips or repeats a trade, trader labels on every row |
GET /defi/v3/token/holder | GET /v1/token/holders | EVM and Solana |
GET /defi/v2/tokens/top_traders | GET /v1/token/top-traders | ranked by PnL, amount bought or sold, or trade count, lifetime or over 1h to 30d |
GET /defi/token_security | GET/POST /v1/token/security | batch up to 100; the contract audit is GET /v1/audit/contract |
GET /defi/v3/pair/overview/single, /multiple | GET /v1/pool/data, POST /v1/pool/data | price, liquidity, venue and windowed stats of one pool, or of up to 100 pools |
GET /defi/v3/ohlcv/pair, GET /defi/ohlcv/pair | GET/POST /v1/pool/ohlcv | the candles of one pool, batch up to 10 pools |
GET /defi/txs/pair (+ seek_by_time) | GET /v1/pool/trades, POST /v1/pool/trades | the trades of one pool, or the tape of up to 200 pools since a timestamp |
GET /wallet/v2/current-net-worth | GET /v1/wallet/positions | EVM and Solana, entry price + PnL included; includeNative and includeStables add the native coin and USD stablecoins |
POST /wallet/v2/token-balance | GET /v1/wallet/positions?tokens= | up to 50 tokens per call (Birdeye takes 500), entry price + PnL on top of the balances |
GET /wallet/v2/net-worth | GET /v1/wallet/equity/history | total wallet value in USD over a window |
GET /wallet/v2/pnl*, POST /wallet/v2/pnl/details | GET /v1/wallet/pnl | PnL curve + summary (buys, sells and their USD volumes), explicit usdBasis |
GET /trader/txs/seek_by_time | GET /v1/wallet/trades | multihop-deduplicated |
GET /v1/wallet/tx_list | GET /v1/wallet/swaps, GET /v1/wallet/transfers | swaps one row per transaction, token movements in and out, opaque cursor |
POST /wallet/v2/transfer | GET /v1/wallet/transfers | deposits, withdrawals and transfers of a wallet |
GET /wallet/v2/funded-by, POST /wallet/v2/tx/first-funded | GET/POST /v1/wallet/funding | first funder + entity tag |
GET /identity/v1/single, POST /identity/v1/multiple | GET/POST /v1/wallet/profile | identity graph: names, ENS/.sol, socials, 18M+ wallets, linked-wallet clusters |
GET /defi/networks | GET /v1/meta/chains | every chain we serve, with its family and native coin |
GET /utils/v1/credits | GET /v1/usage | the current cycle of the key, free |
WS SUBSCRIBE_PRICE | Streams ohlcv channel, or token-updates for the price alone | one connection for all chains, not one per chain |
WS SUBSCRIBE_TOKEN_STATS | Streams token-updates channel | price, mcap, liquidity and windowed stats together |
WS SUBSCRIBE_TXS | Streams trades channel | REST-shaped events, a token or one pool |
WS SUBSCRIBE_WALLET_TXS | Streams wallet-trades channel | every trade of the wallets you follow; a wallet on several chains, or on every EVM chain with chains: "evm", is one subscription; a subscription by tags alone (every smart_trader or kol wallet) has no equivalent |
WS SUBSCRIBE_TOKEN_NEW_LISTING, SUBSCRIBE_NEW_PAIR | Streams pulse / pulse-pools channel, model: new | launchpad lifecycle views (new, bonding, graduated), one row per token or per pool; on EVM chains new also lists the tokens launched directly on a DEX (dexes filter, venues per chain in dexesByChain of GET /v1/meta/factories); new lists new tokens, not every new pair: a new pool of a token older than 24 hours, and on Solana a token launched directly on a DEX, are not in it |