# BingX Crypto Ticker Scraper - Prices, Volume & 24h Change (`ninhothedev/bingx-scraper`) Actor

$0.5/1K 🔥 BingX crypto scraper! Price, 24h volume, high/low & change for 800+ spot pairs. No key. JSON, CSV, Excel or API in seconds. Feed trading bots, alerts & portfolio tools ⚡

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

## Pricing

from $0.50 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## BingX Crypto Ticker Scraper - Live Prices, 24h Volume & Change (No API Key)

Scrape **live BingX spot market data** for every trading pair in seconds. This Apify Actor pulls the official public BingX ticker endpoint and returns a clean, flat, ready-to-analyse record for each market: last price, bid, ask, 24h high/low, base volume, quote volume, absolute price change and a **normalized 24h percent change**.

No API key. No login. No proxy. No BingX account. Just run it and get data.

***

### What this BingX scraper does

- Fetches the **complete BingX spot ticker snapshot** (800+ trading pairs) in a single request
- Returns **normalized numeric fields** - every price and volume is a real `float`, not a string
- Normalizes BingX's `"-2.95%"` string into a clean numeric `change_pct_24h` of `-2.95`
- Converts `closeTime` epoch milliseconds into an **ISO-8601 UTC timestamp**
- Optional **symbol filter**: get only USDT markets, only BTC pairs, or one specific pair
- Sorts results by **24h quote volume** so the most liquid markets come first
- Exports to **JSON, CSV, Excel, XML** or straight into your own pipeline via the Apify API

### Why use it

Crypto data is only useful when it is fast, clean and consistent. Exchange APIs return mixed types, percent signs inside strings, and epoch timestamps that break spreadsheets. This BingX ticker scraper normalizes all of it for you, so your dashboard, trading bot or research notebook can consume the output directly.

### Use cases

- **Crypto trading** - screen BingX markets for the biggest 24h movers, spread opportunities or breakout candidates before entering a position.
- **Price monitoring** - schedule the Actor every few minutes and build a time series of BingX prices, spreads and volumes.
- **Trading bots** - feed live BingX prices, bid/ask and liquidity into signal generation, backtests or automated execution logic.
- **Portfolio tracking** - value a BingX portfolio in USDT or BTC, track 24h P\&L, and reconcile positions across exchanges.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | select | `tickers` | What to scrape. `tickers` returns the 24h ticker snapshot for every BingX spot pair. |
| `symbolFilter` | string | *(empty)* | Case-insensitive substring filter on the BingX symbol (`BASE-QUOTE`). e.g. `USDT`, `BTC`, `SOL-USDT`. Empty = all pairs. |
| `maxItems` | integer | `500` | Maximum records to save (hard cap `5000`). Pairs are sorted by liquidity, so a small limit still returns the top markets. |

#### Example input

```json
{
  "mode": "tickers",
  "symbolFilter": "USDT",
  "maxItems": 500
}
```

### Output

Each dataset item is one BingX trading pair:

```json
{
  "symbol": "BTC-USDT",
  "last_price": 63278.34,
  "open": 65166.49,
  "high_24h": 65737.21,
  "low_24h": 63066.58,
  "bid": 63278.33,
  "ask": 63278.34,
  "base_volume_24h": 2377.29,
  "quote_volume_24h": 153875199.24,
  "price_change": -1888.15,
  "change_pct_24h": -2.9,
  "close_time": "2026-07-28T01:51:03.351000+00:00",
  "source": "bingx",
  "scraped_at": "2026-07-28T01:51:03.741032+00:00"
}
```

#### Field reference

| Field | Type | Meaning |
| --- | --- | --- |
| `symbol` | string | BingX market symbol, format `BASE-QUOTE` (e.g. `BTC-USDT`) |
| `last_price` | float | Most recent traded price |
| `open` | float | Price 24 hours ago |
| `high_24h` | float | Highest price in the last 24 hours |
| `low_24h` | float | Lowest price in the last 24 hours |
| `bid` | float | Best bid price on the order book |
| `ask` | float | Best ask price on the order book |
| `base_volume_24h` | float | 24h traded volume in the base asset |
| `quote_volume_24h` | float | 24h traded volume in the quote asset (liquidity proxy) |
| `price_change` | float | Absolute 24h price change |
| `change_pct_24h` | float | 24h change as a percent, rounded to 2 decimals (`-2.9` = -2.9%) |
| `close_time` | string | Ticker window close time, ISO-8601 UTC |
| `source` | string | Always `bingx` |
| `scraped_at` | string | When the record was captured, ISO-8601 UTC |

All fields are nullable - if BingX omits a value for an illiquid pair you get `null` instead of a broken row.

### Pricing

Roughly **$0.50 per 1,000 results**. One run over the full BingX spot universe (800+ pairs) costs well under a cent of compute plus platform usage. The Actor makes a single HTTP request regardless of how many pairs you keep, so it is cheap to schedule frequently.

### How to use

1. Click **Try for free** / **Start**
2. Optionally set `symbolFilter` (e.g. `USDT`) and `maxItems`
3. Run the Actor - it finishes in seconds
4. Download the dataset as JSON, CSV or Excel, or pull it via the Apify API
5. Schedule it (every 5 minutes, hourly, daily) to build a price history

### Run it locally

```bash
git clone https://github.com/notninoo-private/bingx-scraper.git
cd bingx-scraper
pip install -r requirements.txt
python -m src.main
```

### FAQ

**Do I need a BingX API key?** No. This Actor uses BingX's public market-data endpoint, which requires no key, no signature and no account.

**Is scraping BingX prices legal?** This Actor only reads publicly available market data that BingX publishes for everyone. No personal data is collected.

**Is `change_pct_24h` a fraction or a percent?** A percent. BingX returns `"-2.95%"` as a string; the Actor strips the sign and stores `-2.95`.

**How fresh is the data?** Every run hits BingX live. `close_time` tells you the exchange-side window and `scraped_at` tells you when the Actor captured it.

**How many pairs does BingX have?** Around 800 spot pairs, most of them quoted in USDT.

**Can I get just one pair?** Yes - set `symbolFilter` to the exact symbol, e.g. `SOL-USDT`.

**Can I use it for futures?** This Actor covers the **spot** market. Ask and futures support can be added.

### Related crypto scrapers

Building a multi-exchange dataset? Combine this Actor with:

- [OKX Scraper](https://apify.com/ninhothedev/okx-scraper)
- [Bitget Scraper](https://apify.com/ninhothedev/bitget-scraper)
- [MEXC Scraper](https://apify.com/ninhothedev/mexc-scraper)
- [Gate.io Scraper](https://apify.com/ninhothedev/gateio-scraper)

### Support

Found a bug or need an extra field (order books, klines, futures)? Open an issue on the Actor page - feature requests are usually shipped fast.

### Disclaimer

This Actor returns public market data for informational purposes only. It is not financial advice. Trading crypto assets carries risk.

# Actor input Schema

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

What to scrape from BingX. 'tickers' fetches the 24h ticker snapshot (last price, bid, ask, high, low, volume and percent change) for every BingX spot trading pair in a single request.

## `symbolFilter` (type: `string`):

Optional case-insensitive substring filter applied to the BingX symbol (format BASE-QUOTE, e.g. BTC-USDT). Use 'USDT' for all USDT markets, 'BTC' for every pair containing BTC, or 'SOL-USDT' for one specific pair. Leave empty to return all spot pairs.

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

Maximum number of ticker records to save to the dataset. Pairs are sorted by 24h quote volume (most liquid first), so a low limit still returns the most relevant markets. Default 500, hard maximum 5000.

## Actor input object example

```json
{
  "mode": "tickers",
  "symbolFilter": "USDT",
  "maxItems": 500
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("ninhothedev/bingx-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ninhothedev/bingx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BingX Crypto Ticker Scraper - Prices, Volume & 24h Change",
        "description": "$0.5/1K 🔥 BingX crypto scraper! Price, 24h volume, high/low & change for 800+ spot pairs. No key. JSON, CSV, Excel or API in seconds. Feed trading bots, alerts & portfolio tools ⚡",
        "version": "0.1",
        "x-build-id": "6JYoSe0b6EkxyZErf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ninhothedev~bingx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ninhothedev-bingx-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/ninhothedev~bingx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ninhothedev-bingx-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/ninhothedev~bingx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ninhothedev-bingx-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": "Scrape mode",
                        "enum": [
                            "tickers"
                        ],
                        "type": "string",
                        "description": "What to scrape from BingX. 'tickers' fetches the 24h ticker snapshot (last price, bid, ask, high, low, volume and percent change) for every BingX spot trading pair in a single request.",
                        "default": "tickers"
                    },
                    "symbolFilter": {
                        "title": "Symbol filter (optional)",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter applied to the BingX symbol (format BASE-QUOTE, e.g. BTC-USDT). Use 'USDT' for all USDT markets, 'BTC' for every pair containing BTC, or 'SOL-USDT' for one specific pair. Leave empty to return all spot pairs."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of ticker records to save to the dataset. Pairs are sorted by 24h quote volume (most liquid first), so a low limit still returns the most relevant markets. Default 500, hard maximum 5000.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
