# Crypto Options Tracker — Deribit IV, Put/Call Ratio, Max Pain (`gochujang/crypto-options-tracker`) Actor

Track BTC & ETH options market data from Deribit: implied volatility, put/call ratio, max pain strike, IV skew, ATM IV, and options sentiment. No API key required.

- **URL**: https://apify.com/gochujang/crypto-options-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 option trackeds

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

### What does Crypto Options Tracker do?

The **crypto options tracker** pulls live **BTC ETH options data** directly from Deribit's public REST API — no API key or account required. For every active options instrument, it collects the strike, expiry, implied volatility (mark IV), bid/ask spread, open interest in contracts and USD, and full Greeks (delta, gamma, theta, vega). It then computes market-level aggregate signals — put/call ratio, max pain strike, ATM IV, IV skew, and overall options sentiment — delivering everything a quant or trader needs for **Deribit options analytics** in a single run.

### Why use Crypto Options Tracker?

**1. Implied volatility monitoring**
Track ATM IV and IV skew across all active BTC and ETH expiries without writing a Deribit API client. Elevated skew (puts pricing richer than calls) signals hedging demand and often precedes directional moves.

**2. Max pain analysis before expiry**
Options market makers are incentivized to pin price near the **max pain strike** at expiry. Knowing this level before monthly/quarterly expirations gives directional context for the last few days of an expiry cycle.

**3. Put/call ratio sentiment signal**
A put/call ratio above 1.2 indicates heavy hedging or bearish positioning; below 0.8 indicates call-heavy bullish sentiment. Schedule this Actor daily to track positioning shifts across the entire **BTC ETH options data** market.

**4. Greeks-aware options dashboard**
Download delta, gamma, theta, and vega per instrument to build custom risk dashboards, identify high-gamma expiry clusters, or measure aggregate market delta exposure.

**5. Pre-event OI concentration scanning**
Before major macro events (FOMC, ETF decisions, CPI prints), scan which expiry holds the highest open interest concentration. High OI expiries often pin price or see outsized volatility.

### How to use Crypto Options Tracker

1. Open the Actor on Apify Store and click **Try for free**.
2. Set `currency` to `BTC`, `ETH`, or `both` depending on what you want to track.
3. Adjust `minOiUsd` to filter out illiquid instruments (default $10,000 is a good starting point).
4. Set `maxDaysToExpiry` to focus on near-term expiries only (e.g., `30` for monthly).
5. Click **Start**. The Actor fetches all active instruments from Deribit and populates the dataset plus a `SUMMARY` with aggregate signals.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | string | `BTC` | `BTC`, `ETH`, or `both` |
| `minOiUsd` | integer | `10000` | Minimum open interest in USD to include an instrument |
| `maxDaysToExpiry` | integer | `90` | Exclude instruments expiring beyond this many days |
| `optionType` | string | `all` | Filter by `all`, `call`, or `put` |

**Minimal input** (all BTC options, standard filters):

```json
{}
```

**Near-term ETH puts only:**

```json
{
  "currency": "ETH",
  "optionType": "put",
  "maxDaysToExpiry": 30,
  "minOiUsd": 50000
}
```

### Output

One dataset row per instrument:

```json
{
  "currency": "BTC",
  "instrument_name": "BTC-27DEC24-60000-C",
  "option_type": "call",
  "strike": 60000.0,
  "expiry_date": "27DEC24",
  "days_to_expiry": 14,
  "moneyness": "OTM",
  "mark_iv": 58.32,
  "mark_price": 0.0423,
  "bid": 0.041,
  "ask": 0.044,
  "bid_ask_spread_pct": 7.04,
  "open_interest_contracts": 128.0,
  "open_interest_usd": 8729600.0,
  "underlying_price": 68200.0,
  "delta": 0.31,
  "gamma": 0.00002,
  "theta": -125.4,
  "vega": 48.2,
  "timestamp": "2024-12-13T10:00:00Z"
}
```

A `SUMMARY` record in the Key-Value Store holds market-level **Deribit options analytics**:

```json
{
  "timestamp": "2024-12-13T10:00:00Z",
  "total_instruments_tracked": 312,
  "currencies": [
    {
      "currency": "BTC",
      "spot_price": 68200.0,
      "instruments_tracked": 312,
      "put_call_ratio": 0.92,
      "max_pain_strike": 65000.0,
      "atm_iv_pct": 61.4,
      "iv_skew_pct": 4.8,
      "expiry_cluster": "27DEC24",
      "options_sentiment": "neutral"
    }
  ]
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `mark_iv` | Mark implied volatility in % — the market's implied annualized vol for this instrument |
| `bid_ask_spread_pct` | Liquidity proxy — wide spreads indicate low interest |
| `moneyness` | `ITM` / `ATM` / `OTM` classification relative to current spot |
| `open_interest_usd` | Total open interest valued in USD |
| `delta` | Rate of change of option price vs spot; directional exposure |
| `gamma` | Rate of change of delta; high gamma near expiry |
| `theta` | Daily time decay in USD |
| `vega` | Sensitivity to 1% change in implied volatility |
| `put_call_ratio` | Summary: total put OI ÷ call OI (>1.2 bearish, <0.8 bullish) |
| `max_pain_strike` | Summary: strike where aggregate option holder loss is maximized at expiry |
| `iv_skew_pct` | Summary: 25-delta put IV minus 25-delta call IV (positive = fear premium) |
| `options_sentiment` | Summary: `"bullish"` / `"neutral"` / `"bearish"` from PC ratio + skew |

### Cost estimation

This Actor uses **Pay-Per-Event (PPE)** pricing:

| Scenario | Instruments | Estimated Cost |
|----------|-------------|----------------|
| BTC only, `minOiUsd=10000`, 90 days | ~200–300 | ~$0.41–$0.61 |
| ETH only, same filters | ~100–150 | ~$0.21–$0.31 |
| Both currencies | ~350–500 | ~$0.71–$1.01 |
| Daily monitoring (BTC, 30 days) | ~150/day | ~$4.50/month |

Rate: **$0.001 flat start** + **$0.002 per instrument tracked**.

### FAQ

**Q: Does this require a Deribit account or API key?**
No. All data comes from Deribit's fully public REST API endpoints (`/public/get_instruments`, `/public/ticker`, `/public/get_index_price`). No authentication is needed.

**Q: How current is the data?**
Data is fetched live on each Actor run directly from Deribit. Timestamps reflect the moment of the API call, typically accurate to within seconds.

**Q: Can I track weekly expiries separately from quarterly expiries?**
Yes — use `maxDaysToExpiry` to narrow the expiry window. For example, setting `maxDaysToExpiry: 7` returns only instruments expiring within the next week. Post-processing on the `expiry_date` field gives full expiry-level segmentation.

***

**Disclaimer:** Options data is sourced from Deribit's public API for informational purposes. Not affiliated with Deribit. Not financial or investment advice. Options trading involves substantial risk of loss.

**Keywords:** crypto options tracker, BTC ETH options data, Deribit options analytics, implied volatility, put/call ratio, max pain strike, IV skew, options Greeks, open interest BTC ETH

# Actor input Schema

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

Underlying currency to track options for

## `minOiUsd` (type: `integer`):

Filter out instruments with open interest below this threshold (USD). Set to 0 to include all.

## `maxDaysToExpiry` (type: `integer`):

Only include instruments expiring within this many days. Set to 0 for no limit.

## `optionType` (type: `string`):

Filter by option type

## Actor input object example

```json
{
  "currency": "BTC",
  "minOiUsd": 10000,
  "maxDaysToExpiry": 90,
  "optionType": "all"
}
```

# 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("gochujang/crypto-options-tracker").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("gochujang/crypto-options-tracker").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 gochujang/crypto-options-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/crypto-options-tracker"
        }
    }
}
```

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/stW0Z5KC7YLBd6fZe/builds/bXoDd1IVGg1UkLYEO/openapi.json