# CoinGecko Scraper · Coin Prices, Market Caps & Exchanges (`reapx/coingecko-scraper`) Actor

Scrape CoinGecko coin prices, market caps, 24h volumes, supply and all-time highs in any of 63 quote currencies, plus the ranked exchange list with trust scores. Filter by category or specific coin ids. No login, no API key.

- **URL**: https://apify.com/reapx/coingecko-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.33 / 1,000 market record returneds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## CoinGecko Scraper · Coin Prices, Market Caps & Exchanges

**CoinGecko scraper** for live cryptocurrency market data: coin prices, market caps, 24-hour volumes, circulating and maximum supply, all-time highs and lows, and percentage change across six windows - in any of 63 quote currencies. It also pulls CoinGecko's ranked exchange list with trust scores. No login, no API key, no browser.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is
> inferred, modelled or filled in, and a field absent from the source is absent from the row.
> The extracted archive for this source is browsable at
> [reapx.dev/data/coingecko-scraper/](https://reapx.dev/data/coingecko-scraper/) and mirrored as an open dataset on
> [Hugging Face](https://huggingface.co/datasets/reapxdev/coingecko-scraper) and
> [Kaggle](https://www.kaggle.com/datasets/reapxdev/coingecko-scraper). Questions: reapxdev@proton.me

### What you get

One row per coin (or per exchange), with a stable `id` you can use as a primary key:

| Field | Example |
|---|---|
| `id` / `name` / `symbol` | bitcoin / Bitcoin / BTC |
| `currentPrice` / `vsCurrency` | 63456 / usd |
| `marketCap` / `marketCapRank` / `fullyDilutedValuation` | 1273247047393 / 1 / 1273247047393 |
| `totalVolume` / `high24h` / `low24h` | 15886580511 / 63701 / 62758 |
| `priceChangePercentage1h … 1y` | six windows: 1h, 24h, 7d, 14d, 30d, 1y |
| `circulatingSupply` / `totalSupply` / `maxSupply` | 20064906 / 20064906 / 21000000 |
| `ath` / `athDate` / `atl` / `atlDate` | 126080 / 2025-10-06 / 67.81 / 2013-07-05 |

Exchange rows carry `country`, `yearEstablished`, `trustScore`, `trustScoreRank` and `tradeVolume24hBtc`.

Four named views ship with the dataset: **Coin market data**, **Price performance**, **Supply and valuation** and **Exchanges**.

### Three ways to select coins

- **The whole market, ranked** - leave everything at its default for the top 250 by market cap
- **By category** - set a CoinGecko category id such as `layer-1`, `decentralized-finance-defi`, `meme-token`, `artificial-intelligence`, `gaming`, `stablecoins` or `real-world-assets-rwa`. There are 852 of them.
- **Specific coins** - list CoinGecko coin ids (`bitcoin`, `ethereum`, `solana`) to fetch exactly those

Order by market cap or 24-hour volume, ascending or descending.

### Rate limits are handled for you

CoinGecko's free public API allows roughly ten calls a minute and answers `429` with a `Retry-After` when you exceed it. This Actor paces its own requests, honours every `Retry-After`, and retries with backoff - so a large run slows down rather than failing. One request returns 250 records, so the default run costs a single call.

### Input configuration

Every field is optional. The prefilled values below are what runs if you press Start without changing anything.

#### What to pull

CoinGecko's public API is free and needs no key. It is rate limited to roughly ten calls a minute, which this Actor respects automatically.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `dataType` | string | `coins`, `exchanges` | Coin market data, or the ranked list of crypto exchanges. Each row is labelled with a recordType so a merged dataset stays readable. Prefilled with `"coins"`. |

#### Coin options

These apply when 'What to scrape' is set to Coins.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `vsCurrency` | string | free text | Currency all prices and market caps are denominated in. CoinGecko supports 63, including usd, eur, gbp, jpy, btc and eth. Prefilled with `"usd"`. |
| `category` | string | free text | Restrict to one CoinGecko category, using its id. Examples: layer-1, decentralized-finance-defi, meme-token, artificial-intelligence, gaming, stablecoins, real-world-assets-rwa. Leave empty for the whole market. |
| `coinIds` | list | one value per line | CoinGecko coin ids, one per line, to fetch exactly those coins instead of a ranked page. Examples: bitcoin, ethereum, solana. When set, the category and ordering below are ignored. |
| `order` | string | one of 5: `market_cap_desc`, `market_cap_asc`, `volume_desc`, `volume_asc`, ... | How the ranked page is sorted before it is returned. Prefilled with `"market_cap_desc"`. |

#### Size and pacing

CoinGecko serves 250 records per request. Larger runs page automatically, pausing between requests to stay inside the free tier's limit.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `maxItems` | integer | 1 to 20000 | Hard stop on how many records are returned and charged. Each record costs $0.0005. 250 records is one request and finishes in seconds. Prefilled with `250`. |
| `requestDelaySecs` | integer | 3 to 60 | Seconds to wait between requests to CoinGecko. The free public tier allows roughly ten calls a minute, so 6 is a safe floor and 3 is the minimum this Actor allows. Raise it if you are running several jobs at once. Prefilled with `6`. |

### Pricing

Pay per event. The primary event is **Market record returned** (`market-record`), charged at **$0.0005 per event** on the free plan, falling to $0.00021 on the highest tier.

Charged once for each CoinGecko record delivered as a complete row: for a coin, its price, market cap, rank, volume, supply, all-time high and low and six price-change windows; for an exchange, its trust score, country, launch year and BTC-denominated volume. Queries that match nothing, rate-limited requests that never return and blocked requests are never charged.

Other charged events: `apify-actor-start` (Actor Start).

Minimum charge cap per run: $0.005.

Tiered discounts apply automatically on every paid Apify plan. Platform usage is absorbed by the Actor, so the per-event price is the whole price.

### Usage examples

#### The prefilled run, which is what Start does with nothing changed

```json
{
  "dataType": "coins",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6
}
```

#### What to scrape

```json
{
  "dataType": "exchanges",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6
}
```

#### Filter by quote currency

```json
{
  "dataType": "coins",
  "vsCurrency": "eur",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6
}
```

#### Filter by category

```json
{
  "dataType": "coins",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6,
  "category": "layer-1"
}
```

#### Filter by specific coins

```json
{
  "dataType": "coins",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6,
  "coinIds": [
    "bitcoin",
    "ethereum"
  ]
}
```

### Output example

One row, exactly as the actor wrote it to the dataset:

```json
{
  "recordType": "coin",
  "id": "bitcoin",
  "name": "Bitcoin",
  "symbol": "BTC",
  "url": "https://www.coingecko.com/en/coins/bitcoin",
  "imageUrl": "https://coin-images.coingecko.com/coins/images/1/large/bitcoin.png?1696501400",
  "vsCurrency": "usd",
  "category": null,
  "currentPrice": 62779,
  "marketCap": 1259672740700,
  "marketCapRank": 1,
  "fullyDilutedValuation": 1259672740700,
  "totalVolume": 15917503515,
  "high24h": 63701,
  "low24h": 62713,
  "priceChange24h": -652.707541990836,
  "priceChangePercentage1h": 0,
  "priceChangePercentage24h": -1.2
}
```

That row carries 43 fields in total; 18 are shown.

#### Fields on every row

| Field | Type | What it is |
| --- | --- | --- |
| `recordType` | string | Which kind of record this row is. Coin rows carry market data; exchange rows carry venue data. Use the named views to see one at a time. |
| `id` | string | Stable CoinGecko identifier - the coin id or the exchange id. Unique per record and safe to use as a primary key. |
| `name` | string | Display name of the coin or exchange. |
| `symbol` | string | Ticker symbol, upper-cased. Coin rows only. |
| `url` | string | CoinGecko page for the coin, or the exchange's own website. |
| `imageUrl` | string | Logo image for the coin or exchange. |
| `vsCurrency` | string | Currency every price and market-cap figure on this row is denominated in. Coin rows only. |
| `category` | string | CoinGecko category the run filtered on, when one was set. Coin rows only. |
| `currentPrice` | number | Latest price in the quote currency. |
| `marketCap` | number | Market capitalisation in the quote currency. |
| `marketCapRank` | integer | Rank by market capitalisation, 1 being the largest. |
| `fullyDilutedValuation` | number | Valuation if the maximum supply were in circulation. |
| `totalVolume` | number | Total traded volume over the last 24 hours, in the quote currency. |
| `high24h` | number | Highest price in the last 24 hours. |
| `low24h` | number | Lowest price in the last 24 hours. |
| `priceChange24h` | number | Absolute price change over the last 24 hours. |
| `priceChangePercentage1h` | number | Percentage price change over the last hour. |
| `priceChangePercentage24h` | number | Percentage price change over the last 24 hours. |
| `priceChangePercentage7d` | number | Percentage price change over the last 7 days. |
| `priceChangePercentage14d` | number | Percentage price change over the last 14 days. |
| `priceChangePercentage30d` | number | Percentage price change over the last 30 days. |
| `priceChangePercentage1y` | number | Percentage price change over the last year. |
| `marketCapChange24h` | number | Absolute market cap change over the last 24 hours. |
| `marketCapChangePercentage24h` | number | Percentage market cap change over the last 24 hours. |
| `circulatingSupply` | number | Units currently in circulation. |
| `totalSupply` | number | Total units that exist. |
| `maxSupply` | number | Hard cap on units that can ever exist, when the asset has one. |
| `ath` | number | Highest price ever recorded, in the quote currency. |
| `athChangePercentage` | number | Percentage below the all-time high. |
| `athDate` | string | When the all-time high was set, ISO 8601. |
| `atl` | number | Lowest price ever recorded, in the quote currency. |
| `atlChangePercentage` | number | Percentage above the all-time low. |
| `atlDate` | string | When the all-time low was set, ISO 8601. |
| `lastUpdated` | string | When CoinGecko last refreshed this coin, ISO 8601. |
| `country` | string | Country the exchange is registered in. Exchange rows only. |
| `yearEstablished` | integer | Year the exchange launched. Exchange rows only. |
| `trustScore` | integer | CoinGecko trust score, 1 to 10. Exchange rows only. |
| `trustScoreRank` | integer | Rank by trust score, 1 being the highest. Exchange rows only. |
| `tradeVolume24hBtc` | number | Exchange trading volume over 24 hours, denominated in BTC. Exchange rows only. |
| `hasTradingIncentive` | true/false | True when the exchange runs a trading incentive scheme. Exchange rows only. |
| `description` | string | CoinGecko description of the exchange. Exchange rows only. |
| `sourceQuery` | string | The resolved query that produced this row, so a merged dataset stays traceable. |
| `scrapedAt` | string | When this Actor read the row from CoinGecko, ISO 8601. |

4 named dataset views ship with it: **Coin market data**, **Price performance**, **Supply and valuation**, **Exchanges**. They drive the Output tab in Console and the Output block on the Actor's `.md` page.

### FAQ

#### Do I need a CoinGecko API key?

No. This Actor uses the free public endpoints, which need no key and no account.

#### Which quote currencies are supported?

63, including usd, eur, gbp, jpy, chf, aud, cad, inr, brl, and crypto quotes such as btc, eth and sol.

#### How do I find a category id?

CoinGecko publishes them at `/api/v3/coins/categories/list`. The id is the slug form, for example `artificial-intelligence` or `real-world-assets-rwa`.

#### How many coins can I get in one run?

Up to 20,000. Records come back 250 per request, and the Actor pages automatically with pacing that stays inside the free tier.

#### How fresh are the prices?

Read live on every run. Each coin row carries `lastUpdated`, CoinGecko's own refresh timestamp for that asset.

#### Can I use this from an AI agent?

Yes. The dataset schema types and documents every field, so the output chains directly into agent workflows through the Apify MCP server.

***

Unofficial - not affiliated with CoinGecko. Collects public data only. reapx. Contact reapxdev@proton.me.

### The full published archive

- **[coingecko scraper archive](https://reapx.dev/data/coingecko-scraper/)** — every entity this Actor has observed
- **[All reapx datasets](https://reapx.dev/data/)** — 20 sources, tens of thousands of pages
- **[llms.txt](https://reapx.dev/llms.txt)** · **[feed.json](https://reapx.dev/feed.json)** ·
  **[feed.xml](https://reapx.dev/feed.xml)** — the machine-readable index, for agents

Each archive page carries Dataset JSON-LD, a canonical URL and the identifiers used, so an agent
can resolve an entity without running anything. Nothing on those pages is estimated or modelled.

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "dataType": "coins",
  "vsCurrency": "usd",
  "category": "",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ],
  "order": "market_cap_desc",
  "maxItems": 10,
  "requestDelaySecs": 6
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "recordType": "coin",
  "id": "bitcoin",
  "name": "Bitcoin",
  "symbol": "BTC",
  "url": "https://www.coingecko.com/en/coins/bitcoin",
  "imageUrl": "https://coin-images.coingecko.com/coins/images/1/large/bitcoin.png?1696501400",
  "vsCurrency": "usd",
  "category": null,
  "currentPrice": 62779,
  "marketCap": 1259672740700,
  "marketCapRank": 1,
  "fullyDilutedValuation": 1259672740700,
  "totalVolume": 15917503515,
  "high24h": 63701,
  "low24h": 62713,
  "priceChange24h": -652.707541990836,
  "priceChangePercentage1h": 0,
  "priceChangePercentage24h": -1.2,
  "priceChangePercentage7d": -3.8,
  "priceChangePercentage14d": -2.7,
  "priceChangePercentage30d": 0.2,
  "priceChangePercentage1y": -44.7,
  "marketCapChange24h": -13067311659.914795,
  "marketCapChangePercentage24h": -1.02671,
  "circulatingSupply": 20065062,
  "totalSupply": 20065062,
  "maxSupply": 21000000,
  "ath": 126080,
  "athChangePercentage": -50.20664,
  "athDate": "2025-10-06T10:57:42.000Z",
  "atl": 67.81,
  "atlChangePercentage": 92482.70928,
  "atlDate": "2013-07-05T16:00:00.000Z",
  "lastUpdated": "2026-08-03T06:15:30.000Z",
  "country": null,
  "yearEstablished": null,
  "trustScore": null,
  "trustScoreRank": null,
  "tradeVolume24hBtc": null,
  "hasTradingIncentive": null,
  "description": null,
  "sourceQuery": "coins=bitcoin,ethereum in USD by market_cap_desc",
  "scrapedAt": "2026-08-03T06:17:26Z"
}
```

### How it works

1. You set the filters below, or none at all.
2. The Actor calls the source's own public endpoint and pages through the results.
3. Every row is pushed to the dataset **as it is built**, not buffered to the end — so a
   run that hits its time limit still returns everything it collected up to that point.
4. You are charged per row returned, so the maximum-results field is also your cost cap.

### 💬 Your feedback

Found a bug, or need a field this does not return yet? Open an issue on the Actor's **Issues**
tab, or write to **reapxdev@proton.me**. Bugs get fixed and reasonable field requests get
added.

# Actor input Schema

## `dataType` (type: `string`):

Coin market data, or the ranked list of crypto exchanges. Each row is labelled with a recordType so a merged dataset stays readable.<br><br>Options: <code>coins</code>, <code>exchanges</code>.

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

Currency all prices and market caps are denominated in. CoinGecko supports 63, including usd, eur, gbp, jpy, btc and eth.<br><br>Leave this field empty to skip this filter.

## `category` (type: `string`):

Restrict to one CoinGecko category, using its id. Examples: layer-1, decentralized-finance-defi, meme-token, artificial-intelligence, gaming, stablecoins, real-world-assets-rwa. Leave empty for the whole market.

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

CoinGecko coin ids, one per line, to fetch exactly those coins instead of a ranked page. Examples: bitcoin, ethereum, solana. When set, the category and ordering below are ignored.<br><br>Leave this field empty to include every option.

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

How the ranked page is sorted before it is returned.<br><br>Options: <code>market\_cap\_desc</code>, <code>market\_cap\_asc</code>, <code>volume\_desc</code>, <code>volume\_asc</code>, <code>id\_asc</code>.

## `maxItems` (type: `integer`):

Hard stop on how many records are returned and charged. Each record costs $0.0005. 250 records is one request and finishes in seconds.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `requestDelaySecs` (type: `integer`):

Seconds to wait between requests to CoinGecko. The free public tier allows roughly ten calls a minute, so 6 is a safe floor and 3 is the minimum this Actor allows. Raise it if you are running several jobs at once.

## Actor input object example

```json
{
  "dataType": "exchanges",
  "vsCurrency": "eur",
  "category": "layer-1",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ],
  "order": "volume_desc",
  "maxItems": 1000,
  "requestDelaySecs": 10
}
```

# Actor output Schema

## `coins` (type: `string`):

Price, market cap, rank and 24h movement - the columns most runs are read for.

## `performance` (type: `string`):

Percentage change across every window, for momentum and drawdown analysis.

## `supply` (type: `string`):

Circulating, total and maximum supply against market cap and fully diluted valuation.

## `exchanges` (type: `string`):

Venue data: trust score, country, launch year and BTC-denominated volume.

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

Every record this run produced, with all fields and no view applied. Field-level titles, types, descriptions and examples are declared in the dataset schema.

# 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 = {
    "dataType": "coins",
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "maxItems": 250,
    "requestDelaySecs": 6
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/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 = {
    "dataType": "coins",
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "maxItems": 250,
    "requestDelaySecs": 6,
}

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

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

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

```

## CLI example

```bash
echo '{
  "dataType": "coins",
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 250,
  "requestDelaySecs": 6
}' |
apify call reapx/coingecko-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/f9AVg4gdNWIuj67DB/builds/zOTklFgrP8BLEMEJW/openapi.json