# Deribit Options Summary Scraper (`parseforge/deribit-options-summary-scraper`) Actor

Scrapes Deribit options, futures, and perpetual summaries by underlying currency. Returns each instrument as a flat row with mark price, implied volatility, Greeks, open interest, and 24h volume.

- **URL**: https://apify.com/parseforge/deribit-options-summary-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Automation, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $27.37 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Deribit Options Summary Scraper

**Scrape Deribit options summary data for BTC, ETH, and other crypto underlyings, filtered by open interest, volume, and instrument name.** Pull the full active instrument list with mark prices, implied volatility, and Greeks in one flat dataset. No API key required.

Deribit's native API requires a client ID, client secret, and careful rate-limit management. This Actor reads the public get\_instruments summary endpoint directly, so you can pull every active option, future, or perpetual for BTC, ETH, USDC, USDT, and EURR without authentication. Filter by quote currency, instrument name, minimum open interest, or 24h volume, and cap the total records per run.

| Who uses it | What they scrape Deribit for |
|---|---|
| Crypto options traders | Build a watchlist of liquid BTC options expiring this quarter. |
| Quantitative researchers | Pull the full ETH option chain to backtest volatility strategies. |
| Risk managers | Monitor open interest concentration across strikes and expiries. |
| Market makers | Export the instrument universe to reconcile mark prices and Greeks. |

### What it does

This Actor collects Deribit options, futures, and perpetual summaries by underlying currency and instrument kind, and returns each instrument as a flat row with mark price, implied volatility, Greeks, open interest, and volume.

- 🎯 **Multi-currency support:** BTC, ETH, USDC, USDT, and EURR underlyings, alone or together.
- 📋 **Instrument kind selector:** Pull all instruments, options only, or futures and perpetuals only.
- 🔍 **Name filter:** Case-insensitive substring match on instrument name, e.g. '25DEC26' or '70000-C'.
- 📊 **Volume and OI floors:** Keep only contracts above a minimum open interest, USD volume, or base-currency volume.
- ⚙️ **Record cap:** Set a hard maximum on the number of instruments returned per run.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Deribit data

**📈 Build a liquid options watchlist.**

A trader selects BTC and ETH options, sets a minimum open interest of 50, and exports the top 200 contracts to monitor daily.

**🧪 Backtest volatility strategies.**

A quant pulls the full ETH option chain with implied volatility and Greeks, then feeds the CSV into a research notebook.

**⚠️ Monitor open interest concentration.**

A risk manager scrapes all BTC options, filters for the nearest monthly expiry, and checks how much OI sits at out-of-the-money strikes.

**💱 Compare quote-currency venues.**

A researcher pulls BTC options quoted in USD and USDC separately to compare liquidity and pricing differences.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Reads the public Deribit summary endpoint; no registration or secret management. |
| **Flat output** | Every instrument is one row, ready for CSV, JSON, Excel, or XML export. |
| **Full Greeks** | Delta, gamma, vega, theta, and rho are included when available. |
| **Flexible filtering** | Keep only the contracts that matter with OI, volume, and name filters. |

### How it compares

This Actor focuses on the raw instrument summary from Deribit's public endpoint, while the alternatives below add derived analytics or unusual-activity scanning on top.

| Feature | ParseForge | Deribit Crypto Options & Derivatives Tracker | Unusual Crypto Options Activity Scanner |
|---|---|---|---|
| Full instrument summary (mark price, IV, Greeks, OI, volume) | Yes | Yes | Not listed |
| Multi-currency support (BTC, ETH, USDC, USDT, EURR) | Yes | Not listed | Not listed |
| Instrument name substring filter | Yes | Not listed | Not listed |
| Minimum open interest and volume filters | Yes | Not listed | Not listed |
| No API key required | Yes | Not listed | Not listed |
| Unusual options activity scanning | Not listed | Not listed | Yes |
| Per-expiry put/call ratios and DVOL index | Not listed | Yes | Not listed |

### Configure the run

Drive the Actor from one or more underlying currencies and an instrument kind, then narrow the result set with an optional instrument name filter, minimum open interest, and minimum 24h volume thresholds. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "currencies": [
    "BTC",
    "ETH"
  ],
  "kind": "any",
  "maxItems": 10
}
```

A larger pull:

```json
{
  "currencies": [
    "BTC",
    "ETH"
  ],
  "kind": "any",
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0365 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $3.65 |
| 1,000 results | $36.50 |
| 10,000 results | $365.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Deribit Options Summary Scraper](https://apify.com/parseforge/deribit-options-summary-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Deribit through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/deribit-options-summary-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting zero results?**

Your filters may be too restrictive. Try removing the instrument name filter, lowering the minimum open interest, or setting the quote currency to 'Any'. Also check that the selected currencies have active instruments for the chosen kind.

**Why are some instruments missing Greeks?**

Deribit does not always return Greeks for every instrument, especially far out-of-the-money options or those with very low liquidity. This is expected behavior from the source.

**The run is taking too long.**

Lower the maxItems value or narrow your filters. Pulling tens of thousands of instruments will take longer. Start with a small cap and increase it once you confirm the output.

**I'm getting instruments I did not expect.**

Check your instrument kind and quote currency settings. 'Any' for both fields returns the widest set. Set kind to 'option' and pick a specific quote currency to narrow results.

**The volume numbers look wrong.**

Deribit reports 24h volume in the base currency. If you set a minVolumeUsd filter, the Actor converts using the current mark price, which may differ slightly from other sources.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Deribit account or API key? | No. This Actor calls the public get\_instruments endpoint, which does not require authentication. |
| What data fields does each row contain? | Each instrument row includes the instrument name, mark price, implied volatility, delta, gamma, vega, theta, rho, open interest, 24h volume, and more. The exact field list is shown in the sample output on the Actor's page. |
| Can I scrape only Bitcoin options? | Yes. Set the currencies field to \['BTC'] and the instrument kind to 'option'. |
| How do I filter for a specific expiry date? | Use the instrument name filter with a date substring like '28MAR25'. Deribit instrument names embed the expiry, so a case-insensitive substring match works. |
| Does this Actor return futures and perpetuals too? | Yes. Set the instrument kind to 'future' to get futures and perpetuals, or 'any' to get everything together. |
| What is the maximum number of instruments I can pull? | You can set maxItems up to 1,000,000. The actual number returned depends on how many active instruments match your filters. |
| Can I filter by strike price? | There is no dedicated strike filter, but you can use the instrument name filter with a strike substring like '70000-C' to match calls at that strike. |
| What quote currencies are supported? | You can limit results to instruments quoted in USD, USDC, USDT, BTC, or ETH, or leave it on 'Any' to keep all settlement currencies. |
| How often should I run this Actor? | Deribit updates instrument summaries frequently. Running every few minutes gives you near-real-time snapshots. Schedule it on Apify for hands-off collection. |
| Can I export the data to Google Sheets? | Yes. After the run completes, use Apify's export to CSV or JSON and import into Google Sheets, or set up an automated integration. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Deribit B.V. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `currencies` (type: `array`):

Underlying crypto currencies to scrape. Pulls every active instrument for each selected currency. Leave empty for the full BTC + ETH coverage.

## `kind` (type: `string`):

Instrument family. 'all' returns options, futures and perpetuals together; pick a single family to narrow the result set.

## `quoteCurrency` (type: `string`):

Limit to instruments quoted in a specific currency (e.g. USD-settled BTC options vs USDC-settled). Leave as 'Any' to keep every settlement.

## `instrumentFilter` (type: `string`):

Optional case-insensitive substring filter applied to the instrument name (e.g. '25DEC26', '70000-C', 'PERPETUAL').

## `minOpenInterest` (type: `number`):

Only include instruments with open interest greater than or equal to this number. Leave blank to include all.

## `minVolumeUsd` (type: `number`):

Only include instruments with at least this much 24-hour traded volume in USD.

## `minVolumeBase` (type: `number`):

Only include instruments with at least this much 24-hour traded volume in the base currency (e.g. BTC, ETH).

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

Maximum number of options contracts to collect per run.

## Actor input object example

```json
{
  "currencies": [
    "BTC",
    "ETH"
  ],
  "kind": "any",
  "quoteCurrency": "",
  "instrumentFilter": "",
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "currencies": [
        "BTC",
        "ETH"
    ],
    "kind": "any",
    "instrumentFilter": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/deribit-options-summary-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 = {
    "currencies": [
        "BTC",
        "ETH",
    ],
    "kind": "any",
    "instrumentFilter": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/deribit-options-summary-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 '{
  "currencies": [
    "BTC",
    "ETH"
  ],
  "kind": "any",
  "instrumentFilter": "",
  "maxItems": 10
}' |
apify call parseforge/deribit-options-summary-scraper --silent --output-dataset

```

## MCP server setup

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