# CoinGecko Scraper (`dami_studio/coingecko-scraper`) Actor

CoinGecko scraper for crypto prices and rankings: the top coins by market cap, one category, or the ids you name. Each row holds price, market cap, rank, 24h volume, 24h and 7d change, supply, all-time high and low. Coin ids are slugs, not tickers: BNB is binancecoin. $2.00 per 1,000 coins.

- **URL**: https://apify.com/dami_studio/coingecko-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Integrations, AI, Other
- **Features:** Limited permissions
- **Stats:** 8 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.94 / 1,000 coins

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 for crypto prices and rankings, as rows**: the top of the market by market cap, a coin
looked up by name or symbol, or exactly the coins you name. Each row carries price, market cap, rank,
24 hour volume, 24 hour and 7 day change, circulating supply, all-time high and low, the logo and the
CoinGecko page link.

It is a snapshot of right now. No candles, no history, nothing older than the moment the run
executed. And the data describes the market; it is not advice about it.

| | |
|---|---|
| **Input** | A mode, plus a search term, a list of coin ids, or a category |
| **Output** | One row per coin: price, market cap, rank, 24h volume, 24h and 7d change, supply, all-time high and low, logo, link |
| **Ceiling** | 5,000 coins per run in Markets mode |
| **Account needed** | None, and no API key |
| **Price** | $2.00 per 1,000 coins on the Free plan, a little less on paid plans. The free plan's $5 a month covers about 2,500 |

### 🔍 What CoinGecko Scraper does

Three modes, and picking the wrong one is the usual reason a row looks thin:

| Mode | What it returns | Fields |
|---|---|---|
| `markets` | The top coins ranked by market cap, or by volume or id, from everything or from one category | the full row |
| `search` | Coins matching a name or symbol | id, name, symbol, rank, image, url. **No prices** |
| `coins` | Exactly the ids you name | the full row |

`search` is how you find a coin's id when you do not know it. Take the `id` from the search row and
feed it into `coins` mode for the numbers.

Prices are quoted in whatever `vsCurrency` you set, so the same coin can come back in `usd`, `eur`
or `btc`.

### 📋 What data you get from each coin

| What you get | Field |
|---|---|
| CoinGecko's id for the coin, its symbol and name | `id`, `symbol`, `name` |
| Price, market cap and rank | `price`, `marketCap`, `marketCapRank` |
| Volume over the last 24 hours | `volume24h` |
| Price change over 24 hours and 7 days | `change24hPct`, `change7dPct` |
| Coins in circulation | `circulatingSupply` |
| All-time high with its date, and all-time low | `ath`, `athDate`, `atl` |
| The logo and the CoinGecko page | `image`, `url` |

### ▶️ How to scrape CoinGecko

1. Open [CoinGecko Scraper](https://apify.com/dami_studio/coingecko-scraper) and click
   **Try for free**.
2. Pick a **Mode**. `markets` for the leaderboard, `search` to find an id, `coins` for a watchlist.
3. Set **Quote currency**, then fill the box your mode uses: **Search query** or **Coin ids**.
4. In Markets mode set **Max coins**, then click **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it from the Apify API.

### 💰 How much does it cost to scrape CoinGecko?

**$2.00 per 1,000 coins** on the Free plan. Paid plans pay a little less: $1.98 on Starter, $1.96 on Scale and $1.94 on Business. On the free plan, the $5 Apify
gives you each month covers about 2,500 coins.

You pay per coin row delivered. Duplicate ids are dropped before they reach you, diagnostic rows are
not charged, and if nothing matches, no rows are charged. A `search` row costs the same as a full row
even though it carries fewer fields, so use `search` to find ids and `coins` to pull the numbers. Set
a maximum cost on the run and it stops when it gets there.

### 📥 What you give it

```json
{
  "mode": "markets",
  "vsCurrency": "usd",
  "maxItems": 100
}
```

| Field | Default | What it is |
|---|---|---|
| `mode` | `markets` | `markets`, `search` or `coins`. **Lower case only**, `Markets` is rejected. |
| `vsCurrency` | `usd` | What prices, market cap and volume are quoted in. `usd`, `eur`, `gbp`, `btc`, `eth` and the rest. Used by `markets` and `coins`. |
| `query` | none, the form starts with `solana` | A coin name or symbol. `search` mode only. |
| `coinIds` | none, the form starts with `bitcoin` and `ethereum` | CoinGecko ids, which are the slugs in a coin's CoinGecko URL. `coins` mode only. |
| `category` | none | Only the coins CoinGecko files under one category, by the id at the end of its CoinGecko page (`meme-token`, `layer-1`) or the name that page shows (`Meme`). `markets` mode only. An unknown category is refused before any coin is read. |
| `order` | `market_cap_desc` | `market_cap_desc`, `market_cap_asc`, `volume_desc`, `volume_asc`, `id_asc` or `id_desc`. In `markets` mode the run takes the first `maxItems` coins in this order. Works in `coins` mode too. |
| `maxItems` | `100` | Coins to return in `markets` mode, up to 5,000. |
| `notionConnector` | none | Optional. Writes every coin into your own Notion as well as the dataset. |
| `notionParentId` | none | Optional. The Notion data source to write into. |
| `proxyConfiguration` | off | Optional, and off by default because a normal run does not need it. |

**Keep `coinIds` lists modest.** A long list goes to CoinGecko in one request and can come back
shorter than you asked for, with the missing coins simply absent. Split a big list across runs and
count the rows.

### 📤 What you get back

A real row from a run on 2 October 2026:

```json
{
  "ok": true,
  "id": "bitcoin",
  "symbol": "BTC",
  "name": "Bitcoin",
  "price": 84513,
  "marketCap": 1698078115337,
  "marketCapRank": 1,
  "volume24h": 45537287109,
  "change24hPct": -0.18692,
  "change7dPct": 0.8945,
  "circulatingSupply": 20092587,
  "ath": 126080,
  "athDate": "2025-10-06T10:57:42.000Z",
  "atl": 67.81,
  "image": "https://coin-images.coingecko.com/coins/images/1/large/bitcoin.png?1696501400",
  "url": "https://www.coingecko.com/en/coins/bitcoin"
}
```

| Field | How to read it |
|---|---|
| `id` | The CoinGecko slug. This is the key for `coins` mode and your join key across runs. |
| `price`, `marketCap`, `volume24h` | Quoted in your `vsCurrency`. |
| `change24hPct`, `change7dPct` | Percentages, already signed. `-0.18692` means down about a fifth of a percent, not 18%. |
| `ath`, `athDate`, `atl` | All-time high with its date, and all-time low. **There is no date for the low.** |
| `symbol` | Upper-cased, so `BTC` rather than `btc`. |
| `image` | The logo. On `search` rows it is the small thumbnail; elsewhere the larger file. |

**A `search` row has six fields only**: `id`, `name`, `symbol`, `marketCapRank`, `image` and `url`.
No price, no market cap, no volume. Any numeric field can be `null` when CoinGecko has no value for
that coin.

### 🧾 Reading the output

Two kinds of row can land in your dataset.

| Row | How to spot it | Billed |
|---|---|---|
| A coin | `ok: true` and an `id` | yes |
| A diagnostic | `ok: false` and an `errorCode` | no |

| Code | What it means |
|---|---|
| `BAD_INPUT` | The mode was not one of the three, `search` had no query, `coins` had no ids, or a `category` or `order` was unknown or set in a mode it does not apply to. Nothing was read. |
| `NO_RESULTS` | Nothing matched. **A currency code CoinGecko does not support lands here too**, rather than complaining about the currency, so check `vsCurrency` first when a Markets run comes back empty. |
| `RATE_LIMITED` | CoinGecko asked for a slower pace. A very large sweep can hit it; split it across runs. |
| `SERVER_ERROR` | CoinGecko answered with a server error. Usually passes on its own. |
| `NOT_FOUND` | CoinGecko answered 404 for the request. |
| `NOT_SERVED` | This coin was not served this run. Re-run it later. Runs before 13 October 2026 wrote `BLOCKED` here, and runs from 13 to 17 October wrote `NETWORK`. |
| `NETWORK` | CoinGecko could not be reached. |
| `TIME_LIMIT` | The run got close to its time limit and stopped on its own. The coins delivered before that are complete and charged. Give the run more time, or ask for fewer coins, to get the rest. |

A run that ends on one of these rows still finishes as succeeded, including when the time limit
stopped it before any coin came back: the `TIME_LIMIT` row and an amber status message say so.

**The default table view hides `id`**, which is the field `search` mode exists to give you, along
with volume, 7 day change, supply and the all-time figures. Switch to **All fields** or export as
JSON.

### 💡 What people use it for

- Snapshotting the top 250 by market cap on a schedule, to build your own history.
- Following one corner of the market, the meme coins or the layer-1 chains, with `category`.
- Refreshing a watchlist of a dozen ids every few minutes for a dashboard.
- Finding the right CoinGecko id for a ticker before wiring it into something else.

From a coin name to a watchlist, in three runs:

1. Run `search` mode with the name or ticker in `query`, and copy the `id` you meant.
2. Put the ids you want into `coinIds` and set `mode` to `coins`.
3. Schedule that run and keep every dataset. Together they are the price history this actor does not
   give you in one go.

### 🚧 What it does not do

- **No history and no candles.** One snapshot per run. If you want a series, schedule it and keep
  the rows.
- **`search` has no prices.** Six fields, by design. Take the `id` and run `coins` mode.
- **Unknown ids vanish silently.** A misspelled id in `coins` mode produces no row and no warning,
  so compare the row count against your list.
- **No exchanges, no order books, no trading pairs, no on-chain data, no NFTs.**
- **`mode` is case-sensitive.** `Markets` is rejected as bad input.
- **One category per run, in `markets` mode only.** CoinGecko answers a category plus a list of ids
  with the whole category, so `coins` mode refuses one.
- **No date for the all-time low**, only for the high. That is what CoinGecko publishes.
- **Large sweeps are slow.** CoinGecko limits how fast anyone can ask, and the run waits rather than
  hammering it.
- **Markets mode writes nothing until it finishes**, so a 5,000-coin run shows an empty dataset
  until the last page is in. If the run gets close to its time limit first, it writes the coins it
  has before going on.
- It is not an official CoinGecko tool. Dami's Studio is independent and is not affiliated with or endorsed by CoinGecko, or by any other company named on this page.

### 🧭 Which market data scraper do you need?

| If you want | Use |
|---|---|
| Coin prices, market caps and rankings | This one |
| Price, liquidity and volume of a DEX trading pair | [DexScreener Pair Price & Liquidity Scraper](https://apify.com/dami_studio/dexscreener-pairs-scraper) |
| The daily Crypto Fear and Greed reading, back to 2018 | [Crypto Fear and Greed Index Scraper](https://apify.com/dami_studio/crypto-fear-greed-scraper) |
| Large Polymarket trades and the wallets behind them | [Polymarket Whale Tracker](https://apify.com/dami_studio/polymarket-whale-tracker) |
| Company filings by keyword, ticker or CIK | [SEC EDGAR Scraper](https://apify.com/dami_studio/sec-edgar-scraper) |
| Indian mutual fund NAVs, today's or back to 2010 | [Indian Mutual Fund NAV Scraper](https://apify.com/dami_studio/mutual-fund-nav-scraper) |

### ❓ Questions people ask

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

No. There is nothing to sign up for.

#### Where do I find a coin id?

In its CoinGecko URL, or run `search` mode and read `id` off the row.

#### Why has my row got no price?

You are in `search` mode. Switch to `coins` with the same id.

#### How fresh are the prices?

They are what CoinGecko had at the moment of the run. Schedule the actor if you need them to keep
updating.

#### Why did I get fewer coins than ids I listed?

Either an id was wrong, or the list was long enough to be cut short on CoinGecko's side. Split it and
run again.

#### Can I call it from code or connect it to an AI assistant?

The [API tab](https://apify.com/dami_studio/coingecko-scraper/api/python) has code for Python, JavaScript and the CLI.
MCP clients like Claude and ChatGPT use
`https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/coingecko-scraper`; coding assistants can load [our
skill
file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-finance-sports-entertainment-SKILL.md).
All three bill your Apify account at the same price.

#### Is scraping CoinGecko legal?

These are public market figures, and the data is about coins rather than people. Check CoinGecko's
terms for how you may redistribute it. Apify's write-up on
[the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting
point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the run ID, the mode and the currency you used. The
`errorCode` and `hint` on the diagnostic row usually name the problem on their own.

# Actor input Schema

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

What to fetch: "markets" = top coins ranked by market cap (full ~15-field rows); "search" = look up coins by name/symbol (lighter 6-field rows: id, name, symbol, marketCapRank, image, url, no price/marketCap/volume); "coins" = fetch specific coins by their CoinGecko id (full rows).

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

The fiat or crypto currency that prices, market cap and volume are quoted in, e.g. usd, eur, gbp, btc, eth. Used by Markets and Coins modes.

## `query` (type: `string`):

Coin name or symbol to search for (only used in Search mode), e.g. "solana", "doge", "bitcoin".

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

List of CoinGecko coin ids to fetch (only used in Coins mode), e.g. \["bitcoin", "ethereum", "solana"]. The id is the slug from a coin's CoinGecko URL.

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

Only the coins CoinGecko files under one category, such as meme-token, layer-1 or decentralized-finance-defi. Use the id from the end of the category's CoinGecko page (coingecko.com/en/categories/meme-token) or the name that page shows (Meme). Markets mode only. Leave empty for every coin.

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

How CoinGecko ranks the coins. In Markets mode the run takes the first Max coins in this order. Market cap, largest first, is the usual leaderboard. Smallest first begins with the coins CoinGecko lists at a market cap of 0.

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

Maximum number of coins to return in Markets mode. The actor paginates 250 per request as needed.

## `notionConnector` (type: `string`):

Optional. Write each coin as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default), results are always saved to the dataset regardless.

## `notionParentId` (type: `string`):

Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead.

## `proxyConfiguration` (type: `object`):

Optional, and not needed for a normal run.

## Actor input object example

```json
{
  "mode": "markets",
  "vsCurrency": "usd",
  "query": "solana",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ],
  "order": "market_cap_desc",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Scraped rows are stored in the default dataset (one row per result). Blocked/empty/error runs return a single uncharged diagnostic row instead.

# 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 = {
    "query": "solana",
    "coinIds": [
        "bitcoin",
        "ethereum"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = {
    "query": "solana",
    "coinIds": [
        "bitcoin",
        "ethereum",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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 '{
  "query": "solana",
  "coinIds": [
    "bitcoin",
    "ethereum"
  ]
}' |
apify call dami_studio/coingecko-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/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/wHIE3RLZXqTzMe8ic/builds/N8Hc2Q221eT1vc9Pr/openapi.json