# Bitget Tickers Scraper (`maximedupre/bitget-tickers-scraper`) Actor

Scrape live Bitget tickers from spot, USDT futures, and coin futures markets. Export prices, 24h change, volume, bid/ask, spreads, funding rate, open interest, source links, and timestamps without a Bitget API key.

- **URL**: https://apify.com/maximedupre/bitget-tickers-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.85 / 1,000 tickers

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

### 📈 Bitget tickers scraper for live market data

Bitget Tickers Scraper exports live ticker snapshots from [Bitget](https://www.bitget.com/) spot, USDT futures, and coin futures markets. Use it to collect Bitget market data such as prices, 24h changes, volumes, bid/ask quotes, spreads, funding rates, open interest, source links, and scrape timestamps in one clean Apify dataset.

This Bitget tickers scraper is built for crypto analysts, trading dashboards, quant research, portfolio monitoring, funding-rate checks, and scheduled price feeds. Instead of wiring several Bitget market categories yourself, run the Actor from Apify Console, call it with the Apify API, schedule repeat snapshots, export CSV/JSON/Excel files, or connect the dataset to webhooks and integrations.

For a small first run, keep the prefilled `spot` category, leave `Quote asset` as `USDT`, and keep `Maximum tickers` at `10`. That returns a quick USDT spot-market sample before you widen the run to futures or all matching markets.

### ✅ What this Actor does

- Scrapes live Bitget spot ticker data.
- Scrapes Bitget USDT futures ticker data.
- Scrapes Bitget coin futures ticker data.
- Filters by quote asset, base asset, or explicit Bitget symbols when provided.
- Sorts matching markets by USDT volume, quote volume, base volume, 24h price change, spread, funding rate, open interest, last price, or symbol.
- Saves one dataset item per accepted Bitget market ticker.
- Includes source URLs, normalized asset fields, prices, volumes, bid/ask data, spread fields, futures fields, ticker timestamps, and scrape timestamps.
- Works without a Bitget API key, login, or user-provided cookies.

The Actor is focused on current ticker snapshots. It does not return order book depth, trades, candles, private account balances, alerts, predictions, or historical archives by itself. If you need history, schedule the Actor and store each finished dataset in your own database or warehouse.

### 📦 Data you can extract

Each output item represents one Bitget market instrument. Fields include:

- `symbol` and `category` for the Bitget market instrument and market type.
- `sourceUrl` for the related Bitget market surface.
- `baseAsset`, `quoteAsset`, `contractType`, and `settleAsset` when available.
- `lastPrice`, `openPrice24h`, `openPriceUtc`, `highPrice24h`, and `lowPrice24h`.
- `priceChangePercent24h` and `priceChangePercentUtc`.
- `bidPrice`, `bidSize`, `askPrice`, and `askSize`.
- `spreadAbs` and `spreadBps` for bid/ask spread analysis.
- `volume24h`, `quoteVolume24h`, and `usdtVolume24h`.
- `fundingRate` and `openInterest` for futures markets when Bitget exposes them.
- `tickerTime` and `scrapedAt` timestamps.

Some fields are category-specific. Spot rows do not have funding rate or open interest. If Bitget does not expose a value for a market, the field may be absent from that row.

### 🚀 How to run it

1. Choose one or more **Market categories**: `spot`, `usdt-futures`, or `coin-futures`.
2. Keep `Quote asset` as `USDT` for a small first run, or clear it to include every quote asset.
3. Optional: add a `Base asset` such as `BTC`, `ETH`, or `SOL`.
4. Optional: add exact Bitget symbols such as `BTCUSDT`, `ETHUSDT`, or `BTCUSD`.
5. Set `Maximum tickers`. Use `0` only when you want every matching ticker.
6. Pick the sort order and run the Actor.

You can open the dataset in Apify, download it as JSON, CSV, Excel, XML, RSS, or HTML, or pull the same rows through the Apify API.

### ⚙️ Input options

```json
{
  "categories": ["spot"],
  "quoteAsset": "USDT",
  "baseAsset": "",
  "symbols": [],
  "maxItems": 10,
  "sortBy": "usdtVolume"
}
````

`Market categories` controls which Bitget markets are scraped. Use `spot` for regular trading pairs, `usdt-futures` for USDT-margined futures, and `coin-futures` for coin-margined futures.

`Quote asset` and `Base asset` are optional filters. They are useful when you only want markets such as USDT pairs, BTC markets, or ETH markets.

`Symbols` lets you keep exact Bitget instruments. Leave it empty for the normal filtered market export.

`Maximum tickers` caps saved rows after filtering and sorting. The default `10` is meant for a low-cost first test.

`Sort by` controls the order before the row cap is applied.

### 🧾 Output example

```json
{
  "symbol": "BTCUSDT",
  "category": "usdt-futures",
  "sourceUrl": "https://www.bitget.com/futures",
  "baseAsset": "BTC",
  "quoteAsset": "USDT",
  "lastPrice": 66692.7,
  "openPriceUtc": 71398.4,
  "priceChangePercent24h": -6.582,
  "priceChangePercentUtc": -6.591,
  "highPrice24h": 71571.1,
  "lowPrice24h": 66310.2,
  "bidPrice": 66692.6,
  "bidSize": 5.0989,
  "askPrice": 66692.7,
  "askSize": 4.3377,
  "spreadAbs": 0.1,
  "spreadBps": 0.01499,
  "volume24h": 87905.2673,
  "quoteVolume24h": 6041977253.88804,
  "usdtVolume24h": 6041977253.88804,
  "fundingRate": 0.000087,
  "openInterest": 34204.1591,
  "contractType": "usdt-margined",
  "settleAsset": "USDT",
  "tickerTime": "2026-06-02T22:57:09.627Z",
  "scrapedAt": "2026-06-02T22:57:09.819Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successfully saved Bitget ticker. Small first runs are inexpensive because the default input saves only `10` ticker rows.

### ⚠️ Limits and caveats

- The Actor returns current market snapshots, not historical candles or streaming updates.
- Futures-only fields such as `fundingRate`, `openInterest`, `contractType`, and `settleAsset` are available only when Bitget exposes them for that ticker.
- `sourceUrl` is a provenance link to the related Bitget market surface. The dataset fields are the source of truth for the exact scraped ticker values.
- Very broad runs can return many rows. Keep `Maximum tickers` low until the output fits your workflow.

### ❓ FAQ

#### Do I need a Bitget API key?

No. The Actor collects public Bitget market ticker data and does not ask for Bitget credentials, cookies, or private account access.

#### Can I scrape Bitget futures data?

Yes. Add `usdt-futures`, `coin-futures`, or both in `Market categories`. Futures rows include funding rate and open interest when those values are available.

#### Can I build a historical Bitget price feed?

The Actor returns one live snapshot per run. To build history, schedule the Actor and store each run's dataset in your own database, sheet, or warehouse.

#### Can I filter to BTC or USDT markets?

Yes. Use `Base asset` for assets such as `BTC` and `Quote asset` for assets such as `USDT`.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~bitget-tickers-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [GMGN CopyTrade Wallet Scraper ↗](https://apify.com/maximedupre/gmgn-copytrade-wallet-scraper) - Export crypto copytrade wallet leaderboards for smart money research.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Normalize public profile stats across major social platforms.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Build rendered website link maps for audits and source inventories.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X posts, profiles, and trending topics.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find public business addresses from company websites.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `categories` (type: `array`):

Enter one or more categories: spot, usdt-futures, or coin-futures. Futures rows include funding rate and open interest when Bitget exposes those values.

## `quoteAsset` (type: `string`):

Keep only markets with this quote asset, such as USDT, USDC, BTC, ETH, EUR, BRL, or USD. Leave empty for every quote asset.

## `baseAsset` (type: `string`):

Keep only markets with this base asset, such as BTC, ETH, SOL, or BGB. Leave empty for every base asset.

## `symbols` (type: `array`):

Optional exact Bitget symbols to keep, for example BTCUSDT, ETHUSDT, or BTCUSD. Leave empty to include every market matching the category and asset filters.

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

Maximum ticker rows to save after filtering and sorting. Keep the default for a small first run. Use 0 only when you want every matching ticker.

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

Order matching Bitget markets before the maximum ticker limit is applied.

## Actor input object example

```json
{
  "categories": [
    "spot"
  ],
  "quoteAsset": "USDT",
  "maxItems": 10,
  "sortBy": "usdtVolume"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one row per scraped Bitget market ticker.

# 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 = {
    "categories": [
        "spot"
    ],
    "quoteAsset": "USDT"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/bitget-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 = {
    "categories": ["spot"],
    "quoteAsset": "USDT",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/bitget-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 '{
  "categories": [
    "spot"
  ],
  "quoteAsset": "USDT"
}' |
apify call maximedupre/bitget-tickers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bitget Tickers Scraper",
        "description": "Scrape live Bitget tickers from spot, USDT futures, and coin futures markets. Export prices, 24h change, volume, bid/ask, spreads, funding rate, open interest, source links, and timestamps without a Bitget API key.",
        "version": "0.0",
        "x-build-id": "FI0S3dvenHhd4aNK3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~bitget-tickers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-bitget-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/maximedupre~bitget-tickers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-bitget-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/maximedupre~bitget-tickers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-bitget-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",
                "required": [
                    "categories"
                ],
                "properties": {
                    "categories": {
                        "title": "Market categories",
                        "type": "array",
                        "description": "Enter one or more categories: spot, usdt-futures, or coin-futures. Futures rows include funding rate and open interest when Bitget exposes those values.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "spot"
                        ]
                    },
                    "quoteAsset": {
                        "title": "Quote asset",
                        "type": "string",
                        "description": "Keep only markets with this quote asset, such as USDT, USDC, BTC, ETH, EUR, BRL, or USD. Leave empty for every quote asset."
                    },
                    "baseAsset": {
                        "title": "Base asset",
                        "type": "string",
                        "description": "Keep only markets with this base asset, such as BTC, ETH, SOL, or BGB. Leave empty for every base asset."
                    },
                    "symbols": {
                        "title": "Symbols",
                        "type": "array",
                        "description": "Optional exact Bitget symbols to keep, for example BTCUSDT, ETHUSDT, or BTCUSD. Leave empty to include every market matching the category and asset filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum tickers",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum ticker rows to save after filtering and sorting. Keep the default for a small first run. Use 0 only when you want every matching ticker.",
                        "default": 10
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "usdtVolume",
                            "quoteVolume",
                            "baseVolume",
                            "priceChangePercent24h",
                            "spreadBps",
                            "fundingRate",
                            "openInterest",
                            "lastPrice",
                            "symbol"
                        ],
                        "type": "string",
                        "description": "Order matching Bitget markets before the maximum ticker limit is applied.",
                        "default": "usdtVolume"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```