# CoinGecko Exchanges Scraper (`logiover/coingecko-exchanges-scraper`) Actor

Scrape every cryptocurrency exchange listed on CoinGecko in one run — 1,400+ exchanges with trust score, trust-score rank, 24h trading volume (BTC), country and year established. Schedule it to track the exchange landscape.

- **URL**: https://apify.com/logiover/coingecko-exchanges-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 84 total users, 9 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 successful extractions

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 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

## 🏦 CoinGecko Exchanges Scraper — Export All 1,000+ Crypto Exchanges to JSON/CSV/Excel

Scrape **every cryptocurrency exchange listed on [CoinGecko](https://www.coingecko.com)** in a single run — 1,000+ exchanges complete with **trust score, trust-score rank, 24h BTC trading volume, country and year established** — straight from the official CoinGecko API. This **CoinGecko exchanges scraper** needs **no login, no API key and no proxy configuration**, and returns clean structured data ready to export to JSON, CSV or Excel.

Built for **scheduled, recurring use**, it lets you track the crypto exchange landscape as trust scores and trading volumes shift over time. Whether you are building an exchange comparison site, a research dataset or a market-monitoring pipeline, this Actor gives you a reliable, fully paginated feed of the entire CoinGecko exchange directory.

### ✨ What this Actor does / Key features

- **Full exchange coverage** — pulls all 1,000+ (often 1,400+) crypto exchanges listed on CoinGecko in one run.
- **Official CoinGecko API** — uses the public CoinGecko exchanges API, so results are reliable and consistently structured.
- **Rich profile data per exchange** — name, country, year established, trust score, trust-score rank, 24h trading volume in BTC, normalized 24h volume, trading-incentive flag, website URL and logo image.
- **Automatic pagination** — handles every page of the API for you; no page parameters to manage.
- **Adjustable run size** — set `maxExchanges` to cap the run for quick tests, or leave it at `0` to grab the complete list.
- **No blocking, no API key** — runs without authentication, captchas or login.
- **Structured, export-ready output** — every record is flat JSON, perfect for JSON, CSV, Excel, or feeding into a database or BI tool.
- **Schedule-friendly** — designed to run daily or weekly so you always have a fresh snapshot of the exchange market.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `maxExchanges` | integer | Maximum number of exchanges to save. Use `0` to scrape **all** exchanges (1,400+). Minimum value is `0`. |

The Actor takes a single optional input. Run it with an empty input `{}` to scrape the entire CoinGecko exchange directory.

### 🚀 Example input

```json
{
  "maxExchanges": 0
}
````

To run a quick test of just the top 50 exchanges:

```json
{
  "maxExchanges": 50
}
```

### 📦 Output

Each item in the dataset is one cryptocurrency exchange. The output is flat, structured JSON — easy to export to CSV or Excel, or to push into your own database.

| Field | Description |
|-------|-------------|
| `id` | CoinGecko internal exchange identifier (e.g. `binance`). |
| `name` | Display name of the exchange. |
| `country` | Country where the exchange is registered or based. |
| `yearEstablished` | Year the exchange was founded. |
| `trustScore` | CoinGecko trust score (0–10) measuring liquidity, scale and confidence. |
| `trustScoreRank` | Exchange rank by trust score (1 = highest-ranked). |
| `tradeVolume24hBtc` | 24-hour trading volume expressed in BTC. |
| `tradeVolume24hBtcNormalized` | Normalized 24-hour BTC volume (CoinGecko's adjusted volume figure). |
| `hasTradingIncentive` | Boolean flag indicating whether the exchange offers trading incentives. |
| `url` | Official website URL of the exchange. |
| `image` | URL of the exchange's logo image. |
| `scrapedAt` | ISO timestamp of when the record was scraped. |

#### Example output record

```json
{
  "id": "binance",
  "name": "Binance",
  "country": "Cayman Islands",
  "yearEstablished": 2017,
  "trustScore": 10,
  "trustScoreRank": 1,
  "tradeVolume24hBtc": 312456.78,
  "tradeVolume24hBtcNormalized": 298765.43,
  "hasTradingIncentive": false,
  "url": "https://www.binance.com/",
  "image": "https://assets.coingecko.com/markets/images/52/small/binance.jpg",
  "scrapedAt": "2026-05-15T08:30:00.000Z"
}
```

### 💡 Use cases

- **Exchange comparison & directory sites** — power an always-current listing of crypto exchanges with trust scores and volume rankings.
- **Traders & investors** — decide where to trade by comparing trust score, rank and real 24h volume across the whole market.
- **Market researchers & analysts** — track how the exchange landscape evolves: new entrants, shifting trust scores, volume migration.
- **Data teams** — build a historical archive of exchange metrics by scheduling daily or weekly runs.
- **Fintech & compliance** — monitor exchanges by country and year established for due-diligence or coverage analysis.
- **Content & SEO sites** — auto-generate up-to-date "best crypto exchanges" pages from fresh data.

### ❓ Frequently Asked Questions

**Is it legal to scrape CoinGecko exchange data?**
This Actor reads data from CoinGecko's public API, which is intended for programmatic access. You are responsible for complying with CoinGecko's terms of service and for how you use the data. Scraping publicly available market data is a common and widely accepted practice.

**Do I need a CoinGecko API key or login?**
No. The Actor uses the public CoinGecko endpoints and requires no API key, no account and no login.

**How many exchanges can I get?**
All of them — typically 1,400+ exchanges in a single run. Set `maxExchanges` to `0` (or leave the input empty) for the complete list, or set a smaller number for a faster test run.

**How long does a full run take and how much does it cost?**
A complete run is lightweight — it paginates the API and finishes quickly, usually within a couple of minutes. Cost depends only on the small amount of Apify compute used; there are no third-party fees.

**Can I filter the results?**
The Actor returns the full exchange list. You can limit how many records are saved with `maxExchanges`, and you can filter or sort the resulting dataset (by `country`, `trustScore`, `tradeVolume24hBtc`, etc.) using Apify's dataset views or after export.

**Can I schedule it to run automatically?**
Yes. Use the Apify Scheduler to run the Actor daily or weekly so you always have a fresh snapshot of the crypto exchange market. This is the recommended way to track changes over time.

**What output formats are supported?**
Results are stored in an Apify dataset and can be exported to JSON, CSV, Excel, XML or HTML, or pulled via the Apify API.

**Does it handle pagination and blocking?**
Yes. The Actor automatically paginates through every page of the CoinGecko API. Because it uses the official public API, there are no captchas or anti-bot blocks to worry about.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to run daily or weekly for an always-fresh crypto exchanges dataset. Export results to JSON, CSV or Excel, pull them through the Apify API, or connect the dataset to Google Sheets, webhooks or your own data pipeline for automated monitoring of the exchange landscape.

# Actor input Schema

## `maxExchanges` (type: `integer`):

Maximum exchanges to save. 0 = all (1,400+).

## Actor input object example

```json
{}
```

# Actor output Schema

## `name` (type: `string`):

name

## `country` (type: `string`):

country

## `trustScore` (type: `string`):

trustScore

## `trustScoreRank` (type: `string`):

trustScoreRank

## `tradeVolume24hBtc` (type: `string`):

tradeVolume24hBtc

## `yearEstablished` (type: `string`):

yearEstablished

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/coingecko-exchanges-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("logiover/coingecko-exchanges-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 '{}' |
apify call logiover/coingecko-exchanges-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinGecko Exchanges Scraper",
        "description": "Scrape every cryptocurrency exchange listed on CoinGecko in one run — 1,400+ exchanges with trust score, trust-score rank, 24h trading volume (BTC), country and year established. Schedule it to track the exchange landscape.",
        "version": "1.0",
        "x-build-id": "vq6tXhe6XZAfI033f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~coingecko-exchanges-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-coingecko-exchanges-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/logiover~coingecko-exchanges-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-coingecko-exchanges-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/logiover~coingecko-exchanges-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-coingecko-exchanges-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": {
                    "maxExchanges": {
                        "title": "Max Exchanges",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum exchanges to save. 0 = all (1,400+)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
