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

Pull live order-book summaries for Deribit BTC and ETH options and futures. Returns mark price, implied volatility, open interest, bid/ask, last trade and volume across every active expiry and strike.

- **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, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📈 Deribit Options Summary Scraper

> 🚀 **Export the Deribit options chain in seconds.** Pull the full **BTC, ETH, USDC, USDT, and EURR** options, futures, and perpetual order-book summary, with mark price, IV, open interest, 24h volume, and underlying index in one run. No sign-up, no token plumbing, no manual paging.

> 🕒 **Last updated:** 2026-05-15 · **📊 28 fields** per record · **📈 90%+ crypto options market share** · **💱 5 underlyings** · **🔁 Live per run**

The **Deribit Options Summary Scraper** queries the official Deribit options market feed and returns **28 fields per instrument**, including instrument name, base and quote currency, kind (option/future/perpetual), option type, strike, expiry, mark price, mark IV, last/bid/ask/mid prices, 24h high/low, 24h price change, open interest, 24h volume in coin and USD, interest rate, underlying price and index, estimated delivery price, and quote timestamp. Deribit handles **90%+ of all crypto options volume** worldwide and is the reference venue for institutional and prosumer crypto derivatives.

The market spans **BTC, ETH, USDC, USDT, and EURR** as underlying or settlement currencies, covering options, futures, and perpetual swaps. This Actor streams matching records as CSV, Excel, JSON, or XML in under five minutes. Filtering runs in-process with strike, expiry, instrument-name substring, minimum open interest, and minimum 24h USD volume thresholds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto options traders, derivatives quants, risk managers, market researchers, journalists, fund analysts, structured-product engineers | IV surface modelling, term-structure tracking, open-interest dashboards, expiry-day skew capture, term-volume monitoring, derivatives research |

---

### 📋 What the Deribit Options Summary Scraper does

Five filtering workflows in a single run:

- 💱 **Currency selector.** Pick BTC, ETH, USDC, USDT, EURR, or any combination.
- 📂 **Kind filter.** `option` for the full chain, `future` for futures and perpetuals, `any` for everything.
- 🔍 **Instrument-name filter.** Case-insensitive substring (e.g. `25DEC26`, `70000-C`, `PERPETUAL`).
- 📈 **Minimum open interest.** Drop low-OI strikes from the result.
- 💰 **Minimum 24h USD volume.** Keep only liquid instruments.

Each record includes the full order-book summary, parsed strike and expiry for options, mark IV, underlying index, and quote timestamp. Together they form a snapshot of the live options market suitable for IV surfaces, skew studies, and OI dashboards.

> 💡 **Why it matters:** the Deribit options chain is the deepest crypto derivatives market in the world. Whether you're modelling the BTC IV surface, tracking ETH 25-delta skew, or monitoring open interest across expiries, this scraper hands you a clean snapshot every run with no order-book plumbing.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded options-chain dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>currencies</code></td><td>string[]</td><td><code>["BTC"]</code></td><td>Underlying or settlement currencies. Pulls every active instrument for each.</td></tr>
<tr><td><code>kind</code></td><td>string</td><td><code>"option"</code></td><td><code>option</code> = full chain, <code>future</code> = futures and perps, <code>any</code> = everything.</td></tr>
<tr><td><code>instrumentFilter</code></td><td>string</td><td><code>""</code></td><td>Case-insensitive substring filter on instrument name.</td></tr>
<tr><td><code>minOpenInterest</code></td><td>integer</td><td><code>null</code></td><td>Only include instruments with OI greater than or equal to this number.</td></tr>
<tr><td><code>minVolumeUsd</code></td><td>integer</td><td><code>null</code></td><td>Only include instruments with at least this much 24h USD volume.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: liquid BTC weekly option chain.**

```json
{
    "currencies": ["BTC"],
    "kind": "option",
    "instrumentFilter": "",
    "minOpenInterest": 100,
    "minVolumeUsd": 50000,
    "maxItems": 500
}
````

**Example: every BTC and ETH instrument including perps.**

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

> ⚠️ **Good to Know:** mark prices and IVs are quoted by the exchange's pricing engine and update second-by-second. The dataset is a snapshot at run time, not a streaming feed. For live order-book feeds, schedule the Actor on a tight cron and pipe the dataset into your time-series store. Strike and expiry fields are parsed from the instrument name and are `null` for futures and perpetuals.

***

### 📊 Output

Each Deribit instrument record contains up to **28 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `instrumentName` | string | `"BTC-26DEC25-100000-C"` |
| 🔗 `url` | string | `"https://www.deribit.com/options/BTC/BTC-26DEC25-100000-C"` |
| 💵 `baseCurrency` | string | `"BTC"` |
| 💵 `quoteCurrency` | string | `"USD"` |
| 📂 `kind` | string | `"option"` |
| 📂 `optionType` | string | `"call"` |
| 💵 `strike` | number | `100000` |
| 📅 `expiry` | string | `"26DEC25"` |
| 🔁 `isPerpetual` | boolean | `false` |
| 💵 `markPrice` | number | null | `0.0782` |
| 📊 `markIv` | number | null | `52.41` |
| 💵 `lastPrice` | number | null | `0.078` |
| 💵 `bidPrice` | number | null | `0.077` |
| 💵 `askPrice` | number | null | `0.0795` |
| 💵 `midPrice` | number | null | `0.07825` |
| 💵 `high24h` | number | null | `0.0825` |
| 💵 `low24h` | number | null | `0.0712` |
| 📊 `priceChangePct24h` | number | null | `4.13` |
| 📈 `openInterest` | number | null | `1842.5` |
| 📈 `volume24h` | number | null | `217.4` |
| 📈 `volume24hUsd` | number | null | `1582440` |
| 📈 `volume24hNotional` | number | null | `21740000` |
| 📊 `interestRate` | number | null | `0` |
| 💵 `underlyingPrice` | number | null | `97385.42` |
| 🏷️ `underlyingIndex` | string | null | `"SYN.BTC-26DEC25"` |
| 💵 `estimatedDeliveryPrice` | number | null | `97385.42` |
| 🕒 `quoteCreatedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>📈 BTC call option: BTC-26DEC25-100000-C</strong></summary>

```json
{
    "instrumentName": "BTC-26DEC25-100000-C",
    "url": "https://www.deribit.com/options/BTC/BTC-26DEC25-100000-C",
    "baseCurrency": "BTC",
    "quoteCurrency": "USD",
    "kind": "option",
    "optionType": "call",
    "strike": 100000,
    "expiry": "26DEC25",
    "isPerpetual": false,
    "markPrice": 0.0782,
    "markIv": 52.41,
    "lastPrice": 0.078,
    "bidPrice": 0.077,
    "askPrice": 0.0795,
    "midPrice": 0.07825,
    "high24h": 0.0825,
    "low24h": 0.0712,
    "priceChangePct24h": 4.13,
    "openInterest": 1842.5,
    "volume24h": 217.4,
    "volume24hUsd": 1582440,
    "interestRate": 0,
    "underlyingPrice": 97385.42,
    "underlyingIndex": "SYN.BTC-26DEC25",
    "estimatedDeliveryPrice": 97385.42,
    "quoteCreatedAt": "2026-05-15T00:00:00.000Z",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📉 ETH put option: ETH-30MAY25-3500-P</strong></summary>

```json
{
    "instrumentName": "ETH-30MAY25-3500-P",
    "url": "https://www.deribit.com/options/ETH/ETH-30MAY25-3500-P",
    "baseCurrency": "ETH",
    "quoteCurrency": "USD",
    "kind": "option",
    "optionType": "put",
    "strike": 3500,
    "expiry": "30MAY25",
    "isPerpetual": false,
    "markPrice": 0.0421,
    "markIv": 64.2,
    "lastPrice": 0.041,
    "bidPrice": 0.04,
    "askPrice": 0.043,
    "midPrice": 0.0415,
    "high24h": 0.0455,
    "low24h": 0.0381,
    "priceChangePct24h": -2.16,
    "openInterest": 5320.0,
    "volume24h": 412.0,
    "volume24hUsd": 581820,
    "interestRate": 0,
    "underlyingPrice": 3398.75,
    "underlyingIndex": "ETHDVOL",
    "estimatedDeliveryPrice": 3398.75,
    "quoteCreatedAt": "2026-05-15T00:00:00.000Z",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔁 BTC perpetual swap: BTC-PERPETUAL</strong></summary>

```json
{
    "instrumentName": "BTC-PERPETUAL",
    "url": "https://www.deribit.com/options/BTC/BTC-PERPETUAL",
    "baseCurrency": "BTC",
    "quoteCurrency": "USD",
    "kind": "perpetual",
    "isPerpetual": true,
    "markPrice": 97412.5,
    "lastPrice": 97411.0,
    "bidPrice": 97410.5,
    "askPrice": 97412.5,
    "midPrice": 97411.5,
    "high24h": 98215.0,
    "low24h": 96120.5,
    "priceChangePct24h": 1.21,
    "openInterest": 248192015,
    "volume24h": 12305,
    "volume24hUsd": 1198215000,
    "interestRate": 0.0001,
    "underlyingPrice": 97402.18,
    "underlyingIndex": "BTC_USDT",
    "estimatedDeliveryPrice": 97402.18,
    "quoteCreatedAt": "2026-05-15T00:00:00.000Z",
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📈 | **Reference venue.** 90%+ of global crypto options volume flows through Deribit. |
| 🎯 | **Multi-currency, multi-kind.** BTC, ETH, USDC, USDT, EURR options, futures, and perps in one Actor. |
| 🧾 | **28 fields per record.** Full order-book summary, IV, OI, volumes in coin and USD, underlying index, and timestamp. |
| 🔍 | **Server-side and in-process filters.** Substring match, minimum OI, and minimum USD volume. |
| ⚡ | **Fast.** Hundreds of instruments per second, full BTC chain in seconds. |
| 🔁 | **Live per run.** Snapshot reflects the order book at run time. Schedule for time-series ingestion. |
| 🚫 | **No authentication.** Public market feed. No login, no token, no rate limits to negotiate. |

> 📊 Reliable options data is the foundation of every IV surface, skew study, and risk dashboard in crypto derivatives.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Deribit Options Summary Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All Deribit instruments** | **Live per run** | currency, kind, name, OI, USD volume | ⚡ 2 min |
| In-house exchange client | Free + dev time | Full | Streaming | Custom code | 🐢 Days |
| Commercial market-data vendors | $$$ / month | Multi-venue | Streaming | Many | ⏳ Hours |
| Manual portal browsing | Free | One instrument at a time | Live | UI only | 🕒 Tedious |

Pick this Actor when you want a clean snapshot of the deepest crypto options market with zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Deribit Options Summary Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick currencies, instrument kind, and any liquidity filters, then set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull your matching instruments.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Volatility & Surface Research

- BTC and ETH IV surfaces across strikes and expiries
- 25-delta skew dashboards by tenor
- Term-structure plots of ATM IV
- Calendar-spread opportunity scanners

</td>
<td width="50%" valign="top">

#### 💼 Risk & Treasury Management

- Open-interest concentration at key strikes
- Notional exposure dashboards by expiry
- Liquidity scoring for hedging instruments
- Greeks-aware position monitoring inputs

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🏦 Structured Products & Funds

- Pricing inputs for retail structured-product builders
- Backtesting datasets for systematic options funds
- Daily mark-to-market snapshots for portfolio reports
- Variance-swap reference data construction

</td>
<td width="50%" valign="top">

#### 📰 Research & Journalism

- Macro narratives backed by skew and OI data
- Coverage of expiry-day positioning
- Monthly term-structure recaps
- Educational dashboards for newsletters

</td>
</tr>
</table>

***

### 🔌 Automating Deribit Options Summary Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Minute, hourly, or daily refreshes power options time-series stores and IV-surface dashboards.

***

### 🌟 Beyond business use cases

The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Crypto-derivatives studies for finance papers
- IV-surface and skew research with replicable snapshots
- Coursework on options pricing and Greeks
- Reproducible studies with cited dataset pulls

</td>
<td width="50%">

#### 🎨 Personal and creative

- Hobbyist option-flow trackers and dashboards
- Personal IV-surface visualisations
- Newsletter charts on weekly skew
- Side projects exploring crypto derivatives data

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Educational explainers on derivatives risk
- Open datasets for student trading clubs
- Transparency content on crypto market structure
- Community resources for new options traders

</td>
<td width="50%">

#### 🧪 Experimentation

- Train models that predict IV moves from OI shifts
- Validate retail options-tool ideas with real data
- Prototype agent pipelines that summarise daily flow
- Test trading dashboards with live snapshots

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Deribit%20Options%20Summary%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Deribit%20Options%20Summary%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Deribit%20Options%20Summary%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Deribit%20Options%20Summary%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick currencies and instrument kind, optionally add OI or USD-volume liquidity floors, and click Start. The Actor pulls the live order-book summary for every matching instrument and returns one structured record per instrument. No browser automation, no captchas, no setup.

#### 📏 How accurate are mark prices and IVs?

Mark prices and mark IVs are produced by the exchange's pricing engine and update second-by-second. The snapshot you receive is the exact value the venue publishes at the moment of run.

#### 🔁 How often is the chain refreshed?

Every run pulls the live order-book summary. For continuous monitoring, schedule the Actor on a tight cron (every minute, every 5 minutes, etc.).

#### 💱 Which underlyings are supported?

BTC, ETH, USDC, USDT, and EURR. Combine any subset in one run.

#### 📂 Can I pull futures and perps too?

Yes. Set `kind` to `future` (futures and perps) or `any` (everything). Each record's `kind` field tells you whether it's an option, perpetual, or dated future.

#### 🔍 Can I filter to one expiry?

Yes. Use `instrumentFilter` with the expiry tag (e.g. `"25DEC26"`). Combine with `minOpenInterest` to drop illiquid strikes.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor every minute, hourly, daily, or on any cron interval, and pipe the dataset into your time-series store.

#### ⚖️ Is this data legal to use?

Public market data published by the venue is generally redistributable for analytics and research. Review the venue's own terms of service if you plan to redistribute commercially.

#### 💼 Can I use this data commercially?

Public market-data snapshots are widely used for analytics, internal tools, and research. Always honour the venue's terms when building a commercial market-data product on top.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Deribit Options Summary Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe options data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh option chains into your IV-surface store, or alert your team in Slack on volume or OI spikes.

***

### 🔗 Recommended Actors

- [**😨 Crypto Fear & Greed Index Scraper**](https://apify.com/parseforge/alternative-me-fear-greed-scraper) - Daily crypto sentiment index back to 2018
- [**📊 Federal Reserve H.15 Rates Scraper**](https://apify.com/parseforge/federalreserve-h15-rates-scraper) - Daily U.S. interest rates and yield curve
- [**📦 NuGet Packages Scraper**](https://apify.com/parseforge/nuget-packages-scraper) - .NET package catalogue and download history
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🦀 Crates.io Scraper**](https://apify.com/parseforge/crates-scraper) - Rust crate metadata, downloads, and versions

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Deribit or any of its operators. All trademarks mentioned are the property of their respective owners. Only publicly available market data is collected. Nothing in this dataset constitutes financial advice; always do your own research before trading derivatives.

# 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`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## 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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/deribit-options-summary-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Deribit Options Summary Scraper",
        "description": "Pull live order-book summaries for Deribit BTC and ETH options and futures. Returns mark price, implied volatility, open interest, bid/ask, last trade and volume across every active expiry and strike.",
        "version": "0.0",
        "x-build-id": "AhEQwedxLjmsJsrfQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~deribit-options-summary-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-deribit-options-summary-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~deribit-options-summary-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-deribit-options-summary-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~deribit-options-summary-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-deribit-options-summary-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "currencies": {
                        "title": "Currencies",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Underlying crypto currencies to scrape. Pulls every active instrument for each selected currency. Leave empty for the full BTC + ETH coverage.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "BTC",
                                "ETH",
                                "USDC",
                                "USDT",
                                "EURR"
                            ]
                        },
                        "default": [
                            "BTC",
                            "ETH"
                        ]
                    },
                    "kind": {
                        "title": "Instrument kind",
                        "enum": [
                            "any",
                            "option",
                            "future"
                        ],
                        "type": "string",
                        "description": "Instrument family. 'all' returns options, futures and perpetuals together; pick a single family to narrow the result set.",
                        "default": "any"
                    },
                    "quoteCurrency": {
                        "title": "Quote currency",
                        "enum": [
                            "",
                            "USD",
                            "USDC",
                            "USDT",
                            "BTC",
                            "ETH"
                        ],
                        "type": "string",
                        "description": "Limit to instruments quoted in a specific currency (e.g. USD-settled BTC options vs USDC-settled). Leave as 'Any' to keep every settlement.",
                        "default": ""
                    },
                    "instrumentFilter": {
                        "title": "Instrument name filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter applied to the instrument name (e.g. '25DEC26', '70000-C', 'PERPETUAL').",
                        "default": ""
                    },
                    "minOpenInterest": {
                        "title": "Minimum open interest",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include instruments with open interest greater than or equal to this number. Leave blank to include all."
                    },
                    "minVolumeUsd": {
                        "title": "Minimum 24h volume (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include instruments with at least this much 24-hour traded volume in USD."
                    },
                    "minVolumeBase": {
                        "title": "Minimum 24h volume (base currency)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include instruments with at least this much 24-hour traded volume in the base currency (e.g. BTC, ETH)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
