# Etherscan Scraper (`maximedupre/etherscan-scraper`) Actor

Scrape public Etherscan data without an Etherscan API key. Export top ETH holders, gas tracker snapshots, or Ethereum token leaderboard rows with prices, market caps, holder counts, balances, and source URLs.

- **URL**: https://apify.com/maximedupre/etherscan-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 scraped etherscan data points

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

### 🔎 Etherscan scraper for Ethereum data

Etherscan Scraper collects public data from [Etherscan](https://etherscan.io/) and saves it as structured Apify dataset rows. Choose one Etherscan data surface per run: top ETH holders, gas tracker snapshots, or the Ethereum token leaderboard.

Use this Etherscan scraper when you need repeatable Ethereum data exports for wallet research, token market tracking, gas-fee dashboards, on-chain analytics, internal reports, or scheduled monitoring. Instead of opening Etherscan pages by hand, you can run the Actor from Apify Console, call it through the Apify API, schedule repeat runs, export CSV/JSON/Excel files, or connect finished datasets to webhooks and integrations.

For a small first run, keep **Etherscan data** set to `Top ETH holders`, lower **Maximum records** to `100`, and start the Actor. You do not need an Etherscan account, login, cookies, wallet connection, browser extension, or user-provided Etherscan API key.

### ✅ What this Actor does

- Scrapes Etherscan top ETH holder rows from the public rich-list pages.
- Scrapes Etherscan gas tracker snapshots with current gas tiers and last block data.
- Scrapes Ethereum token leaderboard rows from the public token tracker.
- Supports token leaderboard sorting by source rank, price, 24h change, 24h volume, market cap, on-chain market cap, or holders.
- Lets you cap saved rows or gas snapshots with **Maximum records**.
- Saves only successful Etherscan data rows to the dataset.
- Adds Etherscan source URLs for holder and token rows when the source exposes them.
- Runs without asking for your Etherscan login, cookies, wallet credentials, or API key.

This Actor is focused on Ethereum mainnet data shown by Etherscan. It does not scrape other block explorers, private wallet data, transaction history, token-holder detail pages, contract ABI/source code, risk flags, wallet portfolios, or multichain explorer data.

### 📦 Data you can extract

Each output item is one successful Etherscan data row. The row shape depends on the selected data surface.

Top ETH holder rows include:

- `rank`
- `address`
- `nameTag`
- `balanceEth`
- `supplyPercentage`
- `transactionCount`
- `sourceUrl`

Gas tracker snapshot rows include:

- `lastBlock`
- `safeGasPriceGwei`
- `proposeGasPriceGwei`
- `fastGasPriceGwei`
- `baseFeeGwei`
- `gasUsedRatio`
- `observedAt`

Ethereum token leaderboard rows include:

- `rank`
- `tokenName`
- `symbol`
- `tokenAddress`
- `priceUsd`
- `change24hPercent`
- `volume24hUsd`
- `circulatingMarketCapUsd`
- `onchainMarketCapUsd`
- `holders`
- `holdersChangePercent`
- `sourceUrl`

Some source fields can be `null` when Etherscan does not show that value for a specific row. For example, holder name tags and token holder-change percentages are not always visible.

### 🎯 Common use cases

- Export the top ETH holders list for concentration or whale-wallet research.
- Collect gas tracker snapshots for fee timing, wallet UX work, or dashboards.
- Build an Ethereum token leaderboard dataset with price, volume, market cap, and holder metrics.
- Schedule repeat runs to keep a lightweight history of public Etherscan data.
- Feed source URLs, ranks, balances, gas prices, and token metrics into spreadsheets, BI tools, databases, or internal APIs.

### 🚀 How to scrape Etherscan data

1. Open the Input tab.
2. Choose **Etherscan data**:
   - `Top ETH holders` for rich-list wallet rows.
   - `Gas tracker snapshots` for current gas data.
   - `Token leaderboard` for Ethereum token rows.
3. Set **Maximum records**. Keep it small for a first test, then raise it when the output fits your workflow.
4. If you selected **Token leaderboard**, choose **Token sort metric** and **Token sort order**.
5. Start the Actor and open the dataset.

You can download the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the same Etherscan scraper through the Apify API, schedule it, or connect it to webhooks and integrations.

### ⚙️ Input example

```json
{
  "dataType": "tokenLeaderboard",
  "maxRecords": 25,
  "tokenSortBy": "holders",
  "tokenSortOrder": "desc"
}
````

For top holders, set `dataType` to `topHolders`. For gas tracker snapshots, set it to `gasTracker`.

### 🧾 Output example

Token leaderboard row:

```json
{
  "dataType": "tokenLeaderboard",
  "rank": 1,
  "tokenName": "Tether USD",
  "symbol": "USDT",
  "tokenAddress": "0xdac17f958d2ee523a2206206994597c13d831ec7",
  "priceUsd": 0.9991,
  "change24hPercent": -0.01,
  "volume24hUsd": 32567118669,
  "circulatingMarketCapUsd": 186260835194,
  "onchainMarketCapUsd": 96971443278.92,
  "holders": 14756956,
  "holdersChangePercent": null,
  "sourceUrl": "https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7"
}
```

Gas tracker row:

```json
{
  "dataType": "gasSnapshot",
  "lastBlock": 25358794,
  "safeGasPriceGwei": 0.213,
  "proposeGasPriceGwei": 0.213,
  "fastGasPriceGwei": 0.224,
  "baseFeeGwei": 0.213,
  "gasUsedRatio": [0.5603],
  "observedAt": "2026-06-20T12:27:25.329Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successful Etherscan data point saved to the dataset. Failed source requests, empty source pages, skipped rows, and handled zero-row runs do not create dataset rows.

Pricing is tiered by Apify plan and starts at `$0.0009` per saved data point on higher tiers. Keep your first run small, review the dataset, then raise **Maximum records** for larger exports or scheduled monitoring.

### ⚠️ Limits and caveats

- The Actor collects public Etherscan data visible at run time.
- One run collects one data surface: top holders, gas tracker snapshots, or token leaderboard rows.
- Token sorting follows source-supported Etherscan ordering. On-chain market cap uses the closest source-supported market-cap order while still returning the on-chain market-cap field when Etherscan shows it.
- The dataset contains successful data rows only. Source failures and empty results are reported in logs, not as placeholder rows.
- This Actor returns data for research and reporting. It does not provide financial advice.

### ❓ FAQ

#### 🔑 Do I need an Etherscan API key?

No. The Actor is built for public Etherscan pages and does not ask for an Etherscan API key, login, cookies, wallet connection, or private account access.

#### 🧭 Can I scrape transactions or token holder detail pages?

No. This Actor covers top ETH holders, gas tracker snapshots, and the Ethereum token leaderboard. Transaction history, token-holder detail pages, wallet portfolios, and contract source data are outside this Actor's scope.

#### 🔌 Can I use this as an Etherscan API?

Yes, for the public rows returned by this Actor. You can call the Actor with the Apify API, export finished datasets, schedule repeat runs, or connect results to webhooks and integrations.

#### 🧩 Why are some fields null?

Etherscan does not show every value for every row. When a visible source value is missing, the Actor keeps the field as `null` instead of inventing data.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~etherscan-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Arkham Wallet Data ↗](https://apify.com/maximedupre/arkham-intelligence-wallet-data-scraper) - Export public Arkham wallet labels, balances, history, portfolio, and P\&L data.
- [GMGN CopyTrade Wallet Scraper ↗](https://apify.com/maximedupre/gmgn-copytrade-wallet-scraper) - Scrape GMGN smart money wallet leaderboards for crypto wallet research.
- [GMGN Wallet Activity Scraper ↗](https://apify.com/maximedupre/gmgn-wallet-activity-scraper) - Export public GMGN wallet trades, transfers, liquidity events, token data, and fees.
- [Bitget Tickers Scraper ↗](https://apify.com/maximedupre/bitget-tickers-scraper) - Collect live Bitget spot and futures ticker snapshots.
- [Stocktwits Scraper ↗](https://apify.com/maximedupre/stocktwits-scraper) - Scrape public ticker messages, trending symbols, and market sentiment data.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `dataType` (type: `string`):

Choose whether this run returns top ETH holders, gas tracker snapshots, or token leaderboard rows.

## `maxRecords` (type: `integer`):

Maximum holder rows, token rows, or gas snapshots to save.

## `tokenSortBy` (type: `string`):

Choose the token leaderboard metric to sort by when collecting token rows.

## `tokenSortOrder` (type: `string`):

Choose ascending or descending order when collecting token leaderboard rows.

## Actor input object example

```json
{
  "dataType": "topHolders",
  "maxRecords": 1000,
  "tokenSortBy": "holders",
  "tokenSortOrder": "desc"
}
```

# Actor output Schema

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

View the default dataset with successful Etherscan data rows.

# 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 = {
    "dataType": "topHolders",
    "maxRecords": 1000,
    "tokenSortBy": "holders",
    "tokenSortOrder": "desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/etherscan-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 = {
    "dataType": "topHolders",
    "maxRecords": 1000,
    "tokenSortBy": "holders",
    "tokenSortOrder": "desc",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/etherscan-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 '{
  "dataType": "topHolders",
  "maxRecords": 1000,
  "tokenSortBy": "holders",
  "tokenSortOrder": "desc"
}' |
apify call maximedupre/etherscan-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etherscan Scraper",
        "description": "Scrape public Etherscan data without an Etherscan API key. Export top ETH holders, gas tracker snapshots, or Ethereum token leaderboard rows with prices, market caps, holder counts, balances, and source URLs.",
        "version": "0.0",
        "x-build-id": "bMkvoTeUosLq3wxlN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~etherscan-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-etherscan-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/maximedupre~etherscan-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-etherscan-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/maximedupre~etherscan-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-etherscan-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",
                "required": [
                    "dataType",
                    "maxRecords",
                    "tokenSortBy",
                    "tokenSortOrder"
                ],
                "properties": {
                    "dataType": {
                        "title": "Etherscan data",
                        "enum": [
                            "topHolders",
                            "gasTracker",
                            "tokenLeaderboard"
                        ],
                        "type": "string",
                        "description": "Choose whether this run returns top ETH holders, gas tracker snapshots, or token leaderboard rows.",
                        "default": "topHolders"
                    },
                    "maxRecords": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum holder rows, token rows, or gas snapshots to save.",
                        "default": 1000
                    },
                    "tokenSortBy": {
                        "title": "Token sort metric",
                        "enum": [
                            "rank",
                            "price",
                            "change24h",
                            "volume24h",
                            "circulatingMarketCap",
                            "onchainMarketCap",
                            "holders"
                        ],
                        "type": "string",
                        "description": "Choose the token leaderboard metric to sort by when collecting token rows.",
                        "default": "holders"
                    },
                    "tokenSortOrder": {
                        "title": "Token sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Choose ascending or descending order when collecting token leaderboard rows.",
                        "default": "desc"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```