# Crypto Price Scraper (`knotless_cadence/crypto-price-scraper`) Actor

Real-time crypto prices — BTC, ETH, altcoins. 4+ runs for trading bots and dashboards. Price history, market cap, volume. JSON. Custom data tool in 48h, $100 pilot. Email: spinov001@gmail.com • Tips: t.me/scraping\_ai

- **URL**: https://apify.com/knotless\_cadence/crypto-price-scraper.md
- **Developed by:** [Alex](https://apify.com/knotless_cadence) (community)
- **Categories:** Business
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Crypto Price Scraper — Market Data, Prices & Trending Coins

Extract real-time cryptocurrency prices and market data from CoinGecko. Get current price, market cap, trading volume, supply metrics, all-time highs, and price changes (1h, 24h, 7d, 30d). Fetch top N coins by market cap, look up specific coins, or discover trending tokens. Free API, no key needed.

### Features

- **Top N Coins** — fetch top 100, 250, or up to 1000 coins ranked by market cap
- **Specific Coin Lookup** — get detailed data for any coin by CoinGecko ID (bitcoin, ethereum, solana)
- **Trending Coins** — discover currently trending cryptocurrencies on CoinGecko
- **Price Change Tracking** — percentage changes over 1 hour, 24 hours, 7 days, and 30 days
- **Supply Metrics** — circulating supply, total supply, max supply, and fully diluted valuation
- **All-Time High/Low** — ATH and ATL prices with dates and percentage from current price
- **Multi-Currency** — prices in USD, EUR, GBP, JPY, or any supported fiat currency

### Output Example

```json
{
  "id": "bitcoin",
  "symbol": "btc",
  "name": "Bitcoin",
  "currentPrice": 87432.00,
  "marketCap": 1720000000000,
  "marketCapRank": 1,
  "totalVolume": 28500000000,
  "high24h": 88100.00,
  "low24h": 86200.00,
  "priceChangePercentage24h": 1.45,
  "priceChangePercentage7d": -2.31,
  "priceChangePercentage30d": 8.72,
  "circulatingSupply": 19650000,
  "maxSupply": 21000000,
  "ath": 108000.00,
  "athDate": "2025-12-15T14:00:00.000Z",
  "athChangePercentage": -19.05,
  "vsCurrency": "usd",
  "scrapedAt": "2026-03-18T10:00:00.000Z"
}
````

### Use Cases

- **Portfolio Tracking** — collect current prices and market data for cryptocurrency portfolios
- **Market Research** — analyze market cap distribution, volume trends, and price movements
- **Trading Signals** — feed price change data into algorithmic trading strategies and alerts
- **DeFi Analytics** — track token prices and supply metrics for decentralized finance research
- **Content & Reporting** — generate crypto market summaries, newsletters, and data visualizations
- **Price Comparison** — monitor prices across multiple fiat currencies simultaneously

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `coins` | array | `[]` | CoinGecko coin IDs (e.g., "bitcoin", "ethereum") |
| `topN` | integer | `100` | Top N coins by market cap (0 to skip, max 1000) |
| `vsCurrency` | string | `usd` | Price currency (usd, eur, gbp, jpy, etc.) |
| `includeMarketData` | boolean | `true` | Include price changes, supply, ATH/ATL |
| `includeTrending` | boolean | `false` | Fetch currently trending coins |

### How It Works

The scraper queries the CoinGecko API to retrieve cryptocurrency market data. For top-N queries, it fetches paginated market listings sorted by market cap. For specific coins, it retrieves detailed profiles including descriptions, links, and community data. Rate limiting with automatic retry on HTTP 429 ensures reliable operation within CoinGecko's free tier limits.

# Actor input Schema

## `coins` (type: `array`):

CoinGecko coin IDs to fetch (e.g., 'bitcoin', 'ethereum', 'solana')

## `topN` (type: `integer`):

Fetch top N coins by market cap (set to 0 to skip). Used when no specific coins are provided.

## `vsCurrency` (type: `string`):

Currency for prices (usd, eur, gbp, jpy, etc.)

## `includeMarketData` (type: `boolean`):

Include detailed market data (price changes, supply, ATH/ATL)

## `includeTrending` (type: `boolean`):

Also fetch currently trending coins on CoinGecko

## Actor input object example

```json
{
  "coins": [],
  "topN": 100,
  "vsCurrency": "usd",
  "includeMarketData": true,
  "includeTrending": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("knotless_cadence/crypto-price-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("knotless_cadence/crypto-price-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 '{}' |
apify call knotless_cadence/crypto-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Price Scraper",
        "description": "Real-time crypto prices — BTC, ETH, altcoins. 4+ runs for trading bots and dashboards. Price history, market cap, volume. JSON. Custom data tool in 48h, $100 pilot. Email: spinov001@gmail.com • Tips: t.me/scraping_ai",
        "version": "1.0",
        "x-build-id": "Be2OTbQqfaScBFcRf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/knotless_cadence~crypto-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-knotless_cadence-crypto-price-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/knotless_cadence~crypto-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-knotless_cadence-crypto-price-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/knotless_cadence~crypto-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-knotless_cadence-crypto-price-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",
                "properties": {
                    "coins": {
                        "title": "Coin IDs",
                        "type": "array",
                        "description": "CoinGecko coin IDs to fetch (e.g., 'bitcoin', 'ethereum', 'solana')",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "topN": {
                        "title": "Top N Coins",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Fetch top N coins by market cap (set to 0 to skip). Used when no specific coins are provided.",
                        "default": 100
                    },
                    "vsCurrency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency for prices (usd, eur, gbp, jpy, etc.)",
                        "default": "usd"
                    },
                    "includeMarketData": {
                        "title": "Include Market Data",
                        "type": "boolean",
                        "description": "Include detailed market data (price changes, supply, ATH/ATL)",
                        "default": true
                    },
                    "includeTrending": {
                        "title": "Include Trending",
                        "type": "boolean",
                        "description": "Also fetch currently trending coins on CoinGecko",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
