Funding Rate Arbitrage

What it is

Perpetual futures don't have an expiry, so exchanges use a funding rate to tether the perp price to spot: longs pay shorts (or vice versa) every funding interval (typically 1, 4, or 8 hours). When that rate is persistently positive, you can short the perp and long the spot of the same asset to harvest funding while remaining delta-neutral on price.

This is the classic "cash-and-carry" trade adapted for crypto. Profit per period ≈ funding_rate × notional, minus trading fees on the two legs and any spot borrowing cost (none if you hold the spot outright).

Variants:

• Positive carry — funding > 0 → long spot, short perp.
• Reverse carry — funding < 0 → short spot (borrow), long perp. Requires margin/spot-borrow availability.
• Cross-exchange funding arb — long perp on the exchange paying funding, short perp on the one charging funding, exploit the spread.

When it works

• Funding rate APR (annualized) exceeds round-trip transaction cost. With ~0.2% combined fees per entry/exit and 0.01% per funding settlement, you typically need >5–10% APR to be worthwhile after slippage.
• Funding regime is stable (consistently positive or negative over a 7–30 day window). Use historical funding to gauge persistence — don't chase a one-off spike.
• You can hold the position long enough to clear fees. DataMaxi+ surfaces a "Recommended Minimum Holding Period" assuming 0.2% total fees and the current rate.
• Margin requirements on the short-perp leg fit your capital. A sharp price move can liquidate the perp if you're under-collateralized — funding gains mean nothing if you blow up first.

Data you need

• Latest funding rate — /api/v1/funding-rate/latest — current rate, interval, and next-funding timestamp per exchange/symbol.
• Historical funding rate — /api/v1/funding-rate/history — 30/7/1-day APR look-back to validate persistence.
• Funding rate exchanges — /api/v1/funding-rate/exchanges — venues supported.
• Funding rate symbols — /api/v1/funding-rate/symbols — per-exchange perp universe.
• Real-time funding stream — ws/v1/cex/funding-rate — push updates.
• Trading fees — /api/v1/cex/fees — fee tier per exchange for accurate net APR.

API recipe

Fetch the top current positive funding rates on Binance perpetuals:

cURL

curl -G 'https://api.datamaxiplus.com/api/v1/funding-rate/latest' \
  -H 'X-DTMX-APIKEY: '"$YOUR_API_KEY" \
  --data-urlencode 'exchange=binance' \
  --data-urlencode 'sort=desc'

Python

import os
import requests

resp = requests.get(
    "https://api.datamaxiplus.com/api/v1/funding-rate/latest",
    headers={"X-DTMX-APIKEY": os.environ["DTMX_API_KEY"]},
    params={"exchange": "binance", "sort": "desc"},
    timeout=10,
)
for row in resp.json().get("data", [])[:10]:
    apr = float(row["f"]) * (365 * 24 / row.get("interval", 8)) * 100
    print(f"{row['symbol']:<20} rate={row['f']:>10}  ~APR={apr:>6.2f}%")

Go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"os"
)

func main() {
	q := url.Values{"exchange": {"binance"}, "sort": {"desc"}}
	req, _ := http.NewRequest("GET",
		"https://api.datamaxiplus.com/api/v1/funding-rate/latest?"+q.Encode(), nil)
	req.Header.Set("X-DTMX-APIKEY", os.Getenv("DTMX_API_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()

	var out struct{ Data []map[string]any `json:"data"` }
	json.NewDecoder(resp.Body).Decode(&out)
	for _, r := range out.Data { fmt.Println(r) }
}

TypeScript

import axios from "axios";

const { data } = await axios.get(
  "https://api.datamaxiplus.com/api/v1/funding-rate/latest",
  {
    headers: { "X-DTMX-APIKEY": process.env.DTMX_API_KEY! },
    params: { exchange: "binance", sort: "desc" },
  },
);
console.log(data.data.slice(0, 10));

Validate persistence with the 30-day history before committing capital:

curl -G 'https://api.datamaxiplus.com/api/v1/funding-rate/history' \
  -H 'X-DTMX-APIKEY: '"$YOUR_API_KEY" \
  --data-urlencode 'exchange=binance' \
  --data-urlencode 'symbol=BTC-USDT' \
  --data-urlencode 'from=2026-05-01' \
  --data-urlencode 'sort=asc'

Risks & caveats

• Funding can flip. A persistently positive regime turns negative inside hours during a reversal; you start paying instead of receiving. Maintain a minimum-realized-APR exit rule.
• Perp basis blow-out. Even hedged, if the perp diverges sharply from spot and you must unwind, the basis move (not the funding) drives your P&L.
• Liquidation on the perp leg. Use isolated margin or a comfortable maintenance buffer (≥30%). Funding income for 30 days is dwarfed by one liquidation.
• Exchange counterparty risk. Spot and perp on the same exchange concentrate risk; splitting across two venues introduces transfer/settlement risk.
• Fee math. A 10% APR before fees becomes 5% after, less after slippage on big sizes. Use the recommended minimum holding period as a sanity check.
• Funding-interval inconsistency. Some exchanges use 1h intervals, others 8h. Always normalize to APR before comparing.

Further reading

• Arbitrage between Spot and Perpetual (UI) — platform's spot-perp dashboard explained.
• Funding Rate page (UI) — visual top/bottom funding tables.
• Funding Rate API reference — full endpoint schemas.
• Arbitrage across Perpetuals (UI) — cross-exchange funding arb.