# CoinPaprika Crypto Market Data Scraper (`automation-lab/coinpaprika-crypto-market-data`) Actor

Search CoinPaprika and export normalized coin metadata, current quotes, exchange markets, recent historical prices, and exchange summaries—no API key.

- **URL**: https://apify.com/automation-lab/coinpaprika-crypto-market-data.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.47 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

## CoinPaprika Crypto Market Data Scraper

Export **CoinPaprika crypto market data** as clean JSON records for research, portfolio monitoring, spreadsheet analysis, and scheduled data pipelines.

The Actor uses CoinPaprika's public API and needs no CoinPaprika account or API key. Choose one of five focused modes: coin search, enriched coin snapshots, exchange markets for a coin, recent historical prices, or exchange summaries.

### What does this CoinPaprika scraper export?

The Actor turns several CoinPaprika API surfaces into one predictable dataset contract.

- Search assets by coin name or symbol.
- Enrich exact CoinPaprika IDs with metadata and a current quote.
- Export exchange pairs, prices, volume, trust scores, and market URLs for a coin.
- Export recent price, 24-hour volume, and market-cap observations.
- List exchange summaries with activity and market coverage.
- Normalize timestamps, source links, and record types for downstream automation.

Every row includes `recordType`, `sourceUrl`, and `scrapedAt`. Mode-specific fields are populated when CoinPaprika provides them; unrelated fields are `null`, so one schema works across exports.

### Who is it for?

**Crypto analysts** can refresh provider-specific quote and history tables without maintaining API clients.

**Portfolio teams** can schedule snapshots or recent historical exports and compare observations between runs.

**Market researchers** can inspect which exchanges and pairs trade a selected asset.

**Data engineers** can send normalized records to Sheets, databases, warehouses, or webhooks through Apify integrations.

**Developers and AI agents** can call one Actor interface through the API or MCP instead of implementing five CoinPaprika response shapes.

### Why use this Actor?

- No CoinPaprika credential is required.
- Exact coin IDs avoid ambiguous symbols when precision matters.
- A query can resolve IDs when discovery is more convenient.
- `maxItems` is enforced across the complete run.
- Transient network, HTTP 429, and temporary server failures use bounded retries.
- Stable input errors and stable upstream 4xx responses fail clearly instead of returning a misleading empty success.
- Direct HTTP keeps memory and infrastructure cost low; no browser or paid proxy fallback is hidden in the run.

This Actor does not claim tick-by-tick real-time delivery or a complete historical archive. It exports what CoinPaprika's anonymous public endpoints return at run time.

### Input modes

| Mode | Use it for | Required targeting |
| --- | --- | --- |
| `search` | Discover matching CoinPaprika assets | `query` |
| `snapshots` | Metadata plus current quote and supply fields | `coinIds` or `query` |
| `markets` | Exchange pairs for selected coins | `coinIds` or `query` |
| `history` | Recent price, volume, and market-cap rows | `coinIds` or `query` |
| `exchanges` | Exchange coverage summaries | none |

When both `coinIds` and `query` are supplied, exact IDs take precedence. Use IDs such as `btc-bitcoin` and `eth-ethereum`, not symbols such as `BTC`, when repeatable identity matters.

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | One of `search`, `snapshots`, `markets`, `history`, or `exchanges`. |
| `query` | string | — | Coin name or symbol used by search and optional ID resolution. |
| `coinIds` | string\[] | `[]` | Up to 50 exact CoinPaprika coin IDs. |
| `quoteCurrency` | string | `USD` | Requested quote currency, such as `USD` or `EUR`. |
| `historyDays` | integer | `7` | Recent history lookback from 1 to 365 days. |
| `historyInterval` | string | `1d` | `1h`, `6h`, `12h`, `24h`, or `1d`. |
| `maxItems` | integer | mode default | Maximum 1–5,000 useful records across the run. |

CoinPaprika may limit quote currencies, historical retention, interval combinations, and anonymous request volume. Invalid source combinations surface as a failed run with the upstream status.

### Getting started

1. Open the Actor input page.
2. Choose a data mode.
3. Enter a search query or exact CoinPaprika IDs when the selected mode needs them.
4. Select a quote currency and a conservative `maxItems` value.
5. For history, choose the lookback days and interval.
6. Click **Start**.
7. Open the default dataset and export JSON, CSV, Excel, XML, or another supported Apify format.

A first discovery run can use:

```json
{
  "mode": "search",
  "query": "bitcoin",
  "maxItems": 10
}
```

### Output fields

The output schema contains a stable superset of all modes.

| Field group | Examples |
| --- | --- |
| Identity | `recordType`, `coinId`, `name`, `symbol`, `rank`, `coinType`, `isActive` |
| Quote | `currency`, `price`, `volume24h`, `marketCap`, percentage-change fields |
| Supply | `totalSupply`, `maxSupply`, `betaValue` |
| Market pair | `exchangeId`, `exchangeName`, `pair`, `category`, `trustScore`, `marketUrl` |
| Exchange summary | `markets`, `currencies`, `fiatCurrencies`, `sessionsPerMonth`, `confidenceScore` |
| Metadata | `description`, `tags`, `team`, `links`, `startedAt` |
| Provenance | `observedAt`, `lastUpdated`, `sourceUrl`, `scrapedAt` |

Numeric values remain numbers. Missing source values remain `null`; they are not converted to zero or an empty string.

### Output example

A snapshot record looks like this (market values change continuously):

```json
{
  "recordType": "snapshot",
  "coinId": "btc-bitcoin",
  "name": "Bitcoin",
  "symbol": "BTC",
  "rank": 1,
  "isActive": true,
  "coinType": "coin",
  "currency": "USD",
  "price": 80885.87,
  "volume24h": 35905089929.64,
  "marketCap": 1624148120316,
  "percentChange24h": 3.71,
  "totalSupply": 20079503,
  "maxSupply": 21000000,
  "observedAt": "2026-09-04T07:08:16Z",
  "sourceUrl": "https://coinpaprika.com/coin/btc-bitcoin/",
  "scrapedAt": "2026-09-04T07:09:00.000Z"
}
```

Download all records with the default dataset API link shown in the run's **Output** tab.

### How much does it cost to export CoinPaprika market data?

Pay-per-event pricing has a one-time **$0.005 Actor start** and one `item` event per useful dataset row. Failed, rejected, duplicate, or empty records are not charged as items.

Measured item tiers are:

| Apify plan | Price per item |
| --- | ---: |
| Free | $0.0028198 |
| Bronze | $0.002452 |
| Silver | $0.0019126 |
| Gold | $0.0014712 |
| Platinum | $0.0014712 |
| Diamond | $0.0014712 |

At the Bronze tier, 10 rows cost about **$0.02952**, 100 rows about **$0.25020**, and 1,000 rows about **$2.457**, including one start event. The Apify Console shows the applicable tier and final charge. These values will be kept aligned with the active Store pricing record.

### Recurring monitoring workflows

Create an Apify Task with `snapshots` or `history` mode, then attach a schedule. Each run has its own default dataset, which prevents older rows from being silently mixed into a new export.

Common workflows include:

1. Daily Bitcoin and Ethereum quote snapshots into a warehouse.
2. Weekly market-pair exports to track venue coverage.
3. Recent historical rows loaded into a notebook before analysis.
4. Exchange summary exports compared between scheduled runs.

The Actor exports observations; it does not send price alerts or calculate changes between runs. Use an Apify integration, webhook, or downstream workflow for those actions.

### Export to spreadsheets and data pipelines

From the dataset, choose **Export** and select CSV or Excel for manual analysis. For automation, connect the run to Google Sheets, Make, Zapier, webhooks, or your own ingestion service.

A pipeline should key coin records by `coinId`, market rows by a combination such as `coinId + exchangeId + pair`, and history rows by `coinId + observedAt + currency`.

### Run with the Apify API

Set `APIFY_TOKEN` in your shell rather than placing it in source code.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~coinpaprika-crypto-market-data/runs?waitForFinish=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"markets","coinIds":["btc-bitcoin"],"quoteCurrency":"USD","maxItems":25}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/coinpaprika-crypto-market-data').call({
  mode: 'snapshots',
  coinIds: ['btc-bitcoin', 'eth-ethereum'],
  quoteCurrency: 'USD',
  maxItems: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/coinpaprika-crypto-market-data').call(run_input={
    'mode': 'history',
    'coinIds': ['btc-bitcoin', 'eth-ethereum'],
    'quoteCurrency': 'USD',
    'historyDays': 7,
    'historyInterval': '1d',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/coinpaprika-crypto-market-data"
```

#### Claude Desktop, Cursor, and VS Code setup

For Claude Desktop, Cursor, VS Code, or another editor client that supports remote MCP servers, use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/coinpaprika-crypto-market-data"
    }
  }
}
```

Example prompts:

- “Search CoinPaprika for assets matching bitcoin and return the top 10 IDs.”
- “Export 25 BTC exchange markets in USD and group them by trust score.”
- “Fetch seven days of daily BTC and ETH observations and prepare a CSV-ready table.”

Treat market data as time-sensitive and ask the agent to retain `observedAt` and `scrapedAt` in any summary.

### Reliability, retries, and limits

The Actor validates input before requesting data. It allows at most 50 coin IDs and 5,000 rows per run.

A request is retried only when it times out, encounters a transport error, receives HTTP 429, or receives a temporary 5xx status. Retry delay respects `Retry-After` when available and is otherwise bounded. Four failed attempts exhaust the request and fail the run.

There is no automatic browser, residential proxy, or credential fallback. This keeps behavior and costs predictable. If CoinPaprika changes or removes an endpoint, the run fails rather than presenting an HTML error page as an empty dataset.

### Troubleshooting

**Why did my run fail with “coinIds or query is required”?**

`snapshots`, `markets`, and `history` need exact IDs or a query that can resolve IDs. Use `btc-bitcoin`, not `BTC`, in `coinIds`.

**Why did a search produce zero rows?**

CoinPaprika returned no currency match for the query. Try a known full name such as `bitcoin`, or find an exact ID on CoinPaprika.

**Why are some fields null?**

The schema is shared by five record types. Market-pair fields do not apply to search rows, for example. CoinPaprika may also omit an applicable field.

**Why are fewer historical rows returned than expected?**

The endpoint controls retention, interval availability, and timestamp alignment. `historyDays` defines a requested lookback, not a promise that every interval exists.

**Can I request thousands of market rows?**

Yes, up to `maxItems`, but CoinPaprika's anonymous limits still apply. Start with a smaller Task and schedule responsibly.

### Responsible use and legal notes

This Actor accesses publicly available CoinPaprika API data. Follow CoinPaprika's terms, documentation, attribution expectations, and request limits. Do not use the output for market manipulation, deceptive promotion, or unlawful activity.

Cryptocurrency values are volatile and source data may be delayed, incomplete, or corrected. The output is research data, not financial, investment, tax, or legal advice. Verify material decisions against appropriate primary sources.

### Related automation-lab Actors

- [CoinGecko Crypto Market Data](https://apify.com/automation-lab/coingecko-crypto-market-data) — a provider-specific alternative for current and historical crypto datasets.
- [Crypto Fear and Greed Index Scraper](https://apify.com/automation-lab/crypto-fear-greed-index) — sentiment observations that can complement market records.
- [DexScreener Token Pair Market Data](https://apify.com/automation-lab/dexscreener-token-pair-market-data) — decentralized-exchange pair data for token research.

Choose one provider as the system of record when IDs or calculation methods must remain consistent.

### FAQ

**Does the Actor require a CoinPaprika API key?**

No. It uses anonymous public endpoints.

**Does it support currencies other than USD?**

Yes, where CoinPaprika supports the requested quote currency. Enter an uppercase code such as `EUR`.

**Is this a real-time price feed?**

No. Each run exports the source's latest available observation. Use schedules for recurring snapshots.

**Does it deduplicate records?**

Exact input coin IDs are deduplicated. Each market or historical observation remains a distinct useful row.

**Are rows stored in a global dataset?**

No. Results go to each run's default dataset, which is compatible with Apify APIs and integrations.

**Can I use the result from JavaScript, Python, or an AI agent?**

Yes. Use the API client examples or the Apify MCP endpoint above.

# Actor input Schema

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

Choose search results, enriched coin snapshots, coin exchange markets, recent history, or exchange summaries.

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

Coin name or symbol, such as bitcoin or ETH. Required for search; it can also resolve coin IDs in snapshot, market, and history modes.

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

Exact CoinPaprika IDs, such as btc-bitcoin and eth-ethereum. These take precedence over the query.

## `quoteCurrency` (type: `string`):

Currency code requested from CoinPaprika, normally USD or EUR.

## `historyDays` (type: `integer`):

Recent lookback window for history mode. Anonymous CoinPaprika availability and granularity apply.

## `historyInterval` (type: `string`):

Requested interval for historical rows. CoinPaprika may constrain intervals for longer windows.

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

Stop after this many useful dataset records across all selected coins.

## Actor input object example

```json
{
  "mode": "search",
  "query": "bitcoin",
  "coinIds": [],
  "quoteCurrency": "USD",
  "historyDays": 7,
  "historyInterval": "1d",
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

API URL for all normalized records in the default dataset.

# 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 = {
    "mode": "search",
    "query": "bitcoin",
    "quoteCurrency": "USD",
    "historyDays": 7,
    "historyInterval": "1d",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/coinpaprika-crypto-market-data").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 = {
    "mode": "search",
    "query": "bitcoin",
    "quoteCurrency": "USD",
    "historyDays": 7,
    "historyInterval": "1d",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/coinpaprika-crypto-market-data").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 '{
  "mode": "search",
  "query": "bitcoin",
  "quoteCurrency": "USD",
  "historyDays": 7,
  "historyInterval": "1d",
  "maxItems": 20
}' |
apify call automation-lab/coinpaprika-crypto-market-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/coinpaprika-crypto-market-data"
        }
    }
}

```

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/8lJEFO7SxYRc5XQeb/builds/di5xroSw5BYYh5yYF/openapi.json