How to Scrape CoinGecko Derivatives Tickers in 2026

If you trade or research crypto derivatives, the single most useful cross-venue dataset is CoinGecko’s derivatives feed: every perpetual swap and dated future, across 50+ exchanges, with funding rates, open interest, basis and volume normalized into one place. That’s over 22,000 tickers. The data is exposed through CoinGecko’s public derivatives REST API, so the work isn’t anti-bot evasion — it’s pulling the full feed, flattening per-ticker market metrics, and handling rate limits so a scheduled snapshot doesn’t break. This guide covers the endpoint, the metrics that matter for derivatives work, and how to build a clean feed.

What’s worth extracting

The derivatives feed carries far more than price. Per ticker you get:

• Market identity — exchange (venue), contract symbol, the underlying index it tracks, contract type (perpetual vs. dated future) and expiry where applicable.
• Contract price — the current futures/perp price.
• 24h price change — move over the trailing day.
• Underlying spot index — the index price the contract is marked against.
• Basis — contract price minus index. For perps this hovers near zero; for dated futures it’s the carry/roll signal.
• Bid/ask spread — top-of-book spread, a liquidity proxy.
• Funding rate — perpetuals — the periodic funding payment, the core input for funding-rate arbitrage.
• Open interest — total open contracts, the positioning signal.
• 24h volume — contract volume over the day.
• Timestamp — snapshot time.

Funding rate, open interest and basis are the three fields that make this a derivatives dataset rather than a price list. They’re what funding-arb bots, basis traders and positioning analysts actually consume.

How the API is exposed

This is CoinGecko’s public derivatives REST API. The key endpoint returns the entire feed in one shot:

GET https://api.coingecko.com/api/v3/derivatives

The realities that shape the puller:

• One response, full universe. Unlike coins/markets, the derivatives endpoint returns all 22,000+ tickers in a single response — no per-ticker pagination. That makes a full snapshot fast.
• Rate limits still apply. It’s the same CoinGecko API surface, so the free tier’s per-minute call cap governs how often you can snapshot. Built-in backoff keeps a scheduled job from tripping it.
• Funding is perp-only. Dated futures have no funding rate; they have an expiry and a meaningful basis instead. A correct schema keeps funding nullable.
• Basis sign matters. Contract minus index — positive means contango/premium, negative means backwardation. Don’t drop the sign.

Because it’s a single-response API, the engineering is flattening each ticker into a row, in-stream filtering/sorting, and a volume threshold to trim dust contracts — not anti-bot.

REST snapshots vs. websocket

For derivatives analytics — funding monitoring, OI tracking, basis scanning, exchange volume share — scheduled REST snapshots are the right tool. Funding settles on multi-hour cadences and OI shifts over minutes, so a snapshot every few minutes captures everything a funding-arb or positioning dashboard needs. A live websocket would be over-engineering for anything short of live execution.

▶ Run the CoinGecko Derivatives Scraper — one run flattens all 22,000+ derivative tickers across 50+ venues into rows with funding rate, open interest, basis, spread and volume. In-stream filtering and volume trimming included. Priced per ticker extracted.

Build it yourself vs. use a managed scraper

The single-call endpoint makes a naive puller easy. The managed case is flattening, filtering and scheduling:

• Building from scratch — flatten each nested ticker into a stable row, classify perp-vs-dated, compute or carry basis with the right sign, apply a volume threshold to drop dust, and add backoff plus a scheduler.
• Using a managed actor — set a volume threshold and sort, run on a schedule, export flat CSV/JSON. The flattening and trimming are done.

For a funding-arb or basis dashboard refreshed every few minutes, the managed path removes the flattening and rate-limit work.

Schema design for downstream use

A flattened per-ticker record:

{
  "exchange": "Binance (Futures)",
  "symbol": "BTCUSDT",
  "index_id": "BTC",
  "contract_type": "perpetual",
  "expiry": null,
  "price": 63410.0,
  "change_24h_pct": 2.05,
  "index_price": 63402.0,
  "basis": 0.013,
  "spread_pct": 0.01,
  "funding_rate": 0.0001,
  "open_interest": 5120000000,
  "volume_24h": 28400000000,
  "timestamp": "2026-05-26T12:00:00Z"
}

Schema choices worth making:

• Keep contract_type and expiry. Perp vs. dated future is the first thing every consumer filters on; expiry drives roll math for futures.
• Make funding_rate nullable. Dated futures have none — null, not zero.
• Preserve the sign of basis. Contango and backwardation are opposite signals.
• Carry index_id so you can group all venues’ BTC perps for cross-venue funding comparison.
• Store open_interest and volume_24h as numbers for aggregation across venues.
• Always store the timestamp. Funding and OI move continuously.

Typical use cases

• Funding-rate arbitrage — compare funding across venues for the same underlying (group by index_id) to find carry trades.
• Basis / cash-and-carry desks — scan dated futures for high-yield roll opportunities using the basis and expiry fields.
• Open-interest and positioning analytics — aggregate OI per underlying to detect crowded positioning and risk buildup.
• Volume and market-share dashboards — rank exchanges by aggregate contract volume.
• Quant research / backtesting — frequent snapshots build the funding/OI/basis history strategies need.
• Risk and liquidation monitoring — track OI shifts and funding extremes as stress signals.
• Exchange comparison content — fee/funding leaderboards and daily-refresh pages.
• On-chain perp benchmarking — compare DEX perp protocols against centralized venues.

Cost math

Pricing is pay-per-event, charged per ticker extracted. A full snapshot is ~22,000 tickers; trimming to liquid contracts with a volume threshold cuts that dramatically and is the right move for most use cases. A focused snapshot of, say, the top few thousand liquid tickers every few minutes is a predictable, modest monthly cost with no infrastructure.

Self-hosting has no data cost on the free tier, but you own the flattening, the basis/perp logic, the backoff and the scheduler. For a recurring derivatives feed, the managed actor trades a small per-ticker fee for skipping all of that.

Common pitfalls

• Treating dated futures like perps. They have no funding and a meaningful basis/expiry. Branch on contract_type.
• Dropping the basis sign. Positive and negative basis are opposite trades. Keep the sign.
• Not trimming dust. 22,000 tickers include thousands of illiquid contracts. Apply a volume threshold or your analytics drown in noise.
• Comparing funding without grouping by underlying. Funding is only comparable across venues for the same index. Group by index_id.
• Ignoring rate limits. Same CoinGecko API surface — snapshot too aggressively without backoff and you get throttled.
• No timestamp. Funding and OI are time-sensitive; a snapshot without its time is useless for series analysis.

Wrapping up

CoinGecko’s derivatives feed is the broadest cross-venue source of funding, open interest and basis in crypto — 22,000+ tickers across 50+ exchanges in a single API response. The work is flattening, perp-vs-dated handling, dust trimming and rate-limit-safe scheduling, not anti-bot. For a one-off scan the API is easy. For a funding-arb, basis or positioning dashboard refreshed continuously, a managed actor hands you flat rows with the derivatives metrics already normalized.

▶ Open the CoinGecko Derivatives Scraper on Apify — 22,000+ tickers with funding rate, open interest, basis, spread and volume across every derivatives venue. Schedule for a fresh feed. Priced per ticker. Start on Apify’s free monthly credit.