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

Extract Yahoo Finance options with no API key: five trend screeners and the full chain for any underlying, with strike, expiry, premium, bid and ask, volume, open interest and implied volatility. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/yahoo-options-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Options data is where the free APIs stop. Yahoo publishes five screeners and a full chain for every underlying it lists, and neither is reachable without a session. This Actor reads both: one record per contract with strike, expiry, premium, bid and ask, volume, open interest and implied volatility, either from a screener or from the whole chain.

### What it does

- Two routes on one input. **Trends** returns the five Yahoo screeners, **chain** returns every listed contract for the underlyings you name.
- Reads all five screeners: **most active, gainers, losers, highest implied volatility and highest open interest**. Pick any combination.
- Returns **one record per contract**, keyed on `contractSymbol`, so calls and puts at every strike and expiry are separate rows.
- Carries **implied volatility as a percent** next to the premium, which is what tells you whether a contract is expensive rather than just moving.
- Reports **volume against open interest**, the pair that separates a new position from an existing one being traded.
- Needs **no API key**. Yahoo exposes no supported options API at all, which is why this reads the public pages.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Find unusual activity | Run the most-active screener and compare `volume` against `openInterest` |
| Screen for expensive premium | Run the highest-implied-volatility screener and read `impliedVolatilityPercent` |
| Price a spread | Pull the chain for one underlying and read `bid` and `ask` at each strike |
| Watch one expiry | Pull the chain and filter on `expirationDate` |
| Track a position | Schedule the chain route and follow one `contractSymbol` over time |
| Feed a trading agent | Call the Actor over MCP and let the model ask for what it needs |

### Quick start

1. Click **Try for free**.
2. Leave **Route** on `trends` for the screeners, or switch it to `chain` for a full chain.
3. For trends, pick the screeners you want: `most-active`, `gainers`, `losers`, `highest-implied-volatility`, `highest-open-interest`.
4. For a chain, add the underlyings in **Tickers**, one per line.
5. Click **Start**. Rows appear within seconds.
6. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `route` | string | `trends` | `trends` reads the screeners, `chain` reads every contract for your tickers |
| `trends` | array | `most-active` | Which screeners to read on the trends route |
| `tickers` | array | `AAPL` | Underlyings to read on the chain route |
| `maxItems` | integer | `0` | Caps how many contracts are returned. `0` returns them all |

```json
{
    "route": "trends",
    "trends": [
        "most-active",
        "highest-implied-volatility"
    ],
    "maxItems": 0
}
```

### Output

One dataset item per contract. A ticker Yahoo lists no options for comes back with `status: "failed"` and a reason, so an empty chain is distinguishable from a bad symbol.

| Field group | Fields |
| --- | --- |
| Contract | `status`, `contractSymbol`, `tickerSymbol`, `contractType`, `strike`, `expirationDate`, `url` |
| Premium | `value`, `changePercent`, `bid`, `ask` |
| Activity | `volume`, `openInterest` |
| Volatility | `impliedVolatilityPercent` |

```json
{
    "status": "ok",
    "contractSymbol": "AAPL261218C00320000",
    "tickerSymbol": "AAPL",
    "contractType": "call",
    "strike": 320.0,
    "expirationDate": "2026-12-18",
    "value": 14.85,
    "changePercent": -6.31,
    "bid": 14.75,
    "ask": 14.95,
    "volume": 18422,
    "openInterest": 41208,
    "impliedVolatilityPercent": 28.4,
    "url": "https://finance.yahoo.com/quote/AAPL261218C00320000"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~yahoo-options-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"route": "trends", "trends": ["most-active", "highest-implied-volatility"], "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/yahoo-options-scraper").call(run_input={"route": "trends", "trends": ["most-active", "highest-implied-volatility"], "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["value"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/yahoo-options-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| A ticker returns `failed` | Yahoo lists no options for it. Index and many foreign listings have no chain. |
| The chain route returns a very large number of rows | That is the whole chain: every strike at every expiry, calls and puts. Set **Max items**, or filter after the run. |
| `impliedVolatilityPercent` is missing | Yahoo publishes no IV for that contract, which happens on very thin strikes. |
| `volume` is 0 but `openInterest` is high | Nothing traded today and the position is held from earlier. That contrast is the useful signal. |
| Premiums look stale | Options quotes go stale fast outside market hours. Read the run time and treat an out-of-hours pull as the last print. |

### FAQ

#### Does Yahoo Finance have an options API?

No. Yahoo publishes no supported API for options at all, and the internal endpoints need a session. This Actor reads the public screener and chain pages.

#### What is the difference between the two routes?

`trends` gives you Yahoo's own five screeners, which is where you look when you do not know what to look at. `chain` gives you every contract for an underlying you name, which is what you want when you already do.

#### How do I find unusual options activity?

Run the most-active screener and compare `volume` against `openInterest`. Volume far above open interest means new positions rather than existing ones changing hands.

#### Does it return historical options data?

No. Each record is the current quote for that contract. To build a series, schedule the chain route and let the dataset accumulate.

#### Are the Greeks included?

No. Yahoo publishes implied volatility but not delta, gamma, theta or vega, so neither does this Actor. Computing them from strike, expiry, premium and the underlying is your call, and the fields you need for it are all here.

#### Do I need a Yahoo Finance API key?

No. You need an Apify token to call the Actor over the API. No Yahoo Finance credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

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

This Actor reads public Yahoo Finance data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

### Changelog

- **0.0.1** First release. Trend screeners and full chains.

### Feedback

Found a field Yahoo Finance publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

## `route` (type: `string`):

Trend screeners return the contracts Yahoo ranks in each category. Chain returns every contract Yahoo lists for an underlying, calls and puts, and is the only route that carries implied volatility.

## `trends` (type: `array`):

Which screeners to read on the Trends route. Each returns the 25 contracts Yahoo ranks in that category.

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

Underlying symbols, or Yahoo quote URLs. One per line. Only used on the Chain route.

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

Stop after this many charged contracts. 0 means no cap.

## Actor input object example

```json
{
  "route": "trends",
  "trends": [
    "most-active"
  ],
  "tickers": [
    "AAPL",
    "TSLA"
  ],
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

One item per requested input, in the default 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 = {
    "route": "trends",
    "trends": [
        "most-active"
    ],
    "tickers": [
        "AAPL",
        "TSLA"
    ],
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/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 = {
    "route": "trends",
    "trends": ["most-active"],
    "tickers": [
        "AAPL",
        "TSLA",
    ],
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/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 '{
  "route": "trends",
  "trends": [
    "most-active"
  ],
  "tickers": [
    "AAPL",
    "TSLA"
  ],
  "maxItems": 0
}' |
apify call publicmoney/yahoo-options-scraper --silent --output-dataset

```

## MCP server setup

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