Skip to main content
Birdeye Data Services (BDS) and Codex cover a similar problem space: real-time token, trade, and wallet data across Solana and EVM chains. This guide maps every Birdeye endpoint to its Codex equivalent, shows working side-by-side examples for the most common patterns, and ends with a copy-paste prompt you can hand to an LLM to migrate the rest of your codebase.

​
Mental model

Birdeye is a REST API where the network is a request header (x-chain, defaults to Solana) and most resources have separate v1, v2, and v3 endpoints with different field naming conventions (camelCase in v1/v2, snake_case in v3+). Codex is a single GraphQL Supergraph: one endpoint (https://graph.codex.io/graphql), one auth header, one query language, and the network is just a parameter (networkId) on each field. What that means in practice:
  • You stop maintaining version-specific code paths (the /defi/v2/... vs /defi/v3/... decision goes away).
  • You stop juggling x-chain headers. Network selection lives next to the data, so the same query covers Solana, Ethereum, Base, BNB, and 80+ networks.
  • Multi-token requests stop needing separate batch endpoints. GraphQL aliases and array inputs handle that natively, and you only pay for the fields you request.
  • Real-time data has two delivery options instead of one. Birdeye is WebSocket-only; Codex gives you WebSocket subscriptions and webhooks, and you can mix them in the same app.
If you’ve never used GraphQL, Learn GraphQL is a 10-minute primer that’s enough to follow the rest of this guide.

​
Authentication

Birdeye uses an X-API-KEY header plus an x-chain header that defaults to solana (so it’s effectively required for every non-Solana request). Codex uses an Authorization header with your API key from the dashboard, and network comes through as a field argument instead of a header.
Birdeye
curl "https://public-api.birdeye.so/defi/price?address=So11111111111111111111111111111111111111112" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana"
Codex
curl https://graph.codex.io/graphql \
  -H "Authorization: $CODEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"{ getTokenPrices(inputs: [{ address: \"So11111111111111111111111111111111111111112\", networkId: 1399811149 }]) { priceUsd timestamp address } }"}'
For browser-facing apps, generate a short-lived JWT with createApiTokens and pass it as Bearer <token>. See Authentication for the full pattern.

​
Endpoint mapping

The table covers the Birdeye endpoints customers ask about most often, grouped by surface area. Where Birdeye splits a concept across v1, v2, and v3 endpoints, the Codex equivalent on the right replaces all of them.

​
Prices and OHLCV

BirdeyeCodex equivalentNotes
GET /defi/pricegetTokenPricesPass a single-element array.
GET /defi/multi_price, POST /defi/multi_pricegetTokenPricesNative batch input, max 25 tokens per call (anything over is truncated). Birdeye’s multi_price allows up to 100, so chunk larger batches.
GET /defi/historical_price_unixgetTokenPrices with a timestamp inputPass the unix timestamp on the input to get the price at that moment.
GET /defi/history_pricegetTokenBarsToken-level OHLCV; pair-level via getBars.
GET /defi/ohlcv, /defi/v3/ohlcvgetTokenBarsCodex supports 1-second up to weekly (7D) intervals.
GET /defi/ohlcv/pair, /defi/v3/ohlcv/pairgetBarsPair-scoped OHLCV.
GET /defi/ohlcv/base_quotegetBars with quoteTokenInvert the pair to quote in the other token.
GET /defi/price_volume/single, POST /defi/price_volume/multigetDetailedTokenStatsPrice and volume in one query, plus much more.
GET /defi/v3/price/stats/single, POST /defi/v3/price/stats/multiplegetDetailedTokenStatsStats over multiple timeframes.

​
Token data

BirdeyeCodex equivalentNotes
GET /defi/token_overviewtoken + getDetailedTokenStatsOne GraphQL request returns metadata, stats, safety, and launchpad context.
GET /defi/v3/token/meta-data/singletokenRicher payload than Birdeye’s, including social links and image URLs.
GET /defi/v3/token/meta-data/multipletokens(ids: [{ address, networkId }])Batch token metadata.
GET /defi/v3/token/market-data (single + multiple)getDetailedTokenStats
GET /defi/v3/token/trade-data/single, /defi/v3/token/trade-data/multiplegetDetailedTokenStatsTrade stats are part of detailed token stats.
GET /defi/token_securitytokenSafety fields (isScam, mintable, freezable, creatorAddress, top-holder concentration) are inline on the token object.
GET /defi/token_creation_infotokencreatedAt, creatorAddress.
GET /defi/v3/token/exit-liquidity, /defi/v3/token/exit-liquidity/multipleliquidityMetadata + liquidityMetadataByTokenPlus liquidityLocks for locked-LP context.
BirdeyeCodex equivalentNotes
GET /defi/token_trendingfilterTokens ranked by trendingScore24See the Discover Tokens recipe.
GET /defi/v3/token/list, GET /defi/v3/token/list/scroll, GET /defi/tokenlistfilterTokensFilters and rankings collapse into one query.
GET /defi/v2/tokens/new_listingfilterTokens ranked by createdAtOr subscribe to onTokenLifecycleEventsCreated / onLatestTokens.
GET /defi/v3/searchfilterTokens(phrase: ...)Use $SYMBOL for exact symbol matches.
GET /defi/v3/token/meme/detail/single, GET /defi/v3/token/meme/listfilterTokens + launchpad contextCodex models meme launches as launchpad lifecycle events (pump.fun, LetsBonk, etc.).
GET /smart-money/v1/token/listfilterTokens plus filterWalletsSee the Wallets recipe for the smart-money pattern.

​
Pairs and markets

BirdeyeCodex equivalentNotes
GET /defi/v3/pair/overview/singlegetDetailedPairStatsPair-level trade stats (volume, buys/sells, price change) are included. Birdeye has no separate pair trade-data endpoint; those fields live on the overview response.
GET /defi/v3/pair/overview/multiplegetDetailedPairsStats
GET /defi/v2/marketslistPairsForToken + listPairsWithMetadataForTokenAll venues for a token.

​
Trades

BirdeyeCodex equivalentNotes
GET /defi/txs/token, GET /defi/v3/token/txs, GET /defi/txs/token/seek_by_timegetTokenEventsSwap and lifecycle events for a token; pass a timestamp range for the “seek by time” variant.
GET /defi/txs/pair, GET /defi/txs/pair/seek_by_timegetTokenEventsPass the pair address in query: { address: ... }.
GET /defi/v3/txs, GET /defi/v3/txs/recentgetTokenEvents
GET /defi/v3/token/txs-by-volumegetTokenEvents with priceUsdTotal filterFilter swaps by USD size.
GET /defi/v3/token/mint-burn-txs (Solana)getTokenEvents with eventDisplayType: [Mint, Burn]Mint/burn lifecycle events.
GET /defi/v3/all-time/trades/single, POST /defi/v3/all-time/trades/multiplegetDetailedTokenStats (statsUsd.volume, statsNonCurrency.transactions)Aggregate metrics, not raw rows.

​
Holders

BirdeyeCodex equivalentNotes
GET /defi/v3/token/holderholdersRanked holder list.
GET /holder/v1/distributiontop10HoldersPercent field on tokenConcentration in one field.
GET /token/v1/holder-profiletop10HoldersPercent on token + holdersCombine concentration with the ranked holder list.
GET /token/v1/holder/chartPartial via onHoldersUpdatedCodex streams live holder counts; historical timeseries is not a first-class endpoint.
GET /token/v1/holder-positionsfilterTokenWalletsWallets ranked by per-token PnL.
POST /token/v1/holder/batchbalances (per wallet)One call per wallet; aliases let you batch in a single GraphQL request.

​
Wallets

BirdeyeCodex equivalentNotes
GET /v1/wallet/token_listbalancesWallet portfolio with prices. Native balances on EVM chains require traces support; not available on Sui.
GET /v1/wallet/token_balance, POST /wallet/v2/token-balancebalances with tokens: [...]Pass the token IDs (address:networkId) you want; max 200 per request.
GET /v1/wallet/list_supported_chaingetNetworksNetwork catalog used everywhere else in the API.
GET /v1/wallet/tx_listgetTokenEventsForMakerCodex returns swap events for a wallet; raw transfers are not exposed.
GET /wallet/v2/current-net-worthdetailedWalletStatsPnL, volume, swap counts.
GET /wallet/v2/net-worth, /wallet/v2/net-worth-details, POST /wallet/v2/net-worth-summary/multiplewalletChart + detailedWalletStatsUse GraphQL aliases to batch multiple wallets in one request.
GET /wallet/v2/pnl, /wallet/v2/pnl/summary, GET /wallet/v2/pnl/multiple, POST /wallet/v2/pnl/detailsdetailedWalletStats + filterWallets
GET /wallet/v2/balance-changeonBalanceUpdated subscriptionLive balance changes; historical reconstruction requires combining events.
POST /wallet/v2/tx/first-fundedNot directly supportedFlag during migration.

​
Traders

BirdeyeCodex equivalentNotes
GET /defi/v2/tokens/top_traderstokenTopTradersTop buyers/sellers/PnL for a token.
GET /trader/txs/seek_by_timegetTokenEventsForMaker
GET /trader/gainers-losersfilterWallets ranked by realizedProfitUsd*Far richer filtering than Birdeye’s endpoint.

​
Utility

BirdeyeCodex equivalentNotes
GET /defi/networksgetNetworksReturns networkIds you’ll use everywhere else.
GET /defi/v3/txs/latest-blockblocksLook up blocks by blockNumbers or timestamps; pass the current timestamp to resolve the latest block.
GET /utils/v1/creditsCodex usage in the dashboard

​
Side-by-side examples

The four patterns below are the ones Birdeye customers most commonly migrate first. Token addresses are real and queries are runnable.

​
1. Multi-token price

curl -X POST "https://public-api.birdeye.so/defi/multi_price" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana" \
  -H "Content-Type: application/json" \
  -d '{"list_address":"So11111111111111111111111111111111111111112,EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"}'
For a live price feed instead of polling, subscribe to onPricesUpdated.

​
2. OHLCV chart

curl "https://public-api.birdeye.so/defi/v3/ohlcv?address=So11111111111111111111111111111111111111112&type=1H&time_from=1716595200&time_to=1717200000" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana"
Codex supports resolutions from 1-second up to weekly (7D). Sub-minute resolutions (1S-30S) are only populated for the last 24 hours, and Birdeye’s monthly (1M) candles have no direct equivalent (aggregate from 1D or 7D bars). For live chart updates, layer in the onBarsUpdated subscription. See the Charts recipe for a full Lightweight Charts integration.

​
3. Token overview (metadata + stats + safety)

Birdeye splits this across /defi/token_overview, /defi/v3/token/market-data, and /defi/token_security. Codex returns the same picture in a single request. 
curl "https://public-api.birdeye.so/defi/token_overview?address=So11111111111111111111111111111111111111112" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana"

curl "https://public-api.birdeye.so/defi/token_security?address=So11111111111111111111111111111111111111112" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana"
The Detailed Token Page recipe shows the full pattern Codex customers use to build a token detail screen.

​
4. Wallet portfolio

curl "https://public-api.birdeye.so/v1/wallet/token_list?wallet=Bi4rd5FH5bYEN8scZ7wevxNZyNmKHdaBcvewdPFxYdLt" \
  -H "X-API-KEY: $BIRDEYE_API_KEY" \
  -H "x-chain: solana"
Enrich the response with live USD pricing by batching the returned tokenIds into getTokenPrices. For wallet-level PnL and volume, see detailedWalletStats and the Wallets recipe.

​
Real-time data

Birdeye delivers real-time data exclusively through WebSocket subscriptions at wss://public-api.birdeye.so/socket/<chain>. Codex gives you the same data with two delivery options, and you can use both at once:
  • WebSocket subscriptions: persistent connection, updates pushed inline. Best for dashboards, trading UIs, anything user-facing.
  • Webhooks: Codex calls an HTTP endpoint you control when an event fires. Best for background jobs, alerts, and queue-driven systems.
Birdeye channelCodex subscriptionCodex webhook
SUBSCRIBE_PRICEonPriceUpdated, onPricesUpdatedPrice webhook
SUBSCRIBE_BASE_QUOTE_PRICEonBarsUpdated
SUBSCRIBE_TOKEN_STATSonDetailedTokenStatsUpdated
SUBSCRIBE_TXSonTokenEventsCreated, onEventsCreatedToken swap webhook
SUBSCRIBE_WALLET_TXSonEventsCreatedByMakerToken swap webhook (maker filter)
SUBSCRIBE_LARGE_TRADE_TXSonEventsCreated with min-volume filter
SUBSCRIBE_NEW_PAIR, SUBSCRIBE_TOKEN_NEW_LISTINGonTokenLifecycleEventsCreated, onLatestTokens, onLaunchpadTokenEvent
SUBSCRIBE_MEMEonLaunchpadTokenEvent + onDetailedTokenStatsUpdated
SUBSCRIBE_TRANSFERNot directly supportedCodex streams swap and lifecycle events, not arbitrary token transfers. Pair with an RPC provider if you need this.

​
Gaps

Things Birdeye does that Codex doesn’t, and what to do about them:
  • Perpetuals data (/perps/v1/*). Codex is a spot-trading API. If your product depends on open positions, liquidation maps, or perp wallets, keep Birdeye for that surface or pair Codex with a perps-native provider.
  • Wallet-level transfers (non-swap) (/wallet/v2/transfer*, /token/v1/transfer*). Codex returns swap and token-lifecycle events, not arbitrary token transfers. Combine Codex with an RPC provider or Etherscan-family API if transfer history is core to your product.
  • NFT data. Birdeye doesn’t ship a full NFT product either, but if your codebase touches NFT collections or holdings, Codex won’t fill that gap.
  • Centralized exchange liquidity dashboards. Codex is onchain-only.
  • First-funded-by lookup (POST /wallet/v2/tx/first-funded). No direct equivalent; flag during migration.
  • Native-token balances on chains without traces. balances returns ERC-20/SPL holdings on every supported network, but native-token amounts on EVM chains require traces support. Sui balances aren’t available at all (networkId: 101).

​
What you pick up

Things Codex offers that Birdeye doesn’t:
  • One query, many shapes. GraphQL lets you combine token metadata, price, holders, recent trades, and chart data into a single request and only pull the fields you render. A typical Birdeye-powered token page hits three or four endpoints; the Codex equivalent is one.
  • Webhooks alongside subscriptions. Push real-time data to your servers without holding open a WebSocket. Configure via createWebhooks.
  • Prediction markets. Polymarket and Kalshi event, market, trade, and trader data via the filterPredictionEvents family. See Prediction Markets.
  • Launchpad lifecycle data. First-class support for pump.fun, LetsBonk, Believe, and other launchpads, including bonding-curve state, graduation, and migration events. See Launchpads.
  • Wallet discovery by performance. filterWallets lets you query for wallets matching specific PnL, win-rate, or trading-volume criteria across all networks, not just for a single token.
  • Liquidity locks. liquidityLocks surfaces locked-LP context that Birdeye’s /defi/v3/token/exit-liquidity doesn’t.
  • Built for AI agents. A docs MCP server, prebuilt Codex Skills for Claude/Cursor/Codex CLI, and pay-per-query access via MPP.

​
AI migration prompt

Most Birdeye integrations span dozens of call sites: a price service here, a chart loader there, a portfolio screen, a webhook handler. Hand the prompt below to an IDE agent (Claude Code, Cursor, Codex CLI, or similar), run it from the repo root, and it will discover every Birdeye touchpoint, propose a plan, and execute the migration with your approval.
Pair this prompt with our Codex Skills and docs MCP server so the agent can look up Codex queries on demand instead of guessing at field names.
You are migrating this codebase from Birdeye Data Services (BDS) to Codex (https://docs.codex.io). Birdeye and Codex overlap heavily on token, trade, holder, and wallet data, so most call sites have a direct replacement. A few do not, and those need to be surfaced rather than silently dropped.

## Phase 1: Discovery (do this first, do not edit yet)

Search the codebase for every Birdeye integration point. At minimum, look for:

- HTTP calls to `public-api.birdeye.so` (any path under `/defi`, `/wallet`, `/token`, `/trader`, `/perps`, `/smart-money`, `/utils`, `/holder`, or `/v1/wallet`).
- WebSocket connections to `wss://public-api.birdeye.so/socket/...`.
- Imports of any Birdeye SDK or client library.
- Environment variables and config keys named `BIRDEYE_*` or `BDS_*`.
- Header usage of `X-API-KEY` and `x-chain`.
- Code that switches behavior on Birdeye `chain` strings (`solana`, `ethereum`, `base`, etc.).
- Tests, fixtures, and mocks that reference any of the above.

Produce a Migration Plan with:

1. A grouped list of every call site, organized by Birdeye endpoint.
2. The proposed Codex equivalent for each group (use the mapping below).
3. Any call sites you cannot map cleanly, flagged for human review.
4. The order you intend to make changes (shared client/config first, then leaf call sites, then tests).
5. New dependencies, env vars, and config you will introduce.

Stop and surface the plan before editing any source files. Wait for confirmation.

## Phase 2: Execution (after the plan is approved)

Ground rules:

1. Codex is a GraphQL API at `https://graph.codex.io/graphql`. Auth header is `Authorization: <api-key>` for long-lived keys, or `Authorization: Bearer <jwt>` for short-lived keys.
2. Codex ships an official SDK for TypeScript/JavaScript only (`@codex-data/sdk`). Prefer it over hand-rolled HTTP in TS/JS projects. For Python and every other language there is no official SDK: use raw GraphQL over HTTP against `https://graph.codex.io/graphql`.
3. Network is a parameter (`networkId`), not a header. Convert Birdeye `x-chain` strings to Codex network IDs: `solana` → 1399811149, `ethereum` → 1, `base` → 8453, `bsc` → 56, `polygon` → 137, `arbitrum` → 42161, `optimism` → 10, `avalanche` → 43114, `sui` → 101. For others, call `getNetworks` once and build a lookup.
4. Token IDs in Codex are the string `"<address>:<networkId>"`. Construct them explicitly; never assume an integration relies on bare addresses.
5. Where a Birdeye integration hits two or three endpoints to fill one screen (for example token_overview + token_security + market-data), collapse them into a single GraphQL query.
6. For real-time data, use WebSocket subscriptions when the consumer is a long-lived client (dashboards, trading UIs) and webhooks when the consumer is a server endpoint (alerts, background workers, queues).
7. Preserve existing public function signatures, return shapes, and error semantics wherever possible. Internal helpers can be refactored freely.
8. Update tests as you change code. If a test relied on a Birdeye response fixture, replace the fixture with a Codex equivalent rather than deleting the test.
9. When you hit a gap (perpetuals, non-swap wallet transfers, first-funded-by lookup, CEX liquidity), do not silently drop the feature. Leave the call site intact, add a `TODO(migration):` comment with a one-line note explaining what's missing and what provider could fill it, and list it in your final report. Note that Sui (`networkId: 101`) is supported broadly, but `balances` is not available on Sui: flag any Sui balance lookups specifically.

## Birdeye → Codex endpoint mapping

Prices and OHLCV:
- `GET /defi/price`, `GET|POST /defi/multi_price` → `getTokenPrices(inputs: [...])` (max 25 inputs per call; chunk Birdeye `multi_price` batches larger than 25 or they will be silently truncated)
- `GET /defi/historical_price_unix` → `getTokenPrices(inputs: [{ address, networkId, timestamp }])` (the historical price at a unix timestamp)
- `GET /defi/history_price` → `getTokenBars`
- `GET /defi/ohlcv`, `/defi/v3/ohlcv` → `getTokenBars`
- `GET /defi/ohlcv/pair`, `/defi/v3/ohlcv/pair`, `/defi/ohlcv/base_quote` → `getBars` (use `quoteToken: token0 | token1` to invert the pair)
- `GET /defi/price_volume/*`, `/defi/v3/price/stats/*` → `getDetailedTokenStats(tokenAddress, networkId, durations: [...])` (top-level args, not an `input` object)

Token data:
- `GET /defi/token_overview` → `token` + `getDetailedTokenStats` in one query
- `GET /defi/v3/token/meta-data/single` → `token(input: { address, networkId })`
- `GET /defi/v3/token/meta-data/multiple` → `tokens(ids: [{ address, networkId }, ...])`
- `GET /defi/v3/token/market-data*`, `/defi/v3/token/trade-data/*` → `getDetailedTokenStats`
- `GET /defi/token_security` → safety fields on `token` (`isScam`, `mintable`, `freezable`, `creatorAddress`, `top10HoldersPercent`). `circulatingSupply` and `totalSupply` live under `token.info`, not the top-level token object.
- `GET /defi/token_creation_info` → `createdAt`, `creatorAddress` on `token`
- `GET /defi/v3/token/exit-liquidity`, `/defi/v3/token/exit-liquidity/multiple` → `liquidityMetadata`, `liquidityMetadataByToken`, `liquidityLocks`

Discovery:
- `GET /defi/token_trending` → `filterTokens(rankings: [{ attribute: trendingScore24, direction: DESC }])`
- `GET /defi/v3/token/list`, `/defi/v3/token/list/scroll`, `/defi/tokenlist`, `/defi/v2/tokens/new_listing` → `filterTokens(...)`
- `GET /defi/v3/search` → `filterTokens(phrase: "$SYMBOL", ...)`
- `GET /defi/v3/token/meme/*` → `filterTokens` plus launchpad fields on `token.launchpad`
- `GET /smart-money/v1/token/list` → `filterWallets` + `filterTokens` (see Wallets recipe)

Pairs:
- `GET /defi/v3/pair/overview/single` → `getDetailedPairStats` (pair trade stats are part of this response; Birdeye has no separate pair `trade-data` endpoint)
- `GET /defi/v3/pair/overview/multiple` → `getDetailedPairsStats`
- `GET /defi/v2/markets` → `listPairsForToken` or `listPairsWithMetadataForToken`

Trades:
- `GET /defi/txs/token`, `/defi/txs/token/seek_by_time`, `/defi/v3/token/txs`, `/defi/v3/txs`, `/defi/v3/txs/recent` → `getTokenEvents(query: { address, networkId, ... })`
- `GET /defi/txs/pair`, `/defi/txs/pair/seek_by_time` → `getTokenEvents` (pair address as `query.address`)
- `GET /defi/v3/token/txs-by-volume` → `getTokenEvents` with `priceUsdTotal` filter
- `GET /defi/v3/token/mint-burn-txs` → `getTokenEvents` with `eventDisplayType: [Mint, Burn]` (Solana only)
- `GET /defi/v3/all-time/trades/single`, `POST /defi/v3/all-time/trades/multiple` → `getDetailedTokenStats` (read `statsUsd.volume.currentValue`, `statsNonCurrency.transactions.currentValue`)

Holders:
- `GET /defi/v3/token/holder` → `holders(input: { tokenId, sort: { attribute: BALANCE, direction: DESC } })` (`BALANCE` is the only supported sort attribute; `DATE` exists but is deprecated)
- `GET /holder/v1/distribution`, `/token/v1/holder-profile` → `top10HoldersPercent` on `token` (combine with `holders` for the ranked list)
- `GET /token/v1/holder/chart` → partial via `onHoldersUpdated` (live counts only; no first-class historical timeseries)
- `GET /token/v1/holder-positions` → `filterTokenWallets`
- `POST /token/v1/holder/batch` → `balances` per wallet (use GraphQL aliases to batch)

Wallets:
- `GET /v1/wallet/token_list`, `/v1/wallet/token_balance`, `POST /wallet/v2/token-balance` → `balances(input: { walletAddress, networks: [Int!], removeScams, tokens, limit })` (the network field is plural/array, not `networkId`; max 200 tokens per request)
- `GET /v1/wallet/list_supported_chain` → `getNetworks`
- `GET /v1/wallet/tx_list` → `getTokenEventsForMaker` (swap events; flag if raw transfers are required)
- `GET /wallet/v2/current-net-worth`, `/wallet/v2/pnl`, `/wallet/v2/pnl/summary`, `/wallet/v2/pnl/multiple`, `POST /wallet/v2/pnl/details` → `detailedWalletStats` and `filterWallets`
- `GET /wallet/v2/net-worth`, `/wallet/v2/net-worth-details`, `POST /wallet/v2/net-worth-summary/multiple` → `walletChart` + `detailedWalletStats` (alias multiple wallets in one request)
- `GET /wallet/v2/balance-change` → `onBalanceUpdated` subscription

Traders:
- `GET /defi/v2/tokens/top_traders` → `tokenTopTraders(input: { tokenAddress, networkId, tradingPeriod })` (`tradingPeriod` is `DAY | WEEK | MONTH | YEAR` — no hourly value)
- `GET /trader/txs/seek_by_time` → `getTokenEventsForMaker`
- `GET /trader/gainers-losers` → `filterWallets(input: { rankings: [{ attribute: realizedProfitUsd1d, direction: DESC }] })` (pick `1d` / `1w` / `30d` / `1y` to match the timeframe)

Real-time (WebSocket → Codex subscription):
- `SUBSCRIBE_PRICE` → `onPriceUpdated` / `onPricesUpdated`
- `SUBSCRIBE_BASE_QUOTE_PRICE` → `onBarsUpdated`
- `SUBSCRIBE_TOKEN_STATS` → `onDetailedTokenStatsUpdated`
- `SUBSCRIBE_TXS`, `SUBSCRIBE_LARGE_TRADE_TXS` → `onTokenEventsCreated` / `onEventsCreated` (apply a min-volume filter for the large-trade variant)
- `SUBSCRIBE_WALLET_TXS` → `onEventsCreatedByMaker`
- `SUBSCRIBE_NEW_PAIR`, `SUBSCRIBE_TOKEN_NEW_LISTING`, `SUBSCRIBE_MEME` → `onTokenLifecycleEventsCreated`, `onLatestTokens`, `onLaunchpadTokenEvent`
- `SUBSCRIBE_TRANSFER` → not supported (Codex streams swaps and lifecycle events, not arbitrary transfers)

Utility:
- `GET /defi/networks` → `getNetworks`
- `GET /defi/v3/txs/latest-block` → `blocks(input: { networkId, blockNumbers, timestamps })`

Gaps (flag, do not drop):
- `/perps/v1/*`: not supported
- `/wallet/v2/transfer*`, `/token/v1/transfer*`: Codex is swap-focused; pair with an RPC provider for raw transfers
- `POST /wallet/v2/tx/first-funded`: no direct equivalent
- NFT endpoints: Codex does not expose NFT data
- Sui (`networkId: 101`): broadly supported, but `balances` does not work on Sui. Flag Sui balance call sites specifically.
- EVM native balances via `balances` are only available on networks with traces enabled. If a customer relies on native-token portfolio values on a chain without traces, flag it.

When you need details on any Codex field, fetch the reference page at `https://docs.codex.io/api-reference/queries/<name>` (or `subscriptions`, `mutations`) rather than guessing. Before migrating any real-time code, fetch `https://docs.codex.io/concepts/subscriptions` and `https://docs.codex.io/concepts/webhooks` so you pick the right delivery mechanism.

## Phase 3: Final report

When the migration is done, produce a single report with:

1. Files changed, grouped by area (client/config, call sites, tests, docs).
2. Every `TODO(migration):` you added, with file path, line, and the reason.
3. New env vars and dependencies, with the line to add to `.env.example` and the package manager command to install.
4. Birdeye integrations that were removed entirely, and what replaced them.
5. A short manual-verification checklist the human should run before merging (which features to click through, which endpoints to spot-check, which dashboards to load).

Run the project's linter and test suite before declaring the migration complete. If tests fail, fix the underlying integration, do not weaken the test.

​
Getting help

  • Browse the API Reference for the full schema.
  • Skim the Recipes for end-to-end examples that solve specific product problems.
  • Ask in our community if you hit a wall during migration.