# CoinPaprika Crypto Market Scraper (`logiover/coinpaprika-crypto-market-scraper`) Actor

Scrape live cryptocurrency market data from CoinPaprika: price, volume, market cap, supply, ATH and 1h/24h/7d/30d price changes for thousands of coins. Schedule it for continuous market snapshots.

- **URL**: https://apify.com/logiover/coinpaprika-crypto-market-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Business, Developer tools
- **Stats:** 21 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

Learn more: https://docs.apify.com/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

## 🪙 CoinPaprika Crypto Market Scraper — Live Coin Prices, Market Cap & Supply Data

Scrape **live cryptocurrency market data from CoinPaprika** — thousands of coins ranked by market cap — straight from the official CoinPaprika API. No login, no API key, no blocking. This Apify Actor returns a clean, structured snapshot of the crypto market: price, 24h volume, market cap, rank, supply, all-time high, and multi-timeframe price changes.

If you need bulk **CoinPaprika price data** or a continuously fresh crypto market feed you can export to JSON, CSV, or Excel, this Actor is built for scheduled, recurring use.

### ✨ What this Actor does / Key features

- **Official CoinPaprika API source** — reliable, fully structured, and consistent output.
- **Broad market coverage** — thousands of cryptocurrencies ranked by market cap in one run.
- **Rich data per coin** — USD price, 24h trading volume, market cap, and rank.
- **Multi-timeframe momentum** — 1h, 24h, 7d, and 30d price change percentages.
- **Historical extremes** — all-time high (ATH) price, ATH date, and percentage change from ATH.
- **Supply data** — total supply and max supply.
- **Simple configuration** — one optional setting to cap the number of coins.
- **Built for scheduling** — run hourly or daily for an always-fresh market dataset.

### 🔍 Input

| Field | Type | Description |
|---|---|---|
| `maxCoins` | integer | Maximum coins to scrape, ranked by market cap. `0` = all coins. |

### 🚀 Example input

Scrape the entire market:

```json
{
  "maxCoins": 0
}
````

Scrape just the top 100 coins:

```json
{
  "maxCoins": 100
}
```

### 📦 Output

Each dataset item is one cryptocurrency with its market snapshot. Output fields:

| Field | Description |
|---|---|
| `id` | CoinPaprika coin ID. |
| `name` | Coin name. |
| `symbol` | Ticker symbol. |
| `rank` | Rank by market cap. |
| `priceUsd` | Current price in USD. |
| `volume24h` | 24h trading volume. |
| `marketCap` | Market capitalization. |
| `percentChange1h` | 1h price change percentage. |
| `percentChange24h` | 24h price change percentage. |
| `percentChange7d` | 7-day price change percentage. |
| `percentChange30d` | 30-day price change percentage. |
| `athPrice` | All-time high price. |
| `athDate` | Date of the all-time high. |
| `percentFromAth` | Percentage change from the all-time high. |
| `totalSupply` | Total supply. |
| `maxSupply` | Maximum supply. |
| `lastUpdated` | CoinPaprika's last-updated timestamp for the coin. |
| `scrapedAt` | Timestamp of when the record was scraped. |

### 💡 Use cases

- **Traders & analysts** — work from a fresh, broad snapshot of the crypto market in one dataset.
- **Portfolio & dashboard tools** — power live price, rank, and market-cap displays.
- **Research & datasets** — build a historical market archive by scheduling recurring runs.
- **Crypto screeners** — filter the market by momentum, rank, and market cap.
- **Quant & backtesting pipelines** — feed structured market data into models and notebooks.

### ❓ Frequently Asked Questions

**Do I need a CoinPaprika API key or account?**
No. The Actor pulls from the official CoinPaprika API and handles everything — you only need an Apify account.

**Is it legal to use this data?**
The Actor accesses publicly available market data from CoinPaprika. Use it in line with CoinPaprika's terms of service.

**How many coins can I get in one run?**
Thousands of coins, ranked by market cap. Set `maxCoins` to `0` for the full market, or set a number for a smaller, faster run.

**Can I limit the results?**
Yes. Use `maxCoins` to cap how many coins are scraped — the highest-ranked coins are returned first.

**How fresh is the data?**
It reflects CoinPaprika's latest market data at run time, with each coin's `lastUpdated` timestamp included. Schedule the Actor hourly or daily to keep your dataset current.

**Does it include all-time high data?**
Yes. Every coin includes `athPrice`, `athDate`, and `percentFromAth` so you can see how far each coin is from its peak.

**What output formats are supported?**
JSON, CSV, Excel (XLSX), HTML, and JSONLines, available through the Apify dataset and API.

### ⏰ Scheduling & integration

Schedule the Actor on Apify to run hourly or daily for a continuously updated crypto market dataset. Export to JSON, CSV, or Excel, call it from the Apify API, or push results into Google Sheets, databases, trading dashboards, or Slack with webhooks and no-code tools like Make and Zapier.

***

**Keywords:** coinpaprika scraper, coinpaprika api, crypto price scraper, cryptocurrency market data, crypto market cap data, coin price api, crypto screener data, altcoin prices scraper, crypto market snapshot, coinpaprika coins data

# Actor input Schema

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

Maximum coins to scrape (ranked by market cap). 0 = all.

## Actor input object example

```json
{}
```

# Actor output Schema

## `rank` (type: `string`):

rank

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

name

## `symbol` (type: `string`):

symbol

## `priceUsd` (type: `string`):

priceUsd

## `volume24h` (type: `string`):

volume24h

## `marketCap` (type: `string`):

marketCap

## `percentChange24h` (type: `string`):

percentChange24h

## `percentChange7d` (type: `string`):

percentChange7d

# 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/coinpaprika-crypto-market-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/coinpaprika-crypto-market-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/coinpaprika-crypto-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinPaprika Crypto Market Scraper",
        "description": "Scrape live cryptocurrency market data from CoinPaprika: price, volume, market cap, supply, ATH and 1h/24h/7d/30d price changes for thousands of coins. Schedule it for continuous market snapshots.",
        "version": "1.0",
        "x-build-id": "xP2dnMZcLcDIfNMmn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~coinpaprika-crypto-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-coinpaprika-crypto-market-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~coinpaprika-crypto-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-coinpaprika-crypto-market-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~coinpaprika-crypto-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-coinpaprika-crypto-market-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": {
                    "maxCoins": {
                        "title": "Max Coins",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum coins to scrape (ranked by market cap). 0 = all."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
