How to Scrape Nasdaq Stock Market Data in Python
Use Nasdaq’s documented data interfaces to retrieve market data in Python. Choose the right product, authenticate, handle limits, and understand usage rights.
To retrieve Nasdaq stock market data in Python, first choose the specific dataset or market-data product you are entitled to use, then follow its documented access method. Nasdaq Data Link offers interfaces for time-series datasets and tables, while separate market-data products may provide bars, snapshots, delayed data, real-time data, or streaming. There is no single endpoint or API key that automatically grants access to every Nasdaq-listed stock or every type of data.
This guide shows the Python client pattern, explains how to select a product and authenticate, and covers practical checks for returned data, errors, rate limits, and permitted use. The examples use placeholders where the product code and access terms depend on your account.
1. Choose the data product before writing code
“Nasdaq stock data” can mean several different things: historical daily observations, intraday bars, quotes, snapshots, reference data, or a continuous real-time feed. Start with the exact fields, instruments, time range, and update frequency your application needs. Nasdaq Data Link documents APIs for multiple data types and delivery patterns; its platform overview describes snapshots, reference data, and bars. Bars provide open, high, low, close, and volume over date ranges and intervals. Nasdaq states that subscribers can access more than 10 years of history through the Bars endpoint, subject to the specific product, account, and coverage. Nasdaq Data Link APIs
| Need | Look for | Questions to resolve |
|---|---|---|
| Historical observations | A time-series dataset or historical bars endpoint | Which symbols, date span, interval, and fields are included? |
| Structured records that are not time series | A table API | What filters and pagination parameters does the table support? |
| A point-in-time lookup | A REST request for a snapshot, quote, or reference record | Is the response delayed or real-time, and what is your entitlement? |
| Continuous updates | A documented streaming interface | What onboarding, credentials, connection behavior, and usage terms apply? |
REST is suited to request-based lookups, snapshots, or historical retrieval. Streaming is for continuous real-time delivery. The access route, available data, and credentials depend on the product; some products require onboarding or a sales contact. Check Nasdaq’s current access-tools documentation and the product’s own documentation rather than treating an old sample endpoint as universal.
2. Check access, timing, and license terms
Before integrating an API, confirm that your account can access the product and that its delivery timing fits your application. A dataset, delayed feed, and real-time feed are different products with potentially different credentials, coverage, and commercial terms. Python is a way to make requests; installing a Python package does not grant market-data rights.
- Find the exact product and its current documentation.
- Confirm the instruments, fields, historical range, and update timing it supports.
- Review whether the product requires an account, API key, subscription, or onboarding.
- Read the applicable order form, license, and third-party data terms for your intended storage, display, and redistribution.
Nasdaq Data Link’s terms describe a limited license through an applicable order form and restrict unauthorized redistribution and other uses. Do not assume that data you can retrieve is data you may republish. Check the agreement and third-party terms that apply to your product and use case; this guide does not interpret those agreements. Nasdaq Data Link terms
3. Install and configure the official Python client
For Data Link time-series datasets and tables, Nasdaq publishes a Python package. Its repository describes itself as the official documentation for Nasdaq Data Link’s Python package and documents get() for time-series datasets and get_table() for tables. The repository shows installation with pip install nasdaq-data-link and API-key configuration options. Consult the current README for supported Python versions and setup details, since package requirements can change. Nasdaq Data Link Python Client README
python -m pip install nasdaq-data-linkKeep the API key out of source code and version control. The client documents local configuration and environment-based options; follow its current instructions for the method you choose. For a shell session, an environment variable can keep the secret outside the script:
export NASDAQ_DATA_LINK_API_KEY="YOUR_API_KEY"Then configure the client from that environment variable:
import os
import nasdaqdatalink
api_key = os.environ.get("NASDAQ_DATA_LINK_API_KEY")
if not api_key:
raise RuntimeError("Set NASDAQ_DATA_LINK_API_KEY before running this script")
nasdaqdatalink.ApiConfig.api_key = api_keyUse the configuration mechanism documented by the installed package version. The key is a credential, so do not print it in logs, commit it, or include it in a notebook that will be shared publicly.
4. Retrieve a time-series dataset
The following is a complete script structure for an entitled time-series dataset. Replace the placeholder with a real dataset code from your account’s current product documentation. The placeholder is explanatory; it does not identify a guaranteed existing or freely accessible product.
import os
import nasdaqdatalink
api_key = os.environ.get("NASDAQ_DATA_LINK_API_KEY")
if not api_key:
raise RuntimeError("Set NASDAQ_DATA_LINK_API_KEY before running this script")
nasdaqdatalink.ApiConfig.api_key = api_key
# Replace with the dataset code you are entitled to use.
series = nasdaqdatalink.get("DATASET/CODE")
print(series.head())
print(series.columns)
print(series.index.min(), series.index.max())The exact call parameters, date filters, response columns, and available history are product-specific. After retrieval, inspect a few rows and the returned index before treating the result as prices for a particular date or interval. Do not infer that a series represents real-time values unless the product documentation explicitly says so.
5. Retrieve a table
For a non-time-series table, the documented client method is get_table(). This example demonstrates the shape of a filtered call; use the actual table code and supported filters listed for your product.
import os
import nasdaqdatalink
api_key = os.environ.get("NASDAQ_DATA_LINK_API_KEY")
if not api_key:
raise RuntimeError("Set NASDAQ_DATA_LINK_API_KEY before running this script")
nasdaqdatalink.ApiConfig.api_key = api_key
# Replace TABLE/CODE and ticker with values supported by your product.
rows = nasdaqdatalink.get_table("TABLE/CODE", ticker="AAPL")
print(rows.head())
print(rows.columns)Tables can require pagination or additional filters when they contain many records. Check the product documentation for parameter names, result limits, and pagination behavior. Avoid assuming a table filter has the same meaning across products.
6. Use the documented REST or streaming route for market-data products
The Data Link Python client examples above illustrate dataset and table access. For bars, quotes, snapshots, delayed data, or real-time products, use the specific product’s API documentation and its supported method. If it documents a REST request, follow its exact endpoint, query parameters, authentication, and response format. If you need a continuous feed, use the documented streaming interface rather than repeatedly polling a snapshot endpoint and calling that real-time streaming.
Nasdaq’s access guide distinguishes request-based REST retrieval from streaming delivery. Product-specific onboarding and credentials may apply. Do not copy a legacy endpoint from an old tutorial without confirming that the product and endpoint remain current. Nasdaq’s legacy Python CLI page indicated retirement was scheduled for August 31, 2026; use the current access-tools documentation for supported methods. Legacy Python CLI documentation
7. Validate dates, fields, and completeness
A successful HTTP response is not enough to establish that the data is suitable for analysis. Make data checks part of the ingestion job:
- Inspect the schema: log column names and types, and alert if an expected field disappears or changes.
- Check the time range: record the earliest and latest returned timestamps and compare them with the requested range.
- Check empty results: distinguish a valid empty response from a wrong product code, unsupported filter, or lack of entitlement.
- Respect the product’s time semantics: confirm timezone, interval boundaries, delayed status, and whether dates represent trading sessions or calendar dates.
- Track ingestion state: store the last successfully processed date or cursor so retries do not silently skip or duplicate records.
These checks are especially useful when a product changes coverage, permissions, or response parameters. Treat the documentation for your specific data product as authoritative.
8. Handle failures and limits safely
| Symptom | Common cause | What to do |
|---|---|---|
| Authentication error | Missing, malformed, or inactive API key | Confirm the key is configured in the process that runs the script. Rotate a key if it was exposed, and avoid logging it. |
| Only sample or limited data appears | The request is unauthenticated or lacks the required entitlement | Check the official client’s warning about unauthenticated requests and verify account access to the selected product. |
| Unknown dataset or table | Placeholder code, typo, retired product, or code from another product | Copy the exact current code from the product documentation and confirm it is available to your account. |
| Parameter or filter error | The endpoint does not support that field or filter | Check the product’s parameter reference; table filters and time-series parameters are not interchangeable by default. |
| Empty result | No records match the date range/filter, or access/coverage differs from expectations | Inspect the request parameters and product coverage, then test a documented interval or filter you are entitled to query. |
| Timeout or interrupted download | Slow response, broad query, network issue, or service-side limit | Narrow the requested range, use documented pagination or chunking, and retry transient failures with bounded backoff. |
| Rate or entitlement limit | Request frequency or product access exceeds account terms | Reduce concurrency and polling, cache where permitted, and consult the account and product documentation for limits. |
| Unexpectedly old observations | The selected product is delayed or the request uses historical data | Verify the product’s update timing and entitlement; choose a suitable documented product if fresher data is required. |
Retries should be bounded and selective. Retrying a malformed request or a denied entitlement will not fix the underlying issue. For scheduled pipelines, record the failure status and request context without recording secrets, and make reruns idempotent so a retry cannot corrupt downstream data.
9. Performance, reliability, and cost
Market-data performance depends on product, query shape, entitlement, network, and delivery method. Request only the dates and fields your job needs. For large histories, use documented range limits or pagination and persist each completed chunk. For continuous updates, use the supported streaming service if available instead of creating a high-frequency polling loop.
For reliability, separate the request layer from validation and storage. Track response status, row counts, date coverage, and schema; alert on unexpected gaps. Use bounded retries for transient network failures and preserve enough request metadata to reproduce an issue. Verify the provider’s current service and rate-limit guidance rather than assuming a fixed request budget.
Cost and access terms vary by product and account. The cited Nasdaq materials do not establish one universal price for all data. Confirm subscription, onboarding, entitlement, and usage terms with the current product documentation and applicable order form. Also confirm whether caching, internal display, external display, or redistribution is allowed. A technically successful download does not itself settle those permissions.
Or skip the browser setup
For a visual capture of a public market page, [ScreenshotNeo](https://screenshotneo.com) provides a website screenshot API and MCP server. This does not replace a structured market-data API when your application needs machine-readable prices, fields, or a licensed feed. It is useful when the task is to capture the page itself.
One GET request can return an image or PDF. See the ScreenshotNeo API documentation for options and request details.
curl -G "https://api.screenshotneo.com/v1/shot" \
-d access_key=YOUR_API_KEY \
--data-urlencode url=https://www.nasdaq.com/market-activity \
-o shot.webpScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and whether the request was billed. Its MCP server offers take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots, and every feature is on every plan.
Create a free ScreenshotNeo account for 1,000 screenshots a month, with no card required.
Frequently asked questions
Does the Python package provide access to every Nasdaq-listed stock?
No. The package is a client for documented Data Link products. Available symbols and fields depend on the dataset or market-data product and your entitlement.
Can I use this data in a public dashboard?
Check the applicable order form and data terms for your product and intended display. API access alone does not establish redistribution or public-display permission.
Is REST suitable for real-time trading data?
It depends on the product. Nasdaq distinguishes request-based REST retrieval from streaming for continuous real-time delivery. Confirm the product’s timing, access requirements, and terms before designing around it.
Why did an unauthenticated request return something instead of an error?
The official Python client README notes that calls without an API key may return limited or sample data. Configure the required key and verify that the account is entitled to the product before relying on results.
