📉 Crypto Perp Funding Rates Tracker — Binance Futures

Pricing

Rating

Developer

Actor stats

Categories

Share

Pay-per-result perpetual-futures funding data — $0.10 per market record. Live 8-hour and annualized funding rates, mark and index prices across every Binance USDⓈ-M perpetual contract, delivered as flat JSON with no terminal seat and no exchange API key.

Funding rate is the single most-watched leverage-positioning signal in crypto. When perpetual contracts trade above spot, longs pay shorts and funding goes positive; when the market is short-heavy, funding flips negative and shorts pay longs. The Crypto Perp Funding Rates Tracker pulls the current funding rate (both the raw per-8-hour figure and its annualized equivalent), the live mark price, and the next funding timestamp for every USDⓈ-M perpetual market listed on Binance Futures — the deepest-liquidity perp venue in the world — and hands it back as one structured record per market. No websocket plumbing, no rate-limit juggling, no rolling your own funding-history store: pass a filter, get a ranked table, pay only for the rows you keep.

This actor is built for the people who trade or model leverage: crypto quants backtesting carry strategies, prop desks monitoring crowded positioning, basis traders sizing cash-and-carry spreads, and risk teams watching for funding spikes that precede liquidation cascades.

Why use this

Funding-rate data is technically "free" from Binance's public REST API — until you actually try to operationalize it. The raw endpoints split funding rate, mark price, and premium index across separate calls; they geo-block US IPs; they return per-interval rates that you still have to annualize correctly; and they hand you every market unsorted with no way to filter for the extremes that actually matter. This actor collapses all of that into one call:

• Geo-handled out of the box. Binance Futures geo-blocks US-originating requests. The actor routes through a residential proxy (Singapore by default, configurable) so you get data regardless of where your job runs.
• Annualization done correctly. Funding settles every 8 hours, three times a day. The actor returns both lastFundingRatePct (the per-interval rate) and annualizedFundingRatePct (rate × 3 × 365), so you can compare carry across markets without re-deriving the math.
• Extreme-funding filtering. Set minAbsFundingRatePct to surface only the markets where positioning is stretched — the +/- tails where mean-reversion and squeeze setups live — instead of scrolling 300 rows of near-zero funding.
• One record per market, ranked. Sort by funding rate or mark price, cap the result count, filter by symbol substring. The output is a clean leaderboard, not a raw dump.
• No API key, no subscription. You never hand the actor an exchange credential. Billing is per result on Apify's pay-per-event model — pull 20 markets one day and 300 the next, and pay only for what you pull.

What you get

Each record is one Binance USDⓈ-M perpetual market with the following real output fields:

• symbol — the perpetual contract symbol (e.g. BTCUSDT, ETHUSDT, SOLUSDT)
• markPrice — the current mark price used for unrealized-PnL and liquidation calculations
• lastFundingRatePct — the most recent funding rate as a percentage, per 8-hour interval (e.g. 0.0100 = 0.01% per interval)
• annualizedFundingRatePct — the same funding rate annualized (per-interval rate × 3 intervals/day × 365 days), so positive carry and negative carry are directly comparable across the board
• nextFundingTime — the UTC timestamp of the next funding settlement, so you know exactly how long a position must be held to pay or collect the next funding payment

Every field comes straight from Binance's live futures data — no inference, no enrichment, no placeholder values. If Binance reports it, you get it; if it doesn't, the field is absent rather than guessed.

Use cases

• Funding-carry screening. Sort all markets by annualizedFundingRatePct descending to find the highest positive-carry perps for a short-perp / long-spot cash-and-carry trade, or sort ascending to find the deepest negative funding for the inverse.
• Crowded-positioning alerts. Schedule the actor every 8 hours just before funding settlement, filter minAbsFundingRatePct to (say) 0.05%, and route any market that breaches the threshold into Slack or a trading dashboard as a "stretched positioning" flag.
• Basis-trade sizing. Combine markPrice and annualizedFundingRatePct to estimate the gross carry yield of a delta-neutral basis position before fees, then size against your spot inventory.
• Squeeze / mean-reversion research. Persistently extreme funding often precedes a violent unwind. Pull a daily snapshot, store it, and backtest forward returns conditioned on funding percentile.
• Risk-desk monitoring. Watch your book's symbols (symbolContains) for funding regime shifts that change the cost of holding a leveraged position overnight.
• Altcoin opportunity scanning. Filter to a symbol family (e.g. all 1000-denominated meme perps) and rank by funding to find the most over-leveraged corners of the long tail.
• Quant feature engineering. Use annualized funding as a daily cross-sectional feature in a multi-factor crypto model alongside volatility and momentum.
• Newsletter / dashboard content. Generate a "today's most expensive longs and shorts" funding leaderboard for a research product without maintaining exchange infrastructure.

Sample output

A single record returned by the actor:

{
"symbol":"BTCUSDT",
"markPrice":67432.10,
"lastFundingRatePct":0.0100,
"annualizedFundingRatePct":10.95,
"nextFundingTime":"2026-06-25T16:00:00Z"
}

A negative-funding market (shorts paying longs) looks like:

{
"symbol":"WIFUSDT",
"markPrice":2.0157,
"lastFundingRatePct":-0.0312,
"annualizedFundingRatePct":-34.16,
"nextFundingTime":"2026-06-25T16:00:00Z"
}

Input parameters

How to use

Python (apify-client)

from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("nexgendata/crypto-perp-funding-rates-tracker").call(run_input={
"symbolContains":"",
"minAbsFundingRatePct":0.03,
"sortBy":"annualizedFundingRatePct",
"maxResults":50,
"proxyCountry":"SG"
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["symbol"], item["lastFundingRatePct"], item["annualizedFundingRatePct"])

cURL

curl-X POST "https://api.apify.com/v2/acts/nexgendata~crypto-perp-funding-rates-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN"\
-H"Content-Type: application/json"\
-d'{
 "symbolContains": "",
 "minAbsFundingRatePct": 0.03,
 "sortBy": "annualizedFundingRatePct",
 "maxResults": 50,
 "proxyCountry": "SG"
 }'

Schedule it with Apify's built-in scheduler — an 8-hourly cron timed a few minutes before each funding settlement (00:00 / 08:00 / 16:00 UTC) captures the regime right before money changes hands. Results stream into the dataset and can be exported as JSON, JSONL, CSV, or Excel, or pushed via webhook to Slack / Make / n8n / your own API.

Pricing

This actor runs on Apify's pay-per-event (PPE) model — you pay only for the market records returned, never for run-time:

• $0.10 per market record (the primary event — one charge per perpetual market pushed to the dataset)
• A negligible actor-start cost per run (sub-cent at typical memory)

No subscription, no minimum, no per-CPU-second billing. If a run returns zero rows, you pay nothing for results.

Cost worked example

• Top 50 funding-rate markets (maxResults: 50) → 50 × $0.10 = $5.00 per run
• All ~300 USDⓈ-M perps in one sweep → $30.00** per run
• An 8-hourly schedule pulling the top 30 stretched markets → 30 × $0.10 × 3/day = $9.00/day, ~$270/month

You know the cost from the row count before the run starts. Proxy rotation is bundled into the per-row price — there are no add-ons for residential traffic.

How this compares to Coinglass / Nansen

Coinglass and Nansen are excellent dashboards — if you want to stare at a funding heatmap in a browser, use them. But the moment you need funding rates inside a backtest, a feature pipeline, or an automated alert, a per-seat subscription dashboard is the wrong shape and the wrong cost. This actor gives you the same core funding signal as a flat, joinable JSON feed you pay for by the row — a 90%+ cost saving for a weekly or scheduled pull, with nothing to log into.

FAQ

Q: How often does funding settle on Binance?

A: Every 8 hours — at 00:00, 08:00, and 16:00 UTC for most markets. The nextFundingTime field tells you the exact next settlement so you can time a pull (or a position) around it.

Q: How is the annualized rate calculated?

A: annualizedFundingRatePct = lastFundingRatePct × 3 × 365 — three 8-hour intervals per day, 365 days per year. It assumes the current rate persists, which is the standard convention for comparing carry across markets at a point in time.

Q: Why does the actor need a proxy country?

A: Binance Futures geo-blocks requests originating from US IP addresses. The actor routes through a residential proxy (Singapore by default) so the data is reachable no matter where your Apify run executes. Change proxyCountry if you prefer another non-blocked region.

Q: Does this include funding history or only the current rate?

A: This actor returns the current funding snapshot per market (latest funding rate, mark price, next funding time). For a historical time-series you would schedule it on a cron and accumulate snapshots into your own warehouse.

Q: Which markets are covered?

A: All Binance USDⓈ-M perpetual contracts — the USDT/USDC-margined perps. Use symbolContains to narrow to a family (e.g. BTC, SOL) or leave it blank for the full universe.

Q: Do I need a Binance account or API key?

A: No. The actor reads Binance's public futures market data through Apify's infrastructure. You never supply an exchange credential.

Schema stability & versioning

This actor follows NexGenData's additive-only schema contract. New fields may be added over time — they simply appear as new keys, defaulting to absent on older runs. Existing fields (symbol, markPrice, lastFundingRatePct, annualizedFundingRatePct, nextFundingTime) are never renamed or removed without a major-version bump and an advance changelog notice, and field semantics (units, timezones, percentage conventions) are never silently changed. You can build a production funding pipeline on this actor without fear of a Tuesday change breaking a Friday ETL job.

Compliance & legal

• The actor reads public, unauthenticated Binance futures market data — the same data any browser or public client can see. No login, no exchange credential, no private endpoints.
• Requests route through Apify's compliant residential-proxy infrastructure with polite pacing.
• Market data such as funding rates and mark prices is factual, public market information; this actor performs no order placement, no trading, and no movement of funds.
• You are responsible for ensuring your downstream use complies with Binance's terms of service, your local derivatives regulations, and any restrictions in your jurisdiction. Crypto-derivatives trading is restricted or prohibited in some regions — consult counsel before acting on this data commercially.

Related NexGenData actors

Part of NexGenData's crypto & digital-asset markets cluster — pair this actor with:

• DeFi TVL Protocol Tracker — total value locked across DeFi protocols
• Stablecoin Supply & Peg Monitor — supply and peg-deviation tracking across major stablecoins
• Crypto Top-100 Screener — price, market cap, and volume for the top-100 coins
• Kalshi Prediction Markets Tracker — regulated event-contract odds
• Polymarket Prediction Markets Tracker — on-chain prediction-market odds
• Crypto / DeFi MCP — MCP bridge to pull crypto data straight into Claude, Cursor, and other agents

Explore the full catalog of 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b.