.actor

# Specify the base Docker image. You can read more about
# the available images at https://sdk.apify.com/docs/guides/docker-images
# You can also use any other image from Docker Hub.
FROM apify/actor-node:16 AS builder

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

# Install all dependencies. Don't audit to speed up the installation.
RUN npm install --include=dev --audit=false

# Next, copy the source files using the user set
# in the base image.
COPY . ./

# Install all dependencies and build the project.
# Don't audit to speed up the installation.
RUN npm run build

# Create final image
FROM apify/actor-node:16

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

# Install NPM packages, skip optional and development dependencies to
# keep the image small. Avoid logging too much and print the dependency
# tree for debugging
RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

# Copy built JS files from builder image
COPY --from=builder /usr/src/app/dist ./dist

# Next, copy the remaining files and directories with the source code.
# Since we do this after NPM install, quick build will be really fast
# for most source file changes.
COPY . ./


# Run the image.
CMD npm run start:prod --silent


.actor/Dockerfile



# Binance leaderboard scraper
![enter image description here](https://i.ibb.co/xSD7hQk/apify-Bebity-io-3.png)
Welcome to the Readme of **Binance leaderboard trader positions scraper**!

This scraper is designed to extract trader positions on the Binance leaderboard. You can use this data to monitor trading activity on the platform, evaluate market trends, and make informed trading decisions.

To use this scraper, you can directly purchase it on the Apify marketplace and run it in just a few minutes.

 Here are the main features of this scraper:

-   Retrieval of trading positions on the Binance leaderboard
-   Search filters to select criteria of your choice
-   Export of data to various formats such as CSV or JSON


####  How to use the scraper?

1.  Purchase the scraper on the Apify marketplace.
2.  Create a new task in Apify and add the scraper.
3.  Configure the search filters according to the criteria you want to monitor.
![enter image description here](https://i.ibb.co/ZJ0cGMm/Screenshot-from-2023-02-19-02-12-44.png)
4.  Run the task and let the scraper collect the data for you.
		![enter image description here](https://i.ibb.co/SfwCkVw/Screenshot-from-2023-02-19-02-15-46.png)
6.  Export the collected data to the format of your choice.

Note that this scraper is designed for personal use and not for commercial use. It is intended to help traders monitor market trends and make informed trading decisions.

If you have any questions or comments about the scraper, feel free to contact me. I am always happy to help other traders succeed.

.actor/README.md

Get current binance future traders positions directly from leaderboard

binance-future-traders-positions

Positions

.actor/actor.json

Trader

Time

Sort by

Type

Add two integers

.actor/input-schema.json

import axios from "axios"


export type BinanceResponseDto<T> = {
  code: string
  data: T
  message?: string
  messageDetail?: string
  success: boolean
};

export type TraderDto = {
  futureUid?: string
  nickName: string
  userPhotoUrl: string
  rank: number
  pnl: number
  roi: number
  positionShared: boolean
  twitterUrl?: string
  encryptedUid: string
  updateTime: number
  followerCount?: number
  twShared?: unknown
  isTwTrader: boolean
  openId?: string
}

export type LeaderBoardRankResponseDto = BinanceResponseDto<TraderDto[]>;

export type PositionStatusDto = {
  futureUid?: string
  encryptedUid: string
  positionShared: boolean
  hasPosition: boolean
  lastTradeTime?: number
}

export type PositionStatusResponseDto = BinanceResponseDto<PositionStatusDto[]>;

export type TraderPositionsDto = BinanceResponseDto<{
  otherPositionRetList: {
    symbol: string;
    entryPrice: number;
    markPrice: number;
    pnl: number;
    roe: number;
    updateTime: number[];
    amount: number;
    updateTimeStamp: number;
    yellow: boolean;
    tradeBefore: boolean;
    leverage: number;
  }[]
}>;

export type GetLeaderBoardRankOptions = {
  tradeType: "DELIVERY" | "PERPETUAL",
  statisticsType: "PNL" | "ROI",
  periodType: "ALL" | "DAILY" | "WEEKLY" | "MONTHLY",
  isTrader: boolean
}

export class BinanceClient {

  leaderBoardRankUrl = 'https://www.binance.com/bapi/futures/v3/public/future/leaderboard/getLeaderboardRank';
  positionStatusUrl = 'https://www.binance.com/bapi/futures/v1/public/future/leaderboard/getPositionStatus';
  traderPositionsUrl = 'https://www.binance.com/bapi/futures/v1/public/future/leaderboard/getOtherPosition';

  protected http = axios.create();


  async getLeaderBoardRank(options: GetLeaderBoardRankOptions): Promise<LeaderBoardRankResponseDto> {
    const response = await this.http.post<LeaderBoardRankResponseDto>(
      this.leaderBoardRankUrl,
      {
        ...options,
        isShared: true,
      }
    );
    return response.data;
  }

  async getPositionsStatus(encryptedUidList: string[]): Promise<PositionStatusResponseDto> {
    const response = await this.http.post<PositionStatusResponseDto>(
      this.positionStatusUrl,
      {
        tradeType: 'PERPETUAL',
        encryptedUidList
      },
    );
    return response.data;
  }

  async getTraderPositions(encryptedUid: string): Promise<TraderPositionsDto> {
    const response = await this.http.post<TraderPositionsDto>(
      this.traderPositionsUrl,
      {
        encryptedUid,
        tradeType: 'PERPETUAL'
      },
    );
    return response.data;
  }

}

src/binance-client.ts

// This is the main Node.js source code file of your actor.
// An actor is a program that takes an input and produces an output.

// For more information, see https://sdk.apify.com/
import { Actor } from 'apify';
// @ts-ignore
import { BinanceClient, GetLeaderBoardRankOptions, PositionStatusDto, TraderDto } from './binance-client';

(async () => {
    await Actor.init()

    const input = await Actor.getInput() as Omit<GetLeaderBoardRankOptions, 'isTrader'> & { isTrader: 'ALL' | 'copyTrading' | 'FALSE' };

    console.log(input)

    const client = new BinanceClient();

    const { data: tmpTraders } = await client.getLeaderBoardRank({
        ...input,
        isTrader: input?.isTrader === 'ALL' ? false : true,
    });

    const tradersStatus = await client.getPositionsStatus(tmpTraders.map((trader: TraderDto) => trader.encryptedUid).slice(0, 10));

    const traders = tmpTraders.filter((trader: TraderDto) => {
        const traderStatus = tradersStatus.data.find((status: PositionStatusDto) => status.encryptedUid === trader.encryptedUid);
        return traderStatus?.hasPosition;
    })

    const traderPositions = await Promise.all(traders.map(async (trader: TraderDto) => {
        const tmp = await client.getTraderPositions(trader.encryptedUid);
        return { trader, positions: (tmp?.data?.otherPositionRetList ?? []) };
    }));


    for await (const traderPosition of traderPositions.sort((a, b) => a.trader.rank - b.trader.rank)) {
        for await (const position of traderPosition.positions) {
            await Actor.pushData({
                // @ts-ignore
                ...Object.keys(traderPosition.trader).reduce((a, c) => (a[`trader_${c}`] = traderPosition.trader[c], a), {} as any),
                // @ts-ignore
                ...Object.keys(position).reduce((a, c) => (a[`position_${c}`] = position[c], a), {} as any)
            });
        }
    }

    await Actor.exit();

})();

src/main.ts

# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

# git folder
.git


.dockerignore

package.json

tsconfig.json

ℹ️ Use my Apify actor to scrape open positions of top Binance traders and implement copy trading strategies! Analyze their performance and replicate their success. Stay ahead of the competition and make informed decisions with real-time data. Get started today!

binance-leaderboard-scraper

🔥 Binance leaderboard scraper

🔥 Binance leaderboard scraper · Apify

Input · 🔥 Binance leaderboard scraper · Apify

API · 🔥 Binance leaderboard scraper · Apify

Related Actors · 🔥 Binance leaderboard scraper · Apify

ℹ️ Use my Apify actor to scrape open positions of top Binance traders and implement copy trading strategies! Analyze their performance and replicate their success. Stay ahead of the competition and...

Where next?