# LiquidVision — Crypto Derivatives Data [Verified owner] [Health: Active]

**Category:** 💰 Finance & Fintech  
**Repository:** https://liquidvision.app/data  
**Views:** 6  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/liquidvision-crypto-derivatives-data

## Description
Exchange-exact crypto derivatives data for AI agents: open interest, funding and liquidations on 13 venues, measured Hyperliquid and Lighter positions with liquidation prices. 49 tools, 19 of them conclusions in one call: ask (plain-words question, answered with numbers and sources, no model), test_rule (any trigger tested against the hourly archive: episodes, outcomes, base rate), check_position (your liquidation price per venue from the venues' real maintenance-margin tiers, the crowd between mark and liquidation, funding cost), attest_snapshot (Ed25519-signed receipt of what the exchanges reported). Conclusions and live snapshots free, no key; history and positions metered (free key 100/day). Every number checked against the exchanges every 10 minutes at /accuracy.

## Tools
Capabilities this server exposes over MCP:

- **list_markets** — [measured] What exists: every venue we track and, for each, the contracts with live open
    interest right now (BASEUSDT symbols), plus the top-100 coin pool. Call this first when unsure
    which symbol or exchange string another tool accepts.
- **get_accuracy** — [measured] The public accuracy audit: our open interest and funding vs Binance, Bybit, OKX and
    Hyperliquid's own endpoints, sampled every 10 min (diff %, snapshot age, 24h mean/max), plus how
    the modeled liquidation map scored against realized liquidations. Read this before trusting
    any number here with money.
- **get_funding_rates** — Latest perpetual funding rates and mark prices for every tracked
    exchange/symbol pair. Positive rate = longs pay shorts.
- **get_microstructure** — Cross-venue order book microstructure for BTC, ETH and SOL.

    Per venue: spread in bps, immediately-executable depth in USD and the bid
    share of it, measured over a band narrow enough that every venue's stream
    captured it, each venue around its own mid. Also the basis - how far apart
    venues price the same asset - plus a per-minute spread history.

    Does NOT answer "what moves price 0.5%": the streams only carry the
    innermost levels, so that would be extrapolation, not measurement.
    
- **get_positioning_regime** — Per-coin positioning regime from price direction crossed with open interest.

    price up + OI up = new longs; price up + OI down = short covering (a rally
    with no new buyers); price down + OI up = new shorts; price down + OI down =
    long flush. Returns a market summary (coins and net OI per regime) plus per
    coin the price change, OI change and current OI over the window.
    
- **get_liquidation_cascades** — [measured, PAST] Liquidation CASCADES as discrete events: bursts of liquidations detected
    against each coin's own 7-day normal minute. Use it for "when did forced selling snowball and
    what did price do"; not for totals (get_liquidations_summary), raw orders (get_liquidations)
    or open positions at risk (*_liquidation_map). Each event: coin, which side broke, start, how
    long it ran, total and peak-minute USD, multiple of the coin's normal minute, the mark-price
    move during it and in the hour after. market_wide lists minutes when three or more unrelated
    coins cascaded together. hours: display window (baseline is always the last 7 days).
- **list_history_packages** — [measured] Monthly Parquet history packages for backtests: liquidations (11 venues), funding hourly and
    settlements, open interest hourly, Hyperliquid and Lighter positions with liquidation prices — one file per
    dataset per month since 2026-07 with rows, bytes and sha256. Each entry has `url` (download with the API key
    in X-API-Key) and `available` for the caller's tier: Pro = this month and the previous one, Bot = all,
    free = none (use get_history for the last 24 h).
- **get_funding_arbitrage** — [measured] Funding carry screener on REALIZED numbers, out of sample: for each coin, the venue
    pair a desk would have put on a week ago (short where funding WAS richest, long where it was
    cheapest, chosen on days 14-7 ago: selection_week_apr) and what that pair then earned from funding
    over the last 7 days (realized_7d_*, negative when the spread reversed) and 30 days, annualized;
    positive_share_7d = share of the week's hours the pair was net positive (0.5 is a coin flip);
    current_spread_apr = the same pair right now; mark_gap_bps = short-venue mark over long-venue
    mark (positive = entry in your favour). Use get_funding_dispersion for the live spread across
    all venues. Everything is gross: before taker fees, basis moves and two margin accounts.
    Not financial advice.
- **get_funding_dispersion** — Coins ranked by how far funding disagrees ACROSS exchanges.

    For each coin: the spread in APR points between the venue charging the most
    and the one paying the most, plus which venue to hold the long on and which
    to hold the short on. Every leg is annualized with its own settlement cycle
    (1h / 4h / 8h), and the ranking uses the median rate over `window` minutes
    rather than the latest print, which is noisy for hourly contracts.
    
- **get_funding_settlements** — Settled funding rates, one row per settlement, from Binance and Bybit
    history — up to 730 days for any pool coin (e.g. BTCUSDT). The backtest
    series; get_funding_history is the live 10-second archive since July 2026.
- **get_open_interest** — Latest open interest (contracts and USD) per exchange/symbol.
- **get_open_interest_history** — [measured] Open interest over time for one contract, one row per venue per time
    bucket: ts (ms), exchange, oi (coins, one side), oi_usd. Use it to see how positioning
    built up or unwound; for the current snapshot with shares and 1h/4h/24h changes use
    get_oi_board, for every contract at once get_open_interest. symbol: BASEUSDT (BTCUSDT).
    minutes: look-back window, 5 to 20160 (14 days); snapped to a fixed set of windows.
- **get_funding_history** — [measured] Funding rate over time for one contract, one row per venue per time bucket:
    ts (ms), exchange, funding_rate (per settlement interval, a fraction), mark_price and
    funding_hours (that contract's interval: 1, 4 or 8). Annualize as rate * 8760 / funding_hours.
    This is the LIVE predicted rate sampled over time; for the rates actually paid at each
    settlement (2 years back) use get_funding_settlements. symbol: BASEUSDT. minutes: 5 to 20160.
- **get_long_short_ratio** — Latest global long/short account ratio per exchange/symbol.
- **get_liquidations** — [measured, PAST] Individual liquidation ORDERS that already happened (side, price, qty),
    newest first, at most `limit` rows (max 2000). This is the raw feed: use it when you need the
    orders themselves. For totals use get_liquidations_summary; for cascades as events use
    get_liquidation_cascades; for where OPEN positions would be liquidated use a *_liquidation_map
    tool. Market-wide, 500 rows is only a few minutes of a busy hour: pass `symbol` (BTCUSDT)
    and/or `min_usd` to look further back. side=long means a long position was liquidated.
- **get_liquidations_summary** — [measured, PAST] TOTALS of liquidations that already happened: rekt (USD liquidated in the
    last 1h/4h/12h/24h, split long/short), by_symbol and by_exchange over the last `minutes`, and
    series (30-minute buckets). The one to call for "how much was liquidated"; it does not return
    individual orders (get_liquidations) or events (get_liquidation_cascades), and says nothing
    about open positions (the *_liquidation_map tools). Totals are a floor: Binance and Bitget
    throttle their feeds. side=long means longs were liquidated. minutes: 1 to 1440.
- **get_oi_board** — Per-venue open-interest ranking for a perp symbol (e.g. BTCUSDT): OI in
    coins and USD, market share %, 1h/4h/24h OI change % and USD flow, and
    OI / 24h-volume ratio per exchange, plus market totals.
- **get_cash_flows** — Derivatives cash flow per exchange: net USD into/out of open interest
    over 1h/4h/24h windows, per core symbol. Positive = money flowing in.
- **get_arbitrum_perps** — Arbitrum perps board: GMX v2 open interest per coin and its share of every
    tracked venue, GMX funding next to the CEX median (8h basis), on-chain
    liquidations over 24h. Ask this for 'how is Arbitrum positioned vs CEXs'.
- **get_top_traders** — Top lead traders (OKX copy trading, public data): total PnL, win rate,
    AUM, copiers, live open positions (pair, side, leverage, entry, uPnL) and
    recently closed trades with realized PnL.
- **get_token_unlocks** — Upcoming token unlock events for pool coins, nearest first: next unlock
    timestamp and token amount per public vesting schedule.
- **get_stocks** — Crypto-related equities (COIN, MSTR, miners) and spot BTC/ETH ETF quotes:
    price, day change %, range, volume. ~15-min delayed.
- **get_liquidation_map** — [modeled, RISK AHEAD, CEX, now] ESTIMATED open leveraged positions on Binance/Bybit/OKX per
    price bin at their liquidation price, from candles and open-interest deltas (the CEXs do not
    publish positions). Current snapshot only; for its evolution over time use
    get_liquidation_heatmap; for REAL positions use get_hl_liquidation_map (Hyperliquid) or
    get_lighter_liquidation_map (Lighter); for what already got liquidated use the PAST tools.
    Returns notional per bin split by leverage tier (5/10/20/25/50/100x) and by exchange, plus
    cumulative long/short curves from the current price outward. exchange: all | binance | bybit |
    okx. range: 12h | 1d | 3d | 7d. It ranks levels ("if price reaches this level, how much is
    there": top quarter of traded levels holds ~30-32% of liquidated USD, chance ~24%); it does NOT
    predict where price will go. Live scoring: get_accuracy.
- **get_hl_liquidation_map** — [measured, RISK AHEAD, Hyperliquid] REAL open positions on Hyperliquid binned by the
    liquidation price the exchange itself reports: the 10,000 largest accounts plus every account
    that traded since the reader started (~10,000 accounts, ~40-45% of venue open interest, stated
    in covered_long_pct/covered_short_pct). Not a model. Use this for Hyperliquid; use
    get_lighter_liquidation_map for Lighter and get_liquidation_map (modeled) for the CEXs.
    Returns long/short notional per bin, cumulative curves and the largest positions. range: 12h
    | 1d | 3d | 7d | max (±100%, recommended: large accounts run low leverage).
- **get_liquidation_heatmap** — [modeled, RISK AHEAD, CEX, over time] The same estimated CEX map as get_liquidation_map but
    as a time series: grid[t][b] is the estimated USD of leveraged positions with their
    liquidation price in price bin b at time cols[t] (ms), bins[b] the bin's centre price (240
    bins fitted to the traded range), price[t] the close. A level disappears once price trades
    through it. Call this only to see WHEN a cluster formed and whether it survived; for the
    current picture call get_liquidation_map (far smaller answer, split by leverage and exchange).
    The answer is large (about 35,000 numbers). symbol: BASEUSDT. exchange: all | binance | bybit
    | okx. range: 12h | 1d | 3d | 7d.
- **get_orderbook_heatmap** — [measured] Resting limit orders over time on ONE exchange: cells of (time bucket, price
    bucket, quantity in coins) from archived order-book snapshots, with price_min, price_max,
    price_step and time_step (seconds) describing the grid. Shows where bid and ask walls
    stood and when they were pulled; not liquidations (see get_liquidation_heatmap for
    those) and not trades (get_footprint). exchange: binance | bybit | okx. symbol: BTCUSDT,
    ETHUSDT or SOLUSDT only. minutes: 1 to 1440.
- **get_market_brief** — Deterministic market brief for a perp symbol: 24h liquidations (totals,
    by exchange), current funding + 24h extremes per venue, OI by venue with
    1h/4h/24h changes, net position flows, modeled liquidation risk zones
    above/below price, and top-trader positioning. Free, no LLM involved —
    ideal input for your own reasoning.
- **ask** — ONE CALL instead of five: ask in plain words ('where is leverage stacked on BTC',
    'why did ETH drop', 'is SOL funding crowded', 'biggest whales near liquidation') and get
    `answer`: short statements with the numbers in them, `facts`: the same numbers as JSON,
    `sources`: which endpoints were read and how old their data is, `caveats`. The question is
    read for its topics (liquidations, funding, open interest, whales, levels, sentiment;
    English or Russian) and only those endpoints are fetched. No model involved: facts, not
    opinion, so you do the judging. Free, no key. For the base rate of the current state
    call get_precedents; for a narrative with an LLM call explain_market.
- **get_precedents** — [measured] When did the market look like this before, and what did price do next?
    Scans our hourly archive for hours whose positioning resembled now (OI change 24h within
    3 pp, funding APR within 15 points and same sign, long share within 5 pp, liquidation
    volume within x2.5), one per day, and returns the 24h and 72h price outcome of those
    look-alikes: count, share that went up, median and quartiles, worst and best, next to the
    unconditional base rate over the same archive. `verdict` says whether the sample is big
    enough to mean anything. Frequencies from our archive (since 2026-09), NOT a forecast.
    Metered: free key (100/day), Pro/Bot, or x402.
- **test_rule** — [measured] Test a trigger against our hourly archive BEFORE acting on it or alerting on
    it: when was this rule true before, and what did price do next? Returns matched hours,
    independent episodes (one per 24 h) with each one's 24 h and 72 h return, the outcome
    statistics (share up, median, quartiles, worst, best), the unconditional base rate over the
    same hours, whether the rule is true right now, and a `verdict` on sample size. The rule
    syntax is the condition-alert syntax, so a rule that tests well becomes create_alert(type=
    'condition', ...) with the same metric/op/threshold. Frequencies from our archive (hourly,
    since 2026-07 for BTC/ETH/SOL), NOT a forecast. Priced: $0.10 per call (x402), 20 prepaid credits, a free
    key's daily quota (100 metered calls), or Pro/Bot.
- **scan_rule** — [measured] One rule tested on up to 100 coins in a single call: on which coins it was true in
    our hourly archive, what price did over the next 24 h and 72 h per coin (share up, median,
    worst, best) next to each coin's base rate, the POOLED outcome across coins with the number
    of distinct days behind it (coins move together, so days, not episodes, are the sample), and
    `true_now`: the coins the rule is true on right now. Use it to find where a setup has
    occurred and where it is live, instead of calling test_rule per coin. Frequencies from our
    archive, NOT a forecast; the note explains why the best of many scans is not an edge.
    Priced: $1.00 per call (x402, USDC on Base or Arbitrum), 200 prepaid credits (one $1 pack),
    or a Pro/Bot key. Takes 10-40 s on a cold cache.
- **check_position** — [measured + modeled] Your own position against the market in one call: the liquidation
    price on each venue from THAT venue's maintenance-margin tier at this notional (read from
    the exchanges' public tables, 'estimated' where none is published), the distance from the
    current mark, how much modeled CEX leverage and how much MEASURED Hyperliquid leverage sits
    between the mark and your liquidation price on your side, the funding cost per day at the
    venue's live rate, and how often in our hourly archive price moved at least that far against
    your side within 24 h and 72 h (a frequency, not a forecast). Assumes isolated margin and
    ignores fees, so the real level is slightly nearer the entry. ONE venue (venue= given) is free; the
    12-venue comparison is an answer we price: $0.02 per call (x402), 4 prepaid credits, or a key's daily quota.
- **attest_snapshot** — [receipt] A SIGNED snapshot: the wrapped endpoint's JSON plus an attestation (SHA-256 of the
    canonical JSON, server time, Ed25519 signature, key id). Anyone can verify it offline with
    the public key at /api/v1/attest/key, so an agent acting for someone else can prove what the
    exchanges reported when it decided. Free snapshots and conclusions only (no metered history).
    It certifies what LiquidVision served, not that the exchange was right. Priced: $0.05 per call (x402),
    10 prepaid credits, or a key's daily quota; the public key at /attest/key is free.
- **buy_credits** — [payment] How an agent with a wallet buys a prepaid API key by itself, with ONE x402 USDC
    payment and no human, email or account. Returns the exact payment requirements (price, asset,
    payTo, network, the resource URL) for GET https://liquidvision.app/api/v1/credits/buy?usd=N.
    Send that GET with a PAYMENT-SIGNATURE (x402 v2) or X-PAYMENT (v1) header from your wallet and the
    answer is a key of tier 'prepaid' with the credits ($0.005 each; a row costs 1, a 12-venue position check 4, precedents or an attestation 10, a rule test 20); the same wallet always tops up the same key.
    Credits are spent per call by price class; every
    conclusion and live snapshot stays free. This tool itself moves no money.
- **credits_balance** — [account] Remaining prepaid credits on a key bought with buy_credits. Free/Pro/Bot keys are
    metered by daily quota instead (X-Raw-Quota-* headers) and return a note saying so.
- **explain_market** — AI risk-intelligence answer: ask e.g. 'Why did BTC drop 4%?' and get a
    concise grounded explanation (liquidation cascades, funding extremes, where
    the positions sit, next risk zone) computed from live derivatives data
    across 13 venues (CEXs, Hyperliquid and GMX).
- **get_footprint** — [measured] Footprint chart data: for each candle, taker BUY and taker SELL volume in
    USD and the trade count at each of 30 price levels, from the archived trade streams of
    Binance, Bybit, OKX, Bitget and Gate. Use it to see at which prices aggressive buyers
    or sellers were absorbed; for the net flow over time by trade size use get_cvd. symbol:
    BTCUSDT, ETHUSDT or SOLUSDT only. minutes: look-back window, 15 to 10080. step: candle
    size in minutes, 1 to 240.
- **get_cvd** — Cumulative volume delta split by trade size (retail <$10K, mid <$100K,
    large <$1M, whale >$1M). Whale-vs-retail divergence is the usual smart-money reading; buckets
    are per published row and only Binance aggregates taker orders, so compare buckets within one
    exchange (exchange=binance) rather than across venues.
- **get_spoofing** — Order-book wall lifecycle heuristic: large levels classified as
    active_wall / absorbed / pulled_wall / suspected_spoof based on whether
    trades executed into them before they vanished.
- **get_api_key** — Get a free LiquidVision API key for this agent's owner, by email, without a browser.
    Works for a NEW email only (an existing account's key is never returned; its owner sees it
    at liquidvision.app/data). Use the key as X-API-Key on REST or on this MCP endpoint: 120 req/min
    instead of the shared anonymous budget, plus 100 metered calls a day (history, positions:
    get_funding_history, get_open_interest_history, get_funding_settlements, get_hl_whales, get_history...),
    and to upgrade later to Pro/Bot (10,000 / 100,000 metered calls a day, exports, webhook alerts). Ask the user for the email
    first; do not invent one.
- **get_history** — [measured] Historical rows as CSV, for backtests. dataset: liquidations | funding_settlements
    (since 2024-09) | funding_hourly | open_interest_hourly | hl_positions (Hyperliquid whale
    positions with liquidation prices). start/end are ISO dates (UTC). Without a key or on the free
    tier only the last 24 hours are available; Pro: any 31-day window; Bot: full history. The key
    is read from the MCP connection's X-API-Key header, or pass api_key. limit caps rows here
    (max 5000); for bulk use download_url with the same key.
- **create_alert** — Subscribe an HTTPS URL to push alerts instead of polling (Pro: 3, Bot: 20 subscriptions).
    type='condition': YOUR OWN trigger on one symbol — fires when `metric` `op` `threshold` becomes
    true (edge-triggered: once per crossing, again only after it was false). metric = funding_apr_pct
    (median annualised funding across venues) | oi_chg_1h_pct | oi_chg_24h_pct (Binance+Bybit+OKX, in
    coins) | liq_1h_usd | liq_24h_usd | price_chg_1h_pct | price_chg_24h_pct (Binance mark) | long_pct
    (mean long share of accounts) — the SAME definitions test_rule backtests, so test a rule first and
    alert on it after; op = gt | lt. Example: symbol='BTC', metric='funding_apr_pct', op='gt',
    threshold=50. The payload carries the value, the threshold and every other metric as context.
    Checked every 60 s.
    type='position': YOUR OWN position (symbol, side, entry, leverage, notional_usd, venue) — fires when it is
    within max_dist_pct of its liquidation price, computed every 60 s from the venue's maintenance-margin
    tier and the live mark (same numbers as check_position); again only when it gets a whole percent closer.
    type='cascade': a liquidation cascade just ended, over min_usd and x_normal times the coin's
    normal minute. type='hl_near_liq': a Hyperliquid whale position over min_usd within
    max_dist_pct of its liquidation price. type='cluster_sweep': price reached one of the 10
    largest modeled liquidation-map clusters (size over min_usd; no symbol = BTC, ETH, SOL), sent
    3 min later with modeled vs actually liquidated USD. Returns the signing secret ONCE: verify header
    X-LiquidVision-Signature = hex HMAC-SHA256(secret, raw body). Needs a Pro or Bot key.
- **list_alerts** — The webhook alert subscriptions that belong to the caller's API key (read-only): id,
    type, url, filters (symbol, min_usd, x_normal, max_dist_pct) and delivery health:
    last_status (HTTP code or error of the last delivery), fails (consecutive failures; a
    subscription pauses itself at 20) and active. Call it to find the id for delete_alert or
    to check why alerts stopped arriving. Needs a Pro or Bot key, from the MCP connection's
    X-API-Key header or the api_key argument; without one it returns an error object, not
    an exception.
- **delete_alert** — Permanently delete one webhook alert subscription. DESTRUCTIVE and not reversible:
    deliveries to its URL stop at once and its signing secret is discarded (create_alert
    issues a new one). Only a subscription owned by the caller's API key can be deleted;
    an id belonging to another key returns {"deleted": false} and changes nothing. id: the
    number returned by create_alert or list_alerts. Needs a Pro or Bot key (X-API-Key header
    of the MCP connection, or api_key).
- **get_hl_whales** — [measured] Leveraged positions of the 10,000 largest Hyperliquid accounts with the
    exchange-reported liquidation price, closest to liquidation first (sort='value' = largest
    first). Filters: coin (BTC), side (long|short), min_usd, max_dist_pct. Each row carries the
    account address; pass it to get_hl_account. Snapshot age is in age_s.
- **get_detective_events** — [measured] Detective: what the watched large holders did. Private wallets with a large
    share of a token's supply (Ethereum, Solana) and Hyperliquid accounts with a large share of
    a contract's open interest are watched live. Event types: to_exchange (a watched wallet sent
    tokens to a recognised exchange, custodian, market maker, DEX pool or bridge: a possible sale,
    reported at any size), large_move (at least $100k to an address we do not recognise),
    hl_position (a watched Hyperliquid position opened, closed or changed by a quarter and $1M+).
    Each event carries the sender's share of supply when it was added to the list, the destination
    label and its source, amount, best-effort USD and an explorer link. Filters: hours (1-720),
    chain (ethereum|solana|hyperliquid), type, symbol (coin). The watch list itself: GET
    https://liquidvision.app/api/v1/detective/watch.
- **get_lighter_liquidation_map** — [measured, RISK AHEAD, Lighter] REAL open positions on Lighter (zk perp DEX; crypto plus
    equity indices, stocks, forex, commodities) binned by Lighter's own liquidation price. Not a
    model. Use this for Lighter; get_hl_liquidation_map for Hyperliquid; get_liquidation_map
    (modeled) for the CEXs. Accounts are discovered from the public trade stream, so coverage
    (covered_long_pct/covered_short_pct of venue open interest) grows with time. Returns long/short
    notional per bin, cumulative curves and the largest positions. range: 12h | 1d | 3d | 7d | max.
- **get_lighter_whales** — [measured] Leveraged positions on Lighter with the exchange-reported liquidation price,
    closest to liquidation first (sort='value' = largest first). Filters: coin (BTC), side
    (long|short), min_usd, max_dist_pct. address is the Lighter account index, l1_address the
    wallet. Snapshot age is in age_s.
- **get_hl_account** — [measured] One Hyperliquid account by address: live positions (size, entry, mark,
    liquidation price, distance to liquidation, leverage, unrealized PnL), account value, and
    its archived position snapshots. History depth: 24 h free, 31 days Pro, everything since
    2026-09-27 on Bot (key from the MCP connection's X-API-Key header, or api_key).
- **get_tokenized_stocks** — [measured] Tokenized stocks, indices, ETFs, commodities, FX, rates and pre-IPO names traded as
    PERPS on DEXs (Lighter and Hyperliquid builder markets): one row per underlying (NVDA, TSLA,
    S&P 500, Gold, EUR/USD, Anthropic...) with every venue's mark, open interest, 24 h volume,
    funding APR and the price gap between venues in bps. asset_class filters: equity |
    crypto_equity | etf | index | commodity | fx | rates | preipo. Use get_hl_builder_markets for
    the raw Hyperliquid HIP-3 list by dex.
- **get_hl_builder_markets** — [measured] Perp markets deployed on Hyperliquid by third parties (HIP-3 builder dexs):
    equity indices, single stocks, commodities and pre-IPO names such as xyz:SP500 or xyz:GOLD.
    For each dex: its markets (coin named dex:COIN), open interest in USD (one side), 24h
    volume, mark price, hourly funding and its APR. These are NOT in get_open_interest or
    get_funding_rates, which cover Hyperliquid's own crypto listing. Live from Hyperliquid,
    cached 2 minutes. No arguments.
- **get_hip3_markets** — [measured] The HIP-3 board: Hyperliquid's builder-deployed perp markets (equity indices,
    stocks, commodities, pre-IPO names; coins named dex:COIN such as xyz:SP500) with what the live
    list alone cannot tell you. Per dex: OI, share, 24h/7d OI change, 24h volume, liquidations.
    Per market: mark, 24h change, OI and its 24h/7d change, 24h volume and turnover (volume/OI),
    hourly funding and APR, liquidations 24h/7d (count, USD, long share), and gap_bps = HIP-3 mark
    vs the mean mark of other venues listing the same underlying (Lighter, Ostium, gTrade).
    `leaders` lists OI growth/decline, funding extremes, most liquidated, widest gap.
    dex filters to one builder (xyz, io, para...); sort = oi | volume | funding | liq | gap | oi_change;
    limit caps the markets list. OI changes are null until the archive is that old (started
    2026-10-31). No key needed.

## Claude Desktop Quick Installation
No generated config for this server: it installs through its own setup steps.

The project's own setup steps (from https://liquidvision.app/llms.txt), copied verbatim. Run them in order; they are not an mcpServers config.

Remote server, nothing to install. No key for conclusions and live snapshots; send X-API-Key for history and positions.

1. Claude Code:

```sh
claude mcp add --transport http liquidvision https://liquidvision.app/mcp
```

2. Any MCP client (config):

```sh
{ "mcpServers": { "liquidvision": { "url": "https://liquidvision.app/mcp" } } }
```

3. Lite server: the 19 conclusion tools only:

```sh
claude mcp add --transport http liquidvision-lite https://liquidvision.app/mcp/lite
```

## Documentation

## What LiquidVision — Crypto Derivatives Data does

LiquidVision — Crypto Derivatives Data exposes crypto market data and analysis tools over MCP for derivatives research. Coverage spans 13 venues, including centralized exchanges, Hyperliquid, and GMX. The tool set includes current and historical funding, open interest, liquidations, positioning regimes, cash flows, order-book conditions, trade-flow statistics, and liquidation-risk views.

It also provides related market context. Agents can retrieve token unlocks, public OKX copy-trading statistics, Arbitrum GMX positioning, crypto-related equities, and spot BTC and ETH ETF quotes. The `get_market_brief` tool combines several derivatives indicators into a deterministic summary, while `explain_market` produces a concise risk-oriented explanation grounded in live derivatives data.

## How it works

Start with `list_markets` when the accepted exchange or symbol format is unclear. It returns tracked venues, contracts with current open interest, and a top-100 coin pool. Symbols generally use the `BASEUSDT` form, such as `BTCUSDT`.

Use snapshot tools for current conditions and history tools for changes over time. Funding history contains predicted rates sampled over time; funding settlements contains rates actually paid at settlement and reaches back up to 730 days for supported pool coins. Open-interest history shows venue-level changes, while the OI board adds market share, flow, and OI-to-volume comparisons.

Liquidation tools are separated by purpose. Raw liquidation orders, aggregate totals, and cascade events describe past activity. Modeled CEX liquidation maps estimate open positions ahead of price moves, whereas Hyperliquid and Lighter maps use exchange-reported positions. `get_accuracy` supplies audit statistics for the modeled and collected data.

## Setup and configuration

The service is accessed through MCP and exposes the tools listed in this entry. History package results include download URLs and SHA-256 checksums. Downloads use an API key in the `X-API-Key` header. Monthly Parquet availability depends on the account tier: Pro includes the current and previous month, Bot includes all packages, and free access includes none; `get_history` can be used for the last 24 hours.

## Tools and capabilities

- Compare latest funding, mark prices, funding dispersion, realized funding arbitrage, and settled funding.
- Inspect open interest by venue, historical OI changes, market share, cash flows, and long/short account ratios.
- Retrieve liquidation orders, totals, cascades, modeled CEX maps, measured Hyperliquid and Lighter maps, and historical liquidation heatmaps.
- Examine spreads, executable depth, cross-venue basis, order-book walls, footprint levels, and cumulative volume delta by trade size.
- Analyze price and OI combinations as new longs, short covering, new shorts, or long flushes.
- Download monthly Parquet history packages for liquidations, funding, settlements, open interest, and selected positions.

## Limitations and notes

CEX liquidation maps are estimates derived from candles and open-interest changes because those exchanges do not publish individual positions. They should not be treated as exchange-reported positions or as price forecasts. Hyperliquid coverage is based on the largest accounts and accounts observed by the reader, with coverage reported in the response; Lighter has a separate measured map.

Liquidation totals are a floor because Binance and Bitget throttle their feeds. Order-book microstructure measures only the innermost captured levels and cannot answer how much liquidity exists across a wider price move. CVD buckets are intended for comparison within Binance, where taker orders are aggregated. Stock and ETF quotes are approximately 15 minutes delayed. Funding-arbitrage results are gross figures before fees, basis changes, and the cost of maintaining two margin accounts.

_Full upstream README: https://allmcps.com/mcp/liquidvision-crypto-derivatives-data/readme_