# Coinlore Crypto Prices Scraper (`zerobreak/coinlore-crypto-prices-scraper`) Actor

CoinLore Crypto Prices Scraper is a Python tool designed to extract real-time cryptocurrency prices, market caps, trading volumes, circulating supplies, and rankings from CoinLore. It exports structured digital asset datasets into clean CSV or JSON formats for financial research.

- **URL**: https://apify.com/zerobreak/coinlore-crypto-prices-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### CoinLore Crypto Prices Scraper — Crypto Tickers, Markets, and Prices

### Overview

CoinLore Crypto Prices Scraper collects cryptocurrency market data, including paginated ticker lists, individual coin quotes, exchange market pairs, and global market statistics.

Choose a collection mode, specify coin IDs where applicable, and save the results to an Apify dataset for export as JSON, CSV, or Excel.

### Features

- Collect paginated cryptocurrency ticker lists.
- Retrieve individual coin price and market information.
- Extract exchange market pairs, prices, and trading volumes.
- Capture global cryptocurrency market statistics.
- Collect market rankings, price changes, and supply figures when available.
- Remove duplicate coin IDs and repeated market pairs.
- Export structured records for financial research and market analysis.

### Use Cases

- **Price snapshots:** Collect cryptocurrency prices and compare BTC, ETH, and other assets over time.
- **Individual coin research:** Retrieve market information for a specific coin, such as Bitcoin.
- **Exchange market analysis:** Review trading pairs, prices, and market volumes.
- **Market breadth monitoring:** Track total market capitalization, active markets, and cryptocurrency dominance.
- **Spreadsheet reporting:** Export datasets to CSV or Excel for financial analysis.
- **Historical comparisons:** Run recurring collections and compare successive market snapshots.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | String | `tickers` | Collection mode: `tickers`, `coin`, `markets`, or `global`. |
| `coinIds` | Array | `["90"]` | Numeric CoinLore IDs used in `coin` and `markets` modes. ID `90` represents Bitcoin. |
| `maxItems` | Integer | `100` | Maximum number of records to save per run, including error records. Hard maximum: 1,000. |
| `requestDelaySecs` | Number | `1` | Minimum delay between requests. Values below one second are raised to one second. |
| `timeoutSecs` | Integer | `300` | Overall run time limit in seconds. |
| `requestTimeoutSecs` | Integer | `30` | Maximum wait for an individual request, in seconds. |

### Example Input

#### Collect cryptocurrency tickers

```json id="cl101"
{
  "mode": "tickers",
  "coinIds": ["90"],
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

#### Retrieve an individual coin

```json id="cl102"
{
  "mode": "coin",
  "coinIds": ["90"],
  "maxItems": 1
}
```

#### Other collection modes

Set `mode` to `markets` to collect market pairs for the selected coin IDs, or `global` to retrieve an overall cryptocurrency market snapshot.

### What Data Does This Actor Extract?

The actor stores records in the default Apify dataset. Available fields vary by collection mode.

#### Example Output

The following example illustrates a cryptocurrency ticker record.

```json id="cl103"
{
  "id": "90",
  "symbol": "BTC",
  "name": "Bitcoin",
  "nameid": "bitcoin",
  "rank": 1,
  "price_usd": "83402.18",
  "percent_change_24h": "0.45",
  "percent_change_1h": "-0.37",
  "percent_change_7d": "-2.03",
  "price_btc": "1.00",
  "market_cap_usd": "1665612572235.40",
  "volume24": 62153299759.54,
  "volume24a": 14292353128.15,
  "csupply": "19970852.00",
  "tsupply": "19970852",
  "msupply": "21000000",
  "mode": "tickers",
  "scraped_at": "2026-10-12T00:00:00+00:00"
}
```

#### Extracted Data Fields

| Field | Type | Description |
|---|---|---|
| `id` | String | Cryptocurrency identifier. |
| `symbol` | String | Cryptocurrency ticker symbol, such as `BTC`. |
| `name` | String | Coin or exchange name, depending on the record type. |
| `nameid` | String | Coin's URL-friendly identifier. |
| `rank` | Integer | Market ranking when available. |
| `price_usd` | String | Coin price in USD. |
| `percent_change_1h` | String | Percentage price change over one hour. |
| `percent_change_24h` | String | Percentage price change over 24 hours. |
| `percent_change_7d` | String | Percentage price change over seven days. |
| `price_btc` | String | Price expressed in BTC. |
| `market_cap_usd` | String | Market capitalization in USD. |
| `volume24` | Number | 24-hour trading volume. |
| `volume24a` | Number | Alternate 24-hour volume figure when available. |
| `csupply` | String | Circulating supply. |
| `tsupply` | String | Total supply. |
| `msupply` | String | Maximum supply when defined. |
| `base` | String | Base asset in a market pair. |
| `quote` | String | Quote asset in a market pair. |
| `price` | Number | Market price in the quote currency. |
| `volume` | Number | Market trading volume. |
| `volume_usd` | Number | Market trading volume expressed in USD. |
| `coins_count` | Integer | Number of coins represented in the global snapshot. |
| `active_markets` | Integer | Number of active markets in the global snapshot. |
| `total_mcap` | Number | Total cryptocurrency market capitalization. |
| `total_volume` | Number | Total market trading volume. |
| `btc_d` | String | Bitcoin market dominance. |
| `eth_d` | String | Ethereum market dominance. |
| `mode` | String | Collection mode: `tickers`, `coin`, `markets`, or `global`. |
| `scraped_at` | String | UTC timestamp indicating when the record was saved. |

#### Data by Mode

- **Tickers:** Coin IDs, symbols, names, rankings, USD prices, percentage changes, market capitalization, volume, and supply information.
- **Coin:** Individual cryptocurrency details and available market statistics.
- **Markets:** Market pairs, base and quote assets, prices, exchange names, and volume information when provided.
- **Global:** Overall market statistics, including coin counts, active markets, total market capitalization, total volume, and BTC and ETH dominance.

### Working with Your Dataset

After the actor finishes, open the Apify dataset to inspect or export the collected records.

- **JSON:** Use structured cryptocurrency data in Python applications and data pipelines.
- **CSV:** Import market information into spreadsheets, databases, and analytics tools.
- **Excel:** Compare prices, rankings, volumes, and market statistics.

For recurring market analysis, retain the collection timestamps so that successive snapshots can be compared consistently.

### Important Notes

- Cryptocurrency prices, rankings, market capitalization, and volume figures can change between collection runs.
- The latest available data depends on the source's publication and update schedule.
- The default request delay is one second to help avoid excessive request frequency.
- The `maxItems` setting defaults to 100 and cannot exceed 1,000 records per run.
- Ticker collection may involve multiple pages, depending on the requested record count.
- Available fields differ between ticker, coin, market, and global records.
- Coin IDs must correspond to supported entries in the source dataset.
- Market prices and volume figures are informational and may differ across trading platforms.

### FAQ

**What collection modes are available?**

The actor supports four modes: `tickers` for cryptocurrency listings, `coin` for individual coin details, `markets` for market pairs, and `global` for overall market statistics.

**Which coin ID represents Bitcoin?**

CoinLore ID `90` represents Bitcoin in the provided examples.

**Can I collect multiple coins?**

Yes. Supply the relevant coin IDs in the `coinIds` array for `coin` or `markets` mode.

**How often should I collect market data?**

The appropriate schedule depends on your analysis requirements. Cryptocurrency markets change continuously, so more frequent collections provide more snapshots but also generate more requests.

**Can I export the dataset to CSV or Excel?**

Yes. The Apify dataset supports JSON, CSV, and Excel exports.

### Disclaimer

This actor is an independent tool and is not affiliated with or endorsed by CoinLore. Cryptocurrency data is provided for informational and analytical purposes and should not be treated as financial advice. Verify important figures before using them for investment decisions or financial reporting.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects information from public pages. It does not log in and it does not bypass access controls.

For a longer explanation, see Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

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

Which CoinLore feed to collect: tickers (paged price list), coin (one id per row), markets (exchanges for a coin), or global (one market-wide snapshot).

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

CoinLore numeric coin ids used by coin and markets modes. 90 is Bitcoin. One id per line.

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

Maximum dataset rows to save this run, including error rows. Free cap is 1000.

## `requestDelaySecs` (type: `number`):

Seconds to wait between CoinLore requests. CoinLore asks for about one request per second, so the floor is 1.

## `timeoutSecs` (type: `integer`):

Stop the run after this many seconds and keep rows already saved.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single CoinLore response before retrying.

## `proxyConfiguration` (type: `object`):

Optional proxy for CoinLore requests. Default is no proxy.

## Actor input object example

```json
{
  "mode": "tickers",
  "coinIds": [
    "90"
  ],
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `datasetUrl` (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 = {
    "coinIds": [
        "90"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/coinlore-crypto-prices-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": ["90"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/coinlore-crypto-prices-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": [
    "90"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call zerobreak/coinlore-crypto-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zerobreak/coinlore-crypto-prices-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/RCZ4pJQDYX829r9Ie/builds/qOdakjcNZ1c27xqSz/openapi.json