# Bybit Tickers Scraper (`parseforge/bybit-tickers-scraper`) Actor

Collects live Bybit tickers by market category (spot, linear, inverse) and returns each as a flat row with price, volume, and turnover. Sort by turnover, volume, price, or symbol and cap results up to one million per run.

- **URL**: https://apify.com/parseforge/bybit-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $31.27 / 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/actors/running/actors-in-store.md#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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Bybit Tickers Scraper

**Scrape live ticker data from Bybit spot, USDT perpetual, and inverse futures markets, up to a million per run.** Every ticker includes last price, 24h volume, turnover, and symbol, sorted by your chosen metric. Export to CSV, JSON, Excel, or XML.

Bybit's official API needs an account, API key management, and rate-limit handling. This reads the public market ticker endpoint directly, filtered by market category and sorted by turnover, volume, or price, and returns each match in one fixed schema. No login or API key required.

| Who uses it | What they scrape Bybit for |
|---|---|
| Crypto traders | Spot the most active Bybit pairs by 24h turnover before placing a trade. |
| Quantitative analysts | Pull sorted ticker snapshots into a backtesting pipeline for volatility models. |
| Market data resellers | Build a unified crypto market feed by merging Bybit tickers with other exchange data. |
| Portfolio trackers | Update current prices and 24h activity for Bybit positions in a dashboard. |

### What it does

This Actor collects live Bybit tickers by market category and returns each one as a flat row with price, volume, and turnover data.

- 📊 **Market categories:** spot, USDT/USDC perpetual (linear), and coin-margined inverse futures.
- 📈 **Flexible sorting:** order by 24h turnover, 24h volume, last price, or symbol before capping results.
- 🔢 **Volume control:** set a hard limit from 1 to 1,000,000 tickers per run to match your plan.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Bybit data

**📈 Rank the most active Bybit pairs.**

A trader sets the category to linear, sorts by 24h turnover, and caps at 20 tickers to focus on the highest-activity USDT perpetuals for the day.

**🔍 Feed a market scanner with fresh Bybit data.**

A quant runs the Actor every five minutes for the spot category, sorted by volume, and pipes the top 500 tickers into a volatility scanner.

**📊 Build a multi-exchange price board.**

A data engineer collects Bybit inverse futures tickers sorted by last price, merges them with other exchange feeds, and publishes a unified internal dashboard.

**💹 Monitor coin-margined contract activity.**

A risk analyst pulls the top 100 inverse tickers by turnover every hour to track shifts in coin-margined market interest.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Reads Bybit's public market endpoint with zero account setup. |
| **Sorted output** | Get the top tickers by turnover, volume, or price, not a raw unsorted dump. |
| **Fixed schema** | Every run returns the same flat columns for reliable pipelines. |
| **Three market types** | One Actor covers spot, linear perpetuals, and inverse futures. |

### How it compares

This Actor focuses on live ticker snapshots with sorting and volume capping, while the CEX Token Listings Tracker tracks new listing and delisting events across multiple exchanges.

| Feature | ParseForge | CEX Token Listings Tracker - New Listings & Delistings |
|---|---|---|
| Live ticker prices and volume | Yes | Not listed |
| Sort by turnover, volume, or price | Yes | Not listed |
| Spot, linear, and inverse markets | Yes | Not listed |
| New token listing alerts | Not listed | Yes |
| Multi-exchange coverage | Bybit only | Yes |

### Configure the run

Drive the Actor from a single market category and a sort order, and the maxItems cap runs after sorting so only the top tickers reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "category": "spot",
 "maxItems": 10,
 "sortBy": "turnover24h"
}
```

A larger pull:

```json
{
 "category": "spot",
 "maxItems": 200,
 "sortBy": "turnover24h"
}
```

### Pricing

Pay-per-result: **$0.0417 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $4.17 |
| 1,000 results | $41.70 |
| 10,000 results | $417.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Bybit Tickers Scraper](https://apify.com/parseforge/bybit-tickers-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Bybit through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/bybit-tickers-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting fewer tickers than my maxItems setting?**

Bybit returns only the tickers currently available in the selected category. If the market has fewer active pairs than your maxItems value, you will get all of them.

**Why does the sort order look wrong?**

Check the sortBy field. Turnover and volume sorts are descending, symbol is ascending. If you need a different order, you can re-sort the exported dataset in your own tool.

**The run failed with a timeout.**

A very large maxItems value combined with a slow network can hit the default timeout. Try reducing maxItems or increasing the run timeout in the Actor's advanced settings.

**I see zero results for the inverse category.**

Bybit's inverse market may have fewer active pairs at certain times. Verify on the Bybit website that tickers exist for that category, then try again.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Bybit account or API key? | No. This Actor reads Bybit's public market ticker endpoint, so no account, API key, or authentication is required. |
| What market categories can I scrape? | You can choose spot, USDT/USDC perpetual (linear), or coin-margined inverse futures from the category dropdown. |
| How are the tickers sorted? | You pick the sort field: 24h turnover, 24h volume, last price, or symbol. Sorting is applied before the maxItems limit cuts the list. |
| What data fields does each ticker include? | Each row returns the symbol, last price, 24h volume, 24h turnover, and other standard Bybit ticker fields in a flat schema. |
| Can I limit how many tickers I get? | Yes. Set maxItems to any number from 1 to 1,000,000. The Actor returns the top N tickers after sorting. |
| How often should I run this Actor? | Ticker data changes every second. Run it as frequently as your use case requires, but be mindful of Apify platform usage if you set very short intervals. |
| Does this Actor handle Bybit futures and spot? | Yes. It covers spot, USDT/USDC perpetuals, and coin-margined inverse futures in one Actor with a simple category selector. |
| What export formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML from the Apify run console. |
| Can I get historical ticker data? | This Actor returns a live snapshot. For historical data, you would need to schedule regular runs and accumulate the results over time. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Bybit Fintech Limited. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `category` (type: `string`):

Market category

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

How many tickers to collect per run.

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

Sort results by this field

## Actor input object example

```json
{
  "category": "spot",
  "maxItems": 10,
  "sortBy": "turnover24h"
}
```

# 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 = {
    "category": "spot",
    "maxItems": 10,
    "sortBy": "turnover24h"
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/bybit-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/TgDRmh5vHwzYaujlS/builds/ImHqgwagdrIfuCAiL/openapi.json