# CoinPaprika Scraper (`publicmoney/coinpaprika-scraper`) Actor

Extract CoinPaprika market data for any coin with no API key: price, market cap, rank, volume, supply, all-time high, and percent change from 15 minutes out to a year across nine windows. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/coinpaprika-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

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

Most crypto sources give you a 24 hour change and stop. CoinPaprika publishes percent change from **nine** windows, from 15 minutes out to a full year, and this Actor returns all of them in one record alongside price, market cap, rank, volume, supply and the all-time high. That makes it the source to reach for when you care about how fast a move is happening, not just that it happened.

### What it does

- Returns **one record per coin**, in order. A coin id CoinPaprika does not know comes back with `status: "failed"` and a reason.
- Carries **nine change windows** in one record: 15m, 30m, 1h, 6h, 12h, 24h, 7d, 30d and 1y. No other source in this fleet gives you the short end.
- Keeps both names: `requested` is the id you sent and `tickerSymbol` is the ticker, so records join back to a watchlist keyed either way.
- Prices in **any quote currency CoinPaprika supports**, not just USD.
- Carries the **all-time high with its date**, so a price has context.
- Needs **no API key**. CoinPaprika's free tier is open and this Actor uses it.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Catch a move as it happens | Read `percentChange15m` and `percentChange1h` rather than waiting for the daily number |
| Compare momentum across windows | Chart 1h against 24h against 7d in the same record |
| Rank a watchlist | Sort on `rank` and `marketCap` |
| Find how far a coin is off its high | Read `ath` and `athDate` |
| Feed a crypto research agent | Call the Actor over MCP and let the model ask for the coin it needs |
| Track a market every 15 minutes | Schedule the run to match the shortest change window |

### Quick start

1. Click **Try for free**.
2. Add CoinPaprika coin ids, one per line: `btc-bitcoin`, `eth-ethereum`, `sol-solana`. The id is the ticker and the name joined by a hyphen.
3. Set **Quote currency** if you want something other than `USD`.
4. Click **Start**. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `coinIds` | array | `btc-bitcoin, eth-ethereum` | CoinPaprika coin ids to read, written `ticker-name` |
| `quoteCurrency` | string | `USD` | The quote currency code |
| `maxItems` | integer | `0` | Caps how many coins are read. `0` reads them all |

```json
{
    "coinIds": [
        "btc-bitcoin",
        "eth-ethereum",
        "sol-solana"
    ],
    "quoteCurrency": "USD",
    "maxItems": 0
}
```

### Output

One dataset item per coin. Fields CoinPaprika does not publish for a coin are dropped rather than returned as `null`.

| Field group | Fields |
| --- | --- |
| Identity | `status`, `requested`, `tickerSymbol`, `name`, `rank`, `url` |
| Price | `value`, `quoteCurrency` |
| Short-window change | `percentChange15m`, `percentChange30m`, `percentChange1h`, `percentChange6h`, `percentChange12h` |
| Long-window change | `percentChange24h`, `percentChange7d`, `percentChange30d`, `percentChange1y` |
| Market and supply | `marketCap`, `volume24h`, `circulatingSupply`, `totalSupply`, `maxSupply` |
| Extremes | `ath`, `athDate`, `percentFromPriceAth` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "requested": "btc-bitcoin",
    "tickerSymbol": "BTC",
    "name": "Bitcoin",
    "rank": 1,
    "value": 104238.61,
    "quoteCurrency": "USD",
    "percentChange15m": 0.08,
    "percentChange1h": -0.31,
    "percentChange24h": -1.84,
    "percentChange7d": 3.12,
    "percentChange1y": 62.4,
    "marketCap": 2068442110394,
    "volume24h": 41220118844,
    "circulatingSupply": 19842193.0,
    "maxSupply": 21000000.0,
    "ath": 126198.0,
    "athDate": "2026-07-14T00:00:00.000Z",
    "validFrom": "2026-09-04T20:00:01.000Z"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~coinpaprika-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"coinIds": ["btc-bitcoin", "eth-ethereum", "sol-solana"], "quoteCurrency": "USD", "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/coinpaprika-scraper").call(run_input={"coinIds": ["btc-bitcoin", "eth-ethereum", "sol-solana"], "quoteCurrency": "USD", "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["name"], item["value"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/coinpaprika-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| A coin returns `failed` | You sent a bare ticker. CoinPaprika ids are `ticker-name`, so it is `btc-bitcoin`, not `BTC` and not `bitcoin`. |
| The short-window changes are all zero | The coin barely trades, so nothing moved in 15 or 30 minutes. Check `volume24h`. |
| `maxSupply` is missing | CoinPaprika publishes no max supply for coins that have none. That is the source, not a gap. |
| A change window is missing | CoinPaprika omits a window it has too little history for, which happens on newly listed coins. |
| Prices differ from CoinGecko or CoinMarketCap | Each aggregator weights a different set of venues. Read `validFrom` and compare like for like. |

### FAQ

#### Is the CoinPaprika API free?

CoinPaprika has an open free tier, which is what this Actor uses, so there is no key to register. The Actor itself is charged per record.

#### What is a CoinPaprika coin id?

The ticker and the name joined by a hyphen: `btc-bitcoin`, `eth-ethereum`, `sol-solana`. It is neither a bare ticker nor a bare name.

#### Why use CoinPaprika over CoinGecko or CoinMarketCap?

The short change windows. CoinPaprika is the only source in this fleet that publishes 15 minute, 30 minute and 1 hour change, which matters when you are watching a move rather than reporting on a day.

#### Does it return historical prices?

No series, but the nine change windows in each record cover 15 minutes out to a year. To build a series, schedule the Actor and let the dataset accumulate.

#### Can I price in something other than USD?

Yes. Set the quote currency to any code CoinPaprika supports.

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

No. You need an Apify token to call the Actor over the API. No CoinPaprika credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape CoinPaprika?

This Actor reads public CoinPaprika data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

### Changelog

- **0.0.2** Added the full set of nine change windows and the all-time high date.
- **0.0.1** First release. Market data for any listed coin.

### Feedback

Found a field CoinPaprika publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

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

CoinPaprika coin ids to read, one per line. An id is the ticker and the name joined by a hyphen, so it is neither a bare ticker nor a bare name. Examples: 'btc-bitcoin', 'eth-ethereum', 'sol-solana'. Default is 'btc-bitcoin', 'eth-ethereum'.

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

The currency every price, market cap and volume is quoted in. Any code CoinPaprika supports works. Examples: 'USD', 'EUR', 'BTC'. Default is 'USD'.

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

Maximum number of coins to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every coin given.

## Actor input object example

```json
{
  "coinIds": [
    "btc-bitcoin",
    "eth-ethereum"
  ],
  "quoteCurrency": "USD",
  "maxItems": 0
}
```

# Actor output Schema

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

One item per requested input, 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 = {
    "coinIds": [
        "btc-bitcoin",
        "eth-ethereum"
    ],
    "quoteCurrency": "USD",
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/coinpaprika-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 = {
    "coinIds": [
        "btc-bitcoin",
        "eth-ethereum",
    ],
    "quoteCurrency": "USD",
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/coinpaprika-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "coinIds": [
    "btc-bitcoin",
    "eth-ethereum"
  ],
  "quoteCurrency": "USD",
  "maxItems": 0
}' |
apify call publicmoney/coinpaprika-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/coinpaprika-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2AzmNN4fBCmXJYhmi/builds/Cuh90rPzEBgZ65xMT/openapi.json