# WhiteBIT Crypto Tickers Scraper (`parseforge/whitebit-tickers-scraper`) Actor

Scrape live spot tickers from WhiteBIT public API including last price, 24h volume, change percent, and frozen status for all trading pairs. No API key required.

- **URL**: https://apify.com/parseforge/whitebit-tickers-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 $25.13 / 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://github.com/ParseForge/apify-assets/raw/main/banner.jpg)

## ⚪ WhiteBIT Crypto Tickers Scraper

> 🚀 **Export live spot and perpetual tickers from the WhiteBIT public API in seconds.** Pull **every trading pair** with last price, base and quote volume, percent change, and frozen status. No API key, no rate-limit setup.

> 🕒 **Last updated:** 2026-05-13 · **📊 10 fields** per record · **⚪ 1,000+ markets** · **💵 USDT / USDC / USD / BTC quotes** · **🇪🇺 EU-headquartered exchange**

The **WhiteBIT Tickers Scraper** queries the WhiteBIT public v4 ticker endpoint and returns **10 fields per record**, including the trading symbol, base and quote assets, last price, base and quote volume, 24h percent change, frozen status, and a direct link to the trade page. WhiteBIT is one of the largest European cryptocurrency exchanges, headquartered in Estonia, with deep coverage of USDT pairs alongside USDC, USD, BTC, and several fiat quote currencies.

The feed is built around a single upstream call (`/api/v4/public/ticker`) that returns every active market as an object map, which this Actor flattens, parses, sorts, and writes to a clean dataset.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Quant teams, market-data engineers, arbitrage desks, exchange researchers, fintech and trading-product builders | Cross-exchange spreads, perpetual funding signals, USDT volume scans, dashboard feeds, alerting, market-cap snapshots |

---

### 📋 What the WhiteBIT Scraper does

Four built-in workflows in a single run:

- 🌍 **Full market export.** All active WhiteBIT tickers (spot, perp, fiat) in one pull.
- 💵 **Quote-currency filter.** Restrict to `USDT`, `USDC`, `USD`, or `BTC` pairs.
- 📊 **Server-side sort.** Order by 24h quote volume, percent change, last price, or symbol.
- 🧊 **Frozen-status flag.** Each record exposes the exchange's `isFrozen` flag so you can detect halted pairs.

Each record includes the symbol (e.g. `BTC_USDT`), split base and quote assets, raw price and volume numbers, percent change for the 24h window, the frozen flag, and a deep link to the corresponding trade page on WhiteBIT.

> 💡 **Why it matters:** WhiteBIT consistently ranks in the top global exchanges by reported spot volume and is a key venue for European crypto-asset trading. Clean tickers feed arbitrage bots, market-data dashboards, treasury exports, and any system that needs live USDT-denominated quotes alongside or instead of CEX majors.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough from signup to a downloaded WhiteBIT dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>quoteCurrency</code></td><td>string</td><td><code>""</code></td><td>One of <code>USDT</code>, <code>USDC</code>, <code>USD</code>, <code>BTC</code>, or empty for all pairs.</td></tr>
<tr><td><code>sortBy</code></td><td>string</td><td><code>"volume"</code></td><td>One of <code>volume</code>, <code>changePercent</code>, <code>price</code>, <code>symbol</code>.</td></tr>
</tbody>
</table>

**Example: top 50 USDT markets by 24h quote volume.**

```json
{
    "maxItems": 50,
    "quoteCurrency": "USDT",
    "sortBy": "volume"
}
````

**Example: biggest 24h movers across all quote currencies.**

```json
{
    "maxItems": 25,
    "quoteCurrency": "",
    "sortBy": "changePercent"
}
```

> ⚠️ **Good to Know:** WhiteBIT's public ticker endpoint returns a single payload covering every active market, which makes this Actor very fast. The `change` field is already expressed as a percent. Pairs ending in `_PERP` are perpetual contracts, and they show up alongside spot markets in the feed.

***

### 📊 Output

Each ticker record contains **10 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `symbol` | string | `"BTC_PERP"` |
| 🔗 `url` | string | `"https://whitebit.com/trade/BTC_PERP"` |
| 🪙 `base` | string | `"BTC"` |
| 💵 `quote` | string | `"PERP"` |
| 💰 `last_price` | number | `79332.4` |
| 📦 `base_volume` | number | `50878.331` |
| 📊 `quote_volume` | number | `4096202800.5908` |
| 📈 `change` | number | `-1.58` |
| 🧊 `isFrozen` | boolean | `false` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T22:24:59.589Z"` |

#### 📦 Sample records

<details>
<summary><strong>🟠 Bitcoin perpetual: BTC_PERP</strong></summary>

```json
{
    "symbol": "BTC_PERP",
    "url": "https://whitebit.com/trade/BTC_PERP",
    "base": "BTC",
    "quote": "PERP",
    "last_price": 79332.4,
    "base_volume": 50878.331,
    "quote_volume": 4096202800.5908,
    "change": -1.58,
    "isFrozen": false,
    "scrapedAt": "2026-05-13T22:24:59.589Z"
}
```

</details>

<details>
<summary><strong>🟣 Ether perpetual: ETH_PERP</strong></summary>

```json
{
    "symbol": "ETH_PERP",
    "url": "https://whitebit.com/trade/ETH_PERP",
    "base": "ETH",
    "quote": "PERP",
    "last_price": 2254.31,
    "base_volume": 861816.67,
    "quote_volume": 1968087851.0775,
    "change": -1.44,
    "isFrozen": false,
    "scrapedAt": "2026-05-13T22:24:59.589Z"
}
```

</details>

<details>
<summary><strong>🟢 Solana perpetual: SOL_PERP</strong></summary>

```json
{
    "symbol": "SOL_PERP",
    "url": "https://whitebit.com/trade/SOL_PERP",
    "base": "SOL",
    "quote": "PERP",
    "last_price": 90.8912,
    "base_volume": 4790187.17,
    "quote_volume": 447881870.246578,
    "change": -4.1,
    "isFrozen": false,
    "scrapedAt": "2026-05-13T22:24:59.589Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇪🇺 | **European exchange.** WhiteBIT is headquartered in Estonia and ranks among the largest crypto venues by spot volume. |
| 💵 | **Multi-quote coverage.** USDT, USDC, USD, BTC pairs, plus regional fiat quotes (KZT, TRY) and PERP contracts. |
| 🔖 | **Compact 10-field schema.** Easy to ingest into spreadsheets, BI tools, and downstream pipelines. |
| 📊 | **Server-side sorting and filtering.** Quote-currency filter and four sort modes, no post-processing required. |
| ⚡ | **Fast.** Hundreds of markets returned in a single upstream call, typically under 5 seconds. |
| 🧊 | **Halt detection.** The `isFrozen` flag surfaces venue-side trading pauses. |
| 🚫 | **No authentication.** Uses only public endpoints. No API key, no IP allowlist. |

> 📊 WhiteBIT ticker data is a strong complement to Binance, OKX, and Bybit feeds in any global crypto market-data stack.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ WhiteBIT Tickers Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All active WhiteBIT markets** | **Live per run** | quote currency, sort, max items | ⚡ 2 min |
| Aggregator APIs (CoinGecko, CMC) | Free tier + paid plans | Many exchanges, less granular | Minutes | API-specific | ⏳ Hours |
| Direct WhiteBIT SDKs | Free | Same upstream, but you maintain code | On-demand | Build your own | 🛠️ Days |
| Manual page scraping | Free | Fragile, captcha-prone | Variable | None | 🐢 Brittle |

Pick this Actor when you want a ready-to-use feed of WhiteBIT tickers with zero maintenance.

***

### 🚀 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 WhiteBIT Crypto Tickers Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a quote currency (or leave empty for all), choose a sort, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull live tickers from WhiteBIT.
5. 📥 **Download.** Grab your results from the **Dataset** tab as CSV, Excel, JSON, or XML.

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

***

### 💼 Business use cases

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

#### 🤖 Trading & Arbitrage

- Cross-exchange spread monitoring against Binance, OKX, Bybit
- Perpetual funding and basis monitoring on `_PERP` pairs
- 24h volume scans for liquidity filters
- Top-of-stack alerts on biggest gainers and losers

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

#### 📊 Market Data & Research

- Global exchange coverage gap-filler for data products
- Long-tail altcoin discovery on USDT pairs
- Volume share comparisons across CEX venues
- Time-series snapshots stored on a schedule

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

#### 💼 Fintech & Product

- In-app price tickers for crypto wallets and apps
- Watchlist seeds with canonical symbol naming
- Embedded widgets for media and content sites
- Reference data for portfolio reporting tools

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

#### 💰 Treasury & Reporting

- Mark-to-market valuations for holdings on WhiteBIT
- Daily price snapshots for accounting exports
- Audit trails on listed markets and halts via `isFrozen`
- Cross-quote conversions through USDT and BTC pairs

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

***

### 🔌 Automating WhiteBIT Tickers 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. Minute-level scrapes feed real-time dashboards, while hourly or daily pulls keep BI warehouses in sync.

***

### 🌟 Beyond business use cases

Structured ticker data fuels more than commercial workflows. The same records support research, education, civic transparency, and personal projects.

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

#### 🎓 Research and academia

- Microstructure studies on USDT pairs across venues
- Coursework on order-book metrics and volume analysis
- Reproducible academic papers with versioned pulls
- Cross-exchange comparison datasets for theses

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

#### 🎨 Personal and creative

- Personal portfolio trackers and dashboards
- Side projects and indie crypto apps
- Content pieces about emerging-market liquidity
- Hobbyist trading bots that need a clean live feed

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

#### 🤝 Non-profit and civic

- Transparency feeds for crypto-savvy NGOs
- Journalism on global exchange flows
- Donor analytics for orgs accepting crypto
- Open-data feeds for civic-tech communities

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

#### 🧪 Experimentation

- Train forecasting models on USDT time series
- Prototype arbitrage agents with safe paper-trading data
- Test alerting pipelines on real percent moves
- Validate fintech product hypotheses with live numbers

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

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20WhiteBIT%20Tickers%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20WhiteBIT%20Tickers%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20WhiteBIT%20Tickers%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20WhiteBIT%20Tickers%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

The Actor hits a single public WhiteBIT endpoint (`/api/v4/public/ticker`) that returns every active market as an object map. It flattens that map, splits each symbol into base and quote assets, applies your quote-currency and sort filters, caps to `maxItems`, and writes one clean record per market to the dataset.

#### 🔁 How often is the data refreshed?

Every run pulls the latest ticker payload directly from WhiteBIT. Tickers update on the exchange every few seconds, so a freshly triggered run is as live as the WhiteBIT API itself.

#### 🌍 What quote currencies are supported?

WhiteBIT lists pairs quoted in USDT, USDC, USD, BTC, and several regional fiat currencies. The `quoteCurrency` filter accepts the four most common values. Leave it empty to get every market in one pull.

#### 🔥 What is `_PERP`?

Symbols ending in `_PERP` are perpetual swap contracts. They live alongside spot pairs in the same payload, and the schema treats `PERP` as the quote currency suffix so you can identify and filter them downstream.

#### 🔐 Do I need an API key?

No. The endpoints used here are entirely public. No login, no API key, no IP allowlist.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron cadence. Minute-level scrapes feed real-time dashboards, hourly or daily pulls keep warehouses in sync.

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

WhiteBIT publishes ticker data through public endpoints. Review the venue terms of service for your specific commercial use, but raw market-data feeds are generally accepted for analytical and trading workflows.

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

Yes. Public exchange ticker data is broadly usable for commercial analytics. Confirm your downstream license obligations for any redistribution to third parties.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts that limit and unlocks scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. The Actor also retries 429 and 503 responses internally with exponential backoff. Partial datasets from failed runs are preserved, so you never lose progress.

#### 🛬 What if I need order-book depth?

This Actor returns ticker-level data only. For full order-book depth, use the WhiteBIT depth or WebSocket endpoints directly, or reach out via the contact form for a companion order-book scraper.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

WhiteBIT Tickers 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 in your channels
- [**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 and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh tickers into your product backend, or alert your team in Slack on big moves.

***

### 🔗 Recommended Actors

- [**🤖 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - Open-source AI model directory and metadata
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🏢 AWS Marketplace Scraper**](https://apify.com/parseforge/aws-marketplace-scraper) - Cloud software listings and pricing
- [**🔌 Stripe App Marketplace Scraper**](https://apify.com/parseforge/stripe-marketplace-scraper) - Fintech app directory metadata
- [**✈️ OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport reference dataset

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-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 WhiteBIT or any of its partners. All trademarks mentioned are the property of their respective owners. Only publicly available ticker data is collected.

# Actor input Schema

## `quoteCurrency` (type: `string`):

Filter pairs by quote currency. 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
{
  "quoteCurrency": "",
  "maxItems": 10,
  "sortBy": "volume"
}
```

# 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 = {
    "quoteCurrency": "",
    "maxItems": 10,
    "sortBy": "volume"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WhiteBIT Crypto Tickers Scraper",
        "description": "Scrape live spot tickers from WhiteBIT public API including last price, 24h volume, change percent, and frozen status for all trading pairs. No API key required.",
        "version": "0.0",
        "x-build-id": "jjqviuPZrDkNfSV8U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~whitebit-tickers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-whitebit-tickers-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~whitebit-tickers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-whitebit-tickers-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~whitebit-tickers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-whitebit-tickers-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": {
                    "quoteCurrency": {
                        "title": "Quote Currency Filter",
                        "enum": [
                            "",
                            "USDT",
                            "USDC",
                            "USD",
                            "BTC"
                        ],
                        "type": "string",
                        "description": "Filter pairs by quote currency. Leave empty for all pairs.",
                        "default": ""
                    },
                    "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": [
                            "volume",
                            "changePercent",
                            "price",
                            "symbol"
                        ],
                        "type": "string",
                        "description": "Sort results by this field",
                        "default": "volume"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
