# 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
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maximedupre/bitget-tickers-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/D8gw0Bfl3U9PEp5PA/builds/YGFIxVgWIgGP0IFUE/openapi.json