# Blockchair Scraper (`publicmoney/blockchair-scraper`) Actor

Extract Blockchair chain statistics and address dashboards for Bitcoin, Litecoin, Dogecoin and Bitcoin Cash: block height, 24h transactions, hashrate, difficulty, mempool and balances. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/blockchair-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 on-chain tooling is EVM-first and treats Bitcoin as an afterthought, which leaves the UTXO chains poorly served. Blockchair indexes them properly, and this Actor reads it two ways: chain statistics (block height, 24h transactions, hashrate, mempool, difficulty, market cap) and address dashboards (balance, transaction count, first and last received).

### What it does

- Covers the **UTXO chains** properly: Bitcoin, Litecoin, Dogecoin, Bitcoin Cash and the others Blockchair indexes, rather than treating them as an EVM afterthought.
- Two **routes** on the same input: `stats` for chain-level health and `address` for a single wallet.
- Reports **network health**, not just prices: `hashrate24h`, `difficulty`, `mempoolTransactions` and block height in one record.
- Gives an address its **history window**: `firstSeenReceiving` and `lastSeenReceiving`, so a dormant wallet is obvious.
- Reads **several chains in one run**, so a multi-chain dashboard is one call rather than one per chain.
- Takes an optional **API key**, which Blockchair requires for the address route. Chain stats work without one.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Monitor network health | Read `hashrate24h` and `difficulty` on the `stats` route and chart them |
| Watch for mempool congestion | Read `mempoolTransactions` on a short schedule |
| Check a Bitcoin wallet balance | Use the `address` route with your Blockchair key |
| Spot a dormant wallet waking up | Compare `lastSeenReceiving` against the previous run |
| Build a multi-chain dashboard | Pass several chains in one run and read the same fields for each |
| Feed an on-chain research agent | Call the Actor over MCP and let the model ask for a chain or address |

### Quick start

1. Click **Try for free**.
2. Add your chains, one per line: `bitcoin`, `litecoin`, `dogecoin`, `bitcoin-cash`.
3. Leave **Route** on `stats` for chain-level data. For the `address` route, add your addresses and paste a Blockchair API key, which Blockchair requires for that route.
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 |
| --- | --- | --- | --- |
| `chains` | array | `bitcoin` | Which Blockchair chains to read |
| `route` | string | `stats` | `stats` returns chain-level health, `address` returns a wallet dashboard |
| `addresses` | array | empty | Addresses to read on the `address` route |
| `apiKey` | string | empty | Blockchair API key. Required for the `address` route, not for `stats` |
| `maxItems` | integer | `0` | Caps how many records are written. `0` writes them all |

```json
{
    "chains": [
        "bitcoin",
        "litecoin",
        "dogecoin"
    ],
    "route": "stats",
    "maxItems": 0
}
```

### Output

One dataset item per chain on the `stats` route, one per address on the `address` route. The dataset has a view for each, so the console shows the right columns for what you asked for.

| Field group | Fields |
| --- | --- |
| Always | `status`, `chain`, `url` |
| Stats route | `blocks`, `transactions24h`, `hashrate24h`, `difficulty`, `mempoolTransactions`, `value`, `currency`, `marketCap` |
| Address route | `address`, `balance`, `transactionCount`, `firstSeenReceiving`, `lastSeenReceiving` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "chain": "bitcoin",
    "blocks": 918442,
    "transactions24h": 412088,
    "hashrate24h": "881.4 EH/s",
    "difficulty": 128841002991172,
    "mempoolTransactions": 18422,
    "value": 104238.61,
    "currency": "USD",
    "marketCap": 2068442110394,
    "validFrom": "2026-09-06T05:30:00.000Z",
    "url": "https://blockchair.com/bitcoin"
}
```

### 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~blockchair-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"chains": ["bitcoin", "litecoin", "dogecoin"], "route": "stats", "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/blockchair-scraper").call(run_input={"chains": ["bitcoin", "litecoin", "dogecoin"], "route": "stats", "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["value"], item["validFrom"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/blockchair-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 |
| --- | --- |
| The address route returns `failed` for everything | Blockchair requires an API key for that route. Paste one into **API key**. Chain stats work without it. |
| A chain returns `failed` | Blockchair does not index it under that name. Chain names are Blockchair's own slugs, such as `bitcoin-cash` rather than `bch`. |
| An address returns `failed` on a chain that works | The address format does not match the chain. A Bitcoin address is not a Litecoin address. |
| `firstSeenReceiving` is missing | The address has never received funds, so there is no first receipt to report. |
| `hashrate24h` is a string, not a number | Blockchair publishes it with its unit, such as `881.4 EH/s`, and the Actor keeps the source value rather than guessing an exponent. |

### FAQ

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

For the `address` route yes, because Blockchair requires one there. Chain statistics work with no key at all. Paste the key into the API key field, which is stored as a secret.

#### Which chains does it cover?

The chains Blockchair indexes, which is where its strength lies: Bitcoin, Litecoin, Dogecoin, Bitcoin Cash and the other UTXO chains. For EVM chains and Solana use the Blockchain Scanner Actor in this fleet.

#### Why use this over the Blockchain Scanner Actor?

Different coverage and different data. Blockchain Scanner does addresses, transactions and tokens across nine mostly EVM chains. This one does chain-level network health, hashrate, difficulty and mempool, which Blockchain Scanner does not read at all.

#### Can I get transaction history for an address?

Not here. The address route returns a balance summary. For a transaction list use the Blockchain Scanner Actor on a chain it supports.

#### Does it return historical chain stats?

No, stats are current. Schedule the Actor and let the dataset accumulate to build a series of hashrate, difficulty and mempool over time.

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

No. You need an Apify token to call the Actor over the API. No Blockchair 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 Blockchair?

Blockchain data is public by design and this Actor reads Blockchair's public pages and API. Addresses are pseudonymous rather than anonymous, so if you link one to a named person you are handling personal data and your own privacy obligations apply. Take your own legal advice for your use case.

### Changelog

- **0.0.2** Added the address route with the first and last received timestamps.
- **0.0.1** First release. Chain statistics across the indexed chains.

### Feedback

Found a field Blockchair 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

## `chains` (type: `array`):

Blockchair chain slugs to read, one per line. Blockchair's strength is the UTXO chains, so this is where Bitcoin and its forks are properly indexed. Use Blockchair's own slugs rather than tickers. Examples: 'bitcoin', 'litecoin', 'dogecoin', 'bitcoin-cash'. Default is 'bitcoin'.

## `route` (type: `string`):

What each record represents. Stats returns chain-level network health: block height, 24h transactions, hashrate, difficulty and mempool size. Address returns a wallet dashboard with balance and the first and last time it received funds. Examples: 'stats', 'address'. Default is 'stats'.

## `addresses` (type: `array`):

Addresses to read on the address route, one per line, in the chain's own format. A Bitcoin address is not a Litecoin address, so match them to the chains you selected. Ignored on the stats route. Examples: '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa'.

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

Maximum number of chains 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 chain given.

## `apiKey` (type: `string`):

Blockchair API key. Blockchair requires one for the address route and returns an error without it. Chain statistics work with no key at all. Stored as a secret and never written to the dataset.

## Actor input object example

```json
{
  "chains": [
    "bitcoin",
    "litecoin"
  ],
  "route": "stats",
  "addresses": [],
  "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 = {
    "chains": [
        "bitcoin",
        "litecoin"
    ],
    "route": "stats",
    "addresses": [],
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/blockchair-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 = {
    "chains": [
        "bitcoin",
        "litecoin",
    ],
    "route": "stats",
    "addresses": [],
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/blockchair-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 '{
  "chains": [
    "bitcoin",
    "litecoin"
  ],
  "route": "stats",
  "addresses": [],
  "maxItems": 0
}' |
apify call publicmoney/blockchair-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicmoney/blockchair-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/N8ufghJDIJvp0QNCe/builds/bpvRfKIRKrRKh8p6N/openapi.json