CoinGlass Liquidation Heatmap Scraper

Export the public CoinGlass Binance BTCUSDT liquidation heatmap as structured JSON.

Instead of saving a screenshot or reading a chart by eye, this Actor returns every Y-axis price level, liquidation-intensity cell, and OHLCV candlestick behind the chart. Use the data in alerts, trading dashboards, notebooks, backtests, and market-risk research.

• 🔥 Models 1 and 2
• ⏱️ Verified anonymous 24-hour market view
• 📊 Complete heatmap cells and candlesticks
• 🕒 CoinGlass update time and source URL
• 🔌 JSON, CSV, Excel, API, webhook, and MCP delivery

What does CoinGlass Liquidation Heatmap Scraper do?

The Actor opens CoinGlass's anonymous liquidation heatmap, captures the chart data decoded by the public web application, and converts positional arrays into documented objects.

Each requested model/range combination produces one dataset item. A record contains the complete heatmap rather than one row per cell, which keeps related chart data together and makes repeated snapshots easy to compare.

The verified anonymous scope is Binance BTC/USDT. CoinGlass currently returns a premium-access response for other pairs on this web surface, so this Actor does not pretend that inaccessible pairs are supported.

Who is it for?

Crypto traders

Watch where estimated leveraged positions cluster above and below the current market. Feed snapshots into a dashboard or alerting rule instead of manually checking a chart.

Quant researchers

Collect model and range snapshots on a schedule. Join liquidation intensity with market prices, funding rates, open interest, or your own signals.

Risk analysts

Measure how liquidation concentration changes during volatile sessions. Retain timestamped source data for later review.

Dashboard builders

Use one stable dataset contract rather than reverse-engineering a changing canvas visualization in every application.

AI and agent developers

Give an agent structured liquidation levels and candles through Apify API or MCP, without asking a multimodal model to interpret chart pixels.

Why use this Actor?

• Structured output — numeric arrays and named objects, not screenshots.
• Repeatable snapshots — run on a schedule and compare update times.
• Two models — request CoinGlass Model 1, Model 2, or both.
• Verified scope — an honest 24-hour anonymous export with no paid CoinGlass key.
• Source traceability — each item includes its CoinGlass URL and scrape time.
• Low input complexity — one small request object defines a full export.
• Apify integrations — datasets, webhooks, schedules, API clients, and MCP are ready to use.

Supported market and current scope

Setting	Supported value
Coin	BTC
Exchange	Binance
Pair	BTCUSDT
Heatmap models	1, 2
Time range	24h
Requests per run	1–5

This scope reflects the data CoinGlass exposes anonymously today. If CoinGlass changes public availability, the Actor can be extended after the additional route is verified.

What data can you extract?

Field	Type	Description
symbol	string	Coin symbol, currently BTC
exchange	string	Exchange, currently Binance
pair	string	Trading pair, currently BTCUSDT
model	string	CoinGlass heatmap model
range	string	Requested chart horizon
interval	number/string	Candle aggregation interval
instrument	object	CoinGlass instrument metadata
priceLevels	number[]	Heatmap Y-axis prices
liquidationLeverageData	object[]	Time index, price index, and intensity
candlesticks	object[]	Timestamp, open, high, low, close, volume
rangeLow	number	Lower chart boundary
rangeHigh	number	Upper chart boundary
precision	number	Source price precision
updateTime	string	CoinGlass update timestamp
sourceUrl	string	Public chart URL
scrapedAt	string	Actor extraction timestamp

How to scrape a CoinGlass liquidation heatmap

1. Open the Actor on Apify.
2. Keep the prefilled 24-hour Model 1 request or edit it.
3. Add both model combinations if needed.
4. Click Start.
5. Open the Dataset tab when the run finishes.
6. Export JSON, CSV, Excel, XML, or another supported format.

A single prefilled request is the best first run.

Input

The main requests field is an array of heatmap request objects.

{
  "requests": [
    {
      "symbol": "BTC",
      "exchange": "Binance",
      "pair": "BTCUSDT",
      "model": "1",
      "range": "24h"
    }
  ]
}

All fields have safe defaults. Explicit fields make saved tasks and audit logs easy to understand.

Compare Models 1 and 2

Request both models in one run:

{
  "requests": [
    {
      "symbol": "BTC",
      "exchange": "Binance",
      "pair": "BTCUSDT",
      "model": "1",
      "range": "24h"
    },
    {
      "symbol": "BTC",
      "exchange": "Binance",
      "pair": "BTCUSDT",
      "model": "2",
      "range": "24h"
    }
  ]
}

The two dataset items share the same documented structure and can be compared directly.

Available time range

The verified anonymous export is 24h, using five-minute candles from CoinGlass's public page.

Other ranges currently return CoinGlass's premium-access response. They are intentionally excluded rather than labeled as supported while returning default or incomplete data.

Output example

The arrays below are shortened for readability. Real output contains the complete source payload.

{
  "symbol": "BTC",
  "exchange": "Binance",
  "pair": "BTCUSDT",
  "model": "1",
  "range": "24h",
  "interval": 5,
  "priceLevels": [59471.68, 59548.21],
  "liquidationLeverageData": [
    { "timeIndex": 10, "priceIndex": 93, "intensity": 16921356.06 }
  ],
  "candlesticks": [
    {
      "timestamp": 1783915800,
      "open": 62772,
      "high": 62845.5,
      "low": 62761.9,
      "close": 62793.3,
      "volume": 27811136.6119
    }
  ],
  "rangeLow": 55480,
  "rangeHigh": 69734.8,
  "updateTime": "2026-07-14T04:09:34.472Z",
  "sourceUrl": "https://www.coinglass.com/pro/futures/LiquidationHeatMap?coin=BTC&time=d1"
}

Understanding liquidation cells

Each liquidation cell has three values:

• timeIndex points to a candlestick position on the X-axis.
• priceIndex points to a value in priceLevels on the Y-axis.
• intensity is the source liquidation-leverage intensity for that coordinate.

Resolve a cell to a timestamp and price like this:

const cell = item.liquidationLeverageData[0];
const timestamp = item.candlesticks[cell.timeIndex]?.timestamp;
const price = item.priceLevels[cell.priceIndex];

Do not interpret intensity as an executed liquidation amount. It is the value provided by CoinGlass's heatmap model.

Understanding OHLCV candles

Each candlestick includes:

• Unix timestamp in seconds
• open
• high
• low
• close
• source volume

The Actor converts numeric strings from the source into JSON numbers.

How much does it cost to extract a CoinGlass liquidation heatmap?

The Actor uses pay-per-event pricing:

• one $0.005 start charge per run
• one result charge per complete heatmap exported
• automatic tier discounts on higher Apify plans

Apify tier	Price per complete heatmap
Free	$0.0050894
Bronze	$0.0044256
Silver	$0.003452
Gold	$0.0026554
Platinum	$0.0017702
Diamond	$0.0012392

You pay for complete heatmap records, not thousands of individual cells.

Run several requested combinations together to avoid unnecessary repeated start charges.

Scheduling a liquidation heatmap monitor

Apify schedules can run the Actor hourly, daily, or on a custom cron expression.

A practical monitor workflow is:

1. Save a task with Model 1 and Model 2.
2. Create an hourly or four-hour schedule.
3. Send dataset items through a webhook.
4. Store snapshots in your database or warehouse.
5. Compare intensity clusters and update times.

Avoid polling more frequently than your analysis requires.

Integration ideas

Trading dashboard

Send each snapshot to PostgreSQL, ClickHouse, BigQuery, or a time-series database. Render cells with your preferred chart library.

Alert engine

Resolve cell indexes to prices and timestamps. Trigger an alert when high-intensity clusters enter a defined distance from the latest candle close.

Research notebook

Download JSON into Python or R, normalize cells into a table, and compare heatmap changes with realized volatility.

Data warehouse

Store one raw snapshot row plus normalized child tables for candles and cells. Keep updateTime as the source version key.

AI market brief

Use MCP or an API call to fetch the latest structured snapshot, then ask an agent to summarize clusters with explicit caveats.

API usage with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/coinglass-liquidation-heatmap-scraper').call({
  requests: [
    { symbol: 'BTC', exchange: 'Binance', pair: 'BTCUSDT', model: '1', range: '24h' }
  ]
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].liquidationLeverageData.length);

Python API example

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/coinglass-liquidation-heatmap-scraper").call(run_input={
    "requests": [
        {"symbol": "BTC", "exchange": "Binance", "pair": "BTCUSDT", "model": "2", "range": "24h"}
    ]
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["updateTime"], len(item["priceLevels"]))

cURL API example

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~coinglass-liquidation-heatmap-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests":[{"symbol":"BTC","exchange":"Binance","pair":"BTCUSDT","model":"1","range":"24h"}]}'

Use the returned run ID to read status and dataset links.

Use with Apify MCP

Connect AI clients through:

https://mcp.apify.com/?tools=automation-lab/coinglass-liquidation-heatmap-scraper

Claude Code setup

$claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/coinglass-liquidation-heatmap-scraper

Claude Desktop setup

Add the server under mcpServers in Claude Desktop's configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/coinglass-liquidation-heatmap-scraper"
    }
  }
}

Cursor setup

Open Settings → MCP → Add server and use the same HTTP URL, or add the mcpServers JSON above to .cursor/mcp.json.

VS Code setup

Open MCP: Add Server from the Command Palette, choose HTTP, and paste the Actor-specific MCP URL.

Example prompts for Claude Code and Desktop

Run the CoinGlass Liquidation Heatmap Scraper for BTC Model 1 and Model 2 over 24 hours. Compare the strongest clusters and cite the update time.

Claude Desktop prompt

Fetch the latest 24-hour BTC liquidation heatmap and explain how to resolve its top cells to prices. Do not call modeled intensity executed liquidations.

Agent workflow prompt

Collect both 24-hour model snapshots, return the source URLs, and prepare normalized candle and cell tables for my database.

Webhooks

Configure a webhook for ACTOR.RUN.SUCCEEDED to notify another service when a fresh snapshot is ready.

The webhook payload contains dataset identifiers. Your service can fetch the item, validate updateTime, and process it idempotently.

Proxy configuration

No proxy is required for normal operation. Leave proxy use disabled for the lowest cost.

If CoinGlass is unavailable from the default network, enable an Apify Proxy in the optional connection section. The Actor uses one proxy session per heatmap page context.

Performance tips

• Start with one 24-hour request.
• Group up to five combinations in one run.
• Leave proxy disabled unless needed.
• Store source snapshots before normalizing them.
• Deduplicate downstream on model, range, pair, and updateTime.
• Schedule at a frequency appropriate for the source update cadence.

Data quality and caveats

Liquidation heatmaps are model outputs, not a ledger of guaranteed future liquidations.

Market conditions and exchange rules change. Treat the data as one research input, verify critical decisions independently, and preserve the source timestamp.

CoinGlass may change its frontend or anonymous availability. The Actor retries transient failures but fails clearly when the verified source data is unavailable.

Troubleshooting: no heatmap was returned

First retry once after a short delay because CoinGlass occasionally returns a transient page error. The Actor already makes up to three bounded attempts.

If failures persist:

1. Check the run log for an HTTP status or timeout.
2. Confirm the request uses the supported BTC/Binance/BTCUSDT values.
3. Try enabling an Apify Proxy.
4. Check whether CoinGlass's public heatmap is available in a browser.

Troubleshooting: why can I not enter ETH?

The public CoinGlass web route currently returns a premium-access code for non-BTC pairs. The Actor intentionally validates the verified anonymous scope instead of returning incomplete or misleading data.

Troubleshooting: arrays look large in CSV

Nested arrays are best consumed as JSON. CSV and Excel exports serialize them into cells.

For analytics, fetch JSON and normalize candlesticks and liquidationLeverageData into child tables.

Legality

This Actor accesses a public, anonymous page and does not bypass login or CAPTCHA. You are responsible for your use case, run frequency, applicable laws, and the source website's terms.

Do not use the data for unlawful activity or represent modeled heatmap values as guaranteed market outcomes.

FAQ

Does the Actor return a screenshot?

No. It returns the structured values behind the chart. This is better suited to analysis and automation.

Which heatmap models are supported?

CoinGlass Model 1 and Model 2.

Which pair is supported?

The verified anonymous Binance BTCUSDT pair.

Can I request several ranges?

Not currently. CoinGlass anonymously exposes the verified 24-hour range; you can request both models in one run.

Does it require a CoinGlass account or API key?

No account or paid API key is required for the supported scope.

How many dataset items will I receive?

One complete item per successful request object.

Are candles numeric?

Yes. The Actor converts source OHLCV strings to numbers.

Can I run it on a schedule?

Yes. Save a task and attach an Apify schedule.

Can I use the data from Python?

Yes. Use apify-client, the dataset API, or a JSON export.

Related scrapers

Explore other finance and market-data Actors from automation-lab for complementary research workflows.

Combine this Actor with exchange price, funding-rate, open-interest, or news datasets when those sources fit your analysis.

Support

If a run fails on a supported request, open an issue from the Actor page and include:

• run URL
• selected model and range
• whether a proxy was enabled
• expected versus actual result

Do not include private credentials in support messages.