# Options Expiration Calendar — OPEX, Max Pain & Put/Call (`gochujang/options-expiration-calendar`) Actor

Get stock options expiration dates, weekly/monthly/quarterly OPEX events, and per-ticker max pain price with put/call ratio. No API key needed — uses Yahoo Finance.

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

## Pricing

from $1.00 / 1,000 event fetcheds

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

## Options Expiration Calendar — OPEX, Max Pain & Put/Call Ratio

**Options Expiration Calendar** delivers upcoming **options expiration dates** (weekly, monthly, and quarterly OPEX), and for specific tickers calculates **max pain price** and **put/call open interest ratio** from live Yahoo Finance option chains. Use it to plan options strategies around gamma events, track triple witching, and find where market makers want price to pin on expiration day.

***

### Why use Options Expiration Calendar?

1. **Gamma event planning** — Monthly OPEX (especially quarterly "triple witching") creates the highest market volume and volatility. Know the dates 3 months out to plan your positions accordingly.
2. **Max pain hedging** — Options market makers are short gamma and hedge to stay delta-neutral. The max pain price is where they collect the most premium — stocks often gravitate toward it in the final days before expiration.
3. **Put/call ratio skew detection** — A PCR above 1.5 signals heavy put buying (fear/hedging); below 0.7 signals call-heavy positioning (bullish or speculative). Track this per expiration.
4. **Earnings + OPEX overlap** — When a company reports earnings in the same week as a major OPEX, IV crush and pin risk combine. Identify these overlaps with this calendar.
5. **Triple witching calendar** — The quarterly OPEX in March, June, September, and December involves simultaneous expiration of equity options, index options, and futures. Volume spikes are predictable — plan liquidity accordingly.

***

### How to use

1. Open the actor on Apify Store and click **Try for free**.
2. Choose `mode`: `calendar` (upcoming OPEX dates) or `ticker` (per-stock chain analysis).
3. For `ticker` mode, paste tickers into `tickers` and enable `includeMaxPain` if you want the full OI analysis.
4. Click **Start**. Calendar mode returns all OPEX events; ticker mode returns per-expiration chain stats.

***

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `"calendar"` | `calendar` for OPEX date list, `ticker` for per-stock analysis |
| `tickers` | string | `""` | Comma-separated tickers for `ticker` mode (e.g. `"AAPL,SPY,QQQ,TSLA"`) |
| `monthsAhead` | number | `3` | Months ahead for calendar mode (max 12) |
| `includeMaxPain` | boolean | `true` | Calculate max pain price from full OI data (ticker mode only) |
| `nextExpiryOnly` | boolean | `false` | Return only the nearest expiration per ticker (faster, cheaper) |

***

### Output

**Calendar mode:**

```json
{
  "date": "2026-09-19",
  "day_of_week": "Friday",
  "type": "quarterly_opex",
  "days_away": 17,
  "is_triple_witching": true,
  "description": "Q3 2026 Quarterly OPEX — Triple Witching"
}
```

**Ticker mode (with max pain):**

```json
{
  "ticker": "AAPL",
  "expiry_date": "2026-09-19",
  "days_to_expiry": 17,
  "current_price": 213.45,
  "max_pain_price": 210.0,
  "max_pain_diff_pct": -1.61,
  "total_call_oi": 1234567,
  "total_put_oi": 987654,
  "put_call_ratio": 0.80
}
```

#### Calendar mode output fields

| Field | Type | Description |
|-------|------|-------------|
| `date` | string | Expiration date (YYYY-MM-DD) |
| `day_of_week` | string | Always Friday for standard expirations |
| `type` | string | `weekly_opex`, `monthly_opex`, or `quarterly_opex` |
| `days_away` | integer | Calendar days until expiration |
| `is_triple_witching` | boolean | True for March/June/September/December quarterly OPEX |
| `description` | string | Human-readable event label |

#### Ticker mode output fields

| Field | Type | Description |
|-------|------|-------------|
| `ticker` | string | Stock symbol |
| `expiry_date` | string | Option expiration date |
| `days_to_expiry` | integer | Calendar days until expiration |
| `current_price` | float | Current stock price from Yahoo Finance |
| `max_pain_price` | float | Strike price where aggregate option seller losses are minimized |
| `max_pain_diff_pct` | float | % gap between current price and max pain (negative = stock above max pain) |
| `total_call_oi` | integer | Total call open interest across all strikes for this expiration |
| `total_put_oi` | integer | Total put open interest across all strikes |
| `put_call_ratio` | float | `total_put_oi / total_call_oi` |

***

### Max pain explained

Max pain is the strike price at which the total value of all in-the-money options (calls + puts) is minimized — meaning option sellers (primarily market makers) would experience the least loss. The max pain theory holds that market makers hedge their short gamma exposure in ways that drive price toward this level near expiration.

**How to interpret it:**

- `max_pain_diff_pct > 0`: stock is below max pain → bullish pin pressure
- `max_pain_diff_pct < 0`: stock is above max pain → bearish pin pressure
- Large divergences (>5%) tend to resolve toward max pain in the final 2-3 days before expiration

***

### OPEX calendar for 2026

| Date | Type | Notes |
|------|------|-------|
| Sep 19, 2026 | Quarterly OPEX | Triple witching — Q3 |
| Oct 16, 2026 | Monthly OPEX | |
| Nov 20, 2026 | Monthly OPEX | |
| Dec 18, 2026 | Quarterly OPEX | Triple witching — Q4 |

Weekly OPEX occurs every Friday (some stocks only monthly).

***

### Cost estimation

**Pay-Per-Event: $0.005 per actor start + $0.005 per OPEX event returned.**

| Use case | Records | Estimated cost |
|----------|---------|----------------|
| 3-month calendar (all OPEX) | ~13 events | ~$0.07/run |
| 5 tickers, 3 expirations each | 15 records | ~$0.08/run |
| 20 tickers, next expiry only | 20 records | ~$0.10/run |
| Weekly monitoring (full chain) | ~50 records | ~$0.25/run |

***

### FAQ

**Does it cover weekly options on all stocks?**
No — weekly expirations are only available on stocks with active options markets. The actor returns only the expirations that Yahoo Finance has data for. Most large-cap and index ETFs have weeklies; smaller stocks may only have monthlies.

**How accurate is max pain?**
Max pain is a theoretical model based on OI at the time of the run. OI changes throughout the week, and max pain is most meaningful in the final 1-2 days before expiration. It's a guide, not a guaranteed pin level.

**Does it cover index options (SPX, NDX, VIX)?**
Yes — pass `tickers: "^SPX,^NDX"` for index options. Note that SPX has daily 0DTE expirations in addition to weekly/monthly.

**What's the difference between monthly and quarterly OPEX?**
All monthly OPEX dates are the 3rd Friday of each month. The quarterly ones (March, June, September, December) are also triple witching — where equity options, index options, and S\&P futures all expire simultaneously, causing the highest volume of the year.

***

### Related actors

- [Upcoming Earnings Calendar](https://apify.com/gochujang/upcoming-earnings-calendar) — Overlay earnings dates with OPEX to find high-IV-crush opportunities
- [Options Unusual Activity](https://apify.com/gochujang/options-unusual-activity) — Large OI and volume spikes that precede directional moves
- [Market Breadth Tracker](https://apify.com/gochujang/market-breadth-tracker) — Broad market indicators that contextualize OPEX moves

### Feedback

If this actor is useful, a quick review helps other options traders find it: [Leave a review on Apify Store](https://apify.com/gochujang/options-expiration-calendar#reviews)

***

**Keywords:** options expiration calendar, OPEX dates, max pain calculator, stock options expiry, weekly options expiration, monthly OPEX, quarterly expiration, put call ratio, open interest by expiry, options gamma exposure, SPX OPEX, options IV crush, options settlement date, derivatives calendar, options chain expiration

# Actor input Schema

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

calendar = market-wide OPEX dates, ticker = per-ticker expiry chain.

## `tickers` (type: `string`):

Ticker symbols for per-ticker chain lookups.

## `monthsAhead` (type: `integer`):

How many months of OPEX dates to return (calendar mode).

## `includeMaxPain` (type: `boolean`):

Calculate max pain price for each expiration (ticker mode only). Slower — fetches full option chain.

## `nextExpiryOnly` (type: `boolean`):

Only return the next upcoming expiration per ticker.

## Actor input object example

```json
{
  "mode": "calendar",
  "tickers": "",
  "monthsAhead": 3,
  "includeMaxPain": false,
  "nextExpiryOnly": false
}
```

# 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/options-expiration-calendar").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/options-expiration-calendar").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/options-expiration-calendar --silent --output-dataset

```

## MCP server setup

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

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/BvxD2Wtb8RjhKUCDh/builds/g5PABPZfPt8nGb54x/openapi.json