On-Chain Whale Flow Analysis

On-chain whale flows—large wallet movements recorded directly on the blockchain—provide a window into where significant capital is moving in near real time. Smart Money tracks sizable swaps and transfers across 8 EVM and Solana chains and exposes them as a single public event feed. This guide covers the data, how to read it, and how to fold it into a trading process.

Table of Contents

What On-Chain Whale Flows Are
The Whale Events Endpoint
Reading an Event
Aggregating by Type & Significance
Multi-Chain Coverage
Surfacing the Largest Movements
Polling for New Events
Trading Applications

What On-Chain Whale Flows Are

On-chain whale flows measure large movements of value across public blockchains: token swaps on DEXs and sizable transfers between addresses, made by high-value wallets. By watching these transactions as they confirm, you can see where big capital is rotating before it is reflected in slower aggregate metrics.

This dataset is on-chain whale activity — not centralized-exchange (CEX) hot-wallet deposit/withdrawal tracking by named exchange (there is no Binance/Coinbase/Kraken deposit-vs-withdrawal feed here). Every event is a real, explorer-verifiable transaction.

Core fields in each whale event:

chain: Which network the event occurred on (8 supported chains)
event_type: The kind of movement — swap, transfer, large_tx
token: The asset that moved (e.g. ETH, USDT, USDC)
amount_usd: USD size of the movement — the field to rank and aggregate on
significance: Severity tag — low, medium, high, critical
tx_hash / block / timestamp: Verify any event on a block explorer

The Whale Events Endpoint

Everything in this guide runs against one public endpoint — GET /v1/whales/events — which needs no API key. Try it from a terminal:

        BASH
      
# Most recent whale events across all chains
curl "https://api.smartmoneyapi.com/v1/whales/events?limit=3"

# Recent events on Ethereum only, last 24h
curl "https://api.smartmoneyapi.com/v1/whales/events?chain=ethereum&limit=3&hours=24"

Query parameters: chain (ethereum, bsc, avalanche, polygon, arbitrum, base, optimism, solana — omit for all chains), limit (default ~50), hours (lookback window), and offset (pagination). The total field in the response tells you how many events exist in the window.

Reading an Event

A single response object looks like this — note the real field names you will work with:

        JSON
      

{
  "events": [
    {
      "chain": "ethereum",
      "address": "0xd43ee7e3d108e5299a753afce2a60e3afa2e7cba",
      "event_type": "large_tx",
      "token": "ETH",
      "amount": 932.30,
      "amount_usd": 1665302.17,
      "tx_hash": "0x07d07b06860d5fe5afd6f25907d5daa465930cc2ec8e5ba6179b6bcb8f95a809",
      "block": 25327093,
      "timestamp": 1781576927,
      "to_address": "0xceb69f6342ece283b2f5c9088ff249b5d0ae66ea",
      "significance": "critical"
    }
  ],
  "count": 1,
  "total": 692335,
  "offset": 0,
  "limit": 1,
  "hours": 24,
  "chain": "ethereum",
  "updated": 1781576927
}
      

Interpretation note: Whale events are directional capital movements, not buy/sell labels. A large swap tells you size and token; a high significance tells you it is outsized relative to typical activity. Pair the raw movement with positioning context (see Trading Applications) rather than reading a single event as a buy or sell signal.

Aggregating by Type & Significance

The first useful transform is to pull recent events and sum amount_usd grouped by event_type and by significance. This turns the raw stream into a snapshot of where the biggest capital is moving.

        PYTHON
      

import requests
from collections import defaultdict

BASE = 'https://api.smartmoneyapi.com/v1'

def analyze_whale_flows(chain=None, hours=24, limit=200):
    """Aggregate recent whale events by type and significance."""
    params = {'limit': limit, 'hours': hours}
    if chain:
        params['chain'] = chain

    # Public endpoint — no API key required
    data = requests.get(f'{BASE}/whales/events', params=params).json()
    events = data['events']

    scope = chain or 'all chains'
    print(f"Whale Flows - {scope} (last {hours}h)")
    print(f"Sampled {data['count']} of {data['total']:,} events in window")

    by_type = defaultdict(float)
    by_sig = defaultdict(float)
    for ev in events:
        usd = ev.get('amount_usd') or 0.0
        by_type[ev['event_type']] += usd
        by_sig[ev['significance']] += usd

    print("\nUSD volume by event_type:")
    for etype, usd in sorted(by_type.items(), key=lambda x: -x[1]):
        print(f"  {etype:<12} ${usd:,.0f}")

    print("\nUSD volume by significance:")
    for sig in ('critical', 'high', 'medium', 'low'):
        if sig in by_sig:
            print(f"  {sig:<10} ${by_sig[sig]:,.0f}")

    return events

analyze_whale_flows(hours=24)
analyze_whale_flows(chain='ethereum', hours=24)
      

Multi-Chain Coverage

The feed spans 8 networks: Ethereum, BSC, Avalanche, Polygon, Arbitrum, Base, Optimism, and Solana. Comparing whale USD volume across chains shows which networks are seeing the most large capital move. Pull the combined feed and group by the chain field, or query each chain individually with the chain parameter.

        PYTHON
      

def compare_chain_flows(hours=24, limit=500):
    """Group recent whale USD volume by chain from the combined feed."""
    events = requests.get(
        f'{BASE}/whales/events',
        params={'limit': limit, 'hours': hours}
    ).json()['events']

    by_chain = defaultdict(lambda: {'usd': 0.0, 'count': 0})
    for ev in events:
        c = ev['chain']
        by_chain[c]['usd'] += ev.get('amount_usd') or 0.0
        by_chain[c]['count'] += 1

    print(f"Whale Flow by Chain (last {hours}h, sampled)")
    for chain, s in sorted(by_chain.items(), key=lambda x: -x[1]['usd']):
        print(f"  {chain:<10} ${s['usd']:>15,.0f}   ({s['count']} events)")

compare_chain_flows(hours=24)
      

Surfacing the Largest Movements

Ranking events by amount_usd isolates the single biggest whale movements in the window — the transactions most worth inspecting on a block explorer via their tx_hash.

        JAVASCRIPT
      

const BASE = 'https://api.smartmoneyapi.com/v1';

async function topMovements({ chain = null, hours = 24, limit = 500, topN = 5 } = {}) {
  const params = new URLSearchParams({ limit: String(limit), hours: String(hours) });
  if (chain) params.set('chain', chain);

  // Public endpoint — no API key required
  const resp = await fetch(`${BASE}/whales/events?${params}`);
  const { events } = await resp.json();

  const ranked = [...events]
    .sort((a, b) => (b.amount_usd || 0) - (a.amount_usd || 0))
    .slice(0, topN);

  for (const ev of ranked) {
    const usd = (ev.amount_usd || 0).toLocaleString('en-US', { maximumFractionDigits: 0 });
    console.log(`$${usd}  ${ev.chain}  ${ev.event_type}  ${ev.token}  `
      + `[${ev.significance}]  ${ev.tx_hash}`);
  }
  return ranked;
}

topMovements({ hours: 24, topN: 5 });
      

Polling for New Events

The feed updates continuously (see the updated timestamp in each response). There is no public WebSocket — poll the endpoint on an interval, dedupe on tx_hash, and react to events above a USD threshold or at high/critical significance.

        PYTHON
      

import requests
import time

BASE = 'https://api.smartmoneyapi.com/v1'

class WhaleFlowMonitor:
    def __init__(self, usd_threshold=1_000_000):
        self.seen = set()          # tx_hash dedupe
        self.usd_threshold = usd_threshold

    def poll(self, chain=None, hours=1, limit=100):
        params = {'limit': limit, 'hours': hours}
        if chain:
            params['chain'] = chain

        # Public endpoint — no API key required
        data = requests.get(f'{BASE}/whales/events', params=params).json()
        for ev in data['events']:
            tx = ev['tx_hash']
            if tx in self.seen:
                continue
            self.seen.add(tx)

            big = (ev.get('amount_usd') or 0) >= self.usd_threshold
            severe = ev['significance'] in ('high', 'critical')
            if big or severe:
                self.alert(ev)

    def alert(self, ev):
        usd = (ev.get('amount_usd') or 0) / 1e6
        print(f"WHALE FLOW: ${usd:,.2f}M {ev['event_type']} of {ev['token']} "
              f"on {ev['chain']} [{ev['significance']}] tx {ev['tx_hash']}")

# Poll every 60s for events >= $1M or high/critical significance
monitor = WhaleFlowMonitor(usd_threshold=1_000_000)
while True:
    try:
        monitor.poll(hours=1)
    except Exception as e:
        print(f"Error: {e}")
    time.sleep(60)
      

Trading Applications

On-chain whale flows are most useful as one input in a multi-factor process — combined with positioning context and market structure rather than traded in isolation. Two other public Smart Money datasets pair well: /v1/whale-consensus (per-symbol directional bias from tracked whale positions) and /v1/onchain/metrics (TVL, stablecoin supply, DEX volume from DeFiLlama).

Whale Flow Pattern Framework

Critical-Significance Cluster: Several critical events on one chain in a short window = outsized capital in motion, worth investigating
Large-Tx Spike: A jump in large_tx USD volume vs. the prior window = elevated whale activity
Swap Concentration: Heavy swap volume into or out of one token = directional rotation
Cross-Chain Surge: Whale USD volume rising across multiple chains at once = broad-based positioning
Flow + Consensus Agreement: Raw on-chain movement that lines up with the bias from /v1/whale-consensus for the same asset = higher-conviction read

The most effective approach: treat a cluster of high/critical whale events as a prompt to investigate, then confirm direction with whale-consensus bias and your own technical analysis before acting. Raw on-chain movement plus aggregated positioning is a stronger signal than either alone.

Monitor On-Chain Whale Flows

Track large wallet movements across 8 EVM and Solana chains in near real time. Aggregate by event type and significance, surface the biggest transactions, and act on whale activity as it lands on-chain.

View API Plans