DEV Community

FoxyyyBusiness
FoxyyyBusiness

Posted on

Migrating from Coinglass to Funding Finder: a step-by-step walkthrough for funding-rate arbitrage traders

#crypto #trading #python #api

This post is for the specific subset of Coinglass users who use the platform mostly for cross-exchange funding-rate arbitrage data and have wondered if there's a cheaper, more focused alternative. There is. I built it. This is a 10-minute migration guide.

If you use Coinglass for liquidations, ETF flows, on-chain data, options flow, or the broader derivatives surface, this post is not for you and you should stay on Coinglass. It's a great product for that breadth.

TL;DR

Before (Coinglass Hobbyist) After (Funding Finder Trader)
Price $29/month €5/month
Rate limit 30 req/min 600 req/min
Exchanges ~30 8
Funding-rate history 180 days 30 days (free tier 24h)
API key required Yes Optional (free tier no key needed)
Cross-exchange arb endpoint No native Yes, ranked + filtered
Open source data layer No Yes (MIT)

The math: you save $24/month if you only use the funding-rate features. The trade-off: smaller exchange coverage, less history.

Step 1: Audit your current Coinglass usage

Before you migrate, run through your actual usage of Coinglass over the last 30 days. Be honest. Most users overestimate what they actually use.

Ask yourself:

  • What endpoints am I calling? If your API logs show 90%+ of calls hit the funding-rate endpoints, the migration math is straightforward.
  • Which exchanges do I actually need? Coinglass covers ~30 venues but most users only consume data from the top 5-8.
  • How much historical data do I actually use? If you mostly look at the last week, the 30-day history of the Trader tier is plenty. If you regularly query 90+ days back, you'll need the Pro tier or stay on Coinglass.
  • Do I use any non-funding endpoint? Liquidations, OI, ETF flows, etc. If yes, stay on Coinglass.

Run this audit honestly. About 60% of "Coinglass for funding-arb" users I've talked to discover they only use 5-10% of what they pay for.

Step 2: Try the Funding Finder free tier

Funding Finder has a no-signup free tier that covers 95% of the data you'd get from a paid Coinglass plan, with one critical caveat: history is capped at 24 hours instead of 180 days.

Try it:

# Current funding rates across all 8 exchanges
curl 'http://178.104.60.252:8083/api/funding/current' | jq '.count, .rows[0]'

# Cross-exchange arbitrage opportunities, sorted by annualized yield
curl 'http://178.104.60.252:8083/api/funding/arb?min_yield=10&min_volume=10000000&limit=10' \
  | jq '.opportunities[] | {base, long_exchange, short_exchange, annualized_yield_pct}'

# History for BTC (24h on free tier)
curl 'http://178.104.60.252:8083/api/funding/history/BTC?hours=24' | jq '.count'
Enter fullscreen mode Exit fullscreen mode

Run those three commands. If the data shape and content match what you need, the migration is feasible.

Step 3: Map your Coinglass API calls to Funding Finder equivalents

Here's the rough mapping for the funding-rate-specific endpoints:

Coinglass Funding Finder
GET /api/futures/fundingRate/v2/list GET /api/funding/current
GET /api/futures/fundingRate/ohlc-history GET /api/funding/history/<base>?hours=N
GET /api/futures/fundingRate/exchange-list GET /api/funding/by_exchange/<ex>
GET /api/futures/fundingRate/arbitrage-list GET /api/funding/arb
(no equivalent) GET /api/funding/extremes?n=20
(no equivalent) GET /api/summary (sentiment + top arb in one call)

The response shapes are different, of course, so you'll need to update your client code. The biggest difference: Funding Finder normalizes everything to a single dict shape regardless of which exchange the data came from, which is one less thing for you to handle.

A typical Coinglass response loop:

# Before (Coinglass)
import coinglass  # hypothetical client
data = coinglass.fundingRate.v2list()
for item in data:
    if item['exchange'] == 'Binance':
        rate = item['fundingRate']  # already a percent? or decimal? check docs
    elif item['exchange'] == 'Bybit':
        rate = item['fundingRate']  # different scale, normalize manually
    ...
Enter fullscreen mode Exit fullscreen mode

After:

# After (Funding Finder)
import requests
data = requests.get("http://178.104.60.252:8083/api/funding/current").json()
for r in data["rows"]:
    rate = r["funding_rate"]              # always decimal, always per-period
    pct = r["funding_rate_pct"]           # already converted to %
    apy = r["annualized_pct"]             # already correctly annualized per-symbol
    interval = r["funding_interval_hours"] # always present, always correct
Enter fullscreen mode Exit fullscreen mode

The Funding Finder schema does the unit conversion and normalization for you, including the per-symbol funding interval (which most other tools get wrong).

Step 4: Update your alerting

If you use Coinglass alerts, you'll need to migrate them to Funding Finder alerts. The endpoints are documented at /docs#alerts.

Sample alert creation:

# Get a paid tier API key first (Trader €5/mo)
curl -X POST 'http://178.104.60.252:8083/api/alerts/create' \
  -H "X-API-Key: $YOUR_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "base": "BTC",
    "min_yield_pct": 100,
    "min_volume_usd": 5000000,
    "telegram_chat_id": "12345",
    "cooldown_seconds": 3600
  }'
Enter fullscreen mode Exit fullscreen mode

The alert worker scans every 60 seconds and sends you a Telegram message when an opportunity matches. Cooldown prevents spam.

Step 5: Run both in parallel for one week

This is the part most people skip and then regret. Don't cancel Coinglass yet. Run both APIs in parallel for one week, log every funding-rate query you make to both, and compare the results. You're looking for:

  • Coverage gaps: any symbol you queried on Coinglass that's not in Funding Finder
  • Numerical discrepancies: same symbol, different funding rate? Investigate which one is right (usually the issue is that Coinglass shows the predicted next rate while Funding Finder shows the latest published rate)
  • Latency differences: how fresh is the data on each side

After a week, you'll have a clear answer to "is this migration worth it for my workflow". If the answer is yes, cancel Coinglass and pocket the $24/month difference. If the answer is no, you've lost €5 and gained the data you needed to make the decision.

Step 6: Self-host the data layer (optional)

If you really care about cost and you're a developer, you can skip the hosted Funding Finder entirely and run the open-source data collector on your own VPS:

git clone https://github.com/clementslowik/funding-collector
cd funding-collector
pip install -e .

# One-shot collection from all 8 exchanges
funding-collector --exchanges binance,bybit,okx,bitget,mexc,hyperliquid,gateio,dydx

# Or run as a daemon
funding-collector --loop 300
Enter fullscreen mode Exit fullscreen mode

That gives you the same data layer that powers the hosted service, MIT-licensed, on your own infrastructure. The hosted service then becomes optional — you'd only pay if you want the API/dashboard/alerts wrapper without the operational overhead.

The OSS package is ~700 lines of Python. You can read the entire codebase in 30 minutes. There's no magic, no plugin system, no async runtime. Just seven fetch_* functions and one SQLite schema.

What you give up by migrating

Honest disclosure of the trade-offs:

  • Smaller exchange coverage. 8 vs ~30. If you trade alts on Bitfinex, BingX, Phemex, etc., they're not in Funding Finder yet. Open a PR if you want them faster.
  • Less historical data on the entry tier. 30 days vs 180 days. Pro tier (€15/mo) gets 12 months but it's still less than Coinglass's higher tiers offer.
  • No liquidations / ETF / on-chain. Funding Finder is funding-rate focused. If you use Coinglass for the broader derivatives surface, stay on Coinglass.
  • Newer product. Funding Finder is months old, not years. The track record is shorter. The road map is clearer than the path actually taken.

What you gain

  • 6x cheaper entry tier. €5 vs $29.
  • 20x rate limit. 600 req/min vs 30.
  • No signup for casual use. Free tier needs no account, no email, no API key.
  • Slippage-aware net APY built into the arbitrage endpoint. Coinglass shows you gross spreads; Funding Finder also computes the net yield after estimated slippage and fees for a given notional size.
  • Open-source self-host option. Run the data layer on your own VPS for free if you want.
  • A focused, simple API surface instead of the broad surface you're not using.

Final thought

Migrating tools is annoying. The cost of the migration is real and the benefit is incremental. For Funding Finder vs Coinglass, the migration is worth it if and only if you're a funding-rate-focused user who finds the $29/month painful. For everyone else, stay on Coinglass.

I built Funding Finder because I am that specific user. If you're reading this and recognizing yourself, the free tier is at http://178.104.60.252:8083/. Take 10 minutes, run the three sample API calls, and decide for yourself.

Comparison page (more detail): http://178.104.60.252:8083/vs/coinglass

API docs: http://178.104.60.252:8083/docs

OSS data collector: github.com/clementslowik/funding-collector (MIT license)

— Clément

Top comments (0)