# Deribit Options Scraper - BTC & ETH Strikes, IV, Open Interest (`ninhothedev/deribit-scraper`) Actor

$0.5/1K 🔥 Deribit scraper! Crypto options & futures — strikes, implied volatility, open interest & prices. No key. JSON, CSV, Excel or API in seconds. Power derivatives & vol research ⚡

- **URL**: https://apify.com/ninhothedev/deribit-scraper.md
- **Developed by:** [ninhothedev](https://apify.com/ninhothedev) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Deribit Crypto Options & Futures Scraper

Scrape the **full Deribit option chain, futures/perpetuals and index prices** — no API key, no login, no proxy required. Every run returns clean, structured rows with strike, expiry, mark/bid/ask price, **implied volatility (IV)**, **open interest**, 24h volume and the underlying price, ready for JSON, CSV, Excel or a direct API pull.

Deribit is the dominant venue for crypto options: the majority of global BTC and ETH options open interest sits on its books. That makes this dataset the reference source for crypto volatility research, options analytics and derivatives risk work.

### What it does

| Mode | What you get |
|---|---|
| `options` | The complete option chain for a currency — every live call and put with strike, expiry, days to expiry, mark/mid/last/bid/ask price, **mark IV, bid IV, ask IV**, volume, volume in USD, open interest and the underlying price. |
| `futures` | All futures and perpetual contracts — mark price, mid, last, bid/ask, 24h high/low, price change, volume and open interest. |
| `index` | Deribit index prices (the spot reference used for settlement) plus the estimated delivery price. |

Supported currencies: **BTC**, **ETH**, **SOL**, **USDC**.

The actor calls two public endpoints and **joins them by `instrument_name`**: `public/get_instruments` supplies static contract metadata (strike, expiry, option type, contract size, settlement period) and `public/get_book_summary_by_currency` supplies live pricing (mark price, IV, open interest, volume). You get one complete row per contract instead of two half-filled datasets.

### Input

```json
{
  "mode": "options",
  "currency": "BTC",
  "maxItems": 500
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `options` | `options`, `futures` or `index`. |
| `currency` | select | `BTC` | `BTC`, `ETH`, `SOL` or `USDC`. |
| `maxItems` | integer | `500` | 1–5000. Results are sorted by expiry then strike, so a lower cap keeps the nearest expiries. Use 5000 for a full BTC chain (800+ contracts). |

### Output sample (options)

```json
{
  "type": "option",
  "instrument_name": "BTC-28AUG26-59000-P",
  "base_currency": "BTC",
  "quote_currency": "BTC",
  "option_type": "put",
  "strike": 59000.0,
  "expiration": "2026-08-28T08:00:00+00:00",
  "days_to_expiry": 31.33,
  "settlement_period": "month",
  "mark_price": 0.01830165,
  "mid_price": 0.018,
  "last_price": 0.018,
  "bid_price": 0.0175,
  "ask_price": 0.0185,
  "mark_iv": 39.86,
  "bid_iv": null,
  "ask_iv": null,
  "volume": 59.0,
  "volume_usd": 66163.48,
  "open_interest": 863.7,
  "underlying_price": 63360.69,
  "underlying_index": "BTC-28AUG26",
  "price_change": 63.6364,
  "high": 0.0185,
  "low": 0.011,
  "contract_size": 1.0,
  "is_active": true,
  "source": "deribit",
  "scraped_at": "2026-07-28T13:36:16+00:00"
}
```

Index mode returns `{ "type": "index", "index_name": "btc_usd", "index_price": ..., "estimated_delivery_price": ..., "source": "deribit", "scraped_at": ... }`.

### Reading the two fields that matter most

**Implied volatility (IV)** — `mark_iv`, `bid_iv`, `ask_iv` are annualised volatility percentages implied by the option's price. `mark_iv: 39.86` means the market prices this contract as if the underlying will move about 39.9% (annualised, one standard deviation) until expiry. Plot `mark_iv` across strikes for a single expiry and you have the **volatility smile**; plot it across expiries at one strike and you have the **term structure**. Rising IV means options are getting more expensive relative to the spot move — the classic signal that the market expects turbulence.

**Open interest (OI)** — the number of contracts currently outstanding at that strike and expiry. Unlike volume (which resets daily), OI is a stock, not a flow: it shows where positioning actually sits. Large OI clusters at round strikes are the levels dealers must hedge around, and they often act as magnets into expiry. Multiply OI by `underlying_price` (and `contract_size`) for notional exposure. Options on Deribit are inverse: option prices are quoted **in the base currency** (a BTC option priced at 0.0183 costs 0.0183 BTC), while futures are quoted in USD.

### Use cases

- **Options trading** — build live chains, scan for mispriced strikes, screen by IV rank, spread width or bid/ask liquidity, and monitor near-dated expiries intraday.
- **Volatility research** — reconstruct the smile, skew and term structure over time; compare BTC vs ETH IV; build a crypto VIX-style index from the mark IVs.
- **Derivatives analytics** — track open interest migration between strikes and expiries, compute max pain, measure put/call ratios and dealer gamma exposure.
- **Risk management** — mark portfolios to Deribit's mark prices, monitor concentration by expiry, and stress-test using the underlying and index prices.

### Pricing

Roughly **$0.50 per 1,000 results** on Apify's pay-per-event model, plus the usual platform compute. A full BTC option chain (about 800 contracts) is a fraction of a dollar per snapshot — cheap enough to run every 15 minutes on a schedule and build your own IV history.

### Notes & limits

- All endpoints are public. No API key, credentials or proxy are needed.
- Deribit does not list options for every currency at all times (SOL options in particular are frequently absent). The actor raises a clear error when a market returns zero contracts.
- Every field is nullable: illiquid contracts have no `last`, and futures have no IV. Handle `null` in downstream code.
- Data is a point-in-time snapshot. Schedule the actor to build a time series.

### Related actors

- [OKX Scraper](https://apify.com/ninhothedev/okx-scraper)
- [Bybit Crypto Scraper](https://apify.com/ninhothedev/bybit-crypto-scraper)
- [DexScreener Scraper](https://apify.com/ninhothedev/dexscreener-scraper)
- [Kraken Crypto Scraper](https://apify.com/ninhothedev/kraken-crypto-scraper)

### Disclaimer

This actor collects publicly available market data from Deribit's open REST API. It is provided for research and information purposes only and is not financial advice. Respect Deribit's terms of service and rate limits.

# Actor input Schema

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

What to scrape. 'options' returns the full option chain (strike, expiry, mark/bid/ask price, implied volatility and open interest). 'futures' returns futures and perpetual contracts. 'index' returns Deribit index (spot reference) prices used for settlement.

## `currency` (type: `string`):

Deribit base currency to scrape. BTC and ETH have the deepest option chains; SOL and USDC markets are smaller and may not list options at all times.

## `maxItems` (type: `integer`):

Maximum number of contracts (or index prices) to push to the dataset. Results are sorted by expiry, then strike, so a lower limit keeps the nearest expiries. Use 5000 to capture an entire BTC option chain.

## Actor input object example

```json
{
  "mode": "options",
  "currency": "BTC",
  "maxItems": 500
}
```

# Actor output Schema

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

No description

# 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("ninhothedev/deribit-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("ninhothedev/deribit-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 ninhothedev/deribit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ninhothedev/deribit-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/FFF7uMvymVrBvIRcn/builds/IhXnXKoMQ2zAfnCJG/openapi.json