# Yahoo Options Scraper (`parsebird/yahoo-options-scraper`) Actor

Scrape Yahoo Finance option chains for stocks, ETFs, and indexes: bid, ask, IV, volume, open interest, plus Greeks, put/call ratios, max pain, and unusual options activity. Export to JSON, CSV, or Excel, with API and scheduling.

- **URL**: https://apify.com/parsebird/yahoo-options-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 data

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?

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

### Yahoo Options Scraper

Yahoo Options Scraper extracts **option chains from Yahoo Finance** for US stocks, ETFs, and indexes: every call and put with strike, expiration, last price, bid, ask, volume, open interest, and implied volatility. It also calculates **Greeks** (delta, gamma, theta, vega, rho) and can return **one summary row per ticker** (put/call ratios, 30-day ATM IV, premium flow, max pain, sentiment) or **scan for unusual options activity**.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Pull up to 60 expirations per ticker for 50 tickers in one run, filter by moneyness, strike window, volume, open interest, IV, and days to expiration, and get clean numeric fields: IV as a decimal, nulls where Yahoo has no data, never fake zeros.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Actor: parsebird/yahoo-options-scraper — scrapes option chains from Yahoo Finance (finance.yahoo.com) for US stocks, ETFs and indexes (AAPL, SPY, ^SPX, ^VIX, BRK.B). Input (unknown fields fail the run): {"tickers": ["AAPL","SPY"] (array, max 50; entries may be comma/space separated), "mode": "chain" (chain = one row per contract | summary = one row per ticker | unusual = unusual-activity scan), "contractTypes": ["calls","puts"], "optionsExpirations": 4 (nearest N expirations, 1-60), "expirationDates": ["2026-11-20"] (exact dates, win over range and count), "expirationFrom"/"expirationTo": "YYYY-MM-DD" (inclusive range, wins over count), "includeGreeks": true, "riskFreeRate": 0.043 (decimal; default = ^IRX 13-week T-bill yield), filters: "moneyness" (all|inTheMoney|outOfTheMoney|atTheMoney), "minStrike", "maxStrike", "strikeWindowPercent", "minVolume", "minOpenInterest", "minImpliedVolatility"/"maxImpliedVolatility" (decimal, 0.3 = 30%), "minDaysToExpiration"/"maxDaysToExpiration", "atmEpsilonPercent": 1.5 (min 0.1); "unusualVolumeOiRatio": 5, "unusualPremiumUsd": 50000; "maxItems": 1000 (whole run, max 25000, shared round-robin across tickers), "sortBy": "yahooOrder" (strikeAsc|strikeDesc|volumeDesc|openInterestDesc|impliedVolatilityDesc|impliedVolatilityAsc|premiumDesc|lastTradeNewest|nearestStrike|moneynessAsc), "concurrency": 4, "maxRetries": 3, "requestDelayMs": 0, "proxyConfiguration": {"useApifyProxy": false}}. Run via ApifyClient("YOUR_TOKEN").actor("parsebird/yahoo-options-scraper").call(run_input=input). Contract rows (rowType "contract"): ticker, contractSymbol, type, strike, expiration, expirationTimestamp, daysToExpiration, lastPrice, bid, ask, mid, spread, spreadPercent, change, percentChange, lastTradeDate, impliedVolatility (decimal), delta, gamma, theta (per day), vega (per vol point), rho (per 1% rate), theoreticalPrice, volume, openInterest, volumeOpenInterestRatio, premiumTradedUsd, inTheMoney, moneyness (ITM/OTM/ATM), moneynessPercent, contractSize, unusualScore, underlyingSymbol, underlyingName, underlyingPrice, underlyingChange, underlyingChangePercent, marketState, currency, marketCap, trailingPE, forwardPE, fiftyTwoWeekLow, fiftyTwoWeekHigh, earningsDate, dividendYield, riskFreeRate, scrapedAt. Summary rows (rowType "summary"): volumes, open interest, putCallVolumeRatio, putCallOpenInterestRatio, avgCallIV, avgPutIV, iv30d, ivSkew30d, atmCallIV30d, atmPutIV30d, atmStrike30d, expiration30d, daysToExpiration30d, premium traded and netPremiumFlowUsd, mostActiveContract, maxPainStrike, maxPainWeighting, maxPainExpiration, sentiment, plus underlying fields. null = Yahoo had no data. Pricing: pay per row saved. Get your API token at https://console.apify.com/account#/integrations. Full API spec: https://apify.com/parsebird/yahoo-options-scraper/api
```

### What is Yahoo Options Scraper?

Yahoo Options Scraper is a **Yahoo Finance options data extraction tool**. It reads the same option chains shown on [Yahoo Finance](https://finance.yahoo.com/) quote pages (for example [AAPL options](https://finance.yahoo.com/quote/AAPL/options/)) and turns them into clean rows you can load into a spreadsheet, database, or trading notebook. Yahoo Finance has no official public options API, so this scraper works as a **Yahoo Finance options API alternative** for traders, quants, analysts, and fintech developers.

The easiest way to try it: keep the prefilled tickers `AAPL` and `SPY`, click **Start**, and open the dataset. You get every contract for the 4 nearest expirations, with Greeks, in a few seconds.

No Yahoo account or API key is needed.

### What can Yahoo Options Scraper do?

- 📈 **Full option chains**: calls and puts for the nearest N expirations, exact dates, or a date range, for up to 50 tickers per run.
- 🧮 **Greeks**: delta, gamma, theta, vega, rho, and a theoretical price, calculated with Black-Scholes-Merton from Yahoo's implied volatility, the dividend yield, and the live 13-week T-bill rate (^IRX).
- 📊 **Ticker summary**: total and per-side volume and open interest, put/call ratios, average IV, 30-day ATM IV and skew, premium flow, most active contract, max pain, and a sentiment label.
- 🚨 **Unusual options activity**: contracts with volume far above open interest and large premium traded, ranked by score.
- 🎯 **Filters**: moneyness (ITM, OTM, ATM), strike range, strike window around spot, minimum volume and open interest, IV range, and days to expiration.
- ↕️ **11 sort orders**: strike, volume, open interest, IV, premium traded, last trade, nearest strike, or moneyness.
- 🧾 **Honest numbers**: every price, IV, Greek, and volume is a number, and missing data is `null`, not `0`.

Because Yahoo Options Scraper runs on the Apify platform, you also get:

- ⏰ [Scheduling](https://docs.apify.com/platform/schedules) to snapshot option chains at the open, the close, or every hour.
- 🔌 [API access](https://docs.apify.com/api/v2) and client libraries for Python and JavaScript.
- 🔗 [Integrations](https://apify.com/integrations) with Google Sheets, Slack, Zapier, Make, webhooks, and more.
- 📁 Exports to JSON, CSV, Excel, XML, or HTML from the dataset.

### What data can you extract from Yahoo Finance options?

| Field | Description |
|-------|-------------|
| `contractSymbol`, `type`, `strike`, `expiration`, `daysToExpiration` | Contract identity (OCC symbol, call or put) |
| `lastPrice`, `bid`, `ask`, `mid`, `spread`, `spreadPercent` | Quote. `mid` and `spread` need a two-sided quote, otherwise they are `null` |
| `change`, `percentChange`, `lastTradeDate` | Change versus the previous close and time of the last trade |
| `impliedVolatility` | Yahoo's implied volatility as a decimal (0.32 = 32%) |
| `delta`, `gamma`, `theta`, `vega`, `rho`, `theoreticalPrice` | Calculated Greeks: theta per calendar day, vega per volatility point, rho per percentage point |
| `volume`, `openInterest`, `volumeOpenInterestRatio`, `premiumTradedUsd` | Activity |
| `inTheMoney`, `moneyness`, `moneynessPercent` | Yahoo's ITM flag, plus a computed ITM / OTM / ATM label |
| `underlyingPrice`, `marketState`, `marketCap`, `trailingPE`, `forwardPE`, `earningsDate`, `dividendYield` | Underlying stock or ETF |
| Summary: `putCallVolumeRatio`, `iv30d`, `ivSkew30d`, `maxPainStrike`, `netPremiumFlowUsd`, `sentiment` | One row per ticker in summary mode |

### How to scrape Yahoo Finance options

1. Open [Yahoo Options Scraper](https://apify.com/parsebird/yahoo-options-scraper) in Apify Console.
2. Enter one or more tickers, such as `AAPL`, `SPY`, or `^SPX`.
3. Choose a mode: **Option chain**, **Summary**, or **Unusual options activity**.
4. Set how many expirations to fetch, or pick exact dates or a date range.
5. Optional: add filters such as at-the-money only, a strike window, or minimum volume.
6. Click **Start**, then download the dataset as JSON, CSV, or Excel, or read it through the API.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `tickers` | array | No | `["AAPL"]` | Symbols, up to 50. Uppercased and de-duplicated. `BRK.B` becomes `BRK-B`, Yahoo's spelling. Yahoo quote URLs work too. |
| `mode` | string | No | `chain` | `chain`, `summary`, or `unusual` |
| `contractTypes` | array | No | `["calls","puts"]` | `calls`, `puts`, or both |
| `optionsExpirations` | integer | No | 1 | Nearest N expirations per ticker, 1 to 60 |
| `expirationDates` | array | No | — | Exact `YYYY-MM-DD` dates. Win over the range and the count |
| `expirationFrom` / `expirationTo` | string | No | — | Inclusive date range. Wins over the count |
| `includeGreeks` | boolean | No | `true` | Calculate Greeks and a theoretical price |
| `riskFreeRate` | number | No | ^IRX | Decimal, e.g. `0.043`. Default: Yahoo's ^IRX quote, or 4.5% if it can't be read |
| `moneyness` | string | No | `all` | `all`, `inTheMoney`, `outOfTheMoney`, `atTheMoney` |
| `minStrike` / `maxStrike` | number | No | — | Strike bounds |
| `strikeWindowPercent` | number | No | — | Keep strikes within N% of the underlying price |
| `minVolume` / `minOpenInterest` | integer | No | — | Liquidity floors |
| `minImpliedVolatility` / `maxImpliedVolatility` | number | No | — | Decimal IV bounds. Contracts without IV are dropped |
| `minDaysToExpiration` / `maxDaysToExpiration` | integer | No | — | DTE window. With a count, picks the nearest expirations inside the window |
| `atmEpsilonPercent` | number | No | 1.5 | Strike distance from spot that counts as ATM, in %. Minimum 0.1 |
| `unusualVolumeOiRatio` | number | No | 5 | Unusual mode: minimum volume / open interest |
| `unusualPremiumUsd` | integer | No | 50000 | Unusual mode: minimum premium traded |
| `maxItems` | integer | No | 1000 | Rows for the whole run, max 25,000, shared round-robin across tickers |
| `sortBy` | string | No | `yahooOrder` | `strikeAsc`, `strikeDesc`, `volumeDesc`, `openInterestDesc`, `impliedVolatilityDesc`, `impliedVolatilityAsc`, `premiumDesc`, `lastTradeNewest`, `nearestStrike`, `moneynessAsc` |
| `concurrency` | integer | No | 4 | Parallel requests over one session, max 8 |
| `maxRetries` | integer | No | 3 | Retries per request, max 5 |
| `requestDelayMs` | integer | No | 0 | Wait before each request |
| `proxyConfiguration` | object | No | none | Optional. The scraper moves to Apify Proxy on its own if Yahoo refuses requests |

Unknown input fields are rejected: a misspelled key such as `maxItem` fails the run with the list of valid fields instead of being silently ignored.

**Quick start**: full chains for three tickers.

```json
{
    "tickers": ["AAPL", "SPY", "NVDA"],
    "optionsExpirations": 4,
    "maxItems": 2000
}
```

**Near-the-money contracts about a month out**, most traded first.

```json
{
    "tickers": ["TSLA"],
    "minDaysToExpiration": 20,
    "maxDaysToExpiration": 45,
    "optionsExpirations": 2,
    "strikeWindowPercent": 10,
    "minVolume": 100,
    "sortBy": "volumeDesc"
}
```

**Unusual options activity scan**

```json
{
    "tickers": ["SPY", "QQQ", "TSLA", "NVDA", "AMD", "AAPL"],
    "mode": "unusual",
    "optionsExpirations": 6,
    "maxItems": 200
}
```

### Output example

A contract row (AAPL, October 2026, market closed):

```json
{
    "rowType": "contract",
    "ticker": "AAPL",
    "contractSymbol": "AAPL261019C00332500",
    "type": "call",
    "strike": 332.5,
    "expiration": "2026-10-19",
    "expirationTimestamp": 1792368000,
    "daysToExpiration": 8,
    "lastPrice": 6.3,
    "bid": 4.65,
    "ask": 5.7,
    "mid": 5.175,
    "spread": 1.05,
    "spreadPercent": 20.29,
    "change": -2.1,
    "percentChange": -25.0,
    "lastTradeDate": "2026-10-09T13:30:44Z",
    "impliedVolatility": 0.153329,
    "delta": 0.717068,
    "gamma": 0.042637,
    "theta": -0.179677,
    "vega": 0.175024,
    "rho": 0.055647,
    "theoreticalPrice": 5.8451,
    "volume": 3,
    "openInterest": null,
    "volumeOpenInterestRatio": null,
    "premiumTradedUsd": 1890.0,
    "inTheMoney": true,
    "moneyness": "ATM",
    "moneynessPercent": 1.2298,
    "contractSize": "REGULAR",
    "unusualScore": null,
    "underlyingSymbol": "AAPL",
    "underlyingName": "Apple Inc.",
    "underlyingPrice": 336.64,
    "underlyingChange": -3.78,
    "underlyingChangePercent": -1.1104,
    "marketState": "CLOSED",
    "currency": "USD",
    "marketCap": 4912984883200,
    "trailingPE": 38.6055,
    "forwardPE": 35.1117,
    "fiftyTwoWeekLow": 243.42,
    "fiftyTwoWeekHigh": 345.34,
    "earningsDate": "2026-11-02T20:00:00Z",
    "dividendYield": 0.0032,
    "riskFreeRate": 0.04057,
    "scrapedAt": "2026-10-11T05:03:06.845Z"
}
```

A summary row (AAPL, 12 expirations; the underlying fields repeat as in contract rows and are trimmed here):

```json
{
    "rowType": "summary",
    "ticker": "AAPL",
    "expirationsAvailable": 23,
    "contractsCount": 1137,
    "totalVolume": 734634,
    "callVolume": 436903,
    "putVolume": 297731,
    "totalOpenInterest": 3213116,
    "putCallVolumeRatio": 0.6815,
    "putCallOpenInterestRatio": 0.7178,
    "avgCallIV": 0.653764,
    "avgPutIV": 0.629438,
    "iv30d": 0.27108,
    "ivSkew30d": -0.028351,
    "atmCallIV30d": 0.285255,
    "atmPutIV30d": 0.256904,
    "atmStrike30d": 335.0,
    "expiration30d": "2026-11-13",
    "daysToExpiration30d": 33,
    "premiumTradedUsd": 270022369.0,
    "netPremiumFlowUsd": 152948329.0,
    "mostActiveContract": "AAPL261012C00340000",
    "mostActiveContractVolume": 34369,
    "maxPainStrike": 337.5,
    "maxPainWeighting": "openInterest",
    "maxPainExpiration": "2026-10-12",
    "sentiment": "bullish",
    "underlyingPrice": 336.64,
    "marketState": "CLOSED"
}
```

### Modes

**Chain** (default): one row per contract, calls and puts, across every selected expiration.

**Summary**: one row per ticker, aggregated over the contracts that pass your filters:

- `putCallVolumeRatio` and `putCallOpenInterestRatio`: put total divided by call total.
- `avgCallIV` / `avgPutIV`: simple average over contracts with a usable IV. Far-from-the-money wings pull it up, so use `iv30d` for a headline number.
- `iv30d`, `ivSkew30d`, `atmCallIV30d`, `atmPutIV30d`: ATM IV for the fetched expiration closest to 30 days, only if it is within 20 to 40 days. Otherwise these fields are `null`. `daysToExpiration30d` shows the actual DTE. `atmStrike30d` is the strike nearest spot, `iv30d` averages its call and put IV, and `ivSkew30d` is put IV minus call IV.
- `netPremiumFlowUsd`: call premium traded minus put premium traded.
- `maxPainStrike`: the strike where option holders' total payout at expiry is lowest, weighted by open interest (or by volume if the chain has no open interest; `maxPainWeighting` says which). It always uses the full, unfiltered nearest expiration (`maxPainExpiration`), so a filter can't leave too few contracts for a meaningful number.
- `sentiment`: a vote of three signals. Each put/call ratio votes bearish above 1.2 and bullish below 0.8. Net premium flow counts only when a ratio points the same way, because premium flow alone is a weak signal. More bullish votes = `bullish`, more bearish = `bearish`, a tie = `mixed`, no directional signal = `neutral`.

**Unusual**: contracts with volume at least `unusualVolumeOiRatio` times open interest and at least `unusualPremiumUsd` in premium traded. A contract with no open interest yet qualifies on volume alone. Rows are ranked by `unusualScore = 0.4 × log10(volume / open interest) + 0.6 × log10(premium traded)`, then by premium, within each ticker, and tickers are interleaved.

### How it works

1. The scraper opens one Yahoo Finance session (cookie and crumb handshake) and reuses it for every request. With `includeGreeks` on, it reads the ^IRX 13-week Treasury bill yield once for the risk-free rate.
2. For each ticker, the first request returns the nearest expiration and the list of all expirations. Each additional expiration is one more request. For example, the quick start (3 tickers, 4 expirations) used 15 requests in total.
3. Greeks use Black-Scholes-Merton with the ticker's dividend yield as a continuous yield, and time to expiry measured to 4:00 pm New York time on the expiration day. The implementation is tested against textbook values (Hull) and put-call parity.
4. Filters are applied, rows are sorted per ticker, and `maxItems` is shared round-robin across tickers, so with 3 tickers and `maxItems: 50` you get 17, 17, and 16 rows.
5. If Yahoo returns errors or rate limits, the scraper renews the session and, after repeated failures, switches to Apify Proxy (datacenter, then residential).
6. A ticker that fails after retries fails the run (rows already collected are still saved). Tickers with no options on Yahoo, such as crypto or FX pairs, are skipped with a warning. If nothing is saved, the run fails with the reason.

### Data quality notes

These numbers come from our own sample of 4,059 contracts (AAPL, SPY, NVDA, TSLA, AMD, KO, nearest 6 expirations), taken on Sunday, October 11, 2026, with US markets closed.

- **Missing IV**: 190 contracts (4.7%) had an implied volatility below 1%. All of these were Yahoo's near-zero placeholder (about 0.00001). The scraper treats IV below 1% as missing: `impliedVolatility` and all Greeks are `null` for those contracts.
- **Very high IVs on the wings**: the median IV was 51.9%, and 23% of contracts had IV above 100% (the maximum was about 1,890%). In the quick-start sample, contracts above 100% IV were a median 45.5% away from the underlying price, and none were at the money. Far-from-the-money contracts close to expiry carry these extreme values, so filter with `strikeWindowPercent` or `maxImpliedVolatility` if they skew your analysis.
- **Market closed**: with markets closed, at-the-money IVs for the nearest expirations were low (median 10.4% for AAPL, SPY, and NVDA). Quotes and IVs reflect Yahoo's last published values, so for analysis that depends on IV, run during US market hours and check `marketState` on each row.
- **Greeks inherit the IV**: they are model output, only as good as Yahoo's IV. On contracts expiring today or tomorrow, Greeks move fast and mean little.
- **Premium traded is an estimate**: `premiumTradedUsd = lastPrice × volume × 100`. A stale last price can overstate it, so `volumeOpenInterestRatio` is often the more reliable activity signal.

### How much does it cost to scrape Yahoo Finance options?

Yahoo Options Scraper uses pay-per-event pricing. You pay per row saved to the dataset: one contract in chain or unusual mode, one ticker in summary mode. Compute and proxy costs are included in the price, so there are no extra platform usage charges.

| Event | Free plan | Bronze | Silver | Gold |
|-------|-----------|--------|--------|------|
| `row-scraped`: per row saved | $0.00109 | $0.00099 | $0.00089 | $0.00089 |
| Per 1,000 rows | **$1.09** | **$0.99** | **$0.89** | **$0.89** |

For example, a full 4-expiration chain for AAPL and SPY (1,215 contracts in our test) costs about $1.32 on the Free plan, while a summary of 50 tickers costs about $0.05. Use `maxItems`, filters, or a [spending limit](https://docs.apify.com/platform/actors/running/usage-and-resources) to cap a run; the scraper never saves more rows than the limit allows. Apify's Free plan includes monthly platform credits you can use to try the scraper.

### Use Yahoo Options Scraper with the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/yahoo-options-scraper").call(run_input={
    "tickers": ["AAPL", "MSFT", "NVDA"],
    "mode": "summary",
    "optionsExpirations": 12,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["ticker"], row["putCallVolumeRatio"], row["iv30d"], row["maxPainStrike"], row["sentiment"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/yahoo-options-scraper').call({
    tickers: ['SPY'],
    optionsExpirations: 3,
    moneyness: 'atTheMoney',
    sortBy: 'volumeDesc',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const c of items) console.log(c.contractSymbol, c.bid, c.ask, c.impliedVolatility, c.delta);
```

See the [API tab](https://apify.com/parsebird/yahoo-options-scraper/api) for all endpoints and the [Apify API client docs](https://docs.apify.com/api/client/python) for more options.

### Is it legal to scrape Yahoo Finance options data?

Yahoo Options Scraper only reads option quotes that Yahoo Finance shows publicly to logged-out visitors. It does not log in or access paid data. Market data belongs to Yahoo and its data providers, so check [Yahoo's terms](https://legal.yahoo.com/us/en/yahoo/terms/otos/index.html) before redistributing it, and make sure your use complies with the laws and exchange rules that apply to you. Consult a lawyer if in doubt. Read more in Apify's post [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) This data is for research and information, not investment advice.

### Other finance scrapers

- [Yahoo Finance Scraper](https://apify.com/parsebird/yahoo-finance-scraper): quotes, historical prices, fundamentals, analyst ratings, news, and screeners.
- [Stocktwits Sentiment Scraper](https://apify.com/parsebird/stocktwits-sentiment-scraper): trending tickers and bullish or bearish chatter.
- [SEC Insider Scraper](https://apify.com/parsebird/sec-insider-scraper): SEC Form 4 insider buys and sells.
- [Congress Stock Trades & Financial Disclosures](https://apify.com/parsebird/congress-stock-trades-scraper): U.S. Congress members' stock trades.
- [PR Newswire Scraper](https://apify.com/parsebird/pr-newswire-scraper): earnings and corporate press releases with tickers.
- [Polymarket Market Scraper](https://apify.com/parsebird/polymarket-market-scraper): prediction market prices and volumes.

### FAQ

**Which tickers have options data?**
US-listed stocks and ETFs with listed options, and indexes such as `^SPX`, `^NDX`, `^RUT`, and `^VIX`. In our tests, Yahoo listed no options for `^GSPC` (use `^SPX`), futures (`ES=F`), crypto (`BTC-USD`), FX pairs (`EURUSD=X`), or non-US listings such as `SHOP.TO` and `VOD.L`. Those tickers are skipped with a warning.

**How many expirations can I get?**
Up to 60 per ticker, which covers every listed expiration in our tests (^SPX had the most: 53). Use `optionsExpirations` for the nearest N, `expirationDates` for exact dates, or `expirationFrom` / `expirationTo` for a range. If an exact date doesn't exist, the run log lists the available dates.

**Why is `mid` null when bid and ask are 0?**
Yahoo shows 0 when there is no two-sided quote, which is common outside market hours. A mid price or spread built from that would be a false claim about the market, so `mid`, `spread`, and `spreadPercent` are `null` unless both bid and ask are above 0.

**How is moneyness calculated?**
`moneyness` is `ATM` when the strike is within `atmEpsilonPercent` (default 1.5%) of the underlying price, otherwise `ITM` or `OTM`. `moneynessPercent` is how far the contract is in the money, as a percent of the underlying price (positive = in the money, negative = out of the money). `inTheMoney` is Yahoo's own flag.

**Is the data real time?**
Quotes are what Yahoo Finance publishes, which can be delayed. Yahoo Options Scraper takes a snapshot when it runs. There is no historical options data; schedule runs to build your own history.

**Is the contract multiplier always 100?**
`premiumTradedUsd` assumes 100, the standard for US equity options. Adjusted contracts (after splits or mergers) can differ, and `contractSize` shows what Yahoo reports.

**Something isn't working or I need a field?**
Open an issue in the [Issues tab](https://apify.com/parsebird/yahoo-options-scraper/issues) and tell us what you need.

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/yahoo-options-scraper/changelog.md

# Actor input Schema

## `tickers` (type: `array`):

Enter stock, ETF, or index symbols, one per line, e.g. <code>AAPL</code>, <code>SPY</code>, <code>^SPX</code>. Share classes like <code>BRK.B</code> are converted to Yahoo's <code>BRK-B</code>. Up to 50 per run. Only symbols with US-listed options on Yahoo Finance return data.

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

<b>Chain</b>: one row per option contract. <b>Summary</b>: one row per ticker with volume, open interest, put/call ratios, average IV, 30-day ATM IV, premium flow, max pain, and a sentiment label. <b>Unusual</b>: only contracts with unusual volume and premium, ranked by score.

## `contractTypes` (type: `array`):

Choose calls, puts, or both.

## `optionsExpirations` (type: `integer`):

How many of the nearest expiration dates to fetch per ticker. The nearest expiration is often 0 to 2 days away, where Greeks mean little; 4 to 12 usually reaches a month out. Each extra expiration is one more request.

## `expirationDates` (type: `array`):

Fetch these expiration dates (YYYY-MM-DD), e.g. <code>2026-11-20</code>. Takes priority over the range and the number of expirations.

## `expirationFrom` (type: `string`):

Fetch every expiration on or after this date. Takes priority over the number of expirations.

## `expirationTo` (type: `string`):

Fetch every expiration on or before this date.

## `includeGreeks` (type: `boolean`):

Add delta, gamma, theta, vega, rho, and a theoretical price, calculated with Black-Scholes-Merton from Yahoo's implied volatility.

## `riskFreeRate` (type: `number`):

Rate for the Greeks as a decimal, e.g. <code>0.043</code>. Leave empty to use the 13-week US Treasury bill yield (^IRX) from Yahoo Finance.

## `moneyness` (type: `string`):

Keep only in-the-money, out-of-the-money, or at-the-money contracts. At the money means a strike within the ATM tolerance of the underlying price.

## `minStrike` (type: `number`):

Keep strikes at or above this price.

## `maxStrike` (type: `number`):

Keep strikes at or below this price.

## `strikeWindowPercent` (type: `number`):

Keep strikes within this many percent of the underlying price, e.g. <code>10</code>.

## `minVolume` (type: `integer`):

Keep contracts that traded at least this many times today.

## `minOpenInterest` (type: `integer`):

Keep contracts with at least this much open interest.

## `minImpliedVolatility` (type: `number`):

Decimal, e.g. <code>0.3</code> for 30%. Contracts without IV are dropped.

## `maxImpliedVolatility` (type: `number`):

Decimal, e.g. <code>1.5</code> for 150%. Contracts without IV are dropped.

## `minDaysToExpiration` (type: `integer`):

Keep expirations at least this many calendar days away. Without exact dates or a range, the nearest expirations inside this window are fetched.

## `maxDaysToExpiration` (type: `integer`):

Keep expirations at most this many calendar days away.

## `atmEpsilonPercent` (type: `number`):

How close the strike must be to the underlying price to count as at the money, in percent. Minimum 0.1.

## `unusualVolumeOiRatio` (type: `number`):

Unusual mode flags contracts whose volume is at least this many times open interest. Contracts with no open interest yet qualify on volume alone.

## `unusualPremiumUsd` (type: `integer`):

Unusual mode also requires at least this much estimated premium traded (last price x volume x 100).

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

Maximum rows for the whole run. With several tickers, rows are shared round-robin so one ticker can't use up the limit.

## `sortBy` (type: `string`):

Order of contract rows within each ticker (chain mode). Unusual mode always ranks by score.

## `concurrency` (type: `integer`):

Tickers and requests fetched in parallel over one session.

## `maxRetries` (type: `integer`):

Retries per request before a ticker fails.

## `requestDelayMs` (type: `integer`):

Wait this long before each request.

## `proxyConfiguration` (type: `object`):

Optional. The Actor switches to Apify Proxy by itself if Yahoo Finance refuses direct requests.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "SPY"
  ],
  "mode": "chain",
  "contractTypes": [
    "calls",
    "puts"
  ],
  "optionsExpirations": 4,
  "includeGreeks": true,
  "moneyness": "all",
  "atmEpsilonPercent": 1.5,
  "unusualVolumeOiRatio": 5,
  "unusualPremiumUsd": 50000,
  "maxItems": 1000,
  "sortBy": "yahooOrder",
  "concurrency": 4,
  "maxRetries": 3,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "tickers": [
        "AAPL",
        "SPY"
    ],
    "optionsExpirations": 4,
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/yahoo-options-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 = {
    "tickers": [
        "AAPL",
        "SPY",
    ],
    "optionsExpirations": 4,
    "maxItems": 1000,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/yahoo-options-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 '{
  "tickers": [
    "AAPL",
    "SPY"
  ],
  "optionsExpirations": 4,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parsebird/yahoo-options-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/yahoo-options-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/AbePpyqyckSjYpgIh/builds/en2dDfpTet6PstSNP/openapi.json
