Nasdaq Stock Screener Scraper

Export Nasdaq's public US stock screener as clean, typed data—without an API key, browser, or manual spreadsheet work.

Nasdaq Stock Screener Scraper downloads the current Nasdaq, NYSE, and AMEX stock universe, applies your filters, and saves normalized records to an Apify dataset. Use it for daily stock-universe refreshes, sector lists, company enrichment, quant research, market maps, and watchlist automation.

• 🏛️ Screen Nasdaq, NYSE, AMEX, or a deterministic balanced sample of all three
• 📋 Enrich up to 500 exact ticker symbols in one watchlist run
• 🔎 Filter by company, classification, market cap, price, volume, percent change, and IPO year
• 📊 Export price, change, volume, market cap, IPO year, and classification data
• 🔗 Keep canonical Nasdaq URLs and raw source values for traceability
• ⚡ Run through the Console, API, schedules, webhooks, or Apify MCP

What does Nasdaq Stock Screener Scraper do?

The Actor calls Nasdaq's public stock-screener data surface and converts formatted market values into machine-friendly numbers.

For every matching stock, it can return:

• ticker symbol and company name;
• listing exchange;
• last sale price, net change, and percent change;
• trading volume and market capitalization;
• country, IPO year, sector, and industry;
• canonical Nasdaq stock URL;
• original formatted market values;
• UTC collection timestamp.

The Actor uses one exchange-specific request per selected exchange. Independent requests run concurrently, which keeps exchange attribution accurate and reduces all-exchange wall time without adding requests. Capped all-exchange results are merged round-robin in Nasdaq, NYSE, and AMEX order so a broad sample is not filled from Nasdaq alone.

Who is it for?

Investors and analysts

Refresh sector lists, compare company universes, and create repeatable screens without downloading CSV files by hand.

Quant and data teams

Feed a normalized US equity universe into notebooks, warehouses, factor pipelines, validation jobs, or instrument-master tables.

Market researchers

Build market maps by country, sector, industry, IPO year, volume, or capitalization.

Lead and enrichment teams

Turn public-company tickers into company lists with classification and source URLs for downstream enrichment.

AI and automation builders

Give agents a structured, bounded stock-screening tool through the Apify API or MCP server.

Why use this Nasdaq stock scraper?

• No API key: the useful source is publicly accessible.
• Source-specific: records come from Nasdaq's own public screener surface.
• Typed numbers: currency signs, commas, and percent signs are removed from normalized fields.
• Raw values retained: audit the original source formatting when needed.
• Fail-closed filters: records with unknown numeric values do not pass an active numeric boundary.
• Balanced all-exchange caps: qualifying rows are selected round-robin from Nasdaq, NYSE, and AMEX.
• Bounded runs: maxRecords controls output volume and cost.
• Automation-ready: schedule runs and connect datasets to webhooks, Zapier, Make, or cloud storage.

What Nasdaq stock data can you extract?

Field	Type	Description
symbol	string	Stock ticker
companyName	string	Nasdaq company/security name
exchange	string	nasdaq, nyse, or amex
lastSale	number	Normalized last sale price
netChange	number	Net price change
percentChange	number	Percentage price change
volume	number	Reported trading volume
marketCap	number	Market capitalization in USD
country	string	Issuer country when supplied
ipoYear	number	IPO year when supplied
sector	string	Nasdaq sector classification
industry	string	Nasdaq industry classification
url	string	Canonical Nasdaq stock page
rawLastSale	string	Original formatted price
rawPercentChange	string	Original formatted percentage
collectedAt	string	ISO 8601 UTC timestamp

Optional source fields are omitted when Nasdaq does not supply a useful value; the Actor does not invent data.

How to scrape the Nasdaq stock screener

1. Open the Actor in Apify Console.
2. Choose one exchange or All US exchanges.
3. Add an exact ticker or batch watchlist, plus optional company, classification, market-cap, price, volume, change, or IPO-year filters.
4. Set a maximum number of stock records.
5. Click Start.
6. Open the Dataset tab to preview results.
7. Export JSON, CSV, Excel, XML, or RSS, or consume the dataset API.

Start with 25 records to validate a workflow, then increase the limit for production refreshes.

Input parameters

Input	Type	Default	Purpose
exchange	string	all	Scan all exchanges, Nasdaq, NYSE, or AMEX
symbol	string	—	Match one exact ticker
symbols	string[]	—	Match up to 500 exact tickers in one run
search	string	—	Match ticker or company name text
sector	string	—	Partial case-insensitive sector match
industry	string	—	Partial case-insensitive industry match
country	string	—	Partial case-insensitive country match
minMarketCap	number	—	Inclusive minimum USD market cap
maxMarketCap	number	—	Inclusive maximum USD market cap
minPrice / maxPrice	number	—	Inclusive normalized last-sale range
minVolume / maxVolume	number	—	Inclusive reported-volume range
minPercentChange / maxPercentChange	number	—	Inclusive percentage-change range; negatives allowed
minIpoYear / maxIpoYear	integer	—	Inclusive IPO-year range from 1600 through next year
maxRecords	integer	100	Output cap from 1 to 10,000

Each minimum must not exceed its matching maximum. Price, volume, and market-cap values cannot be negative. Use either symbol or a non-empty symbols list, not both; list entries are trimmed, matched case-insensitively, and deduplicated.

Example input: Nasdaq technology stocks

{
  "exchange": "nasdaq",
  "sector": "Technology",
  "country": "United States",
  "minMarketCap": 1000000000,
  "maxRecords": 100
}

This screen returns up to 100 Nasdaq-listed US technology companies with a reported market cap of at least $1 billion.

Example input: exact ticker lookup

{
  "exchange": "all",
  "symbol": "AAPL",
  "maxRecords": 1
}

Ticker matching is case-insensitive and exact. Use search instead when you want a partial company-name or ticker match.

Example input: batch watchlist with trading filters

{
  "exchange": "all",
  "symbols": ["AAPL", "MSFT", "IBM"],
  "minPrice": 10,
  "minVolume": 100000,
  "minPercentChange": -5,
  "maxPercentChange": 5,
  "maxRecords": 100
}

The Actor returns only available exact watchlist symbols whose current normalized values satisfy every active inclusive bound.

Example output

{
  "symbol": "A",
  "companyName": "Agilent Technologies Inc. Common Stock",
  "exchange": "nyse",
  "lastSale": 131.46,
  "netChange": -0.54,
  "percentChange": -0.41,
  "volume": 1337000,
  "marketCap": 37128503358,
  "country": "United States",
  "ipoYear": 1999,
  "sector": "Industrials",
  "industry": "Biotechnology: Laboratory Analytical Instruments",
  "url": "https://www.nasdaq.com/market-activity/stocks/a",
  "rawLastSale": "$131.46",
  "rawPercentChange": "-0.41%",
  "collectedAt": "2026-07-18T02:30:00.000Z"
}

Values change with the source. The snippet demonstrates the output shape, not a price guarantee.

How much does it cost to scrape Nasdaq stocks?

This Actor uses pay-per-event pricing: a $0.005 run start plus one charge for every stock saved.

Apify tier	Price per stock	1,000 stocks plus start
Free	$0.000036179	about $0.0412
Starter / Bronze	$0.00003146	about $0.0365
Scale / Silver	$0.000024539	about $0.0295
Business / Gold	$0.000018876	about $0.0239
Platinum	$0.000012584	about $0.0176
Diamond	$0.00001	about $0.0150

A small 20-stock test costs about $0.0057 on the Free tier. maxRecords gives you direct control over the variable portion of the run cost.

Because filtering happens before output, you pay the per-stock event only for records saved to your dataset. The formula-derived price was validated against an 83-record, three-exchange cloud run with an 89.7% net margin.

Filtering behavior

Text filters use case-insensitive partial matching except symbol, which is exact.

For example:

• sector: "tech" can match Technology;
• industry: "semi" can match a semiconductor industry label;
• country: "united" can match United States;
• search: "micro" checks both ticker and company name.

All numeric filters are inclusive. If a source row has no parseable value while the corresponding market-cap, price, volume, percent-change, or IPO-year filter is active, that row is excluded rather than guessed.

For exchange: "all", qualifying rows are merged deterministically in Nasdaq, NYSE, and AMEX round-robin order until maxRecords. An exchange with no qualifying row is skipped. Single-exchange source order is unchanged, and duplicate ticker symbols are emitted only once.

Data freshness and coverage

The Actor captures the public screener response available when the run executes. collectedAt records the collection time for every row.

Coverage includes securities returned by Nasdaq's public screener for:

• Nasdaq;
• New York Stock Exchange (NYSE);
• American Stock Exchange (AMEX).

The response may include security names such as common stock, preferred stock, warrants, units, or depositary shares. Use ticker/company text and downstream rules if your workflow needs only one security type.

Tips for reliable stock screens

• 🎯 Use symbol for one deterministic ticker lookup or symbols for a watchlist of up to 500 tickers.
• 🧪 Start with maxRecords: 25 before scheduling a larger universe refresh.
• 💰 Enter market caps as plain USD numbers, not $10B strings.
• 🧭 Keep exchange: "all" when you do not know where a ticker is listed.
• 🔍 Use short industry phrases because source labels can be detailed.
• 🕐 Store collectedAt when comparing snapshots across scheduled runs.
• 🧱 Deduplicate downstream snapshots by symbol plus collectedAt or run ID.

Integrations and workflow patterns

Google Sheets or Excel watchlists

Schedule a daily run, export CSV or XLSX, and refresh a shared equity watchlist.

Data warehouse instrument master

Send completed-run webhooks to a loader, then upsert records by symbol and exchange.

Quant research notebooks

Call the Actor before a notebook job and read the dataset as JSON for universe selection.

CRM and company enrichment

Use company names, countries, sectors, and Nasdaq URLs as seed attributes for public-company enrichment.

Slack or email alerts

Compare today's dataset with yesterday's snapshot and notify a channel when companies enter or leave a selected market-cap or sector screen.

API usage with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nasdaq-stock-screener-scraper').call({
  exchange: 'nasdaq',
  sector: 'Technology',
  minMarketCap: 1_000_000_000,
  maxRecords: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API usage with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nasdaq-stock-screener-scraper').call(run_input={
    'exchange': 'nyse',
    'sector': 'Health Care',
    'maxRecords': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

API usage with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~nasdaq-stock-screener-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"exchange":"all","search":"apple","maxRecords":10}'

Use the returned defaultDatasetId with the dataset items endpoint after the run finishes.

Use Nasdaq Stock Screener Scraper with MCP

Connect the Actor to Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/nasdaq-stock-screener-scraper"

For Claude Desktop, Cursor, or VS Code, add this MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/nasdaq-stock-screener-scraper"
    }
  }
}

Example prompts:

• "Screen Nasdaq technology companies above $5 billion market cap and return 50 records."
• "Look up the current Nasdaq screener row for AAPL."
• "Create a NYSE healthcare stock dataset for my research notebook."

Scheduling and change monitoring

Apify schedules can run the same input hourly, daily, weekly, or on a custom cron expression.

A practical monitor workflow is:

1. schedule a filtered screen;
2. retain each run's dataset ID;
3. compare symbols with the previous successful run;
4. calculate added, removed, or changed records;
5. send a webhook to your alerting or ETL system.

The Actor returns current snapshots; it does not itself calculate historical differences.

Limitations

• Nasdaq controls source availability, field coverage, classifications, and refresh timing.
• This Actor does not provide historical OHLC candles, financial statements, ratios, options, dividends, or investment advice.
• Some numeric fields can be absent or represented as --; normalized fields are then omitted.
• Security names may represent share classes, warrants, units, or depositary securities.
• The public screener is a market-discovery source, not an exchange-certified reference feed.
• A valid filter combination can naturally return zero records.

Is it legal to scrape Nasdaq stock screener data?

The Actor accesses publicly available stock-screener data without bypassing login or access controls. Public market facts are generally not personal data, but source terms, database rights, redistribution rules, and financial-services regulations can vary by country and use case.

You are responsible for ensuring that your collection, storage, publication, and downstream use comply with applicable laws and Nasdaq terms. Do not present delayed or scraped data as an official real-time exchange feed, and do not use the Actor as a substitute for licensed data where your product or regulation requires one.

This independent Actor is not affiliated with, endorsed by, or sponsored by Nasdaq. It does not use AI or send input/output to an AI provider. It keeps no separate external copy or cache; run datasets, key-value stores, and logs follow the retention controls of your Apify account and can be deleted there.

Troubleshooting

Why did my run return no stocks?

Your filters may not overlap. Remove the market-cap boundary first, then broaden sector, industry, or country text. Check that an exact symbol does not conflict with another filter.

Why is a numeric field missing?

Nasdaq sometimes supplies blank text or --. The Actor omits the normalized number instead of returning zero, because zero would be misleading. Check the raw-value dataset view for source formatting.

Why did the run fail after retries?

Nasdaq may be temporarily unavailable or throttling requests. Inspect the log for the HTTP status or response-shape error, then retry later. The Actor uses conservative bounded retries and does not hide total extraction failures.

Why do I see fewer records than maxRecords?

maxRecords is a cap, not a target. The source and filters determine the number of qualifying stocks.

Related Automation Lab actors

• TradingView Stock Screener Scraper — screen stocks, crypto, and forex across multiple markets.
• TradingView Earnings Calendar Scraper — collect upcoming and historical earnings events.
• TradingView Economic Calendar Scraper — extract macroeconomic calendar releases.
• Finviz Quote Scraper — enrich individual stock tickers with Finviz quote data.
• Finviz News Scraper — collect ticker-related market news.

Choose this Actor when you need Nasdaq's public US stock universe and classification fields. Choose TradingView for cross-market screening or Finviz actors for source-specific quote and news enrichment.

FAQ

Does it need a Nasdaq account or API key?

No. The current implementation uses Nasdaq's anonymous public screener JSON response.

Does it use a browser or proxy?

No. Version 0.1 uses lightweight direct HTTP requests with browser-like headers. This keeps runs fast and compute-efficient.

Can I export every US stock?

Yes. Set exchange to all and raise maxRecords up to 10,000. The current public source contains several thousand rows, and the exact count changes over time.

Can I filter several sectors in one run?

The v0.1 input accepts one partial sector phrase. Run separate inputs for unrelated sectors, or export a broad universe and filter multiple values downstream.

Are prices real time?

The Actor returns whatever the public Nasdaq screener provides at run time. Do not assume an exchange-certified real-time entitlement; inspect Nasdaq's data notices for your use case.

How are duplicates handled?

When all exchanges are scanned, the Actor round-robins qualifying rows in Nasdaq, NYSE, and AMEX order and keeps the first selected record for each case-insensitive symbol. Duplicate watchlist entries and duplicate source symbols do not produce duplicate output records.

Can I use the data in an AI agent?

Yes. Use the Apify API or MCP integration and keep maxRecords bounded so the agent receives a manageable dataset.

Does the Actor make investment recommendations?

No. It extracts public screener records and applies mechanical filters. Any analysis, trading decision, or recommendation remains your responsibility.