API to Get the Current BTC Perpetual Funding Rate (Live Call)

The API call for the current BTC perpetual funding rate

If you want a single API to get the current BTC perpetual funding rate, this is the call:

curl -H "X-API-Key: cdk_live_YOUR_KEY" \
  "https://cryptodataapi.com/api/v1/derivatives/binance/funding-rates?symbol=BTCUSDT"

Response, trimmed to the head:

{
  "symbol": "BTCUSDT",
  "current_rate": 0.00005927,
  "avg_rate": 0.000077917,
  "rates": [
    {
      "symbol": "BTCUSDT",
      "funding_rate": 0.00005927,
      "funding_time": 1787731200005,
      "mark_price": 78888.36194203
    }
  ],
  "count": 30
}

current_rate is the latest settled funding rate as a decimal: 0.00005927 = 0.005927%. avg_rate averages the returned history, which is the number you actually want for a carry read — a single print is noisy. rates carries the recent settlements with their mark_price, oldest first.

Positive means longs pay shorts. Negative means shorts pay longs. That sign is the entire sentiment signal.

The interval trap: why 0.0000125 costs more than 0.0000593

This is the mistake that makes cross-venue funding comparisons wrong, and almost nobody flags it. A funding rate is meaningless without its interval.

Two live BTC readings from the same moment today:

• Binance BTCUSDT: 0.00005927, charged every 8 hours — 3 settlements a day.
• Hyperliquid BTC: 0.0000125, charged every hour — 24 settlements a day.

The Hyperliquid number is 4.7× smaller. Annualize both and the ranking inverts:

Hyperliquid longs were paying roughly 1.7× more per year despite quoting a rate that looks tiny next to Binance's. An agent that ranks venues on the raw number picks exactly the wrong one.

The arithmetic is trivial once you know to do it:

PERIODS_PER_YEAR = {"1h": 8760, "8h": 1095}

def annualized(rate, interval):
    return rate * PERIODS_PER_YEAR[interval]

annualized(0.00005927, "8h")  # 0.0649 -> 6.49%
annualized(0.0000125, "1h")   # 0.1095 -> 10.95%

Always normalize to an annual rate before comparing anything. Store the interval next to the rate in your database, not implied by which table it came from.

Getting both venues in one call

Rather than fetching each venue and reconciling naming yourself, the cross-exchange endpoint takes a bare coin symbol and returns both:

curl -H "X-API-Key: cdk_live_YOUR_KEY" \
  "https://cryptodataapi.com/api/v1/derivatives/funding-rates?coin=BTC"

{
  "coin": "BTC",
  "binance": {
    "current_rate": 0.00005927,
    "avg_rate": 0.000077917,
    "count": 30
  },
  "hyperliquid": {
    "current_rate": 0.0000125,
    "history_count": 10
  },
  "cross_exchange": []
}

Note the parameter change: coin=BTC, not symbol=BTCUSDT. The cross-exchange routes take the bare asset and translate to each venue's convention internally — BTCUSDT on Binance, BTC on Hyperliquid. That translation is the whole reason this endpoint exists.

The cross_exchange block carries an additional multi-venue comparison when the upstream feed has coverage for that asset, and is an empty list when it does not. Treat it as optional enrichment, never as the primary read — binance and hyperliquid are always populated.

Funding alone is half a signal

A high funding rate on its own tells you longs are paying. It does not tell you whether that matters. Funding plus open interest is the read that does:

• Rising funding + rising OI — new leveraged longs entering. Crowded, and the fuel for a long squeeze is being loaded.
• Rising funding + flat OI — positioning is rotating, not growing. Much weaker signal.
• Negative funding + rising OI — shorts pressing into strength. Classic short-squeeze setup.
• Funding reverting toward zero + falling OI — the crowd is being flushed. Usually late, not early.

One call gets you all of it, plus the long/short account split:

curl -H "X-API-Key: cdk_live_YOUR_KEY" \
  "https://cryptodataapi.com/api/v1/derivatives/summary?coin=BTC"

{
  "coin": "BTC",
  "binance": {
    "symbol": "BTCUSDT",
    "funding": { "current_rate": 0.00005927, "avg_rate": 0.000077917 },
    "open_interest": { "current": 105453.212, "trend_30d_pct": 0.94 },
    "long_short": { "ratio": 1.0008, "long_pct": 50.0, "short_pct": 50.0,
                    "top_trader_ratio": 1.089 }
  },
  "hyperliquid": {
    "coin": "BTC",
    "funding_rate": 0.0000125,
    "open_interest": 35474.86466,
    "open_interest_usd": 2775642098.16005,
    "mark_price": 78242.5,
    "oracle_price": 78264.3,
    "premium": -0.0003104864
  }
}

Two extra Hyperliquid fields earn their place here. premium is the mark-vs-oracle gap that drives the next funding print — a leading indicator, where funding_rate is a lagging one. And open_interest_usd saves you a multiplication that is easy to get wrong.

Is the current rate high? You need history to answer that

"BTC funding is 0.0059%" is not actionable. "BTC funding is at the 90th percentile of its last 30 days" is. The daily archive gives you the denominator:

curl -H "X-API-Key: cdk_live_YOUR_KEY" \
  "https://cryptodataapi.com/api/v1/derivatives/binance/history?days=30"

That returns daily funding, open interest and long/short from our own stored archive — up to 90 days — rather than a live upstream fetch. Scoring the current print against it is a handful of lines:

import requests

H = {"X-API-Key": "cdk_live_YOUR_KEY"}
BASE = "https://cryptodataapi.com/api/v1"

now = requests.get(f"{BASE}/derivatives/binance/funding-rates",
                   params={"symbol": "BTCUSDT"}, headers=H).json()
hist = requests.get(f"{BASE}/derivatives/binance/history",
                    params={"days": 30}, headers=H).json()["history"]

rates = sorted(d["funding_rate"] for d in hist if d.get("funding_rate") is not None)
cur = now["current_rate"]
pct = 100 * sum(r <= cur for r in rates) / len(rates)

print(f"funding {cur:.6f} = {pct:.0f}th percentile of 30d")

Two calls, and now your agent can say "crowded" or "neutral" instead of reciting a decimal an LLM has no scale for.

One caveat worth knowing: the rates array on the live endpoint serves the most recent settlements from a warm cache for actively tracked symbols, so treat count as "what you got" rather than a number you dictate. For a fixed historical window, use the /history endpoint above.

How often should you poll funding?

Funding settles on a schedule. Polling faster than that schedule burns quota to re-read a number that has not moved.

All four fit comfortably inside the free tier's 1,000 requests/day (10/min). Pro raises that to 10,000/day at 30/min; Pro Plus to 50,000/day at 120/min. Every response returns x-ratelimit-remaining-day so your loop can self-throttle rather than discover the ceiling with a 429.

For an LLM agent that wants prose instead of decimals, add ?format=markdown to /derivatives/summary and the response comes back as plain text ready to drop into a prompt.

When to use funding, and when to ignore it

Funding is a positioning gauge, not a price forecast. It earns its keep in specific places:

• Sizing a leveraged position — annualized funding is a real, compounding holding cost. At 10.95%/yr a swing trade held three weeks pays roughly 0.63% just to exist.
• Picking the cheaper venue — the same directional exposure can cost meaningfully different amounts. Compare annualized, never raw.
• Fading crowded positioning — extreme funding with rising OI marks the trades everyone already has on.
• Cash-and-carry — persistent positive funding is the yield leg of long spot / short perp.

And where it does not help: funding is a poor entry timer. Rates stay extreme for days, and the crowd is often right for longer than the fade is solvent. Use it to size and to cost, and let something with an actual horizon — structure, regime, order flow — do the timing.