ADA to USD and Top ADA Coin Data: Powering Trading Apps with On‑Chain APIs

Best onchain data APIs for trading apps increasingly treat ADA and other major assets as first-class citizens.

For ADA, the core data you need—ADA to USD price, ADA market cap, ADA wallet activity, and Cardano NFT marketplace stats—are all derivable from onchain events plus a reliable price feed. Below, we break down the data model, show how ADA metrics are calculated, and use Codex’s API design as a reference architecture for high-performance trading interfaces.

Note on scope: As of 2026‑10‑08, Codex does not index Cardano mainnet directly. Cardano-specific implementations must use Cardano-native infra today. We use Codex’s API shapes and performance patterns as best-practice templates you can replicate on Cardano.

Reference: Codex supported networks list (EVM + Solana/Aptos/Sui/Starknet, no Cardano): docs.codex.io/networks.

Best onchain data APIs for trading apps (ADA)

To power ADA-aware trading apps, you need three layers of data:

1. Onchain state from Cardano

   • ADA supply and epoch data
   • Transactions, outputs, assets, stake pools
   • NFT metadata and registries

2. Off-chain price aggregation for ADA to USD

   • Real-time ADA/USD price from CEXs and DEXs
   • Liquidity-weighted aggregation and quality filters

3. High-performance API layer for apps

   • Low-latency queries (sub-second p95)
   • WebSocket subscriptions for live updates
   • Unified shapes for prices, charts, wallets, and NFTs

Cardano’s docs explicitly treat the chain as fully queryable public infrastructure: explorers pull from the main database and expose blocks, transactions, epoch data, assets, and stake pools via APIs docs.cardano.org.

Codex, on supported chains, builds on a similar principle but returns enriched, trading-ready objects (tokens, bars, pairs, holders) instead of raw logs docs.codex.io.

For ADA, the key is to mirror that enriched model while sourcing your raw data from Cardano-native indexers.

ADA to USD price API: how ADA pricing is derived

How ADA/USD price is calculated

In most production systems, ADA to USD pricing is derived as:

• Pull ADA prices in various quote currencies (ADA/USD, ADA/USDT, ADA/BTC) from:

  • Major centralized exchanges (CEXs) such as Coinbase, Binance, Kraken.
  • Onchain decentralized exchanges (DEXs) on Cardano or bridged EVM environments.

• Convert all prices to USD and compute a liquidity-weighted average:

  • Weight each market by its on-book liquidity and recent trading volume.
  • Filter out thin or clearly mispriced markets.

Codex implements this pattern for the chains it supports:

• Its bar feed notes that aggregate pricing uses a weighted average across a token’s top pairs based on liquidity and recency, filtering lower-quality pairs docs.codex.io.

For ADA, you should avoid treating a single illiquid pool or smaller exchange as “truth.” A robust ADA to USD price API aggregates multiple markets and applies quality filters.

Current ADA price example (time-stamped)

To illustrate the calculation with real numbers, CoinMarketCap’s ADA page on 2026‑10‑08T12:00:00Z reported:

• ADA price: ~US$0.2535
• 24h volume: ~US$555.16M
• Market cap: ~US$9.32B
• Circulating supply: ~36.79B ADA

Source: coinmarketcap.com/currencies/cardano (retrieved 2026‑10‑08T12:00:00Z).

These are off-chain aggregated metrics, but they mirror what a robust ADA to USD price API would compute from its exchange and DEX data.

Example ADA to USD price API shape (Codex-style)

On supported networks, Codex exposes token prices via getTokenPrices docs.codex.io:

query GetAdaPrice {
  getTokenPrices(
    network: "solana"      # example network
    tokenAddresses: ["ADA_TOKEN_ADDRESS"]
  ) {
    tokenAddress            # string, non-null
    priceUsd                # float, non-null, ADA price in USD
    priceNative             # float, non-null, price in native token
    network                 # string, non-null, network ID
    timestamp               # ISO8601 string, non-null
  }
}

Field definitions:

• tokenAddress (string, non-null): unique token identifier on the given network.
• priceUsd (float, non-null): latest liquidity-weighted price in USD.
• priceNative (float, non-null): price denominated in the chain’s native asset.
• network (string, non-null): network name from Codex’s supported list.
• timestamp (string, ISO8601, non-null): server-side time of the price snapshot.

For Cardano, you’d implement an equivalent getAdaPrice endpoint with these fields, backed by your exchange/DEX aggregation logic.

ADA market cap onchain: math and supply data

ADA market cap formula

ADA market cap is straightforward:

ADA market cap = ADA/USD price × ADA circulating supply

CoinMarketCap defines circulating market cap as:

market cap = price × circulating supply (public float), not total supply.

Reference: CMC supply methodology support.coinmarketcap.com (retrieved 2026‑10‑08T12:00:00Z).

Cardano epoch-659 supply snapshot

Cardano’s own supply page for epoch 659 gives a precise breakdown (retrieved 2026‑10‑08T12:00:00Z):

• Circulation: 36,786,187,632 ADA (81.75%)
• Treasury: 1,370,992,827 ADA (3.05%)
• Rewards: 749,856,625 ADA (1.67%)
• Reserves: 6,087,709,088 ADA (13.53%)
• Max supply: 45,000,000,000 ADA

Source: Cardano supply insights cardano.org/insights/supply (epoch 659).

Cardano also notes:

• Reward calculations occur at the close of each 5-day epoch.
• The currently running epoch in that snapshot had 159,916 transactions, and fees averaged ~0.25 ADA per transaction cardano.org.

To compute ADA market cap onchain:

1. Use Cardano’s circulating supply (e.g., 36,786,187,632 ADA).
2. Multiply by your ADA/USD price from the ADA to USD price API.

Example (using the CMC price above):

• 36,786,187,632 ADA × US$0.2535 ≈ US$9.33B

This matches CMC’s reported ADA market cap (~US$9.32B) within rounding.

Example ADA market cap API shape

You can expose this via a getAdaMarketCap endpoint:

query GetAdaMarketCap {
  getAdaMarketCap {
    priceUsd          # float, non-null
    circulatingSupply # float, non-null, units: ADA
    marketCapUsd      # float, non-null
    epoch             # int, non-null
    timestamp         # ISO8601 string, non-null
  }
}

Fields:

• priceUsd (float): ADA to USD price used in the calculation.
• circulatingSupply (float): ADA circulating supply for the given epoch.
• marketCapUsd (float): computed ADA market cap in USD.
• epoch (int): Cardano epoch number for the supply snapshot.
• timestamp (string): time at which data was computed.

This mirrors how Codex surfaces aggregated metrics (e.g., liquidity and volume on pairMetadata) for supported chains docs.codex.io.

Cardano onchain metrics API & ADA transaction volume API

Trading-grade ADA experiences need Cardano onchain metrics APIs that expose:

• ADA transaction counts and volumes per interval.
• Fee statistics, stake activity, and wallet interactions.
• App-level activity (DEXs, NFT marketplaces, DeFi protocols).

Cardano onchain activity snapshot

Cardano’s transaction leaderboard (Aug. 22 – Sep. 21, 2026) reports:

• 301,498 tracked transactions over the last 30 days.
• 63 apps & standards and 44.2% network coverage in that window.
• DEXs dominate:
  • Minswap: 93,197 tx.
  • WingRiders: 40,795 tx.
  • Splash: 17,036 tx.

Source: Cardano apps leaderboard cardano.org/apps/leaderboard (retrieved 2026‑10‑08T12:00:00Z).

Cardano’s apps directory lists 103 curated mainnet apps cardano.org/apps and shows individual app activity, e.g.:

• Wayup (NFT marketplace): 4,697 tx in last 30 days.
• JPG Store: 392 tx in last 30 days.
• Splash (DEX): 17,036 tx.
• Book.io: 6 tx.

Source: respective Cardano app pages (retrieved 2026‑10‑08T12:00:00Z).

Example ADA transaction volume API (Codex-style)

Codex exposes trades and bars via token-specific endpoints (e.g., getBars, getTokenBars) on supported chains docs.codex.io.

For Cardano, you could define a getAdaTransactionVolume endpoint:

query GetAdaVolume {
  getAdaTransactionVolume(
    interval: "1d"          # string, non-null, e.g. 1m, 5m, 1h, 1d
    from: "2026-09-22T00:00:00Z"
    to: "2026-10-22T00:00:00Z"
  ) {
    intervalStart    # ISO8601 string, non-null
    intervalEnd      # ISO8601 string, non-null
    transactionCount # int, non-null
    volumeAda        # float, non-null
    averageFeeAda    # float, nullable
  }
}

Fields:

• intervalStart / intervalEnd (string): bounds for the aggregated data.
• transactionCount (int): number of ADA-denominated transactions.
• volumeAda (float): total ADA moved in the interval.
• averageFeeAda (float, nullable): mean fee paid per transaction.

This gives product teams a clear API contract for ADA transaction volume, similar to how Codex powers charting and analytics for other tokens.

ADA wallet activity API: building responsive portfolio and UX

Onchain basis for wallet activity

Cardano treats wallet activity as derivable from ledger events:

• Transactions reference addresses whose structure encodes payment and delegation credentials.
• Stake pools, delegation, and asset transfers are all observable onchain.

Cardano’s tracking tools documentation confirms explorers can query:

• Transactions, blocks, epoch details.
• Outputs and assets.
• Stake pools and delegation docs.cardano.org.

This is why ADA wallet activity APIs can be purely onchain: no proprietary data required.

Cardano address and stake structure (high level)

• Cardano addresses combine payment and staking credentials.
• This allows explorers and APIs to derive:
  • ADA balances per wallet.
  • Delegation targets and rewards.
  • NFT holdings and token balances.

Example ADA wallet activity API shape

Codex exposes holders and balances across chains via filterTokenBalances and related queries docs.codex.io.

A Cardano-specific wallet activity endpoint might look like:

query GetAdaWalletActivity {
  getAdaWalletActivity(
    address: "addr1qxyz..."   # string, non-null
    from: "2026-09-01T00:00:00Z"
    to: "2026-10-01T00:00:00Z"
  ) {
    address            # string, non-null
    currentBalanceAda  # float, non-null
    totalReceivedAda   # float, non-null
    totalSentAda       # float, non-null
    transactionCount   # int, non-null
    lastActivity       # ISO8601 string, nullable
    delegatingTo       # string, nullable, stake pool ID
  }
}

Fields:

• address (string): Cardano base or enterprise address.
• currentBalanceAda (float): current ADA balance for the address.
• totalReceivedAda (float): sum of incoming ADA over the period.
• totalSentAda (float): sum of outgoing ADA over the period.
• transactionCount (int): count of ADA-related transactions.
• lastActivity (string, nullable): timestamp of most recent transaction.
• delegatingTo (string, nullable): stake pool the address delegates to.

This shape supports:

• Portfolio views.
• Activity timelines.
• Delegation and staking dashboards.

Codex’s value on supported chains is that it pre-builds and maintains these aggregations so product teams don’t have to run custom indexers.

Cardano NFT marketplace API: ADA NFTs, metadata, and royalties

CIP standards that make Cardano NFTs queryable

Three Cardano Improvement Proposals (CIPs) define how NFT metadata and registries work:

1. CIP-25: NFT metadata standard

   • Specifies how NFT metadata (name, image, attributes) is stored and referenced.
   • Ensures wallets and explorers can display NFTs consistently.
   • Source: developers.cardano.org – CIP-25 (retrieved 2026‑10‑08T12:00:00Z).

2. CIP-68: Token extensions for NFTs

   • Introduces extended token data structures for more complex NFTs and dApps.
   • Allows richer metadata and behavior beyond simple static assets.
   • Reference via Cardano developer documentation developers.cardano.org.

3. CIP-26: Royalty specification / registries

   • Defines how royalty information and registries for NFTs are surfaced.
   • Lets marketplaces honor creator royalties based on onchain registry data.
   • Referenced in Cardano metadata and registry docs developers.cardano.org.

Wallets and marketplaces read these standards to:

• Decode NFT metadata.
• Apply royalty rules.
• Show provenance and attributes consistently.

Marketplace landscape and consolidation

The Cardano NFT marketplace ecosystem is evolving:

• JPG Store reports its platforms have been sunset, but
• Wayup states it continues JPG Store smart contracts, keeping existing listings and royalties functional.

Source: JPG Store site jpg.store and Wayup app page cardano.org/apps/wayup (retrieved 2026‑10‑08T12:00:00Z).

This is a crucial design insight: market liquidity can move between front-ends even while smart contracts remain active.

Example Cardano NFT marketplace API

A robust Cardano NFT marketplace API should expose:

• Listings and bids.
• Settlement events and volumes.
• NFT metadata and royalty data from CIP standards.

Codex, on supported chains, offers token and metadata endpoints plus scam filtering and enriched token details docs.codex.io.

For Cardano NFTs, an API might look like:

query GetAdaNftMarketplaceData {
  getCardanoNftMarketplaceData(
    marketplaceId: "wayup"      # string, non-null
    from: "2026-09-01T00:00:00Z"
    to: "2026-10-01T00:00:00Z"
  ) {
    marketplaceId        # string, non-null
    totalVolumeAda       # float, non-null
    tradeCount           # int, non-null
    uniqueTraders        # int, non-null
    topCollection {      
      policyId           # string, non-null
      name               # string, nullable
      volumeAda          # float, non-null
      tradeCount         # int, non-null
      royaltyPercent     # float, nullable
    }
  }
}

Fields:

• marketplaceId (string): logical ID (e.g., wayup, jpg_store).
• totalVolumeAda (float): total ADA traded in NFTs.
• tradeCount (int): number of NFT trades in the period.
• uniqueTraders (int): count of distinct wallet addresses trading.
• topCollection.policyId (string): Cardano policy ID for the collection.
• topCollection.name (string, nullable): human-readable collection name from metadata.
• topCollection.volumeAda (float): ADA volume for the collection.
• topCollection.tradeCount (int): number of trades for the collection.
• topCollection.royaltyPercent (float, nullable): royalty rate from CIP-26 registry.

This matches product teams’ needs for:

• Activity-aware discovery surfaces.
• Collection leaderboards.
• Liquidity analytics for NFT investors.

Best real-time crypto data API trading 2024–2026: queries vs subscriptions

Industry-wide, trading apps are moving from polling to subscriptions.

Codex frames this distinction clearly docs.codex.io:

• Queries: one-time fetches for snapshots (e.g., latest price, historical bars).
• Subscriptions (WebSockets): continuous streams of updates for:
  • Token price changes.
  • Bar updates (OHLC candles).
  • Prediction event bars and token bars.

Codex’s optimization docs recommend:

• Using subscriptions instead of timer-based polling for real-time UX.

For ADA-aware trading apps, that means:

• Implement WebSocket feeds for ADA/USD price.
• Stream ADA transaction bars (volume, count) per interval.
• Push wallet updates and NFT marketplace trades as they happen.

Example subscription shape (Codex-style token bars):

subscription OnAdaBarsUpdated {
  onTokenBarsUpdated(
    tokenAddresses: ["ADA_TOKEN_ADDRESS"]
    network: "supported_network"
    interval: "1m"
  ) {
    tokenAddress     # string
    interval         # string (e.g., 1m, 5m)
    open             # float
    high             # float
    low              # float
    close            # float
    volumeNative     # float
    timestamp        # ISO8601 string
  }
}

This pattern is equally applicable to ADA on Cardano once you have a streaming data layer.

Onchain data API prediction markets & prediction market API frontend real-time data

Prediction markets are a growing, data-intensive vertical adjacent to trading.

Codex already exposes prediction market data (currently in beta) for platforms like Polymarket and Kalshi:

• Endpoints include filterPredictionEvents, filterPredictionMarkets, and trader analytics docs.codex.io.
• Subscriptions such as onPredictionEventBarsUpdated push real-time event bar updates.

That makes Codex a strong reference for:

• onchain data API prediction markets.
• prediction market API frontend real-time data.

Example prediction event bars subscription (Codex docs):

subscription OnPredictionEventBarsUpdated {
  onPredictionEventBarsUpdated(
    eventIds: ["event_123"]
    interval: "1m"
  ) {
    eventId          # string, non-null
    interval         # string, non-null
    openPrice        # float, non-null
    highPrice        # float, non-null
    lowPrice         # float, non-null
    closePrice       # float, non-null
    volumeUsd        # float, non-null
    timestamp        # ISO8601 string, non-null
  }
}

Fields:

• eventId (string): unique identifier of the prediction event.
• openPrice / highPrice / lowPrice / closePrice (float): prices per interval.
• volumeUsd (float): USD volume traded in the interval.
• timestamp (string): bar end time.

For ADA-linked prediction markets (e.g., ADA price outcome markets), you can reuse this shape:

• Replace eventId with ADA-specific event keys.
• Ensure the underlying data pipeline reads onchain trades and order book events.

This is the same trading-grade data model that makes Codex one of the best onchain blockchain data API providers for prediction markets on supported chains.

Designing ADA-aware experiences with high-performance APIs

To design responsive ADA-aware trading experiences, product and engineering teams should:

1. Normalize ADA price and supply

   • Implement a robust ADA to USD price API with liquidity weighting.
   • Track ADA circulating supply per epoch from Cardano’s onchain data.
   • Expose ADA market cap as a computed metric.

2. Expose ADA transaction and wallet activity

   • Provide ADA transaction volume metrics by interval.
   • Implement wallet activity APIs that summarize balances, flows, and delegation.

3. Index NFT metadata and marketplace events

   • Honor CIP-25, CIP-68, and CIP-26 to surface metadata and royalties.
   • Offer marketplace analytics: volume, unique traders, top collections.

4. Adopt subscriptions for live UX

   • Use WebSockets for price, bars, and event feeds.
   • Reserve queries for initial loads and historical backfills.

Codex proves this pattern at scale on the networks it already supports:

• 80+ networks, 70M+ tokens, 700M+ wallets, indexing thousands of transactions per second docs.codex.io.
• Trading-grade chart data (OHLC bars, candles, volume), holders, balances, and prediction market analytics.

While Cardano support is not live yet, mirroring Codex’s API shapes and performance targets is a pragmatic way to build ADA-aware infra that’s ready for integration with broader token data stacks later.

By combining onchain Cardano data with trading-grade, Codex-style API contracts, product teams can ship ADA-aware trading, wallet, and NFT experiences that are fast, reliable, and ready for high traffic.