# Nasdaq Market Data Scraper (`kibaale/nasdaq-market-data-scraper`) Actor

Scrapes Nasdaq market data: all US stocks, per-symbol bundles (quote, dividends, historical prices, holdings, insider trades), earnings calendar and news. Clean JSON via Nasdaq's own API, no browser, no login, no proxy.

- **URL**: https://apify.com/kibaale/nasdaq-market-data-scraper.md
- **Developed by:** [kibalee](https://apify.com/kibaale) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

## Nasdaq Market Data Scraper

Clean, structured records from Nasdaq — no browser, no login, no API key.
Pick tickers, the whole market, an earnings window or a news topic and get
one JSON record per stock, symbol, earnings event or article, ready for
analysis, monitoring or AI pipelines.

Four modes are supported:

- **Whole market snapshot** — every US-listed stock in a single run: price,
  change, market cap, country, IPO year, volume, sector and industry.
- **Per-symbol bundle** — quote info and summary for each ticker, plus the
  sections you turn on: dividend history, historical prices, institutional
  holdings and insider trades.
- **Earnings calendar** — every earnings event for one or more days.
- **News** — the latest articles matching a keyword.

### What you get

- **One record per stock** — the full screener row for ~7,000 US-listed
  stocks, fetched from Nasdaq's own API in a single request
- **One record per symbol** — quote info (`companyName`, `exchange`,
  `stockType`) and a summary of sector, industry, market cap, P/E, EPS,
  52-week range and more
- **Dividend history** — ex-dividend date, yield, payout ratio and the full
  dividend history table per symbol (on by default)
- **Historical prices** — daily OHLCV rows for any date range (optional)
- **Institutional holdings** — ownership percentage, shares outstanding,
  total value and the top funds with their market value (optional)
- **Insider trades** — open-market buy/sell counts over 3 and 12 months and
  the transaction table (optional)
- **Earnings events** — date, time, company, market cap, fiscal quarter,
  consensus EPS forecast and report date
- **News articles** — title, publisher, image and creation time
- **Always fresh** — data is fetched live on every run

#### A note on data availability

Values come from Nasdaq's own API in display format (`$333.63`, `2.092%`,
`4,829,159,340.00`) — they are strings, not numbers; parse them in your
pipeline when you need numeric values. Analyst ratings are not offered
because Nasdaq no longer exposes that endpoint. Fields stay empty when the
source is empty — nothing is invented.

### Quick start

Input:

```json
{
  "symbols": ["AAPL", "MSFT"],
  "includeDividends": true,
  "includeHistorical": true,
  "historicalStartDate": "2026-09-01",
  "includeHoldings": true,
  "includeInsider": true
}
```

Every symbol becomes one record with the sections you enabled.

### Example records

#### A symbol bundle

Real output for MSFT (history and positions trimmed):

```json
{
  "type": "symbol",
  "symbol": "MSFT",
  "companyName": "Microsoft Corporation Common Stock",
  "stockType": "Common Stock",
  "exchange": "NASDAQ-GS",
  "isNasdaqListed": true,
  "summary": {
    "Exchange": "NASDAQ-GS",
    "Sector": "Technology",
    "Industry": "Computer Software: Prepackaged Software",
    "MarketCap": "$3,928,088,000,000",
    "OneYrTarget": "$573.00",
    "P/E Ratio": "52.74"
  },
  "dividends": {
    "header": {"Ex-Dividend Date": "08/20/2026", "Dividend Yield": "0.53%", "Annual Dividend": "$3.32"},
    "exDividendDate": "08/20/2026",
    "yield": "0.53%",
    "payoutRatio": "24.71",
    "history": [{"exOrEffDate": "08/20/2026", "type": "Cash", "amount": "$0.83", "declarationDate": "06/17/2026", "recordDate": "08/20/2026", "paymentDate": "09/10/2026"}]
  },
  "historical": [
    {"date": "10/06/2026", "close": "$529.30", "volume": "21,107,460", "open": "$531.68", "high": "$535.69", "low": "$528.78"}
  ],
  "institutionalHoldings": {
    "summary": {"Institutional Ownership": "84.33%", "Total Shares Outstanding (millions)": "7,426", "Total Value of Holdings (millions)": "$3,314,427"},
    "positions": [{"owner": "VANGUARD GROUP INC", "sharesHeld": "696,681,290", "marketValue": "$368,644", "lastDate": "06/30/2026"}]
  },
  "insiderTrades": {
    "counts": [{"insiderTrade": "Number of Open Market Buys", "months3": "14", "months12": "28"}],
    "transactions": [
      {"insider": "COLEMAN AMY", "relation": "Officer", "lastDate": "9/15/2026", "transactionType": "Disposition (Non Open Market)", "ownType": "Direct", "sharesTraded": "36", "lastPrice": "$505.41", "sharesHeld": "44,451"}
    ]
  },
  "url": "https://www.nasdaq.com/market-activity/stocks/msft"
}
```

#### A screener row

```json
{
  "type": "stock",
  "symbol": "A",
  "name": "Agilent Technologies Inc. Common Stock",
  "lastsale": "$171.29",
  "netchange": "3.51",
  "pctchange": "2.092%",
  "marketCap": "48291593402.00",
  "country": "United States",
  "ipoyear": "1999",
  "volume": "1768934",
  "sector": "Industrials",
  "industry": "Biotechnology: Laboratory Analytical Instruments",
  "url": "https://www.nasdaq.com/market-activity/stocks/a"
}
```

### Input fields

| Field | Description |
|---|---|
| `symbols` | Tickers for the per-symbol bundle, one per line |
| `screenerLimit` | Set above 0 for the whole-market snapshot; caps how many stock records you take (the API returns the full list in one request) |
| `exchange` | Optional screener filter, e.g. `NYSE`, `NASDAQ`, `AMEX` |
| `earningsStartDate` / `earningsDays` | Earnings calendar window (up to 30 days) |
| `newsQuery` / `newsLimit` | News keyword and max articles |
| `includeDividends` | Dividend history and payout summary (on by default) |
| `includeHistorical` / `historicalStartDate` / `historicalEndDate` | Daily OHLCV for the range (end defaults to today, start to 30 days before) |
| `includeHoldings` | Institutional ownership summary and top positions |
| `includeInsider` | Insider buy/sell counts and transactions |

### Record fields

| Field | Meaning |
|---|---|
| `type` | `stock` (screener), `symbol` (bundle), `earnings` or `news` |
| `symbol` / `name` / `companyName` | Ticker and company name |
| `lastsale` / `netchange` / `pctchange` | Price and change (screener rows) |
| `marketCap` / `volume` / `sector` / `industry` / `country` / `ipoyear` | Market context (screener rows) |
| `exchange` / `stockType` / `isNasdaqListed` | Listing details (symbol records) |
| `summary` | Sector, industry, market cap, P/E, EPS, 52-week range and more, keyed by label |
| `dividends` | `header` (ex-date, yield, payout), `exDividendDate`, `dividendPaymentDate`, `yield`, `annualizedDividend`, `payoutRatio`, `history` |
| `historical` | Daily rows: `date`, `close`, `volume`, `open`, `high`, `low` |
| `institutionalHoldings` | `summary` (ownership %, shares outstanding, total value) and `positions` |
| `insiderTrades` | `counts` (buys/sells, 3 and 12 months), `sharesCounts`, `transactions`, `filers` |
| `earnings` fields | `date`, `time`, `symbol`, `name`, `marketCap`, `fiscalQuarterEnd`, EPS forecast, `numEsts`, `reportDate` |
| `news` fields | `query`, `title`, `image`, `created`, `publisher`, `url` |
| `url` | The Nasdaq page for the stock or article |

### Notes

- Values are display strings as published by Nasdaq (`$333.63`, `2.092%`) —
  convert them in your pipeline when you need numbers.
- Runs are throttled with a small delay between requests and parallel
  workers; a 500-stock snapshot takes a few seconds.
- This actor performs no login, keeps no session and bypasses nothing — it
  reads Nasdaq's own public JSON API.

### How much does it cost you?

One dataset item per record: each screener stock, symbol bundle, earnings
event or news article is one item. You pay per item only when a run actually
finishes — failed runs cost nothing.

### FAQ

**Which exchanges does the screener cover?** All US-listed stocks by
default; use `exchange` to narrow it to `NYSE`, `NASDAQ` or `AMEX`.

**Can I get the whole market in one run?** Yes — Nasdaq's API returns the
full list (~7,000 stocks) in a single request, so a full snapshot is one
API call plus one dataset item per record.

**Why are values strings?** Nasdaq publishes display strings (`$333.63`,
`2.092%`), and this actor passes them through unchanged rather than guessing
formats. Parse them in your pipeline.

**Do you offer analyst ratings?** No — Nasdaq no longer exposes that
endpoint publicly.

**What happens if a section fails for one symbol?** The symbol record is
still returned with the sections that succeeded; the failed section is
simply absent.

# Actor input Schema

## `symbols` (type: `array`):

Tickers for the per-symbol bundle, one per line, e.g. AAPL. Each record carries quote info, summary and — depending on the options below — dividend history, historical prices, institutional holdings and insider trades.

## `screenerLimit` (type: `integer`):

Set above 0 to snapshot the whole US market: every listed stock with price, change, market cap, country, IPO year, volume, sector and industry. Nasdaq's own API returns the full list in one request; this only caps how many records you take. Optional exchange filter below.

## `exchange` (type: `string`):

Optional exchange filter for the screener, e.g. NYSE, NASDAQ or AMEX. Leave empty for all US-listed stocks.

## `earningsStartDate` (type: `string`):

YYYY-MM-DD. Fetches the Nasdaq earnings calendar for this date and the following days (Earnings days). One record per earnings event.

## `earningsDays` (type: `integer`):

How many days of the earnings calendar to fetch, starting at the start date.

## `newsQuery` (type: `string`):

Keyword to fetch Nasdaq news articles for, e.g. markets, earnings, technology. Leave empty to skip news.

## `newsLimit` (type: `integer`):

Upper bound for news records.

## `includeDividends` (type: `boolean`):

Add the full dividend history and payout summary to each symbol record.

## `includeHistorical` (type: `boolean`):

Add daily OHLCV rows for the date range below to each symbol record.

## `historicalStartDate` (type: `string`):

YYYY-MM-DD. Defaults to 30 days before the end date.

## `historicalEndDate` (type: `string`):

YYYY-MM-DD. Defaults to today.

## `includeHoldings` (type: `boolean`):

Add institutional ownership summary and top positions to each symbol record.

## `includeInsider` (type: `boolean`):

Add insider buy/sell counts and the transaction tables to each symbol record.

## Actor input object example

```json
{
  "symbols": [
    "AAPL"
  ],
  "screenerLimit": 0,
  "earningsDays": 1,
  "newsLimit": 20,
  "includeDividends": true,
  "includeHistorical": false,
  "includeHoldings": false,
  "includeInsider": false
}
```

# Actor output Schema

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

Records stored in the run's 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 = {
    "symbols": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kibaale/nasdaq-market-data-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 = { "symbols": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("kibaale/nasdaq-market-data-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 '{
  "symbols": [
    "AAPL"
  ]
}' |
apify call kibaale/nasdaq-market-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kibaale/nasdaq-market-data-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/yXRuKpXvHeSGK3kF7/builds/An03FssNqqJxQoRFm/openapi.json