The smart money dashboard developed by Binance @binancezh is very useful. Domestic wild funds often use this data to pump prices. By observing the average cost basis of smart money, it’s easier to find second-entry entry points. Open-sourced a set of smart-money data — just npm install and use it directly to get all the smart money data to feed to your agent. http://github.com/0xBennie/binance-smart-money-tracker… If this data is good, the next article will share how to build a personalized Database with 20U per month.

0xBennie/binance-smart-money-tracker

Source: https://github.com/0xBennie/binance-smart-money-tracker

binance-smart-money-tracker

Production-grade scraper for Binance Smart Signal (the “Smart Money” tab on binance.com Futures) — pulls the full 17-field whale overview that the public fapi API does not expose, with a 7-layer defense against 418 / 429 / 403 rate-limit bans.

This is the URL that binance.com/zh-CN/smart-money/signal/ calls behind the scenes:
https://www.binance.com/bapi/futures/v1/public/future/smart-money/signal/overview?symbol=BTCUSDT

No API key required. No proxy required (works directly from most VPS regions). But Binance enforces an undocumented per-IP weight budget, and a single careless burst can cost you a 4-hour Retry-After. This repo solves that.

What you get vs. public fapi

The four ★ fields are what makes Smart Signal useful — they tell you not just which side has more positions, but which side is actually making money right now, and at what average entry. Public fapi can’t tell you any of that.

Example interpretation

Symbol Long Profit% Short Profit% Whale Avg L/S Verdict 1000RATSUSDT 5% 92% 0.034 / 0.042 🔴 shorts winning big (price has dropped) 1000LUNCUSDT 71% 41% 0.085 / 0.092 🟢 longs winning big (price has run)

When Short Whale Avg Entry > Long Whale Avg Entry by >5%, it usually means shorts entered too late and are about to get squeezed.

Architecture

``
┌─────────────────┐ ┌──────────────────────────────┐
│ smart-money-tick│ cron 60m├──► binance bapi smart-money │
└────────┬────────┘ └──────────────────────────────┘
│
│ writes ob_smart_money_snapshots
▼
┌─────────────────────────────────────────────┐
│ sqlite (data/snapshots.db) │
│ ob_smart_money_snapshots (21 columns) │
│ ob_top_trader_snapshots (12 columns) │
└────────────────────┬────────────────────────┘
│ read-only
▼
┌──────────────────┐
│ Express dashboard│ http://your-host:3001/
│ + JSON API │
└──────────────────┘

┌─────────────────┐ ┌──────────────────────────────┐
│ top-trader-tick │ cron 30m├──► binance fapi/futures/data │
└─────────────────┘ └──────────────────────────────┘
``

• One sqlite file, two tables, 30-day retention
• One Express dashboard with server-side rendering (no JS framework)
• Two cron entry points (smart-money 60min, top-trader 30min) — staggered
• Library mode: import { getSmartMoneyOverview } from 'binance-smart-money-tracker'

7 layers of 418/429 protection

The Smart Signal endpoint lives on Binance’s web bapi gateway, which is more aggressive than fapi. A single uncoordinated burst can earn a 3.85-hour Retry-After (verified empirically). All seven layers below are wired up by default:

1. Real Retry-After parsing — uses the exact seconds Binance returns, not a guess. parseInt(response.headers['retry-after']).
2. Weight budget tracker — reads X-MBX-USED-WEIGHT-1M from every fapi response; when utilization > 70%, the next call sleeps to the next minute window before firing.
3. Pre-flight ping — every cron entry pings /fapi/v1/ping once before the batch; on 418/403 it aborts immediately, no further requests fired.
4. Jittered spacing — smart-money batches use 12s ± 3s, top-trader uses 1s ± 200ms. Avoids forming a predictable cadence that WAFs flag.
5. Exponential backoff — consecutive soft hits within 1 hour escalate the cooldown 5min → 15min → 60min.
6. Process-wide circuit breaker — isBinanceApiBlocked() short-circuits all downstream calls in the same process; getSmartMoneyOverview() and getTopTraderSnapshot() return cached or null without firing.
7. Memory cache — 10min for smart-money, 5min for top-trader. Repeated calls to the same symbol within the window don’t hit Binance at all.

There is no retry-on-failure path that ignores Retry-After. That is intentional. The single fastest way to escalate a 5-minute soft block into a multi-hour hard block is to retry-loop a 418 — don’t.

Quick start

``bash
git clone https://github.com/0xBennie/binance-smart-money-tracker.git
cd binance-smart-money-tracker
npm install

1. One-shot pull (writes to data/snapshots.db)

npx tsx src/scripts/smart-money-tick.ts

2. Start the dashboard (reads from the same db)

PORT=3001 npx tsx src/scripts/smart-money-dashboard.ts

→ http://localhost:3001/

3. Optional: also pull top-trader supplement (Taker ratio + 5min LSR)

npx tsx src/scripts/top-trader-tick.ts
``

Env vars

As a library

``ts
import {
getSmartMoneyOverview, getTopTraderSnapshot, getOpenInterest,
smartMoneyNotionalUsd, smartMoneyShareOfOI,
} from ‘binance-smart-money-tracker’;

const sym = ‘BTCUSDT’;
const [sm, tt, oi] = await Promise.all([
getSmartMoneyOverview(sym), // 17 whale fields
getTopTraderSnapshot(sym, ‘5m’), // top-account/position LSR + Taker BSR
getOpenInterest(sym), // total market OI + 5m/15m/1h/4h velocity
]);

if (sm && oi) {
console.log(${sm.longWhales} long whales @ avg ${sm.longWhalesAvgEntryPrice});
console.log(${sm.longProfitTraders}/${sm.longTraders} longs in profit);
console.log(Total OI: $${(oi.oiNowUsd / 1e6).toFixed(2)}M, 4h chg ${oi.oiChg4h.toFixed(2)}%);

// Smart Money USD notional, derived from qty × avg-entry (NOT from the
// undocumented totalPositions field whose unit is inconsistent).
const smUsd = smartMoneyNotionalUsd(sm);
const share = smartMoneyShareOfOI(sm, oi.oiNowUsd);
console.log(Smart Money notional: $${(smUsd / 1e6).toFixed(2)}M);
console.log(Smart Money share of total OI: ${share == null ? 'n/a' : (share * 100).toFixed(1) + '%'});
}
``

Why a helper? Binance’s undocumented totalPositions field has > inconsistent units across symbols (sometimes base-coin units, sometimes USD).
smartMoneyNotionalUsd(sm) computes it deterministically from
longTradersQty × longTradersAvgEntryPrice + shortTradersQty × shortTradersAvgEntryPrice
— both fields have known units (base-coin × USD = USD). Don’t divide
totalPositions by anything; use the helper.

The library re-exports all rate-limit helpers (isBinanceApiBlocked, preflightBinanceFapi, waitForBinanceWeightHeadroom) so you can integrate the same circuit breaker into your other Binance calls and share one weight budget across modules.

Pool sizing & cron cadence

Default behavior is all USDT-PERPETUAL symbols (~500 contracts as of 2026). Pick a deployment mode that matches your tolerance for data freshness:

Read “1h refresh” as every symbol gets a fresh snapshot within 1h, achieved by two cron entries at :07 and :37 each pulling half (shard 0/2 and 1/2). The math: smart-money runs at 12s ± 3s spacing (web bapi is rate-sensitive). 500 symbols ≈ 100 min, so it cannot finish inside an hour without sharding. Top-trader and OI both use fapi/data at 1s spacing — 500 symbols ≈ 8 min, fits anywhere.

Sharding

Symbols are split deterministically by index % SHARD_TOTAL == SHARD_INDEX, so each shard always pulls the same set (good for cache locality, and means shards don’t collide on the same symbol within a window).

Data Retention

The sqlite tables (ob_smart_money_snapshots, ob_top_trader_snapshots, ob_oi_snapshots) are pruned to 30 days by the storage.cleanup() call that runs at the end of every smart-money-tick execution. If you need longer history, increase RETENTION_DAYS in src/storage.ts and rebuild, or back the table up before the daily cron runs. Disk usage estimate at default cadence (500 symbols, hourly smart-money + 30min top-trader + 30min OI): roughly 30–80 MB / month with WAL enabled.

Production deployment (pm2)

A. Standard — cap at 200, hourly

js // ecosystem.config.js module.exports = { apps: [ { name: 'smart-money-tick', script: 'node_modules/.bin/tsx', args: 'src/scripts/smart-money-tick.ts', cron_restart: '7 * * * *', // :07 every hour autorestart: false, env: { SMART_MONEY_POOL_MAX: '200' }, }, { name: 'top-trader-tick', script: 'node_modules/.bin/tsx', args: 'src/scripts/top-trader-tick.ts 5m', cron_restart: '*/30 * * * *', autorestart: false, }, { name: 'oi-tick', script: 'node_modules/.bin/tsx', args: 'src/scripts/oi-tick.ts', cron_restart: '15,45 * * * *', // offset from top-trader autorestart: false, }, { name: 'smart-money-dashboard', script: 'node_modules/.bin/tsx', args: 'src/scripts/smart-money-dashboard.ts', autorestart: true, env: { PORT: '3001' }, }, ], };

B. Full coverage with 1h refresh — 2-way sharding

Two pm2 entries, each pulls half the symbols at staggered times:

js module.exports = { apps: [ { name: 'smart-money-tick-a', script: 'node_modules/.bin/tsx', args: 'src/scripts/smart-money-tick.ts', cron_restart: '7 * * * *', // :07 autorestart: false, env: { SMART_MONEY_SHARD_INDEX: '0', SMART_MONEY_SHARD_TOTAL: '2' }, }, { name: 'smart-money-tick-b', script: 'node_modules/.bin/tsx', args: 'src/scripts/smart-money-tick.ts', cron_restart: '37 * * * *', // :37 — 30 min offset from A autorestart: false, env: { SMART_MONEY_SHARD_INDEX: '1', SMART_MONEY_SHARD_TOTAL: '2' }, }, // ... top-trader-tick and dashboard same as Mode A ], };

C. Full coverage, slower refresh — 2-hour cron, no sharding

Cheapest option if hourly freshness isn’t required:

js { name: 'smart-money-tick', args: 'src/scripts/smart-money-tick.ts', cron_restart: '0 */2 * * *', // every 2 hours autorestart: false, // no env vars needed — defaults to all symbols }

Why staggering matters

The circuit breaker lives in per-process module state. Two cron processes running simultaneously cannot share isBinanceApiBlocked() state directly, but each one ping-tests via preflightBinanceFapi() before issuing any data requests — so if process A just got a 418, process B’s preflight will catch it and abort cleanly. Stagger the times anyway to give the IP weight window time to drain between bursts.

What’s not in this repo

• ❌ No trading. This is data only.
• ❌ No proxy. If your IP gets a hard 403 (CloudFront WAF), the only fix is to wait it out or change IP. The whole point of the protection layers is to never get there.
• ❌ No on-chain data, no order book, no aggregated trades. For that, see the projects in Credits.

Credits

• andychien555/binance-smart-money-tracker (https://github.com/andychien555/binance-smart-money-tracker) — original reverse-engineering of the bapi/futures/v1/public/future/smart-money/signal/overview endpoint. Their version is built on Cloudflare Workers + R2 with a static SPA frontend; this repo is the Node + sqlite + express version with stronger rate-limit protection. Different architecture, same source insight.
• y18929284608-byte/BNSmartMoneyMonitor (https://github.com/y18929284608-byte/BNSmartMoneyMonitor) and 6551Team/opentrade (https://github.com/6551Team/opentrade) — parallel implementations that confirmed the endpoint contract.

License

MIT — see LICENSE.

Arya@羊姐社区🦅 (@Arya_web3):
The previous post was correct to compare $UB and $BILL together. The manipulation style, K-line trend, and washout method are extremely similar.
Both $UB and $BILL have entered their second phase.
For $UB, I caught it during the decline. Experience proves this is a very unhealthy way to build a position — catching a falling knife, quite painful. Fortunately I’ve now recovered my cost.
When playing second-phase coins, it’s better to chase them when the right side trend appears.