# Bybit Leaderboard Position Tracker With Trading Signals (`brilliant_gum/bybit-scraper`) Actor

Scrape Bybit copy trading leaderboard, track live open positions of top traders, and generate Winners vs Losers trading signals using Three-Signal Analysis. No account or API key required.

- **URL**: https://apify.com/brilliant_gum/bybit-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Automation, Developer tools, Other
- **Features:** Limited permissions
- **Stats:** 30 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $45.00 / 1,000 trader scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Bybit Copy Trading Scraper — Leaderboard + Live Positions + Trading Signals

![Bybit Copy Trading Scraper](https://i.imgur.com/WlmYyUz.png)

**See exactly what the best traders on Bybit are doing right now.** Get their full stats, live open positions, and AI-style trading signals — all in one run, no account needed.

***

### What You Get

#### 📊 Full Leaderboard Data

Every trader comes with a complete performance profile:

- **ROI %** — return over your chosen period (7, 30, or 90 days)
- **Win Rate %** — percentage of profitable trades
- **Max Drawdown %** — worst peak-to-trough loss
- **Sharpe Ratio** — risk-adjusted performance score
- **Profit/Loss Ratio** — average win vs average loss
- **Followers count** — how many copy traders follow them
- **Follower total profit** — how much their followers actually made

#### 📈 Live Open Positions

For every trader you analyze, you get their **current open trades** in real time:

- Coin (symbol)
- Direction — Long or Short
- Entry price
- Position size & notional value in USD
- Leverage
- Unrealized PNL

Bybit positions are **always public** — traders cannot hide them. You see everything.

#### 🎯 Winners vs Losers Trading Signals

Our unique **Three-Signal Analysis** identifies which coins the top-performing traders are concentrated in right now:

| Signal | Meaning |
|--------|---------|
| `STRONG_LONG` | All three signals agree — buy |
| `LONG` | Two out of three signals agree — buy |
| `NEUTRAL` | Signals conflict — skip |
| `SHORT` | Two out of three signals agree — sell |
| `STRONG_SHORT` | All three signals agree — sell |

Each signal also comes with a **confidence level** (HIGH / MEDIUM / LOW) and full breakdown: notional exposure, trader count, volume-weighted score.

***

### Four Modes, One Tool

| Mode | What runs |
|------|-----------|
| **Leaderboard** | Trader rankings with full stats |
| **Positions** | Live positions for specific traders by ID |
| **Full** | Rankings + live positions for everyone |
| **Analytics** | Everything + Three-Signal trading signals |

***

### Why This Works

Bybit publicly exposes up to **500 top traders** with full stats and open positions. This scraper collects all of it, classifies traders into **Winners** (top % by PNL) and **Losers** (bottom % by PNL), and cross-references what each group is actually holding.

When the Winners are heavily long on a coin and the Losers are not — that's a signal. When all three of our independent scoring methods agree — that's a HIGH confidence signal.

**The more traders you analyze, the stronger and more reliable the signals become.** We recommend at least 50 traders for analytics mode.

***

### Output

Results are saved to the Apify dataset in two record types:

**Trader records** (`_type: "trader"`) — one per trader, includes:

- All leaderboard stats
- Full list of open positions
- Timestamps

**Analytics record** (`_type: "analytics"`) — one per run, includes:

- Market bias (BULLISH / BEARISH / NEUTRAL)
- Winners count, Losers count
- Full ranked signal list with scores and confidence levels

Use the built-in **Traders** and **Signals** dataset views to instantly filter by type. Export to JSON, CSV, or connect via API to your own trading dashboard.

***

### Pricing

**$0.045 per trader** — ~$45 per 1,000 traders.

One charge covers everything: leaderboard stats, open positions, and analytics signals.

| Traders | Cost |
|---------|------|
| 20 (default) | ~$0.90 |
| 50 | ~$2.25 |
| 100 | ~$4.50 |
| 200 | ~$9.00 |
| 500 (max) | ~$22.50 |

***

### Input Options

| Field | Options | Default |
|-------|---------|---------|
| **Mode** | leaderboard / positions / full / analytics | leaderboard |
| **Time period** | 7 / 30 / 90 days | 30 days |
| **Sort by** | ROI % or Profit ($) | ROI % |
| **Max traders** | 1–500 | 20 |
| **Leader Marks** | Specific trader IDs | — |
| **Fetch positions** | Yes / No | Yes |
| **Winners threshold** | Top N% by PNL | 25% |
| **Losers threshold** | Bottom N% by PNL | 25% |

***

### Use Cases

- **Generate trading signals** — find coins where the best traders are concentrated
- **Screen traders before copying** — compare risk metrics before you follow anyone
- **Monitor trader portfolios** — see what your followed traders are holding in real time
- **Track market sentiment** — gauge overall crypto bias from the top performers
- **Build trading dashboards** — connect via Apify API for live data feeds
- **Research & backtesting** — collect position snapshots over time for analysis

***

### No Account Needed

No Bybit account. No API key. No login. Bybit makes all leaderboard and position data publicly available — this scraper simply collects and structures it for you.

# Actor input Schema

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

<b>leaderboard</b> — Scrape the leaderboard rankings only.<br><b>positions</b> — Fetch positions for specific traders by leaderMark.<br><b>full</b> — Leaderboard + positions for all traders.<br><b>analytics</b> — Full + Winners/Losers analysis and trading signals.

## `dataDuration` (type: `string`):

Leaderboard ranking period. Longer periods give more stable signals.

## `sortField` (type: `string`):

Metric to rank traders by.

## `maxTraders` (type: `integer`):

Maximum number of traders to fetch from the leaderboard. Bybit exposes up to 500 traders publicly.<br><br>💡 <b>More traders = more accurate signals.</b> Larger samples reduce noise and improve signal reliability — we recommend at least 50 traders for analytics mode.

## `leaderMarks` (type: `array`):

Bybit trader identifiers (the leaderMark from the trader page URL). Required for <code>positions</code> mode.

## `fetchPositions` (type: `boolean`):

Retrieve each trader's current open positions. Bybit positions are always public — traders cannot hide them.

## `winnersPercent` (type: `integer`):

Top N% of traders by PNL are classified as Winners.

## `losersPercent` (type: `integer`):

Bottom N% of traders by PNL are classified as Losers.

## `proxyConfiguration` (type: `object`):

Leave empty to use the built-in proxy (recommended). Provide your own proxy only if you have a specific requirement.

## Actor input object example

```json
{
  "mode": "leaderboard",
  "dataDuration": "DATA_DURATION_THIRTY_DAY",
  "sortField": "LEADER_SORT_FIELD_SORT_ROI",
  "maxTraders": 20,
  "leaderMarks": [
    "E3I5IM9WD9ddAlQMaIYgKQ=="
  ],
  "fetchPositions": true,
  "winnersPercent": 25,
  "losersPercent": 25
}
```

# Actor output Schema

## `nickName` (type: `string`):

Display name of the copy trader on Bybit.

## `leaderMark` (type: `string`):

Unique Bybit trader identifier (used in profile URL).

## `roi` (type: `string`):

Return on investment over the selected period.

## `winRate` (type: `string`):

Percentage of winning trades.

## `maxDrawdown` (type: `string`):

Maximum peak-to-trough decline in portfolio value.

## `followersCount` (type: `string`):

Number of copy traders following this trader.

## `positionCount` (type: `string`):

Number of currently open trading positions.

## `positions` (type: `string`):

List of current open positions: symbol, side (BUY/SELL), size, entry price, notional value, leverage, unrealized PNL.

## `marketBias` (type: `string`):

Overall market direction from analytics mode: BULLISH, BEARISH, or NEUTRAL.

## `topSignals` (type: `string`):

Ranked list of coins with signal direction, confidence level, and supporting metrics. Analytics mode only.

## `tradersAnalyzed` (type: `string`):

Total number of traders used to generate the analytics signals.

## `winnersCount` (type: `string`):

Number of traders classified as Winners (top % by PNL). Analytics mode only.

## `losersCount` (type: `string`):

Number of traders classified as Losers (bottom % by PNL). Analytics mode only.

## `_type` (type: `string`):

"trader" for individual trader records, "analytics" for the signal summary record.

## `_scrapedAt` (type: `string`):

ISO 8601 timestamp of when this record was collected.

# 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 = {
    "leaderMarks": [
        "E3I5IM9WD9ddAlQMaIYgKQ=="
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/bybit-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 = { "leaderMarks": ["E3I5IM9WD9ddAlQMaIYgKQ=="] }

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/bybit-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 '{
  "leaderMarks": [
    "E3I5IM9WD9ddAlQMaIYgKQ=="
  ]
}' |
apify call brilliant_gum/bybit-scraper --silent --output-dataset

```

## MCP server setup

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