# CoinGecko Scraper \[Only $0.4💰] | 18k Coins | Market Data (`ahmed_jasarevic/coingecko-scraper`) Actor

Get CoinGecko market data for 18,000+ cryptocurrencies without an API key. Prices, market cap, FDV, volume, 24h/7d change, ATH/ATL and supply via the official CoinGecko API — clean datasets for market research, altcoin screening, price monitoring and crypto dashboards, from $0.0004 per result.

- **URL**: https://apify.com/ahmed\_jasarevic/coingecko-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.37 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## CoinGecko Scraper — Full Crypto Market Data via the Official Public API

Pull CoinGecko market data for all ~18,000 coins and tokens **without an API key**: prices, market cap, FDV, 24h volume, 24h/7d change, ATH/ATL and supply metrics in one clean dataset, priced from **$0.0004 per result**. One actor, four modes (`markets`, `trending`, `coin-details`, `categories`) — plain HTTP against CoinGecko's own official public API, so there is no Cloudflare wall, no browser, and no key to manage.

### Main Use Cases

- **Crypto market tracking** — capture hourly or daily market snapshots of price, market cap, volume and supply across 18,000+ coins.
- **Altcoin market screening** — sort by market cap or 24h volume, cap the results to the top N, and spot 24h/7d movers for altcoin research.
- **Token-listing & category monitoring** — watch trending coins and category-level market data to catch shifts in market attention early.
- **Crypto market research & datasets** — build clean, structured datasets for research, backtesting, dashboards and ML/analytics pipelines.
- **Newsletter, affiliate & content data** — fresh price tables and market stats for crypto newsletters, comparison pages and affiliate content.
- **Portfolio & academic analytics** — uniform valuation and supply metrics (FDV, ATH/ATL, circulating/total/max supply) for portfolio analytics and academic studies.

### How It Works — Get Crypto Market Data Without a CoinGecko API Key

This actor queries **CoinGecko's official public API** (`https://api.coingecko.com/api/v3`) — the same data that powers coingecko.com. The keyless public API needs no key, no sign-up and returns clean JSON, so the actor never has to fight Cloudflare, render a page, or solve a CAPTCHA.

The run is plain HTTP: market pages are fetched in parallel (up to 10 concurrent requests), paced by a global rate limiter (default 15 requests/min) with automatic backoff on HTTP 429. Every coin, trending entry or category is pushed as one structured row to an Apify dataset which you can download as **JSON, CSV, Excel, XML or HTML** — or consume via the Apify API.

### Track All 18k Coins or Just the Top N

In `markets` mode the actor pages through CoinGecko's `/coins/markets` endpoint — the full market snapshot. Set `maxCoins` to scrape everything (up to 20,000) or just the top N: top 100, top 250, top 1,000. `perPage` controls page size (max 250) and `order` lets you sort by market cap, volume, gecko score or coin ID. Free-plan runs are capped at a 10-coin preview.

Each row carries price, market cap, rank, FDV, 24h volume, 24h high/low, 24h/7d price change, ATH/ATL (with change % and dates), circulating/total/max supply, a 7-day sparkline, and a link to the coin's page.

### Monitor Trending Coins & Categories

Three more modes cover the rest of the market's attention:

- **`trending`** — pulls CoinGecko's `/search/trending` list: the most-searched coins right now, with trending score, price, 24h change, market cap, volume and sparkline image.
- **`categories`** — pulls every CoinGecko category (`/coins/categories`): category market cap, 24h change, 24h volume and the top 3 coins per sector (DeFi, AI, meme, Layer-1 and more).
- **`coin-details`** — full detail for specific coin IDs via `/coins/{id}`, including the coin's **categories** field — ideal when you need deep data for a small watchlist.

### Input Parameters

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `mode` | enum | No\* | `markets` | `markets` (all coins, paged) · `trending` · `coin-details` (by ID) · `categories`. \*Defaults to `markets` if omitted. |
| `coinIds` | array | For `coin-details` | — | CoinGecko coin IDs (slugs), e.g. `["bitcoin","ethereum","solana"]`. Find IDs in `/coins/list` or from the coin URL. |
| `vsCurrency` | string | No | `usd` | Quote currency: `usd`, `eur`, `btc`, `eth`, … |
| `order` | enum | No | `market_cap_desc` | `markets` mode sort: market cap / volume (asc, desc), gecko score, coin ID. |
| `perPage` | integer | No | `100` | Coins per API page in `markets` mode (min 1, max 250). |
| `maxCoins` | integer | No | `1000` | Max coins/rows to scrape (max 20,000). Free users are capped at 10. |
| `includeSparkline` | boolean | No | `true` | Include the 7-day price sparkline (~168 points) per coin. |
| `includeCategories` | boolean | No | `false` | `markets` mode: also fetch each coin's categories — costs **1 extra API call per coin** via `/coins/{id}`. |
| `requestsPerMinute` | integer | No | `0` (auto → 15/min) | Rate limit for CoinGecko calls (max 600). The actor backs off automatically on 429. |
| `proxy` | object | No | off | Standard Apify proxy picker — **not needed**, the public API is not blocked. |

### Dataset Output Fields

Market rows (`markets` and `coin-details` modes) — one coin per row:

| Field | Description |
|---|---|
| `coinId` / `name` / `symbol` | CoinGecko coin ID (slug), display name, ticker symbol |
| `priceUsd` | Current price in `vsCurrency` |
| `marketCapUsd` / `marketCapRank` | Market capitalization and rank |
| `fullyDilutedValuationUsd` | Fully diluted valuation (FDV) |
| `totalVolume24hUsd` | 24-hour trading volume |
| `high24hUsd` / `low24hUsd` | 24h high / low |
| `priceChange24hUsd` / `priceChangePercentage24h` | Absolute and % 24h price change |
| `priceChangePercentage7d` | 7-day price change % |
| `athUsd` / `athChangePercentage` / `athDate` | All-time high, change % and date |
| `atlUsd` / `atlChangePercentage` / `atlDate` | All-time low, change % and date |
| `circulatingSupply` / `totalSupply` / `maxSupply` | Supply metrics |
| `categories` | Coin category tags (present in `coin-details` mode, or `markets` with `includeCategories: true`) |
| `sparkline7d` | 7-day price sparkline array (~168 points, when `includeSparkline`) |
| `coinDetailUrl` | Link to the coin's page on coingecko.com |
| `imageUrl` | Coin logo image URL |
| `lastUpdated` | Timestamp of the source data |

`trending` rows add `trendingScore` (position in the trending list) and `sparklineUrl` (sparkline image). `categories` rows use `categoryId`, `name`, `marketCapUsd`, `marketCapChange24h`, `volume24hUsd`, `top3Coins`.

### Example Input

Full market snapshot (top 1,000 coins with sparklines):

```json
{
  "mode": "markets",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "perPage": 100,
  "maxCoins": 1000,
  "includeSparkline": true,
  "includeCategories": false,
  "requestsPerMinute": 15
}
```

Minimal run (trending coins):

```json
{ "mode": "trending" }
```

### Example Output

One row from `markets` mode (values are illustrative):

```json
{
  "coinId": "bitcoin",
  "name": "Bitcoin",
  "symbol": "BTC",
  "priceUsd": 81152,
  "marketCapUsd": 1629885248066,
  "marketCapRank": 1,
  "fullyDilutedValuationUsd": 1629886708649,
  "totalVolume24hUsd": 41086727099,
  "high24hUsd": 81675,
  "low24hUsd": 77934,
  "priceChange24hUsd": 3503.87,
  "priceChangePercentage24h": 4.51,
  "priceChangePercentage7d": 5.04,
  "athUsd": 126080,
  "athChangePercentage": -35.63,
  "athDate": "2025-10-06T10:57:42.000Z",
  "atlUsd": 67.81,
  "atlChangePercentage": 119577.33,
  "atlDate": "2013-07-05T16:00:00.000Z",
  "circulatingSupply": 20086450,
  "totalSupply": 20086493,
  "maxSupply": 21000000,
  "sparkline7d": [77257.6, 77342.5, 77320.1],
  "categories": ["Cryptocurrency", "Layer 1"],
  "coinDetailUrl": "https://www.coingecko.com/en/coins/bitcoin",
  "imageUrl": "https://coin-images.coingecko.com/coins/images/1/large/bitcoin.png",
  "lastUpdated": "2026-09-19T08:09:10.000Z"
}
```

`categories` is included when data comes from `coin-details` mode or from `markets` with `includeCategories: true`.

### Integrations, Schedules & Automation

- **Apify API** — start runs and fetch dataset items programmatically via the [Apify REST API](https://docs.apify.com/platform/api).
- **Schedules** — recommend a **daily** run for market-cap ranking snapshots, or an **hourly** run for price monitoring. Recurring runs also improve your Apify Store recommendations.
- **Webhooks** — trigger downstream pipelines (Slack alerts, databases) when a run finishes.
- **Zapier / Make / n8n** — wire the actor into automation flows through Apify's integration suite.
- **Export** — download the dataset as JSON, CSV, Excel, XML or HTML, or connect it to your own app.

### Related Actors & Alternative Data Sources

Crypto market data is a busy cluster on Apify — here are the most relevant companions:

- [🪙 Crypto Intelligence - CoinGecko Market Data](https://apify.com/benthepythondev/crypto-intelligence) — the most-used CoinGecko actor (10,000+ coins, historical charts)
- [CoinGecko](https://apify.com/real1ty/coingecko) — detailed per-coin CoinGecko scraping
- [CoinMarketCap Crypto Scraper](https://apify.com/louisdeconinck/coinmarketcap-crypto-scraper) — the top CoinMarketCap cluster actor
- [Binance Price Scraper](https://apify.com/crawlerbros/binance-price-scraper) — OHLCV candlestick data from Binance
- [CoinGecko Crypto Scraper — Prices, Market Cap & Coin Data](https://apify.com/sian.agency/coingecko-crypto-scraper) — keyless CoinGecko alternative

### FAQ

#### Is there a free CoinGecko API?

Yes. CoinGecko's **keyless public API** (`https://api.coingecko.com/api/v3`) requires no key or sign-up and is documented by CoinGecko itself. It is rate-limited to roughly 10–30 calls/minute (dynamic) and intended for prototyping and low-frequency use. This actor handles the pacing, retries and pagination for you and packages the data into a clean Apify dataset.

#### Why use this actor if CoinGecko already has a public API?

You skip the engineering: no rate-limit coding, no backoff logic, no pagination, no API-key management. You get scheduled runs (hourly/daily) with a data history, dataset export in JSON/CSV/Excel, webhooks, and integration with n8n/Make/Zapier — while CoinGecko's own docs recommend a keyed plan before the keyless API is used for production polling. This actor is the keyless way to run scheduled market snapshots on Apify.

#### Is it free to use?

No — this actor is pay-per-event: **$0.0004 per result** (one dataset row) plus **$0.00005 per run start**, with no free events. A 1,000-coin market snapshot is roughly **$0.40**. Free Apify users get a capped preview of 10 coins per run.

#### How current is the data?

Near-real-time. CoinGecko caches API responses for roughly 1–5 minutes, so prices and market caps refresh within a few minutes — not tick-level data.

#### What are the keyless API rate limits?

The keyless public API allows ~10–30 calls/minute, dynamically. The actor defaults to 15 requests/minute with automatic backoff on HTTP 429 (it doubles the interval up to 60s). Raise or lower the pace with `requestsPerMinute`.

#### What are the four modes?

`markets` — paged snapshot of all coins with full market data · `trending` — the current trending coins list · `coin-details` — full per-coin detail (including categories) for specific coin IDs · `categories` — category-level market data with top 3 coins per sector.

#### Is it legal to scrape CoinGecko data with this actor?

The actor uses only CoinGecko's **official public API** — no login bypass, no CAPTCHA solving, no private or restricted data. Review CoinGecko's [API terms of service](https://www.coingecko.com/en/terms) before large-scale or commercial use; you are responsible for your own compliance.

#### Can I get historical price data?

The actor returns current snapshots plus a 7-day sparkline per coin. For deeper history, schedule it (daily/hourly) and accumulate snapshots. Historical chart endpoints are not part of this actor's scope.

### SEO Keywords

coingecko api, coingecko api free, coingecko public api, coingecko alternative, crypto market data, crypto market data api, cryptocurrency market data, crypto price data, crypto prices api, cryptocurrency market cap, crypto market cap ranking, top 100 cryptocurrencies, altcoin market data, altcoin screener, crypto screener, trending coins, trending crypto, bitcoin price data, meme coin tracker, meme coin prices, stablecoin market cap, defi token data, ai crypto tokens, cryptocurrency dataset, crypto research data

### For AI Agents & LLM Apps

**Purpose:** returns CoinGecko coin/token market data (price, market cap, FDV, volume, 24h/7d change, ATH/ATL, supply, 7-day sparkline, categories, trending lists) as JSON rows in an Apify dataset, via CoinGecko's keyless official public API.

**Minimal working input:**

```json
{ "mode": "trending" }
```

**Variant inputs:**

```json
{ "mode": "markets", "maxCoins": 10, "vsCurrency": "usd", "includeSparkline": false }
```

```json
{ "mode": "coin-details", "coinIds": ["bitcoin", "ethereum", "solana"], "maxCoins": 10 }
```

**Output fields:** `coinId`, `name`, `symbol`, `priceUsd`, `marketCapUsd`, `marketCapRank`, `fullyDilutedValuationUsd`, `totalVolume24hUsd`, `high24hUsd`, `low24hUsd`, `priceChange24hUsd`, `priceChangePercentage24h`, `priceChangePercentage7d`, `athUsd`, `athChangePercentage`, `athDate`, `atlUsd`, `atlChangePercentage`, `atlDate`, `circulatingSupply`, `totalSupply`, `maxSupply`, `sparkline7d`, `categories`, `coinDetailUrl`, `imageUrl`, `lastUpdated`. `trending` rows add `trendingScore` and `sparklineUrl`; `categories` rows use `categoryId`, `marketCapUsd`, `marketCapChange24h`, `volume24hUsd`, `top3Coins`.

**Behaviors an agent should know:**

- `mode` selects the data source (enum: `markets` | `trending` | `coin-details` | `categories`). Omitted → defaults to `markets`.
- `coinIds` are CoinGecko slugs (e.g. `"bitcoin"`) and are required for `coin-details` mode.
- `includeCategories: true` in `markets` mode adds **one extra API call per coin** (via `/coins/{id}`) and effectively doubles the billed cost per coin — prefer `coin-details` for small sets.
- `maxCoins` defaults to 1000; free-plan runs are capped at **10 coins** in any mode.
- `perPage` is capped at 250 (CoinGecko page-size limit).
- The keyless API is rate-limited to ~10–30 calls/min; the actor uses 15/min by default (`requestsPerMinute`) and auto-backs-off on 429.
- CoinGecko caches market data for ~1–5 minutes, so repeated runs within that window return similar values.
- **Billing model:** pay-per-event — $0.0004 per result (dataset row) + $0.00005 per run start.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by CoinGecko**. CoinGecko and coingecko.com are properties of their respective owners.

The actor accesses only CoinGecko's **official public API** (`https://api.coingecko.com/api/v3`) using publicly available, keyless endpoints — it performs no login bypass, no CAPTCHA solving, and does not access private or restricted data.

Users are responsible for their own compliance with CoinGecko's API Terms of Service and applicable data-protection law when using or redistributing the data. Nothing here is financial advice.

# Actor input Schema

## `mode` (type: `string`):

What to scrape: 'markets' = all coins with full market data (paged), 'trending' = top trending coins, 'coin-details' = full detail + categories for specific coin IDs, 'categories' = all CoinGecko categories with market data.

## `coinIds` (type: `array`):

CoinGecko coin IDs (e.g. bitcoin, ethereum, solana) — used in 'coin-details' mode. Find IDs via the CoinGecko API /coins/list or from the coin URL slug.

## `vsCurrency` (type: `string`):

The currency prices/market caps are quoted in (e.g. usd, eur, btc, eth).

## `order` (type: `string`):

How to sort coins in 'markets' mode.

## `perPage` (type: `integer`):

Number of coins per API page in 'markets' mode (max 250).

## `maxCoins` (type: `integer`):

Maximum number of coins to scrape. Free users are capped at 10.

## `includeSparkline` (type: `boolean`):

Include the 7-day price sparkline (array of ~168 price points) for each coin.

## `includeCategories` (type: `boolean`):

In 'markets' mode, also fetch each coin's categories (requires one extra API call per coin via /coins/{id}).

## `requestsPerMinute` (type: `integer`):

Rate limit for API calls. Defaults to 15/min. Lower it if you hit 429 errors, raise it if CoinGecko allows.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "mode": "markets",
  "coinIds": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "perPage": 100,
  "maxCoins": 1000,
  "includeSparkline": true,
  "includeCategories": false,
  "requestsPerMinute": 0,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "markets",
    "coinIds": [
        "bitcoin",
        "ethereum",
        "solana"
    ],
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "perPage": 100,
    "maxCoins": 1000,
    "includeSparkline": true,
    "includeCategories": false,
    "requestsPerMinute": 0,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/coingecko-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "markets",
    "coinIds": [
        "bitcoin",
        "ethereum",
        "solana",
    ],
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "perPage": 100,
    "maxCoins": 1000,
    "includeSparkline": True,
    "includeCategories": False,
    "requestsPerMinute": 0,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/coingecko-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "markets",
  "coinIds": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "perPage": 100,
  "maxCoins": 1000,
  "includeSparkline": true,
  "includeCategories": false,
  "requestsPerMinute": 0,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/coingecko-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/coingecko-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/X3B9jT1hszXvcejpL/builds/1u1VZeeiNVz8JGisJ/openapi.json