# Yahoo Finance Scraper: Stock Quotes, Statistics & History (`hyperbach/yahoo-finance-scraper`) Actor

Scrape Yahoo Finance by ticker: price, change, volume, market cap, day and 52-week ranges, P/E, EPS, dividend, margins, analyst targets, company profile and OHLCV price history with adjusted close, 1-minute to monthly bars. Stocks, ETFs, indices, crypto, FX. Misses free.

- **URL**: https://apify.com/hyperbach/yahoo-finance-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 tickers

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 Finance Scraper: Stock Quotes, Statistics & History

**Yahoo Finance data by ticker symbol, logged out: tickers in, one row per symbol out — the quote (price, change, volume, market cap, the day and 52-week ranges, bid and ask, pre- and after-hours), the main statistics (P/E, EPS, dividend, shares, margins, the analysts' target and rating), the company or fund profile, and the price history you ask for (open, high, low, close, adjusted close, volume; dividends and splits) by range or date window, 1-minute to 3-month bars — for stocks, ETFs, funds, indices, crypto, currencies and futures, many tickers in one run.** A ticker Yahoo Finance does not know gets a free row that says so. No login, no API key, no browser, proxies handled for you.

**$0.50 per 1,000 `ticker` rows on the Free plan, $0.425 on Starter.** A run start is $0.0025. The default input returns about 3 rows for about $0.004. A value that names nothing is a free row that says why.

### Why this Yahoo Finance scraper

- **Everything about a ticker in one row.** The quote, about 50 statistics (valuation, dividend, shares, margins, cash and debt, the analysts' target and rating), the profile (sector, industry, website, employees, address, the business summary) and the price history sit in one row, so a watchlist of 100 tickers is 100 rows.
- **Every kind of symbol.** Stocks on any exchange (`AAPL`, `BMW.DE`, `7203.T`), ETFs and mutual funds with their issuer, category, assets and expense ratio, indices (`^GSPC`), crypto (`BTC-USD`) with its supply, currencies (`EURUSD=X`) and futures (`GC=F`). A quote page URL works too.
- **The history you ask for.** A range (`1d` to `10y`, `ytd`) or your own date window, in 1-minute to 3-month bars; `max` reads every bar since the first trade in the interval you pick (11,562 daily bars of AAPL from 1980-12-12 on our test, 2026-10-29), where Yahoo's own `max` falls back to 3-month bars. Daily and longer bars carry the adjusted close; the dividends and splits of the range come with them.
- **Honest runs.** A ticker Yahoo Finance does not know is a free `not_found` row (two exits agreed), a value that is not a ticker a free `invalid` row, a repeated ticker a free `duplicate` row; a symbol is charged once a run. A history range Yahoo cannot serve in the interval (1-minute bars for a year) is refused before the run starts, with Yahoo's limit in the message.
- **Fast and light.** Yahoo Finance's own JSON over plain HTTP, two requests a ticker, about 9 KB on the wire. On our deployed test 100 tickers with a month of daily bars took 17.5 s of reading, 24 s in all (2026-10-29).

### Who it's for

- **Investors and analysts** — a watchlist's quotes, valuations, dividends and analyst targets every day into a sheet or a dashboard, one row per ticker.
- **Quants and data teams** — daily or intraday OHLCV with the adjusted close for backtests and models, by range or exact date window, with the splits and dividends of the range.
- **Research and AI agents** — a company's profile, sector, size and key figures in one typed row, for screening, enrichment or an agent's tool call.

### Quick start

**Three stocks with a month of daily prices**

```json
{
  "tickers": [
    "AAPL",
    "MSFT",
    "TSLA"
  ]
}
```

**Quotes and statistics only, no history**

```json
{
  "tickers": [
    "SPY",
    "^GSPC",
    "BTC-USD",
    "EURUSD=X",
    "GC=F"
  ],
  "historyRange": "none"
}
```

**Every weekly bar since the first trade**

```json
{
  "tickers": [
    "KO"
  ],
  "historyRange": "max",
  "historyInterval": "1wk"
}
```

**Daily prices for a date window**

```json
{
  "tickers": [
    "NVDA",
    "AMD"
  ],
  "startDate": "2025-01-01",
  "endDate": "2025-12-31"
}
```

**Hourly bars of the last 5 days**

```json
{
  "tickers": [
    "TSLA"
  ],
  "historyRange": "5d",
  "historyInterval": "1h"
}
```

### Output

One row per ticker (and one free row per ticker Yahoo Finance does not answer):

| field | meaning |
|---|---|
| `row_type` | `ticker` (one symbol's data, charged) or `input` (the free row of a ticker with no ticker row, with the reason). |
| `input_index` | The 1-based position of the ticker in `tickers`. |
| `input_value` | The ticker or URL as you gave it. |
| `status` | A ticker row: `ok`. An input row: `not_found`, `invalid`, `duplicate`, `failed` or `not_read` (see the FAQ). |
| `status_detail` | Why, in words, when the status is not `ok`. |
| `scraped_at` | When the row was read (ISO 8601, UTC). |
| `symbol` | The symbol as Yahoo Finance writes it (`AAPL`, `BRK-B`, `^GSPC`, `BTC-USD`). |
| `name` | The company's, fund's or instrument's full name. |
| `short_name` | Yahoo's short name. |
| `quote_type` | `EQUITY`, `ETF`, `MUTUALFUND`, `INDEX`, `CRYPTOCURRENCY`, `CURRENCY`, `FUTURE` … |
| `exchange` | The exchange's code (`NMS`, `NYQ`, `GER`, `JPX` …). |
| `exchange_name` | The exchange's name (`NasdaqGS`, `NYSE`, `XETRA` …). |
| `currency` | The currency of the price and the history (ISO code). |
| `market_state` | `PRE`, `REGULAR`, `POST`, `POSTPOST`, `PREPRE` or `CLOSED` when read. |
| `market_time` | When the regular-session price was set (ISO 8601, UTC). |
| `quote_delay_minutes` | How many minutes the exchange's quote is delayed (0 = real time). |
| `timezone` | The exchange's time zone (`America/New_York`). |
| `price` | The last regular-session price. |
| `change` | The change from the previous close, in the currency. |
| `change_percent` | The change from the previous close, in percent (1.5 = +1.5 %). |
| `previous_close` | The previous session's close. |
| `open` | The session's open. |
| `day_low` | The session's low. |
| `day_high` | The session's high. |
| `volume` | The session's volume. |
| `avg_volume_3m` | The average daily volume over 3 months. |
| `avg_volume_10d` | The average daily volume over 10 days. |
| `market_cap` | The market capitalisation, in the currency. |
| `bid` | The bid when read. |
| `ask` | The ask when read. |
| `fifty_two_week_low` | The lowest price of the last 52 weeks. |
| `fifty_two_week_high` | The highest price of the last 52 weeks. |
| `fifty_two_week_change_percent` | The price change over 52 weeks, in percent. |
| `fifty_day_average` | The 50-day moving average. |
| `two_hundred_day_average` | The 200-day moving average. |
| `pre_market_price` | The pre-market price, when Yahoo has one. |
| `pre_market_change_percent` | The pre-market change, in percent. |
| `post_market_price` | The after-hours price, when Yahoo has one. |
| `post_market_change_percent` | The after-hours change, in percent. |
| `pe_trailing` | The price to the last 12 months' earnings. |
| `pe_forward` | The price to the next year's estimated earnings. |
| `eps_trailing` | Earnings per share, last 12 months. |
| `eps_forward` | Estimated earnings per share, next year. |
| `peg_ratio` | The P/E to the expected earnings growth. |
| `price_to_book` | The price to the book value per share. |
| `price_to_sales` | The market cap to the last 12 months' revenue. |
| `book_value` | The book value per share. |
| `beta` | The beta (5 years, monthly). |
| `dividend_rate` | The yearly dividend per share, in the currency. |
| `dividend_yield_percent` | The dividend yield, in percent (a fund's yield for a fund). |
| `ex_dividend_date` | The last or next ex-dividend date (YYYY-MM-DD). |
| `payout_ratio_percent` | The dividends to the earnings, in percent. |
| `shares_outstanding` | The shares outstanding. |
| `float_shares` | The shares in the public float. |
| `enterprise_value` | The enterprise value, in the currency. |
| `enterprise_to_revenue` | The enterprise value to the revenue. |
| `enterprise_to_ebitda` | The enterprise value to the EBITDA. |
| `held_by_insiders_percent` | The shares insiders hold, in percent. |
| `held_by_institutions_percent` | The shares institutions hold, in percent. |
| `short_ratio` | The shares sold short to the average daily volume (days to cover). |
| `total_revenue` | The revenue of the last 12 months, in `financial_currency`. |
| `revenue_growth_percent` | The quarterly revenue growth, year over year, in percent. |
| `earnings_growth_percent` | The quarterly earnings growth, year over year, in percent. |
| `gross_margin_percent` | The gross margin, in percent. |
| `operating_margin_percent` | The operating margin, in percent. |
| `profit_margin_percent` | The net profit margin, in percent. |
| `ebitda` | The EBITDA of the last 12 months, in `financial_currency`. |
| `return_on_equity_percent` | The return on equity, in percent. |
| `total_cash` | Cash and short-term investments, in `financial_currency`. |
| `total_debt` | The total debt, in `financial_currency`. |
| `free_cashflow` | The free cash flow of the last 12 months, in `financial_currency`. |
| `financial_currency` | The currency of the revenue, EBITDA, cash, debt and cash flow. |
| `target_mean_price` | The analysts' mean price target. |
| `target_high_price` | The analysts' highest price target. |
| `target_low_price` | The analysts' lowest price target. |
| `recommendation_key` | The analysts' consensus: `strong_buy`, `buy`, `hold`, `underperform` or `sell`. |
| `recommendation_mean` | The consensus score, 1 (strong buy) to 5 (sell). |
| `analyst_opinions` | How many analysts' opinions the consensus counts. |
| `fund_family` | A fund's or ETF's issuer. |
| `fund_category` | A fund's or ETF's category (`Large Blend` …). |
| `total_assets` | A fund's or ETF's net assets, in the currency. |
| `expense_ratio_percent` | A fund's or ETF's yearly expense ratio, in percent. |
| `ytd_return_percent` | A fund's or ETF's return this year, in percent. |
| `circulating_supply` | A coin's circulating supply. |
| `volume_24h` | A coin's volume over 24 hours. |
| `sector` | The company's sector. |
| `industry` | The company's industry. |
| `website` | The company's or fund's website. |
| `ir_website` | The company's investor-relations website. |
| `employees` | Full-time employees. |
| `business_summary` | Yahoo's description of the company, fund or coin. |
| `address` | The head office's address in one line. |
| `city` | The head office's city. |
| `state` | The head office's state or region. |
| `country` | The head office's country. |
| `phone` | The head office's phone number. |
| `first_trade_date` | The symbol's first trading day on Yahoo (YYYY-MM-DD). |
| `history_range` | The range asked (`1mo`, `max` …); empty for a date window or no history. |
| `history_interval` | The bar interval asked (`1d`, `1wk`, `1h` …); empty with no history. |
| `history_status` | `ok`, `empty` (no bar in the range), `not_asked` (`historyRange` = none), `not_found` (Yahoo has no chart for the symbol), `refused` (Yahoo refused the range for this symbol) or `failed`. |
| `history_detail` | The window read, or why there is no history, in words. |
| `history_count` | How many bars `history` holds. |
| `history_first_date` | The first bar's day (or day and time for intraday bars). |
| `history_last_date` | The last bar's day (or day and time for intraday bars). |
| `history` | One object per bar, oldest first: `date` (the exchange's own day, or day and time for intraday bars), `time` (UTC), `open`, `high`, `low`, `close`, `adj_close` (daily and longer bars), `volume`. |
| `dividends` | The dividends inside the history's range: `date`, `amount`. |
| `splits` | The splits inside the history's range: `date`, `ratio`, `numerator`, `denominator`. |
| `change_type` | With a memory: `new`, `changed` or `unchanged` against the last time this ticker was delivered. |
| `changed_fields` | With a memory: what moved since the last delivery, among `price`, `change`, `change_percent`, `volume`, `market_cap`, `fifty_two_week_low`, `fifty_two_week_high`, `pe_trailing` and `dividend_yield_percent`. |
| `previous` | With a memory: the changed fields' values at the last delivery. |
| `previous_read_at` | With a memory: when the ticker was last delivered. |
| `previous_price` | With a memory: the price at the last delivery. |
| `price_change` | With a memory: this price minus the price at the last delivery (not Yahoo's day change, which is `change`). |
| `price_change_percent` | With a memory: the move since the last delivery in percent of the previous price. |
| `first_read_at` | With a memory: when the memory first read the ticker. |
| `times_read` | With a memory: how many runs of the memory read the ticker. |

Example record:

```json
{
  "row_type": "ticker",
  "input_index": 1,
  "input_value": "AAPL",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-29T12:13:32Z",
  "symbol": "AAPL",
  "name": "Apple Inc.",
  "short_name": "Apple Inc.",
  "quote_type": "EQUITY",
  "exchange": "NMS",
  "exchange_name": "NasdaqGS",
  "currency": "USD",
  "market_state": "PRE",
  "market_time": "2026-10-28T20:00:01Z",
  "quote_delay_minutes": 15,
  "timezone": "America/New_York",
  "price": 343.83,
  "change": -3.27002,
  "change_percent": -0.942097,
  "previous_close": 347.1,
  "open": 346.885,
  "day_low": 343.53,
  "day_high": 347.18,
  "volume": 34405006,
  "avg_volume_3m": 43379289,
  "avg_volume_10d": 41051470,
  "market_cap": 5017916932096,
  "bid": 343.02,
  "ask": 346.97,
  "fifty_two_week_low": 243.42,
  "fifty_two_week_high": 351.73,
  "fifty_two_week_change_percent": 26.68755,
  "fifty_day_average": 331.7326,
  "two_hundred_day_average": 295.6934,
  "pre_market_price": 348.0895,
  "pre_market_change_percent": 1.238845,
  "post_market_price": 345.7836,
  "post_market_change_percent": 0.568192,
  "pe_trailing": 39.430042,
  "pe_forward": 35.956264,
  "eps_trailing": 8.72,
  "eps_forward": 9.56245,
  "peg_ratio": 2.78,
  "price_to_book": 46.71603,
  "price_to_sales": 10.749079,
  "book_value": 7.36,
  "beta": 1.069,
  "dividend_rate": 1.08,
  "dividend_yield_percent": 0.31,
  "ex_dividend_date": "2026-08-10",
  "payout_ratio_percent": 12.04,
  "shares_outstanding": 14594180000,
  "float_shares": 14569078010,
  "enterprise_value": 5039862054912,
  "enterprise_to_revenue": 10.796,
  "enterprise_to_ebitda": 30.007,
  "held_by_insiders_percent": 1.648,
  "held_by_institutions_percent": 66.337997,
  "short_ratio": 3.48,
  "total_revenue": 466822987776,
  "revenue_growth_percent": 16.4,
  "earnings_growth_percent": 28.7,
  "gross_margin_percent": 48.653,
  "operating_margin_percent": 32.623002,
  "profit_margin_percent": 27.618998,
  "ebitda": 167959003136,
  "return_on_equity_percent": 148.75101,
  "total_cash": 62399000576,
  "total_debt": 84343996416,
  "free_cashflow": 107721875456,
  "financial_currency": "USD",
  "target_mean_price": 332.3858,
  "target_high_price": 405.0,
  "target_low_price": 245.0,
  "recommendation_key": "buy",
  "recommendation_mean": 2.25,
  "analyst_opinions": 38,
  "fund_family": null,
  "fund_category": null,
  "total_assets": null,
  "expense_ratio_percent": null,
  "ytd_return_percent": null,
  "circulating_supply": null,
  "volume_24h": null,
  "sector": "Technology",
  "industry": "Consumer Electronics",
  "website": "https://www.apple.com",
  "ir_website": "http://investor.apple.com/",
  "employees": 150000,
  "business_summary": "Apple Inc. designs, manufactures, and markets smartphones, personal computers, tablets, wearables, and accessories worldwide. The company offers iPhone, a line of smartphones; Mac, a line of personal computers; iPad, a line of multi-purpose tablets; and wearables, home, and accessories comprising AirPods, Apple Vision Pro, Apple TV, Apple Watch, Beats products, and HomePod, as well as Apple branded and third-party accessories. It also provides AppleCare support and cloud services; and operates various platforms, including the App Store that allows customers to discover and download applications and digital content, such as books, music, video, games, and podcasts, as well as advertising services include third-party licensing arrangements and its own advertising platforms. In addition, the company offers various subscription-based services, such as Apple Arcade, a game subscription service; Apple Fitness+, a personalized fitness service; Apple Music, which offers users a curated listening experience with on-demand radio stations; Apple News+, a subscription news and magazine service; Apple TV, which offers original content and live sports; Apple Card, a co-branded credit card; and Apple Pay, a cashless payment service, as well as licenses its intellectual property. The company serves consumers, and small and mid-sized businesses; and the education, enterprise, and government markets. It distributes third-party applications for its products through the App Store. The company also sells its products through its retail and online stores, and direct sales force; and third-party cellular network carriers and resellers. The company was formerly known as Apple Computer, Inc. and changed its name to Apple Inc. in January 2007. Apple Inc. was founded in 1976 and is headquartered in Cupertino, California.",
  "address": "One Apple Park Way, Cupertino, CA, 95014, United States",
  "city": "Cupertino",
  "state": "CA",
  "country": "United States",
  "phone": "(408) 996-1010",
  "first_trade_date": "1980-12-12",
  "history_range": "1mo",
  "history_interval": "1d",
  "history_status": "ok",
  "history_detail": null,
  "history_count": 22,
  "history_first_date": "2026-09-29",
  "history_last_date": "2026-10-28",
  "history": [
    {
      "date": "2026-10-26",
      "time": "2026-10-26T13:30:00Z",
      "open": 343.92,
      "high": 347.09,
      "low": 341.03,
      "close": 343.91,
      "adj_close": 343.91,
      "volume": 42743600
    },
    {
      "date": "2026-10-27",
      "time": "2026-10-27T13:30:00Z",
      "open": 343.17,
      "high": 347.78,
      "low": 342.39,
      "close": 347.1,
      "adj_close": 347.1,
      "volume": 39984400
    },
    {
      "date": "2026-10-28",
      "time": "2026-10-28T13:30:00Z",
      "open": 346.92,
      "high": 347.18,
      "low": 343.52,
      "close": 343.83,
      "adj_close": 343.83,
      "volume": 35595700
    }
  ],
  "dividends": [],
  "splits": [],
  "change_type": null,
  "changed_fields": null,
  "previous": null,
  "previous_read_at": null,
  "previous_price": null,
  "price_change": null,
  "price_change_percent": null,
  "first_read_at": null,
  "times_read": null
}
```

### Pricing

**Pay for the ticker rows a run delivers**, plus one run start; no platform usage is billed to you. The row price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Ticker (`ticker`) | per 1,000 | $0.50 | $0.425 | $0.35 | $0.25 |
| Run start (`start`) | per run | $0.0025 | $0.0025 | $0.0025 | $0.0025 |

A ticker row is **$0.50 per 1,000** on the Free plan ($0.0005 a ticker), with its quote, statistics, profile and the history you ask for, short or long. Each run that delivers a charged row also pays the **run start, $0.0025 once**; a run that delivers no charged row pays nothing at all. So 100 tickers cost $0.0525 on the Free plan; many tickers in one run share one start. A ticker Yahoo Finance does not know (`not_found`), a value that is not a ticker (`invalid`), a repeated ticker (`duplicate`), a ticker left at the charge limit or the time limit (`not_read`) and a refusal the run could not pass (`failed`) get a free row and are never charged. A symbol is charged once a run. A run that stops early (a timeout, an abort) is charged for the rows it delivered. `maxItems` counts the charged rows; before the first request the log names the price of each row at your plan and the most the run can cost. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **A schedule** — Save a task with your tickers and `onlyChanged` (and a `stateStoreName` to name the memory), schedule it daily or hourly: the first run delivers every ticker; each later run delivers (and charges) only the tickers whose price, change, volume, market cap, 52-week range, trailing P/E or dividend yield moved since the last delivery, with `change_type`, `changed_fields`, the `previous` values, `previous_price`, `price_change` and `price_change_percent` on the row. A ticker that did not move reads no history, gets no row and costs nothing; the run summary counts them (`unchanged_skipped`). Ready-made: [Yahoo Finance quote monitor: daily, only the tickers that moved](https://apify.com/hyperbach/yahoo-finance-scraper/examples/yahoo-finance-quote-monitor-daily-only-tickers-that-moved).
- **Tickers** — `tickers` takes Yahoo Finance symbols, one per line, written as Yahoo writes them: a share class with a hyphen (`BRK-B`), a non-US listing with its exchange suffix (`BP.L`, `BMW.DE`, `7203.T`), an index with `^`, a currency pair with `=X`, a future with `=F`. A quote page URL (`https://finance.yahoo.com/quote/AAPL/`) works too. Look a symbol up on finance.yahoo.com when unsure.
- **The price history** — `historyRange` = `1mo` with `historyInterval` = `1d` (the defaults) gives about 22 daily bars a ticker. Pick a longer range, `max`, or a `startDate` (and `endDate`) for a window; `historyRange` = `none` skips the history. Yahoo keeps intraday bars for a limited time: `1m` for 30 days (8 days a run), `2m` to `90m` for 60 days, `1h` for 2 years. `history` holds one object per bar, oldest first.
- **What a row is** — `row_type` = `ticker`: one symbol with its quote, statistics, profile and `history`; a field Yahoo does not carry for that symbol (a P/E for an index, a sector for a coin) is empty. `row_type` = `input`: the free row of a ticker with no ticker row, with its `status` and the reason.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `tickers` | `array` |  | Yahoo Finance symbols, one per line: stocks (`AAPL`, `BRK-B`, `BMW.DE`, `7203.T`), ETFs and funds (`SPY`, `VFIAX`), indices (`^GSPC`), crypto (`BTC-USD`), currencies (`EURUSD=X`), futures (`GC=F`), or a quote page URL (`https://finance.yahoo.com/quote/AAPL/`). Write the symbol as Yahoo does: a share class takes a hyphen (`BRK-B`), a non-US listing its exchange suffix (`.L`, `.DE`, `.T`). Up to 5,000 tickers a run; one row each. |
| `historyRange` | `none` / `1d` / `5d` / `1mo` / `3mo` / `6mo` / `1y` / `2y` / `5y` / `10y` / `ytd` / `max` | `"1mo"` | How far back the price history goes, ending now: `1mo` (the default) to `10y`, `ytd`, `max` (every bar since the first trade, in the interval you pick), or `none` for no history (the quote, statistics and profile only). A start date below replaces it. |
| `historyInterval` | `1m` / `2m` / `5m` / `15m` / `30m` / `60m` / `90m` / `1h` / `1d` / `5d` / `1wk` / `1mo` / `3mo` | `"1d"` | One bar per interval: `1d` (daily, the default), `1wk`, `1mo`, `3mo`, or intraday `1m` to `90m` and `1h`. Yahoo keeps intraday bars for a limited time: `1m` for 30 days and 8 days a run, `2m`-`90m` for 60 days, `1h` for 2 years; a range or window they cannot cover is refused before the run starts. Daily and longer bars carry the adjusted close. |
| `startDate` | `string` |  | The first day of a date window (YYYY-MM-DD). Set it to read the history between this day and the end date instead of the range above. |
| `endDate` | `string` |  | The last day of the date window (YYYY-MM-DD), with a start date. Empty: today. |
| `onlyChanged` | `boolean` | `false` | For a schedule: deliver (and charge) a ticker only when its price, change, volume, market cap, 52-week range, trailing P/E or dividend yield changed since the last run of the same memory. Each row then says what changed and the previous values; a market that did not move costs nothing. |
| `stateStoreName` | `string` | `""` | The name of the onlyChanged memory, so several tasks can share one or keep theirs apart. Empty: a name derived from the inputs. |
| `maxItems` | `integer` | `0` | Stop the run after this many ticker rows (0 = no limit). Free rows are not counted; a ticker left at the cap gets a free `not_read` row. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A ticker Yahoo Finance does not know is not an error: it gets one free row with `status` = `not_found` (two exits agreed), and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Does it give financial statements, news, options or holders?**

No. This actor reads the quote, the main statistics, the profile and the price history. Financial statements, news, options chains, holders, insider trades and Yahoo's screeners are other Yahoo Finance pages; tell us on the Issues tab if you need one.

**Why is my ticker `not_found`?**

Yahoo Finance has no quote for that symbol, on two exits. Check the symbol on finance.yahoo.com: a share class takes a hyphen (`BRK-B`, not `BRK.B`), a non-US listing its suffix (`SAP.DE`), and a renamed or delisted company keeps no quote. A `not_found` row is free.

**Which status is which?**

A ticker row's `status` is `ok`. An input row's `status` is `not_found` (Yahoo has no quote for the symbol; two exits agreed), `invalid` (a value that is not a ticker or a Yahoo Finance quote URL), `duplicate` (the same symbol again: read once), `failed` (a refusal or an error; free) or `not_read` (left at `maxItems`, the charge limit or the run's time limit). `history_status` says how the history went on a ticker row.

**Are the prices real time?**

They are what Yahoo Finance shows logged out: real time for most US stocks and crypto, delayed for some exchanges (`quote_delay_minutes` says by how much). `market_time` is when the price was set.

**Does it need a Yahoo account or API key?**

No. Everything is read from Yahoo Finance's public pages, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/yahoo-finance-scraper').call({"tickers": ["AAPL", "MSFT", "TSLA"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/yahoo-finance-scraper').call(run_input={'tickers': ['AAPL', 'MSFT', 'TSLA']})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/yahoo-finance-scraper --input '{"tickers": ["AAPL", "MSFT", "TSLA"]}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~yahoo-finance-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"tickers": ["AAPL", "MSFT", "TSLA"]}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/yahoo-finance-scraper` and ask, for example: "Get the quotes and a month of daily prices of AAPL, MSFT and TSLA from Yahoo Finance". The agent fills the input from the table above and reads the rows from the run's dataset. The input names are the ones in the table above.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/yahoo-finance-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[ChatGPT Scraper](https://apify.com/hyperbach/ai-search-answers)** — what ChatGPT, Gemini, Perplexity and Google's AI Mode and AI Overviews answer for your queries, with every source they cite.
- **[Substack Scraper](https://apify.com/hyperbach/substack-scraper)** — the posts of a Substack newsletter with the full text of free posts, the date, the paywall flag and the likes.
- **[Google News Scraper](https://apify.com/hyperbach/google-news-scraper)** — Google News articles by keyword or topic in 84 regions and languages, with the publisher, the date and the publisher's own article URL.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Yahoo Finance symbols, one per line: stocks (`AAPL`, `BRK-B`, `BMW.DE`, `7203.T`), ETFs and funds (`SPY`, `VFIAX`), indices (`^GSPC`), crypto (`BTC-USD`), currencies (`EURUSD=X`), futures (`GC=F`), or a quote page URL (`https://finance.yahoo.com/quote/AAPL/`). Write the symbol as Yahoo does: a share class takes a hyphen (`BRK-B`), a non-US listing its exchange suffix (`.L`, `.DE`, `.T`). Up to 5,000 tickers a run; one row each.

## `historyRange` (type: `string`):

How far back the price history goes, ending now: `1mo` (the default) to `10y`, `ytd`, `max` (every bar since the first trade, in the interval you pick), or `none` for no history (the quote, statistics and profile only). A start date below replaces it.

## `historyInterval` (type: `string`):

One bar per interval: `1d` (daily, the default), `1wk`, `1mo`, `3mo`, or intraday `1m` to `90m` and `1h`. Yahoo keeps intraday bars for a limited time: `1m` for 30 days and 8 days a run, `2m`-`90m` for 60 days, `1h` for 2 years; a range or window they cannot cover is refused before the run starts. Daily and longer bars carry the adjusted close.

## `startDate` (type: `string`):

The first day of a date window (YYYY-MM-DD). Set it to read the history between this day and the end date instead of the range above.

## `endDate` (type: `string`):

The last day of the date window (YYYY-MM-DD), with a start date. Empty: today.

## `onlyChanged` (type: `boolean`):

For a schedule: deliver (and charge) a ticker only when its price, change, volume, market cap, 52-week range, trailing P/E or dividend yield changed since the last run of the same memory. Each row then says what changed and the previous values; a market that did not move costs nothing.

## `stateStoreName` (type: `string`):

The name of the onlyChanged memory, so several tasks can share one or keep theirs apart. Empty: a name derived from the inputs.

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

Stop the run after this many ticker rows (0 = no limit). Free rows are not counted; a ticker left at the cap gets a free `not_read` row.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "MSFT",
    "TSLA"
  ],
  "historyRange": "1mo",
  "historyInterval": "1d",
  "onlyChanged": false,
  "stateStoreName": "",
  "maxItems": 100
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per ticker (and one free row per ticker Yahoo Finance does not answer):

## `runSummary` (type: `string`):

How the run went: ticker rows charged, free rows, rows by status and by history status, the price bars delivered, the history asked, the source counters (calls, served, refused, exits, crumbs, rotations, bytes) and the memory watch.

# 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",
        "MSFT",
        "TSLA"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/yahoo-finance-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",
        "MSFT",
        "TSLA",
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/yahoo-finance-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",
    "MSFT",
    "TSLA"
  ],
  "maxItems": 100
}' |
apify call hyperbach/yahoo-finance-scraper --silent --output-dataset

```

## MCP server setup

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