# Nasdaq Scraper (`publicmoney/nasdaq-scraper`) Actor

Extract Nasdaq quotes for stocks, ETFs, indices and mutual funds: last sale, net and percent change, bid and ask, volume, day and 52-week range, and the live market status. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/nasdaq-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 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

Nasdaq is the listing venue itself, so its quote page is the primary record rather than a redistribution, but there is no public API for it. This Actor reads the Nasdaq quote page and returns one structured record per symbol: last sale, net and percent change, bid and ask, volume, day and 52-week range, the listing details, and whether the market was open, closed or in extended hours when the price was read.

### What it does

- Returns **one record per requested symbol**, in order. A symbol Nasdaq does not list comes back with `status: "failed"` and a reason.
- Reports the **live market status** on each record, so you know whether a price is a regular-session print, a pre-market or after-hours quote, or the previous close.
- Says where the day range came from in `dayRangeSource`, because Nasdaq publishes it in more than one place and they can disagree.
- Covers **four asset classes**: stocks, ETFs, indices and mutual funds, each selected by the asset class input.
- Reads from the **listing venue itself**, so quotes are the primary record rather than a redistributed feed.
- Has a second mode for **news**, one record per story on the symbol's Nasdaq news page.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Know whether a price is live | Read `marketStatus` before you act on `value` |
| Price a watchlist at the open | Pass your symbols and schedule the run for the bell |
| Cover ETFs and funds in the same pipeline | Set the asset class and reuse the same field names |
| Catch a 52-week breakout | Compare `value` against the 52-week high on each run |
| Feed a finance agent | Call the Actor over MCP and let the model ask for the symbol it needs |
| Build your own history | Schedule the run and let the dataset accumulate a row per symbol per run |

### Quick start

1. Click **Try for free**.
2. Add your symbols, one per line: `AAPL`, `MSFT`, `NVDA`.
3. Set **Asset class** to match what you asked for: `stocks`, `etf`, `index` or `mutualfunds`. A stock looked up as an ETF will fail.
4. Leave **Mode** on `quote`, or switch it to `news`.
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 |
| --- | --- | --- | --- |
| `symbols` | array | `AAPL` | Symbols to read |
| `assetClass` | string | `stocks` | Which Nasdaq listing type to look the symbols up as |
| `mode` | string | `quote` | `quote` returns a record per symbol, `news` a record per story |
| `newsPerSymbol` | integer | `20` | Stories per symbol in news mode |
| `maxItems` | integer | `0` | Caps how many symbols are read. `0` reads them all |

```json
{
    "symbols": [
        "AAPL",
        "MSFT",
        "NVDA"
    ],
    "assetClass": "stocks",
    "mode": "quote",
    "maxItems": 0
}
```

### Output

One dataset item per symbol. Fields Nasdaq does not publish for an asset class are dropped rather than returned as `null`, so an index carries no bid or ask.

| Field group | Fields |
| --- | --- |
| Identity | `status`, `tickerSymbol`, `name`, `assetClass`, `currency`, `url` |
| Price | `value`, `change`, `changePercent`, `bid`, `ask`, `previousClose` |
| Ranges and volume | `dayLow`, `dayHigh`, `dayRangeSource`, `fiftyTwoWeekLow`, `fiftyTwoWeekHigh`, `volume` |
| Session | `marketStatus`, `exchange` |
| Listing | `marketCap`, `peRatio`, `earningsDate`, `dividendYieldPercent` |
| News mode | `headline`, `publisher`, `datePublished`, `url` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "tickerSymbol": "AAPL",
    "name": "Apple Inc. Common Stock",
    "assetClass": "stocks",
    "currency": "USD",
    "value": 319.97,
    "change": -8.24,
    "changePercent": -2.51,
    "dayLow": 317.86,
    "dayHigh": 328.93,
    "dayRangeSource": "published",
    "fiftyTwoWeekHigh": 344.57,
    "volume": 38272821,
    "marketStatus": "Market Closed",
    "marketCap": 4670000000000,
    "peRatio": 36.65,
    "validFrom": "2026-09-04T20:00:01.000Z",
    "url": "https://www.nasdaq.com/market-activity/stocks/aapl"
}
```

#### What does news mode return?

`mode: "news"` returns the stories on the symbol's Nasdaq news page: `headline`, `publisher`, `datePublished` and `url`, plus the `tickerSymbol` the story was found under. News is charged as news items rather than as quote records, and **News per symbol** sets how many each symbol returns.

### 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~nasdaq-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"symbols": ["AAPL", "MSFT", "NVDA"], "assetClass": "stocks", "mode": "quote", "maxItems": 0}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/nasdaq-scraper").call(run_input={"symbols": ["AAPL", "MSFT", "NVDA"], "assetClass": "stocks", "mode": "quote", "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["name"], item["value"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/nasdaq-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 |
| News article | $0.001 | $0.00035 |
| 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 symbol returns `failed` and I know it exists | The asset class does not match. Nasdaq looks a symbol up within one listing type, so an ETF requested as `stocks` fails. Set **Asset class** correctly. |
| `value` has not moved since yesterday | Read `marketStatus`. When the market is closed, the last sale is the previous close and will not change until the next session. |
| `bid` and `ask` are missing | Nasdaq publishes no book for indices and mutual funds, and none outside session hours for some listings. |
| The day range disagrees with another source | Check `dayRangeSource`. Nasdaq publishes the range in more than one place and the two can differ during extended hours. |
| A mutual fund has no intraday price | Funds price once a day at NAV. That is the instrument, not the Actor. |

### FAQ

#### Does Nasdaq have a public API?

No. Nasdaq publishes no documented public API for this data. The endpoints that libraries reach for are internal and unsupported, and they change without notice. This Actor reads the public quote page, which is why it keeps working.

#### Why does the price not change when the market is closed?

Because the last sale is the closing print. `marketStatus` tells you which state the market was in, so you can hold the value rather than treating it as stale.

#### Can it read ETFs and index funds?

Yes. Set **Asset class** to `etf`, `index` or `mutualfunds`. The field names stay the same across all four, so one pipeline handles every type.

#### Does it return historical prices?

No. Each record is the current snapshot as the source publishes it. To build a series, schedule the Actor and let the dataset accumulate a row per input per run. Each row carries `validFrom`, so the series is correctly timestamped.

#### Is there a Nasdaq news API?

`mode: "news"` is the closest thing, returning the stories on a symbol's Nasdaq news page with headline, publisher, date and URL, charged as news items.

#### Do I need a Nasdaq API key?

No. You need an Apify token to call the Actor over the API. No Nasdaq 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 Nasdaq?

This Actor reads public Nasdaq 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.2** Added news mode, the live market status and `dayRangeSource`.
- **0.0.1** First release. Quote mode across stocks, ETFs, indices and mutual funds.

### Feedback

Found a field Nasdaq 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

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

Symbols to read, one per line. Nasdaq looks a symbol up within one listing type, so the Asset class field has to match what you are asking for. Examples: 'AAPL', 'MSFT', 'NVDA'. Default is 'AAPL'.

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

What each record represents. Quote returns one record per symbol with the last sale, both ranges, volume and the live market status. News returns one record per story on the symbol's Nasdaq news page. Examples: 'quote', 'news'. Default is 'quote'.

## `newsPerSymbol` (type: `integer`):

How many stories to return per symbol in news mode, newest first. Nasdaq carries a rolling window per symbol, so a value above what it holds returns everything available. Ignored in quote mode. Examples: 5, 20, 50. Default is 20.

## `assetClass` (type: `string`):

Which Nasdaq listing type to look the symbols up as. It has to match the instrument: a stock requested as an ETF returns a failure row. Mutual funds price once a day at NAV rather than intraday. Examples: 'stocks', 'etf', 'index', 'mutualfunds'. Default is 'stocks'.

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

Maximum number of symbols to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every symbol given.

## Actor input object example

```json
{
  "symbols": [
    "AAPL",
    "MSFT"
  ],
  "mode": "quote",
  "newsPerSymbol": 20,
  "assetClass": "stocks",
  "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 = {
    "symbols": [
        "AAPL",
        "MSFT"
    ],
    "mode": "quote",
    "newsPerSymbol": 20,
    "assetClass": "stocks",
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/nasdaq-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",
        "MSFT",
    ],
    "mode": "quote",
    "newsPerSymbol": 20,
    "assetClass": "stocks",
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/nasdaq-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",
    "MSFT"
  ],
  "mode": "quote",
  "newsPerSymbol": 20,
  "assetClass": "stocks",
  "maxItems": 0
}' |
apify call publicmoney/nasdaq-scraper --silent --output-dataset

```

## MCP server setup

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