# Crypto Markets Scraper - Prices & Market Data (CoinGecko) (`flash_scraper/crypto-markets-scraper`) Actor

Get live cryptocurrency prices and market data as clean rows: rank, symbol, name, price, market cap, 24h volume, 24h & 7d change %, high/low, ATH, supply and a CoinGecko URL. Pick the quote currency, cap the coin count, or request specific coins by id. Free CoinGecko data, no API key.

- **URL**: https://apify.com/flash\_scraper/crypto-markets-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Crypto Markets Scraper — live prices & market data as clean rows

**Get live cryptocurrency prices and market data as a clean, flat spreadsheet — one row per coin.** Rank, symbol, name, current price, market cap, 24-hour trading volume, 24-hour and 7-day price change %, 24h high/low, all-time high and how far off it is, circulating and total supply, a last-updated timestamp, and a direct CoinGecko link. Pull the **top 100 coins by market cap**, the whole top 1,000, sort by volume, price it in **any currency (USD, EUR, GBP, BTC…)**, or pin the run to a **specific watchlist of coins**. Powered by the free CoinGecko API — **no API key, no proxy, no account**.

Built for **portfolio trackers, market researchers, trading dashboards, and data teams** who need a fresh, structured crypto-market feed they can drop straight into a spreadsheet, database, or automation — without wiring up an API client or paying for a data plan.

---

### What does it do?

This actor calls CoinGecko's public **markets** endpoint and flattens the response into tidy rows. It paginates automatically (250 coins per page) up to the coin count you ask for, sorts by market cap or 24-hour volume, and quotes every price in the currency you pick. Point it at the whole market for a top-N snapshot, or hand it a list of coin ids for a fixed watchlist. Every run pushes a clean dataset you can export to **CSV, JSON, or Excel**, or sync onward.

Because CoinGecko's free tier is rate-limited, the actor uses **generous retry and exponential backoff** (honoring the `Retry-After` header) and paces its page requests, so a busy moment on CoinGecko's side doesn't turn into a failed run.

---

### Why use it

- **Zero setup** — no API key, no signup, no proxy. Enter a currency and a coin count, hit run.
- **Clean flat rows** — CoinGecko's raw JSON has 25+ nested fields; this keeps the 17 that matter, renamed clearly, ready for a spreadsheet.
- **Any quote currency** — price the market in USD, EUR, GBP, JPY, BTC, or any code CoinGecko supports.
- **Top-N or watchlist** — grab the top 1,000 by market cap or volume, or just the handful of coins you track.
- **Rate-limit resilient** — retries with backoff on 429/5xx and never crashes on a transient CoinGecko hiccup; you're charged only for rows actually delivered.
- **Direct links** — every row carries a `coingecko_url` so a human can click straight through.

---

### How to use it

1. Set **Quote currency** (default `usd`).
2. Set **Max coins** (default `100` — the top 100 by market cap).
3. Choose a **Sort order** — market cap or 24-hour volume.
4. Optionally list **Specific coins** by their CoinGecko id (the slug in the coin's URL, e.g. `bitcoin`, `ethereum`, `solana`) to fetch just those.
5. Run it, then export the dataset to CSV, JSON, or Excel.

#### Input

| Field | Type | Description |
|---|---|---|
| `vsCurrency` | string | Currency prices are quoted in (lowercase code). Default `usd`. |
| `maxCoins` | integer | Max coins to return, 1–1000. Default `100`. |
| `order` | enum | `market_cap_desc` or `volume_desc`. Default `market_cap_desc`. |
| `coinIds` | array | Optional list of CoinGecko coin ids for a fixed watchlist. Empty = top coins by sort. |

Every field has a sensible default — running with no changes returns the top 100 coins by market cap in USD.

**Example input:**

```json
{
  "vsCurrency": "usd",
  "maxCoins": 100,
  "order": "market_cap_desc",
  "coinIds": []
}
````

#### JSON output sample

```json
{
  "rank": 1,
  "id": "bitcoin",
  "symbol": "BTC",
  "name": "Bitcoin",
  "current_price": 63361,
  "market_cap": 1269418108561,
  "total_volume": 37529042967,
  "price_change_pct_24h": 0.7724,
  "price_change_pct_7d": 6.8648,
  "high_24h": 64387,
  "low_24h": 61339,
  "ath": 126080,
  "ath_change_pct": -49.7455,
  "circulating_supply": 20052971,
  "total_supply": 20052971,
  "last_updated": "2026-07-07T11:51:07.734Z",
  "coingecko_url": "https://www.coingecko.com/en/coins/bitcoin"
}
```

Results render as a sortable table on the Output tab and export to CSV, JSON, or Excel.

#### Example output

A real sample from a live run:

| # | Name | Symbol | Price | Market cap | 24h % | 7d % |
|---|---|---|---|---|---|---|
| 1 | Bitcoin | BTC | 63,361 | 1,269,418,108,561 | 0.77 | 6.86 |
| 2 | Ethereum | ETH | 1,781.30 | 214,897,700,854 | 0.59 | 3.12 |
| 3 | Tether | USDT | 1.00 | 118,402,551,003 | 0.01 | -0.02 |
| 4 | XRP | XRP | 2.14 | 126,540,993,110 | 1.83 | 9.44 |

***

### Use cases

- **Portfolio tracking** — pull a watchlist of coins on a schedule and log price, market cap, and 24h/7d change over time.
- **Market research** — snapshot the top 100–1,000 coins to study market-cap distribution, volume leaders, or ATH drawdowns.
- **Trading dashboards** — feed a clean, refreshable price/volume table into Google Sheets, a BI tool, or a custom dashboard.
- **Research datasets** — build a time series by scheduling regular runs and appending each dataset for backtesting or analysis.

***

### Use with AI agents & automation

Run this actor from the Apify **MCP** server so AI agents (Claude, ChatGPT, Cursor) can pull live market data as a tool call. Schedule runs on Apify and pipe the dataset to **Google Sheets**, **Make**, **n8n**, or **Zapier** to keep a tracker or dashboard fresh. The flat JSON drops into pipelines with no glue code.

***

### How much does it cost?

This actor uses **pay-per-event pricing: you're charged per result row delivered**. Source data is the free public CoinGecko API — no proxy or third-party data cost. Empty or rate-limited runs return nothing and cost nothing. New Apify accounts get free platform credits each month, so you can pull the full top-1,000 market a few times and test it before paying anything. See the Apify Store page for the current per-result price.

***

### FAQ

**Where does the data come from?** The public **CoinGecko** markets API — the same data behind CoinGecko's site, key-free.

**Do I need an API key?** No. It runs on CoinGecko's free, keyless tier.

**How fresh is the data?** Live at run time. Each row carries a `last_updated` timestamp from CoinGecko (typically within a minute or two of real time). Re-run or schedule the actor to keep a series current.

**Why did a run return fewer coins than I asked for, or none?** CoinGecko's free tier is rate-limited (roughly 10–30 requests/minute). The actor retries with backoff, but during heavy load it may stop early or exit with a "rate-limited, retry in a minute" status. It never fails the run or charges you for rows it didn't deliver — just retry shortly.

**What is a coin id vs. a symbol?** The `coinIds` field wants CoinGecko's **id** (the slug in the coin's URL, e.g. `bitcoin`), not the ticker (`BTC`). Several coins share a ticker, so ids keep the watchlist unambiguous.

**Can I price in EUR or BTC?** Yes — set `vsCurrency` to any code CoinGecko supports (`usd`, `eur`, `gbp`, `jpy`, `btc`, `eth`, …).

**Can I export to CSV or Google Sheets?** Yes — CSV, JSON, or Excel from the Output tab, or sync to Google Sheets via Make, n8n, or Zapier.

***

### Related actors

- [SEC EDGAR Filings Scraper](https://apify.com/flash_scraper/sec-edgar-filings-scraper) — company filings and financial disclosures from the SEC.

Questions or a field you'd like added? Contact support through the Apify Store page — we usually reply within a day.

# Actor input Schema

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

Fiat or crypto currency prices are quoted in, e.g. 'usd', 'eur', 'gbp', 'btc'. Lowercase ISO code.

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

Maximum number of coins to return, ordered by the sort below. Fetched in pages of 250.

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

How to rank the coins that are returned.

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

Optional list of CoinGecko coin ids to fetch instead of the whole market, e.g. 'bitcoin', 'ethereum', 'solana'. Leave empty to return the top coins by the sort above. Use the coin's CoinGecko id (the slug in its URL), not its ticker symbol.

## Actor input object example

```json
{
  "vsCurrency": "usd",
  "maxCoins": 100,
  "order": "market_cap_desc",
  "coinIds": []
}
```

# 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 = {
    "vsCurrency": "usd",
    "maxCoins": 100,
    "coinIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/crypto-markets-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 = {
    "vsCurrency": "usd",
    "maxCoins": 100,
    "coinIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/crypto-markets-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 '{
  "vsCurrency": "usd",
  "maxCoins": 100,
  "coinIds": []
}' |
apify call flash_scraper/crypto-markets-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Markets Scraper - Prices & Market Data (CoinGecko)",
        "description": "Get live cryptocurrency prices and market data as clean rows: rank, symbol, name, price, market cap, 24h volume, 24h & 7d change %, high/low, ATH, supply and a CoinGecko URL. Pick the quote currency, cap the coin count, or request specific coins by id. Free CoinGecko data, no API key.",
        "version": "0.1",
        "x-build-id": "XeWM896OgGE8UfcFp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flash_scraper~crypto-markets-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flash_scraper-crypto-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/flash_scraper~crypto-markets-scraper/runs": {
            "post": {
                "operationId": "runs-sync-flash_scraper-crypto-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/flash_scraper~crypto-markets-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-flash_scraper-crypto-markets-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "vsCurrency": {
                        "title": "Quote currency",
                        "type": "string",
                        "description": "Fiat or crypto currency prices are quoted in, e.g. 'usd', 'eur', 'gbp', 'btc'. Lowercase ISO code.",
                        "default": "usd"
                    },
                    "maxCoins": {
                        "title": "Max coins",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of coins to return, ordered by the sort below. Fetched in pages of 250.",
                        "default": 100
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "market_cap_desc",
                            "volume_desc"
                        ],
                        "type": "string",
                        "description": "How to rank the coins that are returned.",
                        "default": "market_cap_desc"
                    },
                    "coinIds": {
                        "title": "Specific coins (optional)",
                        "type": "array",
                        "description": "Optional list of CoinGecko coin ids to fetch instead of the whole market, e.g. 'bitcoin', 'ethereum', 'solana'. Leave empty to return the top coins by the sort above. Use the coin's CoinGecko id (the slug in its URL), not its ticker symbol.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
