CoinGecko Crypto Scraper — Live Prices, Market Cap & Coin Data | from $0.50/1K

Built for quant analysts, DeFi dashboards, and AI agents that need reliable, schema-stable crypto market data — without maintaining a CoinGecko Pro subscription ($129/mo).

No API key required. Official CoinGecko API — zero fragility. Pay only for results: from $0.50 per 1,000 results (Pay Per Event). includeDetail=true for description + website: $1.50/1,000.

Scrape live cryptocurrency data from CoinGecko via the official public API. No browser, no proxy, no auth required for the Demo tier. Pay only for results.

What you get per coin

Field	Description
coin_id	CoinGecko slug (e.g. bitcoin, ethereum)
symbol	Ticker symbol (uppercased: BTC, ETH)
name	Display name
current_price_usd	Live price in your chosen quote currency
market_cap	Market capitalization
market_cap_rank	Global rank by market cap
total_volume	24h trading volume
price_change_24h_pct	24h price change %
circulating_supply	Circulating supply of coins
ath	All-time high price
ath_date	Date of ATH (ISO 8601)
last_updated	When CoinGecko last updated this coin
image_url	Coin logo URL
description	Short description (first 500 chars) — when includeDetail=true
website_url	Official website — when includeDetail=true
parse_confidence	0.0–1.0 data quality score
warnings	Machine-readable list of any data-quality issues

Modes

• markets — Top coins ranked by market cap (default). Returns the top N coins with all price data in a single efficient batch call. Use order to sort by volume, gecko score, etc.
• coinIds — Fetch specific coins by their CoinGecko ID (e.g. bitcoin, ethereum, solana). Use this when you have a known list of coins to track.
• search — Search CoinGecko by keyword. Returns up to 25 matching coin stubs per query. Use includeDetail=true to add full price data to each result.

Input

{
  "mode": "markets",
  "vsCurrency": "usd",
  "maxItems": 100,
  "order": "market_cap_desc"
}

{
  "mode": "coinIds",
  "coinIds": ["bitcoin", "ethereum", "solana"],
  "vsCurrency": "eur"
}

{
  "mode": "search",
  "searchQueries": ["defi", "layer 2"],
  "includeDetail": true
}

Pricing example

Pay per result (PPE). Charged per coin record pushed:

Fetch	Records	Cost
Top 10 coins by market cap	10	~$0.005
Top 100 coins	100	~$0.05
Top 1,000 coins	1,000	~$0.50
50 coins with includeDetail=true	50 base + 50 detail events	~$0.10

FAQ

Do I need a CoinGecko API key or account? No. The free Demo API is used by default — no key, no sign-up. Provide a Pro key only if you need higher rate limits (>30 req/min).

What formats can I export to? JSON, CSV, and Excel via the Apify dataset download or the REST API. The structured flat schema works directly in pandas, Google Sheets, or any BI tool.

Can I schedule this to run automatically? Yes. Set up a schedule in Apify Console (e.g. every 5 minutes for a live price feed) or trigger via webhook from n8n / Make.

What if it returns empty or partial results? Empty results mean the search query matched no coins or the API was temporarily rate-limited. The actor logs the reason and pushes nothing — you are not charged for empty runs. Check the warnings field and the actor's log for details.

Rate limits & API key

The public CoinGecko Demo API is free with no API key, but rate-limited to ~30 requests/minute. The actor handles 429 responses with exponential backoff automatically.

For higher throughput, provide a CoinGecko Pro API key via the apiKey input (marked secret, not logged). The actor injects it as the x-cg-pro-api-key header.

Competitor comparison

Scraper	Data source	Price model	parse_confidence	Notes
This actor	Official CoinGecko API	PPE $0.50/1K	yes	Stable schema, no proxy
coin-data-scraper (DOM)	HTML scraping	rental $15/mo	no	Breaks on redesigns
crypto-price-tracker (3rd-party API)	Unofficial endpoint	rental	no	ToS risk

Official API = zero fragility. The data structure does not change without notice. DOM scrapers break whenever CoinGecko redesigns their website. Every record carries parse_confidence (0.0–1.0) — not just on error rows, but on every record — so downstream pipelines can filter low-quality data automatically.

Integrations

Built for quant analysts and DeFi dashboard builders feeding live crypto prices and market-cap data into models — the JSON/dataset output drops into the tools you already run, no glue code:

• n8n / Make / Zapier — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: n8n, Make, Zapier.
• Webhooks — fire your own endpoint the moment a run finishes, to push results straight into your pipeline (docs).
• MCP server — expose this actor as a tool to Claude, Cursor, or any MCP client so an AI agent can pull this data mid-conversation (guide).
• API & SDKs — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all Apify integrations.

Not affiliated with CoinGecko

This actor uses CoinGecko's publicly documented API. It is not affiliated with, endorsed by, or sponsored by CoinGecko or its parent company.

Use with AI agents (MCP)

This actor is callable as a tool by AI agents (Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client) via Apify's hosted Model Context Protocol server. An agent uses it to look up live cryptocurrency prices, market caps, and market data mid-conversation — e.g. "what is Bitcoin's price right now?", "show me the top 10 coins by market cap", or "get me price and volume for ETH and SOL".

Point your MCP client at this tool:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=bovi/coingecko-scraper",
        "--header",
        "Authorization: Bearer <YOUR_APIFY_TOKEN>"
      ]
    }
  }
}

Minimal input an agent can send (keep maxItems low for fast, token-lean responses):

{ "mode": "markets", "vsCurrency": "usd", "maxItems": 10 }

Fetch specific coins by slug:

{ "mode": "coinIds", "coinIds": ["bitcoin", "ethereum", "solana"], "vsCurrency": "usd" }

Returns flat rows the agent can reason over directly:

{ "coin_id": "bitcoin", "symbol": "BTC", "name": "Bitcoin",
  "current_price_usd": 67420.0, "market_cap": 1328000000000,
  "market_cap_rank": 1, "total_volume": 29500000000,
  "price_change_24h_pct": 2.14, "circulating_supply": 19700000,
  "ath": 73738.0, "last_updated": "2026-06-03T10:00:00.000Z",
  "parse_confidence": 1.0, "warnings": [] }

Reliability for agents: data comes from CoinGecko's official public API (not HTML scraping), so rows don't break on site redesigns. Every row includes parse_confidence (0.0–1.0) and a machine-readable warnings list for agent-side quality checks. The free Demo API tier (~30 req/min) is sufficient for most agent calls — no API key required inside the tool, only your Apify token in the client config above.

Also in this finance family

• Yahoo Finance Scraper — stocks, ETFs, crypto, indices, forex
• Binance Scraper — spot prices + OHLCV klines for 3,500+ pairs
• Dexscreener Scraper — DEX pairs, on-chain token prices across 50+ chains
• DefiLlama Scraper — DeFi protocol TVL + yield pool APY
• ECB Exchange Rates Scraper — historical FX rates back to 1999

More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

• Credential Breach Checker
• Dexscreener Scraper
• Github Scraper
• Hacker News Scraper

Chain any of them together from the Integrations tab (the Run succeeded trigger) to build a multi-step workflow — one actor's output feeds the next.

Usage statistics

This Actor creates a small, content-free summary at the end of each run. It is used only to monitor reliability and improve this Actor. A copy is saved as USAGE_STATS in your own Apify key-value store, so you can see the exact record created for your run.

Set disableUsageStats to true in the input to opt out. Nothing is sent then; your USAGE_STATS record only says that statistics were disabled.

Only these fields are recorded:

• schema version, Actor name and build number;
• UTC start and finish hour (not a precise timestamp);
• run duration, number of results and time to the first result, each as a coarse range;
• whether the result was empty, the end status, and an error type from a fixed list;
• memory setting and counts of charged events;
• names of the input fields you set, never their values;
• the selected option for input fields that offer a fixed list of choices (for example a sort order).

We do not collect input text, search terms, URLs, domains, usernames, email addresses, names, proxy credentials, tokens, scraped records, output items, raw error messages, stack traces, or hashes of any of those values. Records are kept for no longer than 13 months, used only as aggregated operational statistics, and never sold or shared.

Additional fields (Phase 2)

This Actor also records your Apify user ID, whether Apify marks the account as paying, the size range of list inputs, the selected country when the input offers a fixed list of countries, and one category from a fixed Actor taxonomy. We use these fields only for aggregate reliability, repeat-use and cross-Actor analysis; reports suppress any cell with fewer than five distinct users.

The same disableUsageStats: true input flag turns these fields off too. The user ID is removed after 13 months; we do not export, sell, share, or attempt to re-identify this data.

Run-outcome signals (v2)

To learn whether a run did what it was asked to do, the record also holds a few more coarse ranges and yes/no flags. None of them contains content:

• the result limit you asked for (a range, when the input has one) and what share of it was delivered;
• results delivered per input item you listed (a range);
• output quality as ranges: how fully the result fields were filled, the share of rows that look like errors, the share of duplicate rows, and how many different fields appeared. These are counted in memory while results are saved; no result content is kept;
• how the run was started (console, API, schedule, webhook, another Actor);
• how it ended: stopped by you, timed out, reached the requested limit, stopped by the charge limit, and how many times the platform moved the run;
• if this Actor reports it: how many items to process worked or failed (ranges) and one failure reason from a fixed list;
• a short code made from the names of the input fields you set, never their values.

Repeat-run fingerprint (v2)

When your Apify user ID is recorded (see above), the record also holds an 8-character one-way code made from your input (proxy settings left out) and this Actor's name. It only lets us see that the same account ran the same input again soon after an unsatisfying run; we never see the input itself. It is stored only in the database, never published, and reports use it in aggregate with the same five-user minimum. It is the one exception to the statement above that no hashes are collected, and disableUsageStats: true turns it off.