HyperData Terminal

Hyperliquid whales, liquidation heatmaps and order flow from five exchanges, live in your terminal.
Free and open source. Public feeds only: no API keys, no account, nothing to sign.

pipx install hyperdata-terminal
hyperdata

Why people run it

• See where leverage gets wiped before it happens. A liquidation heatmap and a "closest to liquidation" list built from thousands of live Hyperliquid wallets, for every listed asset. The kind of view paid dashboards charge for.
• Watch the biggest books on Hyperliquid. Size, entry, liquidation price, PnL and leverage of the largest open positions, plus Hyperliquid's own market maker (the HLP vault: AUM, net delta, gross exposure) and the liquidations it absorbs.
• Know when the data is wrong. Every feed is cross-checked and labelled LIVE, PARTIAL, STALE or DRIFT. Confirmed liquidations are never mixed with guesses. Order flow says when a timeframe is still warming up instead of printing a fake signal. See docs/DATA_INTEGRITY.md.
• Plug it into your AI agent. hyperdata mcp gives Claude, Cursor or any MCP client ten read only tools over the same live data.
• Build on it. A local REST and WebSocket API, and a paper trading engine that runs your strategy file on live prices.

Install

pipx install hyperdata-terminal         # or: uv tool install hyperdata-terminal
uvx hyperdata-terminal                  # or run once without installing
pip install hyperdata-terminal          # into the current environment
pipx install git+https://github.com/Co-Messi/HyperData-Terminal   # latest main

Requires Python 3.12 or newer. Want the MCP server too? pipx install "hyperdata-terminal[mcp]".

Use

Add --no-boot to skip the start animation. Ctrl+C returns to the menu or exits. Positions take about 30 seconds to load on the first scan.

Dashboards

MCP server for AI agents

pipx install "hyperdata-terminal[mcp]"
claude mcp add hyperdata -- hyperdata mcp          # Claude Code

For Claude Desktop, Cursor and other clients, add it to the MCP config:

{
  "mcpServers": {
    "hyperdata": { "command": "hyperdata", "args": ["mcp"] }
  }
}

Then ask things like "Where are the biggest BTC liquidation clusters right now?", "Which Hyperliquid whales are within 2% of liquidation?" or "Is anything showing extreme funding, and does order flow agree?"

Every result carries a meta block with uptime and warmup warnings, so an agent can tell "not loaded yet" from "nothing happened". The server is read only: no keys, no orders, no account access.

REST API

hyperdata api --port 8420
curl http://localhost:8420/v1/liquidations/stats?include_estimated=false
curl http://localhost:8420/v1/positions/danger-zone

Local only by default. The API binds to 127.0.0.1 and serves wallet level positions and order flow. A non loopback bind (HYPERDATA_API_HOST=0.0.0.0) is refused unless you set HYPERDATA_API_KEY (then every non health route needs Authorization: Bearer <key> or X-API-Key) or explicitly accept the risk with HYPERDATA_UNSAFE_PUBLIC_API=1. Browsers get no cross origin access unless you list the origin in HYPERDATA_CORS_ORIGINS, and on loopback the Host header must be loopback too (DNS rebinding guard).

Paper trading

A strategy is one class with one method, in a file anywhere on disk:

# my_strategy.py
from hyperdata_terminal.strategies import Signal, Strategy

class CvdBreakout(Strategy):
    name = "cvd_breakout"

    def evaluate(self, hub) -> Signal | None:
        snap = hub.orderflow.get_snapshot("BTC", "5m")
        if snap.warming_up:          # window not filled yet
            return None
        if snap.cvd > 100_000:
            return Signal("BTC", "BUY", size_usd=100, reason="buyers in control")
        if snap.cvd < -100_000:
            return Signal("BTC", "SELL", size_usd=100, reason="sellers in control")
        return None

hyperdata paper -s ./my_strategy.py -s funding_rate_arb --interval 30

Helper modules next to your strategy file can be imported, at the top of the file. Trades print as they happen and are logged to SQLite; Ctrl+C prints the portfolio. Built in strategies: cvd_momentum, funding_rate_arb, liquidation_cascade, whale_follow, and llm_agent, which asks any OpenAI compatible model (OpenAI, Ollama, LM Studio, Groq, Together) for a decision. The full list of what hub exposes is in strategies/base.py.

Data sources

Coverage is honest, not a census. Hyperliquid has no public liquidation feed, so its confirmed liquidations are the ones an HLP vault took the other side of (a few an hour, counted once per liquidation even when two vaults filled it); trades of $10K or more are shown separately as estimated large prints and never counted as liquidations. Binance futures is blocked in some regions (the US among them): there the Binance CVD leg reads silent and spot, long/short and the price cross check fall back to Coinbase, Bybit or OKX, each value naming its source. Details: docs/DATA_INTEGRITY.md.

Configuration

Everything works without configuration. Optional settings go in a .env in the directory you run from (.env.example):

How it works

Hyperliquid  Binance  Bybit  OKX  Coinbase  Deribit      (public WebSocket + REST)
        \       |       |     |      |       /
         HyperDataHub: 14 async components, one event loop, SQLite writer thread
        /        |            |             \
  dashboards   REST + WS    MCP server    paper trading
   (Rich)       (/v1/*)     (stdio)       (your strategies)

The hub owns every data component and its lifecycle; dashboards, API, MCP server and strategies all read the same in memory state.

Development

git clone https://github.com/Co-Messi/HyperData-Terminal.git
cd HyperData-Terminal
pip install -e ".[mcp]" pytest pytest-asyncio ruff
python -m pytest tests -q          # live exchange tests need --live
ruff check hyperdata_terminal tests

The demo GIF is reproducible: vhs assets/demo.tape.

Contributing

Issues and pull requests are welcome. Good places to start: a new exchange adapter (Bitget, Gate, Hyperliquid spot), a new dashboard over data the hub already has, or a new MCP tool. Please run the tests and ruff before opening a PR.

License

Apache License 2.0, see LICENSE. Market data belongs to the exchanges that publish it; this project only reads public endpoints. Nothing here is financial advice.