Miners light the fuse: Tracking Bitcoin liquidation cascades in real-time

A 5% Bitcoin price drop doesn't just hurt holders. It triggers a chain reaction that can turn a routine dip into a 20% crash in under an hour.

The mechanism is well understood by traders but rarely visible in real-time: miners operating at a loss are forced to sell. Their spot selling pushes price down. Leveraged longs get liquidated, which forces more market sells. Each liquidation triggers the next. The cascade has already started.

Miners don't explode the market — but they light the fuse.

In our previous post on mining economics, we showed how hashprice has collapsed 70% since the halving, pushing many miners underwater. This post connects that squeeze to what happens next: how miner capitulation feeds into the derivatives market, and how to track the cascade as it unfolds using Deephaven. We'll also connect an AI assistant via MCP — Claude, Cursor, Windsurf, or any MCP-compatible tool — so you can query your data in plain English while the market moves.

Quick recap from Part 1: Hashprice — daily revenue per terahash — has dropped over 70% since the April 2024 halving. At current electricity rates, most home miners are now underwater. Large operations are either selling BTC to cover costs or shutting down entirely.

The three-stage cascade

Before we build anything, let's understand the mechanics.

Stage 1: Miners capitulate. When the Difficulty Regression Model (Glassnode's estimate of average mining production cost) shows spot price near or below the cost floor, miners have two options: shut down or sell. Large operations choose to sell, often in bulk. This is sustained, predictable sell pressure.

Stage 2: Spot price slides. Miner selling alone rarely crashes markets, but it creates a headwind. Combined with any negative catalyst — a macro event, a regulatory headline, a whale exit — it accelerates the drop.

Stage 3: Futures liquidations cascade. A manageable decline becomes a rout. Traders on 10x or 20x leverage have thin margins. A 5% drop liquidates a 20x long entirely. Each forced liquidation is a market sell order, pushing price lower, triggering the next liquidation. During the worst cascades, hundreds of millions of dollars are liquidated in minutes.

Each stage is visible in data before the next one starts. The rest of this post builds the tools to watch it happen.

The miner stress indicator

Note

The code in this post runs in a Deephaven console. If you don't have Deephaven running yet, see the quickstart guide — Docker or pip, under five minutes. Once it's running, install the extra dependency inside your environment:

pip install numpy

The Difficulty Regression Model estimates Bitcoin's average production cost as a log-log relationship between price and network difficulty:

ln(Price) = A + B × ln(Difficulty)

Instead of using published constants that drift over time, we fit A and B directly from three years of historical data.

The Difficulty Multiple (spot price divided by this estimated cost) is the key signal. When it drops toward 1.0, miners are near breakeven. Below 1.0, forced selling begins.

Let's load difficulty and price history, fit the regression, and calculate the model:

from deephaven import agg, new_table, read_csv
from deephaven import dtypes as dht
from deephaven.column import string_col, double_col
import urllib.request
import json
import numpy as np


def fetch_json(url):
    with urllib.request.urlopen(url) as r:
        return json.loads(r.read().decode())


# Load 3 years of difficulty and price history from Blockchain.com (free, no auth)
col_defs = {"Timestamp": dht.string, "Difficulty": dht.double}
difficulty_csv = read_csv(
    "https://api.blockchain.info/charts/difficulty?timespan=3years&format=csv&sampled=true",
    headless=True,
    header=col_defs,
)

price_data = fetch_json(
    "https://api.blockchain.info/charts/market-price?timespan=3years&format=json&sampled=true"
)
diff_data = fetch_json(
    "https://api.blockchain.info/charts/difficulty?timespan=3years&format=json&sampled=true"
)

# Align by timestamp (the two endpoints may return different sample counts)
price_by_ts = {v["x"]: v["y"] for v in price_data["values"]}
diff_by_ts = {v["x"]: v["y"] for v in diff_data["values"]}
common_ts = sorted(set(price_by_ts) & set(diff_by_ts))

# Fit log-log regression: ln(price) = A + B * ln(difficulty)
ln_d = np.log([diff_by_ts[t] for t in common_ts])
ln_p = np.log([price_by_ts[t] for t in common_ts])
B, A = np.polyfit(ln_d, ln_p, 1)

difficulty_model = difficulty_csv.update_view(
    [
        "Date = parseInstant(Timestamp.replace(` `, `T`) + `Z`)",
        f"Regression_Price = Math.exp({A} + {B} * Math.log(Difficulty))",
    ]
)

That gives us the estimated cost floor for each day. Comparing it against spot price gives the Difficulty Multiple:

# Fetch current BTC spot price from CoinGecko (free, no auth)
url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
with urllib.request.urlopen(url) as response:
    spot_data = json.loads(response.read().decode())

btc_price = spot_data["bitcoin"]["usd"]

# Get the most recent regression price
latest_regression = difficulty_model.tail(1)

# Calculate difficulty multiple
difficulty_multiple = latest_regression.update_view(
    [
        f"Spot_Price = (double){btc_price}",
        f"Difficulty_Multiple = (double){btc_price} / Regression_Price",
        "Status = Difficulty_Multiple < 1.0 ? `STRESS` : Difficulty_Multiple < 1.5 ? `WATCH` : `HEALTHY`",
    ]
)

A Difficulty Multiple below 1.0 means spot price has fallen below production cost. Miners are selling at a loss. The lower it drops, the harder they sell.

Loading liquidation data

Now let's bring in the derivatives side. The example below uses synthetic data so you can follow along without an API subscription — swap in Coinglass or the Binance public WebSocket for a live feed.

import time

# Synthetic 48 hours of hourly liquidation data (illustrative)
rng = np.random.default_rng(42)
n = 48
now_ms = int(time.time() * 1000)
ts_ms = [float(now_ms - (n - 1 - i) * 3_600_000) for i in range(n)]

long_liq = list(rng.exponential(8_000_000, n))
short_liq = list(rng.exponential(4_000_000, n))
# Inject a cascade spike ~20 hours ago
long_liq[26] = 75_000_000.0
long_liq[27] = 120_000_000.0
long_liq[28] = 45_000_000.0

liquidations = new_table(
    [
        double_col("Timestamp_Ms", ts_ms),
        double_col("Long_Liquidations_USD", long_liq),
        double_col("Short_Liquidations_USD", short_liq),
    ]
).update_view(
    [
        "Time = epochNanosToInstant((long)(Timestamp_Ms * 1_000_000L))",
        "Total_Liquidations_USD = Long_Liquidations_USD + Short_Liquidations_USD",
        "Cascade_Signal = Long_Liquidations_USD > 50_000_000 ? `CASCADE` : Long_Liquidations_USD > 10_000_000 ? `ELEVATED` : `NORMAL`",
    ]
)

Hours 26–28 in that dataset are the cascade: $75M, then $120M, then $45M in long liquidations across three consecutive hours. That's the pattern we're watching for in real data.

Connecting miner stress to liquidation events

Historically, large liquidation cascades follow periods of miner stress — the Difficulty Multiple drops first, then a catalyst triggers the cascade days or weeks later. Joining the two datasets makes that relationship visible.

# Align daily difficulty data with daily liquidation totals
daily_liquidations = liquidations.update_view("Date = toLocalDate(Time, 'UTC')").agg_by(
    [agg.sum_("Daily_Long_Liq = Long_Liquidations_USD")], by="Date"
)

# Join with difficulty model (align Date types: Instant -> LocalDate)
combined = (
    difficulty_model.update_view("Date = toLocalDate(Date, 'UTC')")
    .natural_join(daily_liquidations, on="Date")
    .update_view("High_Liq_Day = Daily_Long_Liq > 100_000_000")
)

The pattern is consistent: sustained miner stress (Difficulty Multiple below 1.0) precedes major cascade events. The stress doesn't cause the crash, but it means the market is primed. The June 2022 cascade — over $600M liquidated in 24 hours — followed exactly this pattern: hashprice near all-time lows, then a catalyst (3AC collapse), then the cascade.

Connecting Claude to your data

With your tables live in Deephaven, connect Claude so you can ask questions about the cascade in plain English — no query writing while the market is moving. This post uses Claude Desktop, but Cursor, Windsurf, and any other MCP-compatible agent work identically.

The connection runs through MCP (Model Context Protocol), an open standard for linking AI assistants to external tools. Once configured, Claude can see your ticking tables, write queries, run them, and return results in the chat.

Install the MCP bridge

pip install "deephaven-mcp[core]"

Configure Claude Desktop

Open ~/Library/Application Support/Claude/claude_desktop_config.json and add:

{
  "mcpServers": {
    "deephaven-systems": {
      "command": "/path/to/.venv/bin/dh-mcp-systems-server",
      "args": [],
      "env": {
        "DH_MCP_CONFIG_FILE": "/path/to/deephaven_mcp.json"
      }
    }
  }
}

Create deephaven_mcp.json:

{
  "community": {
    "sessions": {
      "local": {
        "host": "localhost",
        "port": 10000,
        "auth_type": "io.deephaven.authentication.psk.PskAuthenticationHandler",
        "auth_token": "YOUR_PSK_TOKEN"
      }
    }
  }
}

If you launched Deephaven with anonymous auth, set "auth_type": "Anonymous" and omit auth_token. Full configuration options are in the MCP setup guide.

Restart Claude Desktop after saving. For Cursor, Windsurf, or other agents, see the MCP setup guide for per-tool config steps.

Ask Claude about your data

With the MCP connection configured and your tables loaded, you can query everything without writing code. Here are two examples.

"What's the current difficulty multiple and what does it mean for miner selling pressure?"

Claude: I'll pull the current difficulty multiple and flag the stress status.

miner_stress_summary = difficulty_multiple.view(
    [
        "Date",
        "Spot_Price",
        "Regression_Price",
        "Difficulty_Multiple",
        "Status",
    ]
)

Result: The table shows the current Difficulty Multiple and status flag.

Below 1.0, miners are operating at a loss and selling is no longer optional — it's survival. Between 1.0 and 1.5 is the watch zone: margins are thin enough that any price weakness pushes more miners underwater.

"Show me the largest liquidation events in the last 24 hours and flag any cascade conditions."

Claude: I'll filter the last 24 hours, sort by liquidation size, and flag cascade conditions.

from deephaven.time import dh_now

cascade_events = (
    liquidations.where("Time >= dh_now() - 'PT24H'")
    .sort_descending("Long_Liquidations_USD")
    .view(
        [
            "Time",
            "Long_Liquidations_USD",
            "Short_Liquidations_USD",
            "Total_Liquidations_USD",
            "Cascade_Signal",
        ]
    )
)

Result: The table shows hourly liquidation events sorted by size, with cascade signals flagged.

Making it real-time

Polling for liquidation data every 30 seconds gives you a live feed. The joins, aggregations, and cascade signals run continuously on the ticking table — no code changes required when the data updates.

The cascade starts long before crypto Twitter notices. Real-time tracking means you're watching the fuse, not the explosion.

from deephaven import function_generated_table, empty_table
import random


# Synthetic live feed — swap fetch_live_liquidations for a real Coinglass or
# Binance WebSocket implementation to connect to actual market data.
def fetch_live_liquidations():
    long_liq_24h = random.expovariate(1 / 80_000_000)
    short_liq_24h = random.expovariate(1 / 40_000_000)
    signal = (
        "CASCADE"
        if long_liq_24h > 500_000_000
        else "ELEVATED"
        if long_liq_24h > 100_000_000
        else "NORMAL"
    )
    return empty_table(1).update(
        [
            "Timestamp = now()",
            f"Long_Liq_24h = (double){long_liq_24h}",
            f"Short_Liq_24h = (double){short_liq_24h}",
            f"Total_Liq_24h = (double){long_liq_24h + short_liq_24h}",
            f"Cascade_Signal = (String)`{signal}`",
        ]
    )


# Poll every 30 seconds
live_liquidations = function_generated_table(
    fetch_live_liquidations, refresh_interval_ms=30_000
)

Note

Coinglass requires a paid API subscription. For free liquidation data, Binance and Bybit both expose liquidation streams via their public WebSocket APIs — no authentication required for the stream endpoint.

Why this matters beyond trading

Liquidation cascades are often dismissed as a "leverage problem" for speculators. But the effects ripple further.

Miners who haven't hedged face a double squeeze: price drops while their energy costs stay fixed. Energy markets feel it too. Mining facilities cut consumption fast during crashes, shifting grid load in Texas and Kazakhstan. Institutional allocators watch cascade depth as a stress test for crypto exposure.

Try it yourself

The strange thing about cascades is that they're completely predictable in retrospect. Miner stress shows up in the data. So does liquidation depth. So does the join between them. Most people just aren't looking until after the crash.

All the code in this post runs in a stock Deephaven session. Swap the synthetic data for a live feed and everything downstream — joins, signals, Claude queries — updates automatically.

Try it in the browser — no install required.
Install Deephaven — free, takes about five minutes.
Connect Claude — point your AI at your Deephaven session.
Load liquidation data — the code in this post uses synthetic data to get you started. For live data, Coinglass offers a paid API, or use the free Binance liquidation WebSocket stream.
Mining economics post — the first post in this series, covering hashprice and breakeven analysis.

In Part 1, we asked: will Bitcoin's price catch up before more miners capitulate? This post answers the follow-up: when they do capitulate, the cascade doesn't wait. Miner stress compresses the spring. A single catalyst releases it. The liquidations happen in minutes, not hours.

The data tells you when the spring is compressed. The question isn't if the next cascade will happen — it's whether you're watching when it does.

Questions? Join us on Slack.

How miner capitulation triggers futures liquidations — and how to watch it happen live