# Kraken Market Scraper (`logiover/kraken-market-scraper`) Actor

Scrape live market data for every trading pair on Kraken in one run — last price, 24h change, high/low, volume, VWAP, trade count and bid/ask. Schedule it for a continuously fresh price feed.

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

## Pricing

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

## DexScreener Token & Pair Scraper — Scrape New Crypto Tokens & DEX Pairs

Scrape newly listed tokens and trading pairs from **DexScreener** across all chains — Solana, Ethereum, Base, BSC and more. This DexScreener scraper extracts price, 24h volume, liquidity, FDV, market cap, 24h price change and transaction counts for every token and pair, with filters for chain, minimum liquidity and search query. **No login and no API key required.** Built for scheduled, recurring use — crypto data changes constantly, so run it on a schedule for a continuously fresh feed exported to JSON, CSV or Excel.

### ✨ What this Actor does / Key features

- 🆕 **Newest listings mode** — pull the latest tokens listed on DexScreener, enriched with full market data.
- 🔎 **Search mode** — find pairs by token name, symbol or contract address.
- ⛓️ **Multi-chain coverage** — filter by chain (Solana, Ethereum, Base, BSC, etc.) or scrape all chains at once.
- 💧 **Liquidity filter** — set a minimum USD liquidity threshold to filter out dead and scam tokens.
- 📈 **Rich market data** — price (USD), 24h volume, liquidity, FDV, market cap, 24h price change and 24h transaction count.
- 🏷️ **Token & pair identifiers** — token name, symbol, token address, pair address, DEX name and the DexScreener URL.
- ⚡ **Fast API-based scraping** — clean structured JSON with no browser overhead.
- ⏱️ **Schedule-ready** — designed for recurring runs to maintain a live token feed.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | `latest` = newest listed tokens enriched with market data; `search` = search pairs by query. |
| `searchQuery` | string | Token name, symbol or address (used in `search` mode). |
| `chains` | array | Filter by chain, e.g. "solana", "ethereum", "base", "bsc". Leave empty for all chains. |
| `minLiquidityUsd` | integer | Only return pairs with at least this much liquidity (USD). Filters out dead/scam tokens. |
| `maxResults` | integer | Maximum tokens/pairs to save. |

### 🚀 Example input

```json
{
  "mode": "latest",
  "searchQuery": "",
  "chains": ["solana", "base"],
  "minLiquidityUsd": 10000,
  "maxResults": 200
}
````

### 📦 Output

Each token/pair is saved as a structured item in the dataset. Export to JSON, CSV, Excel or XML, or pull via the Apify API.

| Field | Description |
|-------|-------------|
| `chain` | Blockchain the pair is on |
| `dex` | Decentralized exchange the pair trades on |
| `tokenName` | Token name |
| `tokenSymbol` | Token symbol / ticker |
| `tokenAddress` | Token contract address |
| `pairAddress` | Trading pair address |
| `priceUsd` | Current token price in USD |
| `volume24h` | 24-hour trading volume (USD) |
| `liquidityUsd` | Pool liquidity in USD |
| `fdv` | Fully diluted valuation |
| `marketCap` | Market capitalization |
| `priceChange24h` | 24-hour price change (%) |
| `txns24h` | Number of transactions in the last 24 hours |
| `pairCreatedAt` | When the trading pair was created |
| `url` | DexScreener pair URL |
| `scrapedAt` | Scrape timestamp (ISO 8601) |

### 💡 Use cases

- **Memecoin & launch hunters** — monitor newly listed tokens across chains the moment they appear.
- **Crypto traders** — track price, volume and liquidity changes to spot momentum and entry points.
- **DeFi analysts** — study new pair creation rates, liquidity depth and trading activity per chain and DEX.
- **Risk screening** — use the minimum-liquidity filter to surface only tradable tokens and skip rug-prone listings.
- **Dashboards & alerts** — feed a live token feed into your own dashboards, Telegram bots or trading tools.
- **Market research** — analyze trends in DEX activity, token launches and FDV/market-cap distributions over time.

### ❓ Frequently Asked Questions

**Is it legal to scrape DexScreener?**
The Actor only collects publicly available market data displayed on DexScreener. You are responsible for using the data in compliance with DexScreener's terms and applicable laws. This is market data, not financial advice.

**Do I need an API key or a login?**
No. There is no DexScreener account, login or API key required. You only need an Apify account to run the Actor.

**How fresh is the data?**
Data is pulled live at run time. Because crypto prices and liquidity change constantly, schedule the Actor to run frequently for a continuously fresh feed.

**Can I filter by chain or liquidity?**
Yes. You can filter by one or more chains and set a minimum USD liquidity threshold to exclude dead or scam tokens.

**What's the difference between `latest` and `search` mode?**
`latest` mode returns the newest tokens listed on DexScreener enriched with market data. `search` mode lets you look up specific pairs by token name, symbol or contract address.

**How many tokens can I scrape per run?**
Use the `maxResults` field to control how many tokens/pairs are saved per run — from a small watchlist to large bulk pulls.

**What output formats are supported?**
Results are stored in a structured Apify dataset and can be exported as JSON, CSV, Excel or XML, or accessed via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to keep a continuously fresh token and pair feed. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to dashboards, Telegram/Discord bots and webhooks through the Apify API.

# Actor input Schema

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

'latest' = newest listed tokens enriched with market data; 'search' = search pairs by query.

## `searchQuery` (type: `string`):

Token name, symbol or address (used in 'search' mode).

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

Filter by chain, e.g. 'solana', 'ethereum', 'base', 'bsc'. Leave empty for all chains.

## `minLiquidityUsd` (type: `integer`):

Only return pairs with at least this much liquidity. Filters out dead/scam tokens.

## `maxResults` (type: `integer`):

Maximum tokens/pairs to save.

## Actor input object example

```json
{
  "mode": "latest",
  "searchQuery": "",
  "chains": [],
  "minLiquidityUsd": 0,
  "maxResults": 100
}
```

# Actor output Schema

## `tokenName` (type: `string`):

tokenName

## `tokenSymbol` (type: `string`):

tokenSymbol

## `chain` (type: `string`):

chain

## `priceUsd` (type: `string`):

priceUsd

## `volume24h` (type: `string`):

volume24h

## `liquidityUsd` (type: `string`):

liquidityUsd

## `marketCap` (type: `string`):

marketCap

## `priceChange24h` (type: `string`):

priceChange24h

## `url` (type: `string`):

url

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "chains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/kraken-market-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "chains": [] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/kraken-market-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 '{
  "chains": []
}' |
apify call logiover/kraken-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kraken Market Scraper",
        "description": "Scrape live market data for every trading pair on Kraken in one run — last price, 24h change, high/low, volume, VWAP, trade count and bid/ask. Schedule it for a continuously fresh price feed.",
        "version": "0.0",
        "x-build-id": "c5TdLVrP5dudsv7Yp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~kraken-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-kraken-market-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/logiover~kraken-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-kraken-market-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/logiover~kraken-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-kraken-market-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "latest",
                            "search"
                        ],
                        "type": "string",
                        "description": "'latest' = newest listed tokens enriched with market data; 'search' = search pairs by query.",
                        "default": "latest"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Token name, symbol or address (used in 'search' mode).",
                        "default": ""
                    },
                    "chains": {
                        "title": "Chains",
                        "type": "array",
                        "description": "Filter by chain, e.g. 'solana', 'ethereum', 'base', 'bsc'. Leave empty for all chains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minLiquidityUsd": {
                        "title": "Min Liquidity (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return pairs with at least this much liquidity. Filters out dead/scam tokens.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum tokens/pairs to save.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
