# Kraken Crypto Exchange Scraper (`parseforge/kraken-exchange-scraper`) Actor

Scrape live cryptocurrency ticker data from Kraken public API including price, volume, bid/ask, 24h high/low for all trading pairs. No API key required.

- **URL**: https://apify.com/parseforge/kraken-exchange-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.53 / 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/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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/parseforge-banner.png)

## 🐙 Kraken Crypto Exchange Scraper

> 🚀 **Grab live Kraken ticker data for every asset pair in seconds.** Pull last price, bid, ask, 24h volume, VWAP, and trade counts with intraday and full-day windows side by side. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-12 · **📊 26 fields** per record · **700+ asset pairs** · **Two time windows: today and 24h** · **No login**

Kraken Crypto Exchange Scraper hits the public Kraken REST API to return live ticker snapshots for every active asset pair on the exchange. Each record carries the last trade price and volume, top-of-book bid and ask with sizes, today and 24-hour high and low, today and 24h volume, today and 24h volume-weighted average price, today and 24h trade counts, today's open price, the computed 24h price change in absolute terms and percent, and the bid-ask spread in basis points. The actor merges the asset pair metadata endpoint inline so each row also carries the canonical wsname (e.g. `XBT/USD`), the altname slug, and the base and quote asset codes Kraken uses internally.

Crypto traders use this to track Kraken spreads against other venues. Quant researchers compare today and 24h volume-weighted prices to detect intraday momentum. Treasury teams pull end-of-day Kraken marks for stablecoin and BTC reconciliation. The dual-window output (today plus rolling 24h) gives you both the intraday view and the full window without two API calls. Volumes are returned as numbers in the base asset, not as raw strings.

| Target | Kraken public REST API (Ticker + AssetPairs) |
|--------|----------------------------------------------|
| Use Cases | Cross-venue spread tracking, VWAP analytics, treasury marks, market data warehousing |

---

### 📋 What the Kraken Crypto Exchange Scraper does

- 🐙 **Every Kraken pair.** Last price, bid, ask, high, low, VWAP, and trade count for every asset pair the exchange currently quotes.
- 🕒 **Two time windows.** Today and rolling 24-hour values side by side for volume, VWAP, high, low, and trade counts.
- 🟢 **Top-of-book quotes.** Best bid and ask with their respective volumes, plus the computed spread in absolute units and basis points.
- 🔍 **Pair filter.** Pass a list of Kraken pair codes (e.g. `XBTUSD`, `ETHUSD`) to scope the run to specific markets, or leave empty for all.
- 📊 **Sort and slice.** Order by 24h volume, last price, or pair name before applying `maxItems` to focus the dataset.

Each record represents one trading pair with 26 numeric and string fields. The canonical wsname format (e.g. `XBT/USD`) makes it easy to join Kraken data against other venues that use ISO-style ticker conventions.

> 💡 **Why it matters:** Kraken's ticker API returns nested arrays where bid is `[price, wholeLot, lotVol]` and volume is `[today, 24h]`. Parsing those by hand is error-prone. This actor unpacks every nested tuple into named fields, casts everything to numbers, and computes spread and percent change for you.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset.

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>pairs</code></td><td>string[]</td><td><code>[]</code></td><td>List of specific Kraken pair codes (e.g. <code>XBTUSD</code>, <code>ETHUSD</code>). Leave empty to fetch all pairs.</td></tr>
<tr><td><code>sortBy</code></td><td>string (enum)</td><td><code>"volume24h"</code></td><td>Order before truncating. Options: volume24h, lastPrice, pair.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Free users are limited to 10 items. Paid users can request up to 1,000,000.</td></tr>
</tbody>
</table>

**Example: top 25 pairs by 24h volume.**

```json
{
  "pairs": [],
  "sortBy": "volume24h",
  "maxItems": 25
}
````

**Example: targeted snapshot of BTC and ETH against USD.**

```json
{
  "pairs": ["XBTUSD", "ETHUSD"],
  "sortBy": "pair",
  "maxItems": 10
}
```

> ⚠️ **Good to Know:** Kraken uses its own pair naming convention (e.g. `XBT` instead of `BTC`, `XXBTZUSD` legacy code). The actor returns the canonical wsname (`XBT/USD`), the altname (`XBTUSD`), and the raw base and quote codes so you can join with whichever convention you use elsewhere.

***

### 📊 Output

Each record contains **26 fields** covering price, two-window volume and VWAP, trade counts, top-of-book quotes, and spread. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `pair` | string | `"PEPE/USD"` |
| 🔗 `url` | string | `"https://www.kraken.com/prices/PEPEUSD"` |
| 🔤 `altname` | string | `"PEPEUSD"` |
| 💱 `baseAsset` | string | `"PEPE"` |
| 💵 `quoteAsset` | string | `"ZUSD"` |
| 💰 `lastPrice` | number | `0.000004108` |
| 🟢 `bidPrice` | number | `0.000004108` |
| 🔴 `askPrice` | number | `0.000004109` |
| ↔️ `spreadBps` | number | `2.4343` |
| 📈 `high24h` | number | `0.000004386` |
| 📉 `low24h` | number | `0.000004073` |
| 🌅 `openPrice` | number | `0.000004338` |
| 📦 `volume24h` | number | `213933879511.55` |
| 📦 `volumeToday` | number | `179262585163.20` |
| 🧮 `vwap24h` | number | `0.000004221627` |
| 🧮 `vwapToday` | number | `0.000004195469` |
| 🔢 `tradeCount24h` | integer | `8546` |
| 📉 `priceChange24h` | number | `-2.3e-7` |
| 📊 `priceChangePercent24h` | number | `-5.302` |
| ⏱️ `scrapedAt` | string (ISO) | `"2026-05-12T16:29:35.914Z"` |

#### 📦 Sample records

<details>
<summary><strong>🐸 PEPE/USD - micro-priced memecoin, tight spread</strong></summary>

```json
{
  "pair": "PEPE/USD",
  "url": "https://www.kraken.com/prices/PEPEUSD",
  "altname": "PEPEUSD",
  "baseAsset": "PEPE",
  "quoteAsset": "ZUSD",
  "lastPrice": 0.000004108,
  "lastTradeVolume": 391648037.506,
  "askPrice": 0.000004109,
  "askVolume": 496625920,
  "bidPrice": 0.000004108,
  "bidVolume": 3493524796,
  "spreadAbs": 1e-9,
  "spreadBps": 2.4343,
  "high24h": 0.000004386,
  "low24h": 0.000004073,
  "highToday": 0.000004349,
  "lowToday": 0.000004073,
  "openPrice": 0.000004338,
  "volume24h": 213933879511.55005,
  "volumeToday": 179262585163.20145,
  "vwap24h": 0.000004221627,
  "vwapToday": 0.000004195469,
  "tradeCount24h": 8546,
  "tradeCountToday": 6184,
  "priceChange24h": -2.3e-7,
  "priceChangePercent24h": -5.302,
  "scrapedAt": "2026-05-12T16:29:35.914Z"
}
```

</details>

<details>
<summary><strong>🦔 MOG/USD - thin-volume small cap</strong></summary>

```json
{
  "pair": "MOG/USD",
  "url": "https://www.kraken.com/prices/MOGUSD",
  "altname": "MOGUSD",
  "baseAsset": "MOG",
  "quoteAsset": "ZUSD",
  "lastPrice": 1.626e-7,
  "lastTradeVolume": 400000000,
  "askPrice": 1.628e-7,
  "askVolume": 2434641676,
  "bidPrice": 1.626e-7,
  "bidVolume": 703896268,
  "spreadAbs": 2e-10,
  "spreadBps": 12.3001,
  "high24h": 1.748e-7,
  "low24h": 1.615e-7,
  "openPrice": 1.719e-7,
  "volume24h": 945718442046.7876,
  "volumeToday": 615688936605.5106,
  "vwap24h": 1.69982e-7,
  "vwapToday": 1.69586e-7,
  "tradeCount24h": 655,
  "tradeCountToday": 456,
  "priceChange24h": -9.3e-9,
  "priceChangePercent24h": -5.4101,
  "scrapedAt": "2026-05-12T16:29:35.913Z"
}
```

</details>

<details>
<summary><strong>🐔 COQ/USD - wide-spread illiquid pair (263 bps)</strong></summary>

```json
{
  "pair": "COQ/USD",
  "url": "https://www.kraken.com/prices/COQUSD",
  "altname": "COQUSD",
  "baseAsset": "COQ",
  "quoteAsset": "ZUSD",
  "lastPrice": 1.786e-7,
  "askPrice": 1.825e-7,
  "askVolume": 1273602710,
  "bidPrice": 1.778e-7,
  "bidVolume": 421965902,
  "spreadAbs": 4.7e-9,
  "spreadBps": 263.1579,
  "high24h": 1.973e-7,
  "low24h": 1.764e-7,
  "openPrice": 1.81e-7,
  "volume24h": 133076712305.39822,
  "vwap24h": 1.86887e-7,
  "tradeCount24h": 623,
  "priceChange24h": -2.4e-9,
  "priceChangePercent24h": -1.326,
  "scrapedAt": "2026-05-12T16:29:35.910Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🐙 | **Every Kraken pair.** 700+ asset pairs returned in a single call. |
| 🕒 | **Today and 24h windows.** Both windows side by side, no need for a separate intraday call. |
| 🧮 | **VWAP fields parsed.** Volume-weighted average prices are extracted from the nested response and cast to numbers. |
| 🟢 | **Top-of-book with volumes.** Best bid and ask with their order book sizes for spread and depth analysis. |
| 🔁 | **Live per run.** Every execution hits the Kraken public API directly, no caching. |
| 🔤 | **Canonical naming.** wsname (`XBT/USD`), altname (`XBTUSD`), and Kraken's internal base and quote codes all in one record. |
| 🚫 | **No login.** Works with public Kraken market data. No API key, no rate-limit anxiety on small runs. |

> 📊 Kraken is one of the longest-running crypto exchanges (founded 2011) and a primary USD on-ramp for institutional traders in North America and Europe.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Kraken Crypto Exchange Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **700+** pairs, 26 fields | **Live per run** | pair list, sort key, maxItems | ⚡ 2 min |
| Official public API | Free | Full, nested arrays | Real-time | Build your own | 🐢 Hours of parsing |
| Paid live data APIs | $99+/month | Real-time tick stream | Streaming | Many | ⏳ Days |
| Manual browsing | Free (your time) | One pair at a time | Manual | None | 🕒 Slow |

Pick this actor when you want flat, named, numeric ticker data without dealing with Kraken's nested tuple format.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Kraken Crypto Exchange Scraper page on the Apify Store.
3. 🎯 **Set input.** Pass specific pair codes (or leave empty for all), choose a sort key, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the tickers.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📈 Trading and Spread Analysis

- Cross-venue spread monitoring against Binance, Coinbase, and OKX
- Bid-ask depth scoring at the top of the order book
- Intraday vs 24h VWAP divergence signals
- Snapshot-based pair ranking for liquidity scoring

</td>
<td width="50%" valign="top">

#### 🏗️ DeFi and Reference Data

- Centralized exchange marks for oracle pipelines
- VWAP feeds for protocol settlement and lending
- Cross-venue mark comparisons against on-chain prices
- Fiat-pair reference rates for stablecoin treasury

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Treasury and Reporting

- End-of-day mark-to-market for portfolio reconciliation
- USD reference prices from a regulated US exchange
- Audit trails of external venue prices with timestamps
- Periodic snapshots for compliance and accounting

</td>
<td width="50%" valign="top">

#### 🛠️ App and Bot Development

- Price tickers for portfolio apps and Discord bots
- Alert engines fired on percent-change thresholds
- Symbol autocomplete with canonical Kraken pair codes
- Liquidity scoreboards for retail trading dashboards

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Kraken Crypto Exchange Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Schedule a 5-minute pull to keep a rolling Kraken ticker table fresh in your analytics warehouse.

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

The actor calls Kraken's public REST API `/0/public/Ticker` for either all pairs or a list you supply, and merges metadata from `/0/public/AssetPairs` (wsname, altname, base, quote). Each pair is unpacked from Kraken's nested tuple format (`a`, `b`, `c`, `v`, `p`, `t`, `l`, `h`, `o`) into flat named numeric fields. Spread, price change, and percent change are computed inline against the open and last prices.

#### 📏 How accurate is the data?

Prices are exactly what Kraken returned at the moment of the API call. The 24-hour window slides continuously while the "today" window resets at 00:00 UTC, so two close-in-time runs can show slightly different intraday numbers. `scrapedAt` records the precise run timestamp.

#### 🔁 How fresh is the data?

Every run hits the live API. No cache, no scheduled snapshot. Kraken's ticker endpoint refreshes near-real-time, so the snapshot reflects within-second-level pricing.

#### 🔤 Why do bases sometimes start with X or Z?

Kraken uses legacy ISO-style prefixes for some assets: `X` for crypto (e.g. `XXBT` for Bitcoin) and `Z` for fiat (e.g. `ZUSD`). The actor returns both the raw Kraken code (`XXBT`, `ZUSD`) and the canonical wsname (`XBT/USD`) so you can join against ISO-style ticker conventions.

#### 🚫 Can I include futures or margin contracts?

This actor returns Kraken's spot ticker data. Futures and margin contracts trade on Kraken Futures (a separate API surface) and are not included. Open the contact form below if you need a dedicated Kraken Futures scraper.

#### ⚖️ Is this data legal to use?

Kraken publishes ticker data through a public REST endpoint without authentication. Market data redistribution rules vary by jurisdiction, so review Kraken's API terms of service and your local rules before redistributing the data commercially.

#### 💼 Can I use this data commercially?

Yes, within the limits of Kraken's API terms of use. Internal analytics, dashboards, treasury reporting, and oracle pipelines are common commercial applications. Bulk resale of real-time feeds may require explicit licensing from Kraken.

#### 💳 Do I need a paid Apify plan to run this actor?

No. The free Apify plan ships with **$5 monthly credit**, enough for several runs. Free users are limited to 10 items per run for preview. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) to lift the cap to 1,000,000 items.

#### 🚨 What happens if my run fails or returns no results?

Failed runs are not charged. Kraken occasionally returns 429 or 503 codes; the actor retries with backoff respecting any `Retry-After` header. If the run still fails or a pair filter matches nothing, check the run log or open the [contact form](https://tally.so/r/BzdKgA).

#### 📤 How do I export the data?

Apify datasets export as CSV, JSON, JSONL, Excel, HTML, XML, or RSS with one click. You can also pull results via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, Snowflake, and other warehouses through built-in integrations.

#### 📅 Can I schedule the actor to run automatically?

Yes. Apify Schedules supports any cron expression. A 5-minute schedule builds a rolling intraday Kraken ticker archive. Daily schedules give a clean end-of-day mark file. Outputs can fan out to webhooks, Slack, email, or cloud storage.

***

### 🔌 Integrate with any app

Kraken Crypto Exchange Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications and price alerts
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe ticker data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

Use webhooks to fan out new Kraken snapshots to your trading engine, alerting system, or downstream analytics jobs the second a run finishes.

***

### 🔗 Recommended Actors

- [**💰 Binance Crypto Prices Scraper**](https://apify.com/parseforge/binance-prices-scraper) - Live 24h tickers across thousands of Binance spot pairs
- [**🟦 OKX Spot Prices Scraper**](https://apify.com/parseforge/okx-spot-prices-scraper) - OKX spot ticker snapshots across hundreds of pairs
- [**🟧 Bybit Tickers Scraper**](https://apify.com/parseforge/bybit-tickers-scraper) - Bybit spot, USDT-perpetual, and inverse derivatives
- [**💰 CoinGecko Cryptocurrency Scraper**](https://apify.com/parseforge/coingecko-scraper) - Cross-exchange aggregate prices, market cap, and supply metrics
- [**📊 CoinPaprika Tickers Scraper**](https://apify.com/parseforge/coinpaprika-tickers-scraper) - Multi-currency market caps with multi-timeframe percent change

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more crypto and market-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Payward Inc. (Kraken). All trademarks mentioned are the property of their respective owners. Only publicly available data is collected.

# Actor input Schema

## `pairs` (type: `array`):

Specific pairs to scrape (e.g. XBTUSD, ETHUSD). Leave empty for all pairs.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `sortBy` (type: `string`):

Sort results by this field

## Actor input object example

```json
{
  "pairs": [],
  "maxItems": 10,
  "sortBy": "volume24h"
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete 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 = {
    "maxItems": 10,
    "sortBy": "volume24h"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/kraken-exchange-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 = {
    "maxItems": 10,
    "sortBy": "volume24h",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/kraken-exchange-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 '{
  "maxItems": 10,
  "sortBy": "volume24h"
}' |
apify call parseforge/kraken-exchange-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kraken Crypto Exchange Scraper",
        "description": "Scrape live cryptocurrency ticker data from Kraken public API including price, volume, bid/ask, 24h high/low for all trading pairs. No API key required.",
        "version": "0.0",
        "x-build-id": "txHuaH7cTV6DabrT8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~kraken-exchange-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-kraken-exchange-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/parseforge~kraken-exchange-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-kraken-exchange-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/parseforge~kraken-exchange-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-kraken-exchange-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": {
                    "pairs": {
                        "title": "Trading Pairs (optional)",
                        "type": "array",
                        "description": "Specific pairs to scrape (e.g. XBTUSD, ETHUSD). Leave empty for all pairs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "volume24h",
                            "lastPrice",
                            "pair"
                        ],
                        "type": "string",
                        "description": "Sort results by this field",
                        "default": "volume24h"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
