How to Build a Crypto Trading Bot with CoinGlass API

Building a crypto trading bot is not just about writing a script that buys when price goes up and sells when price goes down.

That kind of bot may work for a simple demo, but it is usually not enough for real crypto markets, especially if the bot trades futures, perpetual contracts, or leveraged positions.

Crypto markets are heavily influenced by derivatives. A large price move may be caused by spot buying, but it may also be caused by:

Open interest expansion
Funding rate imbalance
Short liquidations
Long liquidations
Leverage build-up
Forced deleveraging
Order book liquidity gaps
Aggressive taker buy or sell pressure
Cross-exchange positioning

This is why a serious crypto trading bot needs more than price data. It needs market structure data.

CoinGlass API is useful in this context because it provides access to key crypto derivatives data such as open interest, funding rates, liquidations, long/short ratios, order book data, options data, ETF flow data, and other market indicators. CoinGlass API V4 is the current recommended version, while V1–V3 are deprecated and mainly kept for backward compatibility. ([coinglass][1])

In this guide, we will walk through how to build a crypto trading bot using CoinGlass API as a market intelligence layer. The goal is not to build a perfect money-printing machine. The goal is to design a more market-aware trading bot that can understand when a signal is strong, when risk is elevated, and when it is better to stay out.

1. What Kind of Trading Bot Are We Building?

Before writing code, we need to define the bot.

A crypto trading bot can mean many different things:

Bot Type	Description	Data Needed
Price alert bot	Sends alerts when price reaches a level	Price data
Trend-following bot	Buys breakouts and sells breakdowns	Price, volume, OI
Grid bot	Places buy and sell orders in a range	Price, volatility, risk filters
Funding rate bot	Monitors funding rate opportunities	Funding rate, OI, exchange data
Liquidation alert bot	Detects abnormal liquidation events	Liquidation data
Risk management bot	Reduces exposure during extreme market stress	OI, funding, liquidations
Quant strategy bot	Uses multiple factors to generate signals	Historical and real-time data

In this article, we will build a derivatives-aware trading bot framework.

The bot will:

Fetch market data from CoinGlass API
Read open interest, funding rate, and liquidation data
Convert raw data into trading features
Generate market state signals
Combine derivatives signals with a simple price signal
Output a trading decision
Adjust position size based on market risk

This is a realistic architecture because CoinGlass API is best used as a market intelligence layer, while exchange APIs are usually used as the execution layer.

2. CoinGlass API vs Exchange API

Many developers ask:

Why not just use Binance API, OKX API, Bybit API, or another exchange API?

The answer is simple: exchange APIs and CoinGlass API solve different problems.

Function	Exchange API	CoinGlass API
Place orders	Yes	No
Manage account balance	Yes	No
Read current position	Yes	No
Get exchange-specific price	Yes	Sometimes, depending on endpoint
Compare multiple exchanges	Manual work needed	More suitable
Get aggregated derivatives data	Harder	Designed for this
Get funding rate context	Limited to exchange	Broader derivatives view
Get liquidation data	Exchange-specific or limited	More useful as an aggregated market signal
Build market structure signals	Requires heavy engineering	More direct
Execute trades	Yes	No

A good trading system usually uses both:

Exchange API = execution layer
CoinGlass API = market intelligence layer

The exchange API answers:

Can I place this order?
What is my account balance?
What is my current position?

CoinGlass API helps answer:

Should I place this order?
Is the market crowded?
Is leverage building up?
Are traders being liquidated?
Is this breakout healthy?

That distinction is important. A trading bot should not only know how to trade. It should also know when not to trade.

3. Why CoinGlass API Is Useful for Trading Bots

CoinGlass provides a broad set of crypto market data. According to CoinGlass public API materials, its crypto API covers derivatives, spot, options, ETF markets, order book data, and market snapshot data such as price, volume, open interest, and funding rates. ([coinglass][2])

For trading bots, the most useful data categories are:

Data Type	Why It Matters
Open Interest	Shows whether leveraged capital is entering or leaving
Funding Rate	Measures long/short cost and crowding
Liquidations	Shows forced position closures
Long/Short Ratio	Helps detect positioning imbalance
Taker Buy/Sell Volume	Shows aggressive buying or selling pressure
Order Book Data	Helps analyze liquidity and execution risk
Liquidation Heatmap	Helps identify potential liquidation zones
ETF Flow Data	Useful for broader market flow analysis
Options Data	Useful for volatility and institutional positioning

CoinGlass API official materials list futures modules such as open interest, funding rate, liquidation data, global long/short ratios, top trader long/short ratios, and taker buy/sell volume. Some example endpoint categories include /api/futures/openInterest/ohlc-history, /api/futures/fundingRate/oi-weight-ohlc-history, and /api/futures/liquidation/aggregated-history. ([coinglass][3])

These data points help the bot understand market state instead of only reacting to price.

4. Trading Bot Architecture

A simple crypto trading bot architecture looks like this:

Data Layer
    ↓
Feature Layer
    ↓
Signal Layer
    ↓
Risk Layer
    ↓
Execution Layer
    ↓
Logging / Monitoring Layer

Let’s define each layer.

Layer	Purpose
Data Layer	Fetch raw market data from APIs
Feature Layer	Convert raw data into useful indicators
Signal Layer	Generate buy, sell, or hold signals
Risk Layer	Adjust position size and filter bad trades
Execution Layer	Place orders through exchange API
Logging Layer	Store decisions, errors, and performance data

CoinGlass API sits mainly in the Data Layer, but its output is used heavily in the Feature, Signal, and Risk layers.

A practical bot architecture may look like this:

CoinGlass API
  - Open Interest
  - Funding Rate
  - Liquidation Data
  - Long/Short Ratio
  - Order Flow

Exchange API
  - Price Candles
  - Account Balance
  - Order Placement
  - Position Management

Trading Bot
  - Feature Engineering
  - Signal Generation
  - Risk Filtering
  - Position Sizing
  - Execution

This article will focus on the CoinGlass API side and the strategy framework. You can connect the final decision output to your preferred exchange API.

5. Core Strategy Idea

A common beginner bot does this:

If price breaks above moving average → BUY
If price breaks below moving average → SELL

This is simple, but it ignores derivatives market structure.

A better bot does this:

If price gives BUY signal
AND funding rate is not extremely high
AND open interest supports the move
AND liquidation risk is not extreme
THEN allow the trade

Otherwise, reduce size or skip the trade

This is more realistic.

The bot does not simply ask:

Did price go up?

It asks:

Is this price move healthy?
Is leverage supporting it?
Is one side too crowded?
Is the market entering a liquidation cascade?

That is the main difference between a basic bot and a market-aware bot.

6. Key CoinGlass Data for the Bot

For this trading bot, we will focus on three core data types:

Open Interest
Funding Rate
Liquidation Data

These three are enough to build a strong first version.

6.1 Open Interest

Open Interest, or OI, measures the total open futures or perpetual contract positions.

It helps answer:

Is new leverage entering the market?

Price	Open Interest	Possible Interpretation
Price up	OI up	New positions support the move
Price up	OI down	Shorts may be closing
Price down	OI up	New shorts may be entering
Price down	OI down	Longs may be closing or liquidated
Price flat	OI up	Leverage is building before a possible breakout

For bots, OI is useful because it helps confirm whether a price movement is supported by new market participation.

Example:

BTC price rises 3%.
Open interest also rises.
Funding rate remains neutral.

This may be a healthier bullish trend.

But:

BTC price rises 3%.
Open interest rises sharply.
Funding rate becomes extremely positive.
Long/short ratio becomes heavily long.

This may be a crowded long environment.

6.2 Funding Rate

Funding rate is the periodic payment between longs and shorts in perpetual futures.

Funding Rate	Meaning
Positive	Longs pay shorts
Negative	Shorts pay longs
Extremely positive	Longs may be crowded
Extremely negative	Shorts may be crowded
Neutral	Market is more balanced

Funding rate is not a direct buy or sell signal.

A common mistake is:

Funding high = short
Funding low = long

That is too simple.

A better interpretation is:

Funding high = long side may be crowded
Funding low = short side may be crowded

Funding rate is best used as a filter.

Examples:

Price Signal	Funding Rate	Bot Action
BUY	Neutral	Allow trade
BUY	Extremely positive	Reduce size or skip
SELL	Neutral	Allow trade
SELL	Extremely negative	Reduce size or skip
BUY	Negative + short liquidations rising	Possible short squeeze setup

6.3 Liquidation Data

Liquidation data shows forced position closures.

It helps answer:

Which side is being forced out?

Liquidation Event	Interpretation
Long liquidation spike	Longs are being forced out
Short liquidation spike	Shorts are being squeezed
Both sides liquidated	Extreme volatility
Liquidations decline	Leverage pressure may be cooling
Liquidation spike + price recovery	Possible false breakdown or liquidity sweep

Liquidation data is extremely useful for risk management.

A bot can use it to:

Avoid trading during liquidation cascades
Detect short squeeze conditions
Detect long squeeze conditions
Reduce position size during market stress
Avoid buying or selling after a move is already exhausted

7. API Setup

CoinGlass API V4 uses the following base URL in public documentation and examples:

https://open-api-v4.coinglass.com

Requests generally use the CG-API-KEY header for authentication. CoinGlass documentation states that API V4 brings improved performance, faster response times, and optimized data retrieval. ([coinglass][4])

First, install the required Python packages:

pip install requests pandas python-dotenv

Create a .env file:

COINGLASS_API_KEY=your_api_key_here

Then create a Python file named:

bot.py

Basic API client:

import os
import requests
import pandas as pd
from dotenv import load_dotenv

load_dotenv()

BASE_URL = "https://open-api-v4.coinglass.com"
API_KEY = os.getenv("COINGLASS_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing COINGLASS_API_KEY environment variable")

HEADERS = {
    "CG-API-KEY": API_KEY,
    "Accept": "application/json"
}


def request_coinglass(endpoint, params=None):
    """
    Send a GET request to CoinGlass API.
    """
    url = f"{BASE_URL}{endpoint}"

    response = requests.get(
        url,
        headers=HEADERS,
        params=params,
        timeout=10
    )

    response.raise_for_status()
    return response.json()

This function will be reused for all CoinGlass API requests.

8. Add Safe Request Handling

Production bots should not crash because one API request fails.

Let’s improve the request function with retries:

import time


def safe_request_coinglass(endpoint, params=None, retries=3, sleep_seconds=2):
    """
    Send a GET request with retry logic.
    """
    last_error = None

    for attempt in range(retries):
        try:
            return request_coinglass(endpoint, params)

        except requests.RequestException as error:
            last_error = error
            print(f"Request failed: attempt {attempt + 1}/{retries}: {error}")
            time.sleep(sleep_seconds)

    raise last_error

This is important because live bots must handle:

Network errors
Timeout errors
Temporary API issues
Rate limits
Invalid responses
Missing data

A trading bot should fail safely, not blindly continue with broken data.

9. Fetch Open Interest Data

CoinGlass public API materials list Open Interest endpoints such as:

/api/futures/openInterest/ohlc-history
/api/futures/openInterest/aggregated-history
/api/futures/openInterest/exchange-list

For this example, we will use an OHLC-style history endpoint. Always verify endpoint names and parameters with the latest official documentation before production use.

def fetch_open_interest(symbol="BTC", interval="1h", limit=100):
    endpoint = "/api/futures/openInterest/ohlc-history"

    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)

Convert the response into a DataFrame:

def to_dataframe(raw):
    """
    Convert a CoinGlass API response to a pandas DataFrame.
    Adjust this function based on the actual response shape.
    """
    data = raw.get("data", [])

    if isinstance(data, dict):
        # Some APIs may return nested structures.
        # Adjust based on actual response.
        rows = data.get("list", [])
    else:
        rows = data

    df = pd.DataFrame(rows)

    if df.empty:
        return df

    if "time" in df.columns:
        df["time"] = pd.to_datetime(df["time"], unit="ms", errors="coerce")

    return df

Add OI features:

def add_open_interest_features(df):
    data = df.copy()

    # Adjust field names based on actual API response.
    if "close" in data.columns:
        data["oi_close"] = pd.to_numeric(data["close"], errors="coerce")
    elif "openInterest" in data.columns:
        data["oi_close"] = pd.to_numeric(data["openInterest"], errors="coerce")
    else:
        raise ValueError("No recognizable open interest field found")

    data["oi_change"] = data["oi_close"].pct_change()
    data["oi_change_24"] = data["oi_close"].pct_change(24)

    return data

10. Fetch Funding Rate Data

CoinGlass public materials list funding rate endpoints such as:

/api/futures/fundingRate/ohlc-history
/api/futures/fundingRate/oi-weight-ohlc-history
/api/futures/fundingRate/exchange-list

A bot can use funding rate to detect crowded long or short conditions.

def fetch_funding_rate(symbol="BTC", interval="1h", limit=100):
    endpoint = "/api/futures/fundingRate/oi-weight-ohlc-history"

    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)

Add funding rate features:

def zscore(series, window=24):
    mean = series.rolling(window).mean()
    std = series.rolling(window).std()
    return (series - mean) / std


def add_funding_features(df, window=24):
    data = df.copy()

    # Adjust field name based on actual API response.
    if "close" in data.columns:
        data["funding_close"] = pd.to_numeric(data["close"], errors="coerce")
    elif "fundingRate" in data.columns:
        data["funding_close"] = pd.to_numeric(data["fundingRate"], errors="coerce")
    else:
        raise ValueError("No recognizable funding rate field found")

    data["funding_z"] = zscore(data["funding_close"], window)

    return data

Interpretation:

Funding Z-score	Meaning
Above 2	Extremely positive funding
1 to 2	Moderately positive funding
-1 to 1	Neutral
-2 to -1	Moderately negative funding
Below -2	Extremely negative funding

This lets the bot detect whether the market is unusually long-heavy or short-heavy.

11. Fetch Liquidation Data

CoinGlass public materials list liquidation endpoints such as:

/api/futures/liquidation/history
/api/futures/liquidation/aggregated-history
/api/futures/liquidation/heatmap/model2

For this example:

def fetch_liquidation_history(
    symbol="BTC",
    exchanges="Binance,OKX,Bybit",
    interval="1h",
    limit=100
):
    endpoint = "/api/futures/liquidation/aggregated-history"

    params = {
        "exchange_list": exchanges,
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)

Add liquidation features:

def add_liquidation_features(df, window=24):
    data = df.copy()

    rename_map = {
        "longLiquidation": "long_liquidation",
        "shortLiquidation": "short_liquidation",
        "long_liq": "long_liquidation",
        "short_liq": "short_liquidation"
    }

    data = data.rename(columns=rename_map)

    if "long_liquidation" not in data.columns:
        raise ValueError("No long liquidation field found")

    if "short_liquidation" not in data.columns:
        raise ValueError("No short liquidation field found")

    data["long_liquidation"] = pd.to_numeric(
        data["long_liquidation"],
        errors="coerce"
    )

    data["short_liquidation"] = pd.to_numeric(
        data["short_liquidation"],
        errors="coerce"
    )

    data["long_liq_z"] = zscore(data["long_liquidation"], window)
    data["short_liq_z"] = zscore(data["short_liquidation"], window)

    data["total_liquidation"] = (
        data["long_liquidation"] + data["short_liquidation"]
    )

    data["total_liq_z"] = zscore(data["total_liquidation"], window)

    return data

Interpretation:

Liquidation Signal	Meaning
Long liquidation z-score > 2	Longs are being liquidated unusually
Short liquidation z-score > 2	Shorts are being liquidated unusually
Total liquidation z-score > 3	Extreme risk environment
Liquidation z-score near 0	Normal environment

12. Merge Data into One Market Table

Now we need to merge open interest, funding rate, and liquidation data by timestamp.

def prepare_time_column(df):
    data = df.copy()

    if "time" not in data.columns:
        raise ValueError("Missing time column")

    data = data.dropna(subset=["time"])
    data = data.sort_values("time")

    return data


def merge_market_data(oi_df, funding_df, liquidation_df):
    oi = prepare_time_column(oi_df)
    funding = prepare_time_column(funding_df)
    liquidation = prepare_time_column(liquidation_df)

    merged = pd.merge_asof(
        oi,
        funding,
        on="time",
        direction="nearest",
        tolerance=pd.Timedelta("10min"),
        suffixes=("_oi", "_funding")
    )

    merged = pd.merge_asof(
        merged,
        liquidation,
        on="time",
        direction="nearest",
        tolerance=pd.Timedelta("10min")
    )

    return merged

The merged table may include:

Column	Meaning
time	Timestamp
oi_close	Open interest value
oi_change	Short-term OI change
oi_change_24	24-period OI change
funding_close	Funding rate
funding_z	Funding rate z-score
long_liquidation	Long liquidation amount
short_liquidation	Short liquidation amount
long_liq_z	Long liquidation z-score
short_liq_z	Short liquidation z-score
total_liq_z	Total liquidation z-score

This table becomes the bot’s derivatives market state table.

13. Build a Simple Price Signal

CoinGlass API can provide market data, but many bots still combine derivatives data with price signals.

For simplicity, let’s create a moving average signal.

In production, you may get price candles from:

Your exchange API
CoinGlass spot or futures market endpoints
Your own database
Another market data provider

Example:

def generate_price_signal(price_df):
    """
    Simple moving average signal.
    price_df must contain a 'close' column.
    """
    data = price_df.copy()

    data["close"] = pd.to_numeric(data["close"], errors="coerce")
    data["ma_fast"] = data["close"].rolling(20).mean()
    data["ma_slow"] = data["close"].rolling(60).mean()

    latest = data.iloc[-1]

    if latest["ma_fast"] > latest["ma_slow"]:
        return "BUY"

    if latest["ma_fast"] < latest["ma_slow"]:
        return "SELL"

    return "HOLD"

This signal is intentionally simple. The purpose of the article is not to create a perfect price model, but to show how CoinGlass API data can improve the bot’s market awareness.

14. Build a Derivatives Signal

Now let’s convert the merged derivatives data into a market state signal.

def classify_derivatives_state(row):
    funding_z = row.get("funding_z", 0)
    long_liq_z = row.get("long_liq_z", 0)
    short_liq_z = row.get("short_liq_z", 0)
    total_liq_z = row.get("total_liq_z", 0)
    oi_change = row.get("oi_change", 0)

    if pd.isna(funding_z):
        funding_z = 0
    if pd.isna(long_liq_z):
        long_liq_z = 0
    if pd.isna(short_liq_z):
        short_liq_z = 0
    if pd.isna(total_liq_z):
        total_liq_z = 0
    if pd.isna(oi_change):
        oi_change = 0

    if total_liq_z > 3:
        return "RISK_OFF"

    if funding_z > 2 and oi_change > 0:
        return "LONG_CROWDED"

    if funding_z < -2 and oi_change > 0:
        return "SHORT_CROWDED"

    if short_liq_z > 2 and funding_z < 0:
        return "SHORT_SQUEEZE"

    if long_liq_z > 2 and funding_z > 0:
        return "LONG_SQUEEZE"

    return "NEUTRAL"

Signal meanings:

Signal	Meaning
NEUTRAL	Market structure is normal
LONG_CROWDED	Long side may be overcrowded
SHORT_CROWDED	Short side may be overcrowded
SHORT_SQUEEZE	Shorts may be getting forced out
LONG_SQUEEZE	Longs may be getting forced out
RISK_OFF	Extreme liquidation environment

This is the core logic of a derivatives-aware bot.

15. Combine Price Signal and Derivatives Signal

Now combine the basic price signal with the CoinGlass-driven market state.

def final_trading_decision(price_signal, derivatives_state):
    """
    Combine price signal with derivatives market state.
    """

    if derivatives_state == "RISK_OFF":
        return "HOLD"

    if price_signal == "BUY" and derivatives_state == "LONG_CROWDED":
        return "HOLD"

    if price_signal == "SELL" and derivatives_state == "SHORT_CROWDED":
        return "HOLD"

    if price_signal == "BUY" and derivatives_state == "SHORT_SQUEEZE":
        return "BUY"

    if price_signal == "SELL" and derivatives_state == "LONG_SQUEEZE":
        return "SELL"

    if derivatives_state in ["NEUTRAL", "SHORT_SQUEEZE", "LONG_SQUEEZE"]:
        return price_signal

    return "HOLD"

Examples:

Price Signal	Derivatives State	Final Decision
BUY	NEUTRAL	BUY
BUY	LONG_CROWDED	HOLD
SELL	SHORT_CROWDED	HOLD
BUY	SHORT_SQUEEZE	BUY
SELL	LONG_SQUEEZE	SELL
BUY	RISK_OFF	HOLD
SELL	RISK_OFF	HOLD

This logic helps the bot avoid bad trades.

It does not guarantee profit, but it can reduce the likelihood of chasing crowded or unstable market conditions.

16. Add Position Sizing

A trading bot should not only decide whether to trade. It should also decide how much to trade.

def position_size_multiplier(derivatives_state):
    multipliers = {
        "NEUTRAL": 1.0,
        "SHORT_SQUEEZE": 1.0,
        "LONG_SQUEEZE": 1.0,
        "LONG_CROWDED": 0.4,
        "SHORT_CROWDED": 0.4,
        "RISK_OFF": 0.0
    }

    return multipliers.get(derivatives_state, 0.5)

Example:

base_position_size = 1000  # USDT notional
derivatives_state = "LONG_CROWDED"

final_size = base_position_size * position_size_multiplier(derivatives_state)

print(final_size)

If the market is neutral, the bot may use normal size.

If the market is crowded, it may reduce size.

If the market is in risk-off mode, it does not trade.

This is often more useful than simply changing buy/sell signals.

17. Full Bot Framework Example

Below is a simplified full example.

It does not place real orders. Instead, it outputs a final trading decision. This is safer for demonstration and easier to adapt.

import os
import time
import requests
import pandas as pd
from dotenv import load_dotenv

load_dotenv()

BASE_URL = "https://open-api-v4.coinglass.com"
API_KEY = os.getenv("COINGLASS_API_KEY")

if not API_KEY:
    raise RuntimeError("Missing COINGLASS_API_KEY environment variable")

HEADERS = {
    "CG-API-KEY": API_KEY,
    "Accept": "application/json"
}


def request_coinglass(endpoint, params=None):
    url = f"{BASE_URL}{endpoint}"

    response = requests.get(
        url,
        headers=HEADERS,
        params=params,
        timeout=10
    )

    response.raise_for_status()
    return response.json()


def safe_request_coinglass(endpoint, params=None, retries=3, sleep_seconds=2):
    last_error = None

    for attempt in range(retries):
        try:
            return request_coinglass(endpoint, params)

        except requests.RequestException as error:
            last_error = error
            print(f"Request failed: attempt {attempt + 1}/{retries}: {error}")
            time.sleep(sleep_seconds)

    raise last_error


def to_dataframe(raw):
    data = raw.get("data", [])

    if isinstance(data, dict):
        rows = data.get("list", [])
    else:
        rows = data

    df = pd.DataFrame(rows)

    if df.empty:
        return df

    if "time" in df.columns:
        df["time"] = pd.to_datetime(df["time"], unit="ms", errors="coerce")

    return df


def zscore(series, window=24):
    mean = series.rolling(window).mean()
    std = series.rolling(window).std()
    return (series - mean) / std


def fetch_open_interest(symbol="BTC", interval="1h", limit=100):
    endpoint = "/api/futures/openInterest/ohlc-history"

    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)


def fetch_funding_rate(symbol="BTC", interval="1h", limit=100):
    endpoint = "/api/futures/fundingRate/oi-weight-ohlc-history"

    params = {
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)


def fetch_liquidation_history(
    symbol="BTC",
    exchanges="Binance,OKX,Bybit",
    interval="1h",
    limit=100
):
    endpoint = "/api/futures/liquidation/aggregated-history"

    params = {
        "exchange_list": exchanges,
        "symbol": symbol,
        "interval": interval,
        "limit": limit
    }

    return safe_request_coinglass(endpoint, params)


def add_open_interest_features(df):
    data = df.copy()

    if "close" in data.columns:
        data["oi_close"] = pd.to_numeric(data["close"], errors="coerce")
    elif "openInterest" in data.columns:
        data["oi_close"] = pd.to_numeric(data["openInterest"], errors="coerce")
    else:
        raise ValueError("No recognizable open interest field found")

    data["oi_change"] = data["oi_close"].pct_change()
    data["oi_change_24"] = data["oi_close"].pct_change(24)

    return data


def add_funding_features(df, window=24):
    data = df.copy()

    if "close" in data.columns:
        data["funding_close"] = pd.to_numeric(data["close"], errors="coerce")
    elif "fundingRate" in data.columns:
        data["funding_close"] = pd.to_numeric(
            data["fundingRate"],
            errors="coerce"
        )
    else:
        raise ValueError("No recognizable funding rate field found")

    data["funding_z"] = zscore(data["funding_close"], window)

    return data


def add_liquidation_features(df, window=24):
    data = df.copy()

    data = data.rename(columns={
        "longLiquidation": "long_liquidation",
        "shortLiquidation": "short_liquidation",
        "long_liq": "long_liquidation",
        "short_liq": "short_liquidation"
    })

    if "long_liquidation" not in data.columns:
        raise ValueError("No long liquidation field found")

    if "short_liquidation" not in data.columns:
        raise ValueError("No short liquidation field found")

    data["long_liquidation"] = pd.to_numeric(
        data["long_liquidation"],
        errors="coerce"
    )

    data["short_liquidation"] = pd.to_numeric(
        data["short_liquidation"],
        errors="coerce"
    )

    data["long_liq_z"] = zscore(data["long_liquidation"], window)
    data["short_liq_z"] = zscore(data["short_liquidation"], window)

    data["total_liquidation"] = (
        data["long_liquidation"] + data["short_liquidation"]
    )

    data["total_liq_z"] = zscore(data["total_liquidation"], window)

    return data


def prepare_time_column(df):
    data = df.copy()

    if "time" not in data.columns:
        raise ValueError("Missing time column")

    data = data.dropna(subset=["time"])
    data = data.sort_values("time")

    return data


def merge_market_data(oi_df, funding_df, liquidation_df):
    oi = prepare_time_column(oi_df)
    funding = prepare_time_column(funding_df)
    liquidation = prepare_time_column(liquidation_df)

    merged = pd.merge_asof(
        oi,
        funding,
        on="time",
        direction="nearest",
        tolerance=pd.Timedelta("10min"),
        suffixes=("_oi", "_funding")
    )

    merged = pd.merge_asof(
        merged,
        liquidation,
        on="time",
        direction="nearest",
        tolerance=pd.Timedelta("10min")
    )

    return merged


def classify_derivatives_state(row):
    funding_z = row.get("funding_z", 0)
    long_liq_z = row.get("long_liq_z", 0)
    short_liq_z = row.get("short_liq_z", 0)
    total_liq_z = row.get("total_liq_z", 0)
    oi_change = row.get("oi_change", 0)

    values = [funding_z, long_liq_z, short_liq_z, total_liq_z, oi_change]
    values = [0 if pd.isna(v) else v for v in values]

    funding_z, long_liq_z, short_liq_z, total_liq_z, oi_change = values

    if total_liq_z > 3:
        return "RISK_OFF"

    if funding_z > 2 and oi_change > 0:
        return "LONG_CROWDED"

    if funding_z < -2 and oi_change > 0:
        return "SHORT_CROWDED"

    if short_liq_z > 2 and funding_z < 0:
        return "SHORT_SQUEEZE"

    if long_liq_z > 2 and funding_z > 0:
        return "LONG_SQUEEZE"

    return "NEUTRAL"


def final_trading_decision(price_signal, derivatives_state):
    if derivatives_state == "RISK_OFF":
        return "HOLD"

    if price_signal == "BUY" and derivatives_state == "LONG_CROWDED":
        return "HOLD"

    if price_signal == "SELL" and derivatives_state == "SHORT_CROWDED":
        return "HOLD"

    if price_signal == "BUY" and derivatives_state == "SHORT_SQUEEZE":
        return "BUY"

    if price_signal == "SELL" and derivatives_state == "LONG_SQUEEZE":
        return "SELL"

    if derivatives_state in ["NEUTRAL", "SHORT_SQUEEZE", "LONG_SQUEEZE"]:
        return price_signal

    return "HOLD"


def position_size_multiplier(derivatives_state):
    multipliers = {
        "NEUTRAL": 1.0,
        "SHORT_SQUEEZE": 1.0,
        "LONG_SQUEEZE": 1.0,
        "LONG_CROWDED": 0.4,
        "SHORT_CROWDED": 0.4,
        "RISK_OFF": 0.0
    }

    return multipliers.get(derivatives_state, 0.5)


def run_bot_once(symbol="BTC"):
    oi_raw = fetch_open_interest(symbol=symbol, interval="1h", limit=100)
    funding_raw = fetch_funding_rate(symbol=symbol, interval="1h", limit=100)
    liquidation_raw = fetch_liquidation_history(
        symbol=symbol,
        interval="1h",
        limit=100
    )

    oi_df = add_open_interest_features(to_dataframe(oi_raw))
    funding_df = add_funding_features(to_dataframe(funding_raw))
    liquidation_df = add_liquidation_features(to_dataframe(liquidation_raw))

    market_df = merge_market_data(oi_df, funding_df, liquidation_df)

    if market_df.empty:
        raise ValueError("Merged market data is empty")

    latest = market_df.iloc[-1]

    # Example only. Replace this with your real price signal.
    price_signal = "BUY"

    derivatives_state = classify_derivatives_state(latest)
    final_decision = final_trading_decision(price_signal, derivatives_state)

    base_position_size = 1000
    multiplier = position_size_multiplier(derivatives_state)
    final_position_size = base_position_size * multiplier

    result = {
        "symbol": symbol,
        "time": latest["time"],
        "price_signal": price_signal,
        "derivatives_state": derivatives_state,
        "final_decision": final_decision,
        "position_size": final_position_size
    }

    return result


if __name__ == "__main__":
    result = run_bot_once("BTC")

    print("Bot result:")
    for key, value in result.items():
        print(f"{key}: {value}")

This bot framework does not place orders. That is intentional.

Before connecting any strategy to real trading, you should:

Backtest it
Paper trade it
Add exchange execution logic
Add risk limits
Add error handling
Add logs
Add monitoring
Start with small position size

18. How to Add Exchange Execution

Once the CoinGlass API side works, you can connect the decision output to an exchange API.

The execution layer should be separate from the signal layer.

Example structure:

def execute_trade(decision, symbol, position_size):
    """
    Placeholder execution function.
    Replace with your exchange API logic.
    """

    if decision == "BUY":
        print(f"Place BUY order for {symbol}, size={position_size}")

    elif decision == "SELL":
        print(f"Place SELL order for {symbol}, size={position_size}")

    else:
        print(f"No trade for {symbol}")

Then:

result = run_bot_once("BTC")

execute_trade(
    decision=result["final_decision"],
    symbol=result["symbol"],
    position_size=result["position_size"]
)

In production, the execution function should handle:

Order type
Quantity precision
Minimum notional
Slippage
Leverage
Margin mode
Reduce-only orders
Stop loss
Take profit
Position checking
Order status confirmation

Never connect a strategy directly to live execution without safety checks.

19. Risk Management Rules

A trading bot without risk management is not a trading system. It is just an automated order sender.

At minimum, your bot should include:

Rule	Purpose
Max position size	Prevent oversized trades
Max daily loss	Stop trading after major losses
Max open positions	Avoid overexposure
Stop loss	Limit downside
Take profit	Lock gains
Cooldown period	Avoid overtrading
Risk-off mode	Stop trading during extreme events
API failure mode	Avoid trading with stale data

Example risk filter:

def risk_filter(account_state, market_state):
    """
    Example risk control logic.
    """

    if account_state["daily_loss_pct"] < -3:
        return "STOP_TRADING"

    if account_state["open_positions"] >= account_state["max_positions"]:
        return "NO_NEW_POSITIONS"

    if market_state["derivatives_state"] == "RISK_OFF":
        return "NO_NEW_POSITIONS"

    return "ALLOW"

Risk management should override signal generation.

A good rule is:

Signal decides what you want to do.
Risk decides whether you are allowed to do it.

20. Backtesting the Strategy

Before using real money, backtest the bot.

A proper backtest should include:

Price candles
Open interest history
Funding rate history
Liquidation history
Trading fees
Slippage
Funding payments
Latency assumptions
Position size rules
Stop loss logic
Market regime changes

A basic backtest loop may look like this:

def backtest(market_df, price_signals):
    equity = 10000
    position = 0
    trades = []

    for i in range(len(market_df)):
        row = market_df.iloc[i]
        price_signal = price_signals[i]

        derivatives_state = classify_derivatives_state(row)
        decision = final_trading_decision(price_signal, derivatives_state)
        size_multiplier = position_size_multiplier(derivatives_state)

        trades.append({
            "time": row["time"],
            "price_signal": price_signal,
            "derivatives_state": derivatives_state,
            "decision": decision,
            "size_multiplier": size_multiplier
        })

    return pd.DataFrame(trades)

This is only a skeleton. A real backtest must calculate:

Entry price
Exit price
PnL
Fees
Funding payments
Drawdown
Sharpe ratio
Win rate
Average profit/loss
Maximum loss
Exposure time

Do not skip this step.

A strategy that looks good in a single example may fail across different market regimes.

21. Production Checklist

Before putting a CoinGlass API-powered trading bot into production, use this checklist.

Checklist Item	Why It Matters
Confirm latest API endpoints	API routes and parameters may change
Confirm response fields	Field names may differ by endpoint
Store API key securely	Prevent credential leaks
Add request retries	Handle temporary errors
Add timeout handling	Prevent stuck processes
Add data validation	Avoid trading on broken data
Add stale data checks	Avoid using old signals
Add rate limit handling	Prevent API blocking
Add logs	Debug strategy behavior
Add paper trading	Validate real-time behavior
Add risk limits	Prevent catastrophic loss
Add monitoring alerts	Detect failures quickly
Add manual shutdown	Stop bot during emergencies
Start small	Reduce deployment risk

Example stale data check:

def check_data_freshness(latest_time, max_age_minutes=90):
    now = pd.Timestamp.utcnow()

    if latest_time.tzinfo is None:
        latest_time = latest_time.tz_localize("UTC")

    age = now - latest_time

    if age > pd.Timedelta(minutes=max_age_minutes):
        raise ValueError(f"Data is stale: latest data age is {age}")

    return True

22. Common Mistakes

Mistake 1: Using Funding Rate as a Standalone Signal

Funding rate should not be used alone.

Wrong:

Funding high → short
Funding low → long

Better:

Funding high → long side may be crowded
Funding low → short side may be crowded
Confirm with OI, price, and liquidation data

Mistake 2: Entering Immediately After Liquidations

A liquidation spike can mean a reversal, but it can also mean trend continuation.

You need to check:

Did price reclaim the level?
Did open interest drop?
Did funding normalize?
Did volume fade?
Did the liquidation cascade continue?

Mistake 3: Ignoring Open Interest

Price without OI context can be misleading.

Price Move	OI Move	Possible Meaning
Up	Up	New longs or new positions support the move
Up	Down	Shorts closing
Down	Up	New shorts entering
Down	Down	Longs closing or liquidating

Mistake 4: Overfitting Too Many Indicators

Start simple.

A practical first version can use:

Price signal
+ OI confirmation
+ Funding filter
+ Liquidation risk filter
+ Position sizing rule

Then test improvements one by one.

Mistake 5: No Kill Switch

Every live bot needs a manual and automatic kill switch.

Examples:

Stop trading if API data is stale.
Stop trading if daily loss exceeds threshold.
Stop trading if liquidation risk is extreme.
Stop trading if exchange order API behaves unexpectedly.

23. Strategy Templates You Can Build with CoinGlass API

Template 1: Trend Confirmation Bot

Goal:

Trade only when price trend is supported by derivatives data.

Rules:

Condition	Requirement
Price	Breakout or moving average trend
Open Interest	Rising gradually
Funding Rate	Not extreme
Liquidations	No abnormal opposite-side risk
Decision	Allow trade

Best for:

BTC trend strategies
ETH momentum strategies
Multi-asset futures bots

Template 2: Short Squeeze Bot

Goal:

Detect possible short squeeze setups.

Rules:

Condition	Requirement
Funding Rate	Negative
Open Interest	High or rising
Price	Breaks resistance
Short Liquidations	Rising
Decision	Allow long signal

Best for:

Breakout bots
Momentum bots
Event-driven strategies

Template 3: Long Squeeze Risk Filter

Goal:

Avoid long exposure when the long side is overcrowded.

Rules:

Condition	Requirement
Funding Rate	Very positive
Open Interest	Rising
Price	Breaks support
Long Liquidations	Rising
Decision	Exit, reduce, or avoid longs

Best for:

Grid bots
Long-biased bots
Leveraged futures strategies

Template 4: Funding Rate Arbitrage Monitor

Goal:

Detect cross-exchange funding rate opportunities.

Rules:

Condition	Requirement
Funding difference	Large enough
Liquidity	Sufficient
Open Interest	Stable
Liquidation risk	Not extreme
Decision	Alert or evaluate trade

Best for:

Market-neutral strategies
Funding capture bots
Arbitrage dashboards

Template 5: Risk-Off Detector

Goal:

Pause trading during extreme derivatives stress.

Rules:

Condition	Trigger
Total liquidation z-score	Above 3
Funding z-score	Extreme
OI change	Abnormal
Price volatility	High
Decision	Pause trading

Best for:

All leveraged bots
Portfolio risk systems
Multi-strategy trading platforms

24. How to Expand the Bot

After building the first version, you can expand it with more CoinGlass API data.

Add Long/Short Ratio

Use long/short ratio to detect market sentiment imbalance.

Possible rule:

If long/short ratio is extremely long
AND funding is positive
AND OI is rising
THEN reduce long exposure.

Add Taker Buy/Sell Volume

Use taker buy/sell volume to confirm aggressive flow.

Possible rule:

If price breaks resistance
AND taker buy volume rises
AND short liquidations rise
THEN confirm short squeeze.

Add Liquidation Heatmap

Use liquidation heatmap data to identify zones where forced liquidations may occur.

Possible rule:

If price approaches large liquidation cluster
THEN reduce leverage or tighten stop.

Add Order Book Data

Use order book data for execution quality.

Possible rule:

If order book depth is thin
THEN reduce order size or use limit orders.

Add ETF Flow Data

For BTC and ETH, ETF flow data can help detect broader market demand.

Possible rule:

If ETF inflows are strong
AND derivatives data is not overheated
THEN increase bullish confidence.

25. Final Thoughts

Building a crypto trading bot is not just about coding buy and sell rules.

A strong bot needs to understand market conditions.

Price tells you what happened.

Derivatives data helps explain why it happened.

CoinGlass API can help trading bots move from simple price-based automation to a more complete market-aware system by providing data such as:

Open interest
Funding rate
Liquidations
Long/short ratio
Taker buy/sell volume
Order book data
Liquidation heatmap
ETF flow data
Options data

A basic bot might say:

Price is above the moving average, so buy.

A better bot says:

Price is above the moving average.
Open interest is rising.
Funding rate is neutral.
Liquidations are normal.
Market structure is healthy.
Buy signal is allowed.

Or:

Price is above the moving average.
But funding is extremely positive.
Open interest is rising too fast.
Long side is crowded.
Do not chase.

That is the difference between a simple script and a more intelligent trading system.

No API can guarantee profitable trading. CoinGlass API does not replace strategy design, risk management, execution quality, or backtesting.

But it can provide the derivatives market intelligence that many trading bots are missing.

If you are building a crypto futures or perpetual trading bot, CoinGlass API is one of the most practical ways to add market structure awareness to your system.

推荐订阅源

DEV Community

1. What Kind of Trading Bot Are We Building?

2. CoinGlass API vs Exchange API

3. Why CoinGlass API Is Useful for Trading Bots

4. Trading Bot Architecture

5. Core Strategy Idea

6. Key CoinGlass Data for the Bot

6.1 Open Interest

6.2 Funding Rate

6.3 Liquidation Data

7. API Setup

8. Add Safe Request Handling

9. Fetch Open Interest Data

10. Fetch Funding Rate Data

11. Fetch Liquidation Data

12. Merge Data into One Market Table

13. Build a Simple Price Signal

14. Build a Derivatives Signal

15. Combine Price Signal and Derivatives Signal

16. Add Position Sizing

17. Full Bot Framework Example

18. How to Add Exchange Execution

19. Risk Management Rules

20. Backtesting the Strategy

21. Production Checklist

22. Common Mistakes

Mistake 1: Using Funding Rate as a Standalone Signal

Mistake 2: Entering Immediately After Liquidations

Mistake 3: Ignoring Open Interest

Mistake 4: Overfitting Too Many Indicators

Mistake 5: No Kill Switch

23. Strategy Templates You Can Build with CoinGlass API

Template 1: Trend Confirmation Bot

Template 2: Short Squeeze Bot

Template 3: Long Squeeze Risk Filter

Template 4: Funding Rate Arbitrage Monitor

Template 5: Risk-Off Detector

24. How to Expand the Bot

Add Long/Short Ratio

Add Taker Buy/Sell Volume

Add Liquidation Heatmap

Add Order Book Data

Add ETF Flow Data

25. Final Thoughts