# Kalshi Perps Funding Rate, Open Interest & Trades Scraper (`scrapebench/kalshi-perps-funding-rate-scraper`) Actor

Kalshi perps data: single-stock, crypto and metal perps with funding rate history, next-funding estimate, open interest, volume, trades, candles, order books and cross-venue funding spreads.

- **URL**: https://apify.com/scrapebench/kalshi-perps-funding-rate-scraper.md
- **Developed by:** [ScrapeBench](https://apify.com/scrapebench) (community)
- **Categories:** Developer tools
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.002 / market

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kalshi Perps Funding Rate, Open Interest & Trades Scraper

### Pain points

- Kalshi sends every price and size as a decimal string, and an empty ask as 922337203685477.5807 (38 of 127 markets on 2026-11-07, stock perps overnight). Read naively, an equity perp's ask is a quadrillion dollars.
- Kalshi's perps pay funding on two schedules: crypto every 8 hours, stocks, indices, metals and energy once a day. A daily rate set next to an 8-hourly one, unconverted, is off by three times.
- The funding estimate, the funding history, the market list, the trades, the candles and the order books are six separate endpoints, the estimate one call per market.
- Comparing Kalshi's funding with Hyperliquid, Binance, Bybit or Polymarket means four more APIs, with intervals of 1, 4 and 8 hours.

### What we solve

- Every perp and future in one run, with its funding estimate, next funding time and open interest.
- Settled funding history per perp from its first payment, with `interval_hours`, the rate per 8 hours and annualised.
- The trade tape, newest first, across all markets or per ticker; candles by minute, hour or day; full order books best level first.
- Kalshi against Hyperliquid, Binance, Bybit and Polymarket in one row per perp, each venue's rate converted to 8 hours and a year, with the cheapest venue and the spread to it.
- Strings coerced to numbers, empty book sides to null.

### Summary

Pulls Kalshi's perpetual futures, the first US-regulated perps on single stocks (NVDA, AAPL, TSLA and 90 more since 2026-11-05) as well as crypto, metals, indices and energy. One run returns every perp with its price, best bid and ask, open interest and 24-hour volume in contracts and dollars, leverage, and the funding rate building for the next payment. Other modes return the settled funding history (BTC back to 2026-06-03), the public trade tape, price/bid/ask candles, full order books, and Kalshi's funding next to Hyperliquid, Binance, Bybit and Polymarket perps on the same underlying, all normalised to 8 hours and annualised. Numbers come back as numbers, an empty side of the book as null, and every funding row says how often that market pays. Public, keyless APIs: no Kalshi account, no API key, no browser.

### Who it's for

- Quants and bot builders backtesting funding carry on Kalshi BTC and ETH perps
- Traders tracking open interest and funding on the new single-stock perps
- Basis and funding-arbitrage desks comparing a US-regulated perp with offshore venues
- Newsletter and dashboard writers charting Kalshi perps daily
- AI agents answering questions about perps funding through MCP

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "mode": "snapshot"
}
```

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `row_type` | market, funding, trade, candle, orderbook or spread (one per mode) |
| `ticker` | Kalshi ticker, e.g. KXBTCPERP, KXNVDAPERP, KXGOLDPERP, KXWTIFUTURE |
| `title / asset_class / contract_type / status` | Market rows: underlying, Equities/Crypto/Metals/Energy/Indices, perpetual or future, active/inactive |
| `bid / ask / price / mark_price` | Market rows: best bid and ask (null when that side is empty), last price, mark price; per contract, in dollars |
| `open_interest / oi_notional_usd` | Contracts outstanding, and their dollar value |
| `volume_24h / volume_24h_notional_usd` | Contracts traded in 24 hours, and their dollar value (plus lifetime volume) |
| `funding_rate_estimate / premium_index / next_funding_time` | Market rows: the rate building for the next payment, and when it is paid |
| `funding_rate / funding_time / mark_price` | Funding rows: each settled payment's rate (per period) and the mark price at the time |
| `interval_hours / *_8h / *_annualised` | How often the market pays (8 or 24 hours), and the rate per 8 hours and per year |
| `trade_id / created_time / price / count / taker_side / is_block_trade` | Trade rows |
| `interval / period_end / open / high / low / close / mean / bid_* / ask_*` | Candle rows: trade price, bid and ask OHLC, volume and open interest |
| `best_bid / best_ask / mid / spread / bids / asks` | Order book rows: every level as \[price, size], best first, with depth per side |
| `{venue}_rate_8h / {venue}_annualised / {venue}_next_funding_time` | Spread rows, for hyperliquid, binance, bybit and polymarket |
| `best_venue / spread_vs_best` | Spread rows: the venue with the lowest annualised funding, and Kalshi's annualised rate minus it |
| `source_url` | The API endpoint the row came from |

Sample:

```json
{
  "source_url": "https://api.elections.kalshi.com/trade-api/v2/margin/markets/KXNVDAPERP",
  "row_type": "market",
  "ticker": "KXNVDAPERP",
  "title": "NVDA",
  "asset_class": "Equities",
  "contract_type": "perpetual",
  "status": "active",
  "is_open": false,
  "next_open_time": "2026-11-08T23:00:00Z",
  "halted": false,
  "bid": 3.7,
  "ask": 3.78,
  "price": 3.7523,
  "mark_price": 3.7523,
  "open_interest": 79898.0,
  "oi_notional_usd": 299801.2654,
  "volume_24h": 6133688.0,
  "volume_24h_notional_usd": 22784763.9004,
  "contract_size": 0.02,
  "leverage_estimate": 4.0576,
  "funding_rate_estimate": 0.0,
  "funding_rate_estimate_annualised": 0.0,
  "next_funding_time": "2026-11-07T21:00:00Z",
  "interval_hours": 24,
  "funding_cap": 0.02
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `mode` | no | string | `"snapshot"` | snapshot: one row per perp with price, bid/ask, open interest, volume and the next funding estimate. funding_history: every settled funding rate since 'From date'. trades: the public trade tape, newest first. candles: price, bid and ask OHLC per minute, hour or day. orderbook: the current order book per perp. funding_spread: Kalshi's funding next to Hyperliquid, Binance, Bybit and Polymarket perps, normalised to 8 hours and annualised. |
| `ticker` | no | string | — | One Kalshi perp, e.g. KXBTCPERP or KXAAPLPERP. A bare symbol works too: BTC, AAPL, GOLD. Kept alongside 'Tickers' for saved tasks. |
| `tickers` | no | array | `[]` | Many perps in one run (KXBTCPERP, KXETHPERP, AAPL...). Leave empty for every perp. Combined with 'Ticker'; duplicates are removed. |
| `assetClass` | no | string | — | One asset class: Equities, Crypto, Metals, Energy or Indices. Kept alongside 'Asset classes' for saved tasks. |
| `assetClasses` | no | array | `[]` | Keep only these asset classes: Equities (single-stock perps), Crypto, Metals, Energy, Indices. Leave empty for all. |
| `fromDate` | no | string | — | Start of the history (YYYY-MM-DD, UTC) for funding_history, trades and candles. Empty: funding history from the first point (2026-06-03 for BTC), trades newest first, candles the last day (1m), week (1h) or everything (1d). |
| `candleInterval` | no | string | `"1h"` | Candles mode only: one minute, one hour or one day. |
| `includeOrderbook` | no | boolean | `false` | Snapshot mode only: also return each perp's current order book (one extra row per perp, charged as an order book). |
| `maxResults` | no | integer | `1000` | A run-wide spend cap. Snapshot, order book and funding spread: at most this many perps. Funding history, trades and candles: at most this many rows in total across all tickers. A free 'truncated' row says when the cap was reached. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Not needed: the APIs are public. Off by default. |

### Pricing (Pay Per Event)

You pay per result (`market`) — **no charge for empty runs**. Example: **127 markets** at *$0.002/result* ≈ **$0.25**.

One price per row type: $0.002 per market, $0.0005 per funding point, $0.003 per spread row, $0.0001 per trade, $0.0003 per candle, $0.001 per order book. The default snapshot returned 127 markets on 2026-11-07: about $0.25. BTC and AAPL funding history since June returned 472 points (about $0.24). 'Maximum results' caps the run; marker rows are free and empty books or candles are never charged.

### Use cases

- Single-stock perps tracker: every equity perp's open interest, 24-hour volume and funding estimate, refreshed daily on a schedule. Mode snapshot, asset class Equities.
- Funding carry backtest: BTC and ETH funding since June 2026, annualised. Mode funding_history, tickers KXBTCPERP and KXETHPERP.
- Cross-venue funding monitor: where holding a BTC, SOL or NVDA perp is cheapest right now. Mode funding_spread.
- Order flow research: the public trade tape with taker side and block-trade flag. Mode trades, from a date.
- Charting: hourly price, bid and ask candles with open interest. Mode candles, interval 1h.
- Liquidity checks: full order books with depth per side. Mode orderbook, or add books to a snapshot.

### Why this actor

- Funding rows carry `interval_hours`, the rate per 8 hours and annualised, so daily and 8-hourly perps compare directly.
- Kalshi next to Hyperliquid, Binance, Bybit and Polymarket in one row per perp, every rate on the same 8-hour and yearly basis.
- Free marker rows when something stops the run: a cap reached, a venue that did not answer, a ticker that does not exist.

### Limitations & updates

Kalshi perps and futures only (127 markets on 2026-11-07, 41 of them inactive with no funding estimate). Trades are the public tape: no trader identities, no liquidations. The all-markets trade tape is busy: 2,500 trades covered about 35 minutes on 2026-11-07, so set tickers or a date for history. Stock perps close outside US market hours and their prices are stale then by design. The funding spread compares only perps another venue lists, uses each venue's current rate, and does not model fees. Not investment advice.

### FAQ

**How far back does the funding history go?**

To each perp's first payment: KXBTCPERP and the other early crypto perps start on 2026-06-03 (470 points on 2026-11-07), gold on 2026-09-11, the S\&P 500 perp on 2026-10-06, single stocks on 2026-11-05. Set 'From date' to start later.

**Why is a funding rate daily on one perp and 8-hourly on another?**

That is Kalshi's schedule. Crypto perps pay every 8 hours; stocks, indices, metals and energy pay once a day, weekends included for the ones measured (gold, S\&P 500). Every funding row carries interval_hours, the rate per 8 hours and the annualised rate (rate x 8,760 / interval_hours) so you can compare them.

**Why are some asks or bids empty?**

The book has nothing on that side. Kalshi sends 922337203685477.5807 or 0.0000 for an empty side; the actor returns null. Stock perps close outside market hours, so overnight their book is thin and their prices are from the close.

**Which venues does the funding spread compare?**

Hyperliquid, Binance and Bybit (all three as published by Hyperliquid's predictedFundings endpoint) and Polymarket perps. A perp gets a row when at least one venue lists the same underlying: on 2026-11-07, 39 Kalshi perps matched, 16 of them single stocks matched on Polymarket only. Kalshi's rate is its estimate for the period in progress; the other venues' are their current predicted rates.

**Are prices per share or per coin?**

Per Kalshi contract, as Kalshi quotes them. A contract is a fraction of the underlying (contract_size: 0.0001 BTC, 0.02 of an NVDA share), so KXBTCPERP trades around $7.60. The notional fields (oi_notional_usd, volume_24h_notional_usd) are in dollars.

**Is there a liquidation feed?**

No. Kalshi's public API publishes no liquidations, so this actor returns none.

**Do I need an account or a proxy?**

No. All the APIs used are public and keyless. The proxy input is off by default.

### Which actor to choose

Other Actors in the portfolio that pair with this one:

- **Kalshi & Polymarket Prediction Market Odds Scraper** — You want Kalshi's event contracts (yes/no odds), not its perps.
- **Kalshi & Polymarket Election Odds History Scraper** — You want the whole odds history of an election market.

### Guides & use cases

Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:

- **How-to:** [How to run Kalshi Perps Funding Rate, Open Interest & Trades Scraper](https://scrapebench.dev/guides/how-to-kalshi-perps-funding-rate-scraper/)
- **Use case:** [Backtesting funding carry on Kalshi BTC and ETH perps since June 2026](https://scrapebench.dev/use-cases/kalshi-btc-eth-funding-carry-backtest/)
- **Use case:** [Kalshi stock perps: a daily open interest and funding tracker](https://scrapebench.dev/use-cases/kalshi-stock-perps-open-interest-tracker/)

More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**

### Works with AI assistants (MCP)

Callable as an MCP tool, so Claude, Cursor, VS Code Copilot and other MCP clients can run it directly. Grab the config from the [MCP tab](https://apify.com/scrapebench/kalshi-perps-funding-rate-scraper/api/mcp) on this page — Apify hosts the server and keeps that snippet current, and OAuth signs you in on first connect, so no API token goes in your config file.

Then just ask:

> "Show me today's funding rate estimate and open interest for every Kalshi stock perp, sorted by open interest."

That is a snapshot with asset class Equities: 94 stock perps on 2026-11-07, about $0.19. Use mode funding_history with a ticker for the past payments. Runs started this way bill exactly like any other run.

### Data & lawful use

This actor collects publicly available information that Kalshi, Hyperliquid or Polymarket publishes for public
lookup — licence records, business listings and the contact details professionals list there.
Some of it identifies individuals (sole proprietors, licence holders, agents), so treat any
names, phone numbers and emails in your results as personal data.

When you run this actor, you decide what is collected and what it is used for, so you are the
controller of that data and we act only as your processor (Apify Standard Actor Contract).
You need a lawful basis for your use, must honour opt-out and deletion requests, and must
follow the marketing rules that apply to you (CAN-SPAM, TCPA, GDPR, CCPA and similar).
Don't use the output for unsolicited bulk messaging, for screening covered by the FCRA, or
for anything the source's own terms forbid.

Your results are stored in your own Apify account. We don't keep a copy of your results and
don't sell or share them.

### Disclaimer

This is an independent tool. It is not affiliated with, endorsed by or sponsored by
Kalshi, Hyperliquid or Polymarket. Names and marks are used only to describe the data source. Records are
provided as published by the source and may be out of date or incomplete. For anything
consequential (hiring, a permit, a legal decision), confirm the record with the issuing
agency. You are responsible for making sure your use complies with applicable law and the
source's terms.

### Need help?

Open an issue on this actor's **Issues** tab and we'll respond there. Bug reports, missing
fields and feature requests are all welcome. Guides and examples: [scrapebench.dev](https://scrapebench.dev).

If you are a person named in this data and want your record removed from our copy, email
apify-help@scrapebench.dev; the source agency remains the official record.

Your run may be used to improve our services. If something looks off, or you want this actor to fit your use better, please share your run data with us: [Apify Console → Settings → Security → Share run data with developers](https://console.apify.com/settings/security). It lets us see exactly what went wrong and keep improving the actor.

# Actor input Schema

## `mode` (type: `string`):

snapshot: one row per perp with price, bid/ask, open interest, volume and the next funding estimate. funding_history: every settled funding rate since 'From date'. trades: the public trade tape, newest first. candles: price, bid and ask OHLC per minute, hour or day. orderbook: the current order book per perp. funding_spread: Kalshi's funding next to Hyperliquid, Binance, Bybit and Polymarket perps, normalised to 8 hours and annualised.

## `ticker` (type: `string`):

One Kalshi perp, e.g. KXBTCPERP or KXAAPLPERP. A bare symbol works too: BTC, AAPL, GOLD. Kept alongside 'Tickers' for saved tasks.

## `tickers` (type: `array`):

Many perps in one run (KXBTCPERP, KXETHPERP, AAPL...). Leave empty for every perp. Combined with 'Ticker'; duplicates are removed.

## `assetClass` (type: `string`):

One asset class: Equities, Crypto, Metals, Energy or Indices. Kept alongside 'Asset classes' for saved tasks.

## `assetClasses` (type: `array`):

Keep only these asset classes: Equities (single-stock perps), Crypto, Metals, Energy, Indices. Leave empty for all.

## `fromDate` (type: `string`):

Start of the history (YYYY-MM-DD, UTC) for funding_history, trades and candles. Empty: funding history from the first point (2026-06-03 for BTC), trades newest first, candles the last day (1m), week (1h) or everything (1d).

## `candleInterval` (type: `string`):

Candles mode only: one minute, one hour or one day.

## `includeOrderbook` (type: `boolean`):

Snapshot mode only: also return each perp's current order book (one extra row per perp, charged as an order book).

## `maxResults` (type: `integer`):

A run-wide spend cap. Snapshot, order book and funding spread: at most this many perps. Funding history, trades and candles: at most this many rows in total across all tickers. A free 'truncated' row says when the cap was reached.

## `proxyConfiguration` (type: `object`):

Not needed: the APIs are public. Off by default.

## Actor input object example

```json
{
  "mode": "snapshot",
  "tickers": [],
  "assetClasses": [],
  "candleInterval": "1h",
  "includeOrderbook": false,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Snapshot rows: price, bid/ask, open interest, volume, funding estimate.

## `funding` (type: `string`):

One row per settled funding payment, per 8 hours and annualised.

## `spread` (type: `string`):

Kalshi's funding next to Hyperliquid, Binance, Bybit and Polymarket.

## `all` (type: `string`):

Every row, including trades, candles and order books.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebench/kalshi-perps-funding-rate-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapebench/kalshi-perps-funding-rate-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call scrapebench/kalshi-perps-funding-rate-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapebench/kalshi-perps-funding-rate-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rlNEbybIVCGdTRjaD/builds/OZx0rkEKmU6Joi5EZ/openapi.json