# Nasdaq Short Interest Scraper (`automation-lab/nasdaq-short-interest-records`) Actor

Export dated Nasdaq short-interest observations for stock watchlists: short shares, average daily share volume and days to cover. Retrieve bounded source-available history by symbol.

- **URL**: https://apify.com/automation-lab/nasdaq-short-interest-records.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.10 / 1,000 item extracteds

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

## Nasdaq Short Interest Scraper

Export **nasdaq short interest** observations for a stock watchlist as dated, numeric rows. Supply equity symbols to retrieve source-reported short shares, average daily share volume and days to cover, with settlement dates normalized for spreadsheet joins.

This Actor retrieves the history currently returned by Nasdaq, not an unlimited historical archive. It does not calculate trading signals or provide real-time short positions.

### Who is it for?

Equity researchers can track reported positioning across settlement periods. Analysts maintaining recurring watchlists can join observations to price data by symbol and settlement date. Spreadsheet and BI users receive one row per symbol and reporting date instead of parsing nested tables.

### Why use it?

- Process a deduplicated watchlist in one run.
- Keep settlement dates separate from retrieval timestamps.
- Apply inclusive date filters consistently across symbols.
- Export numeric fields without comma-separated share counts.
- Review available history bounds in a per-run coverage summary.

### Nasdaq short interest data

| Field | Meaning |
|---|---|
| `symbol` | Uppercase equity ticker verified against the response |
| `settlementDate` | Reporting settlement date, YYYY-MM-DD |
| `shortInterest` | Reported shares sold short |
| `averageDailyVolume` | Source-reported average daily share volume |
| `daysToCover` | Source-reported ratio; null if explicitly unavailable |
| `sourceUrl` | Nasdaq public JSON endpoint used |
| `scrapedAt` | Retrieval time in UTC |

Share counts are integers. Days to cover is not recomputed. No market capitalization, quotes, short-sale volume, percent float, or period-change estimate is included.

### Getting started

1. Enter a list of stock symbols, such as AAPL and MSFT.
2. Choose a global maximum number of observations.
3. Optionally enter earliest/latest settlement dates.
4. Start the Actor and inspect its terminal status.
5. Export the default dataset as JSON, CSV or Excel through Apify.
6. Read the coverage summary to see what Nasdaq actually returned.

```json
{"symbols":["AAPL","MSFT"],"maxItems":100}
```

### Input parameters

| Parameter | Behavior |
|---|---|
| `symbols` | Required 1–100 ticker strings; trimmed, uppercased and deduplicated |
| `maxItems` | Global accepted-row cap, default 100; integer 1–2500 |
| `startDate` | Optional inclusive minimum settlement date YYYY-MM-DD |
| `endDate` | Optional inclusive maximum settlement date YYYY-MM-DD |

Symbols are processed in input order. Rows within a symbol are newest first. Earlier symbols consume the global cap before later symbols; use a higher cap when you need every symbol's available history. Zero is invalid, not unlimited. URLs, exchange prefixes, unknown fields and invalid date ranges are rejected.

Date filters operate on the returned table locally. They do not retrieve earlier archived observations. A billing budget may reduce output further.

### Output example

AAPL control observed on October 7, 2026:

```json
{
  "symbol":"AAPL",
  "settlementDate":"2026-09-15",
  "shortInterest":128753092,
  "averageDailyVolume":45135477,
  "daysToCover":2.852592,
  "sourceUrl":"https://api.nasdaq.com/api/quote/AAPL/short-interest?assetclass=stocks",
  "scrapedAt":"2026-10-07T20:06:07.465Z"
}
```

The `SUMMARY` key-value record contains saved counts and available date bounds for processed symbols. Dataset and summary links appear in the run's output tab.

### History and limitations

Nasdaq commonly reports semi-monthly observations. The tested AAPL and MSFT responses each contained 23 periods, from October 15, 2025 through September 15, 2026. This is an observation, not a guarantee of 23 records or a fixed one-year archive. Availability varies by symbol and source updates.

No pagination, all-market discovery, ETF-specific mode, monitoring state, alerts, login or paid-data credentials are provided. Symbols without a valid source response fail explicitly. A valid empty table or date range with no matches produces an empty dataset and summary rather than fabricated rows.

### How much does it cost to export Nasdaq short-interest records?

Pay-per-event billing includes a $0.005 start charge and one `item` charge per saved settlement observation. No separate charge exists for summary records, duplicates, rejected rows, or date-filter exclusions. Per-observation prices depend on your aggregate monthly Apify Store spend tier, not the number of rows in this Actor alone:

| Tier | Per observation |
|---|---:|
| FREE | $0.0059478 |
| BRONZE | $0.005172 |
| SILVER | $0.0040342 |
| GOLD | $0.0031032 |
| PLATINUM | $0.0031032 |
| DIAMOND | $0.0031032 |

At BRONZE, estimated totals including start are $0.010172 for one row, $0.05672 for 10, $0.1343 for 25, and $0.5222 for 100. At FREE, 46 observations are estimated at $0.2785988. Estimates are not guaranteed invoices; the active Pricing tab and your charge budget control billing.

Use the observation cap and Apify's maximum-total-charge budget to bound collection. A valid run may legitimately have no matching observations. The start fee covers launching a valid run even when its output is empty.

### Filtering tips

To compare two consecutive reporting periods, use their inclusive settlement dates rather than retrieval timestamps:

```json
{"symbols":["AAPL","MSFT"],"startDate":"2026-08-31","endDate":"2026-09-15","maxItems":10}
```

There is no fuzzy ticker search. Input `aapl` and `AAPL` select the same exact normalized symbol. Dates must exist in the calendar; filtering between reporting dates can naturally return no rows.

### Integrations

Use Apify's dataset exports with Google Sheets or a BI pipeline. Join rows by `symbol` plus `settlementDate`, not retrieval time. A recurring Apify schedule can refresh the same watchlist; downstream code must compare snapshots and deduplicate if retaining history across runs. The Actor does not send alerts itself.

### API usage

Create a run once and retain its ID; check that same run before downloading its dataset. Treat FAILED, TIMED-OUT or ABORTED output as partial.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~nasdaq-short-interest-records/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"symbols":["AAPL","MSFT"],"maxItems":100}'
```

JavaScript with the Apify client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nasdaq-short-interest-records').call({
  symbols: ['AAPL', 'MSFT'], maxItems: 100,
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const page = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
console.log(page.items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nasdaq-short-interest-records').call(
    run_input={'symbols': ['AAPL', 'MSFT'], 'maxItems': 100})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=100).items)
```

### MCP usage

For clients supporting remote HTTP MCP, select this Actor explicitly:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/nasdaq-short-interest-records"
```

Claude Desktop, Cursor, and VS Code clients that support remote HTTP MCP can use equivalent client configuration:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/nasdaq-short-interest-records"}}}
```

Authenticate through your client's supported Apify configuration. Discover actual tool names and argument schemas with `tools/list`; Actor selection also includes run/dataset/KV/abort helpers, not exactly one tool. Discovery itself is read-only and does not authorize execution.

Example prompts for an authorized invocation: “Export available AAPL and MSFT short-interest observations, at most 100 rows, and compare their latest source-reported days to cover.”

Start once and retain run/status/storage IDs; these are metadata, not rows. Server waiting may last 0–45 seconds. If pending, inspect the same run with 2, 4, 8 then 10-second backoff, stopping after 120 seconds. On client timeout recover the known run; do not start a duplicate. Report pending at the deadline and failed terminal statuses honestly.

After success, fetch pages of 20 untransformed rows with explicit offset and fields. Admit at most 100 source rows or 64 KiB serialized UTF-8 into model context, whichever comes first; enforce that byte budget host-side. Stop at exhaustion/budget and disclose truncation plus next source offset. Keep full exports downstream. If your client cannot intercept oversized responses, do not claim a hard byte ceiling. No universal token-saving guarantee is made.

### Troubleshooting and failure behavior

Transient network failures, HTTP 429 and server errors receive at most three attempts with bounded backoff. Blocked pages, permanent HTTP errors, invalid symbols and malformed response schemas fail instead of appearing as successful empty results. No paid proxy/browser fallback is automatically enabled.

If a later symbol fails, earlier saved observations remain partial. Check run status before treating the export as complete. Recheck the ticker spelling and consult Nasdaq's public short-interest page; do not interpret absence of records as zero short interest.

### Legality and privacy

Use public market data according to Nasdaq's terms and applicable rights. This Actor is not affiliated with Nasdaq and provides no financial advice. Settlement figures are delayed reports, not live borrow availability or trading recommendations. Verify important decisions against the source.

No runtime AI service is used. Results and logs remain in your Apify account under its storage retention settings; delete runs and datasets through Apify when no longer needed. There is no Actor-global cache or external market-data copy. Open an issue in the Actor's Apify Issues tab for support.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed. Reports are retained for 30 days.

### FAQ

**Does this return all historical records?** No. It exports only the table Nasdaq returns at run time, subject to filters and limits.

**Why are some symbols missing?** A global row cap may stop before later symbols. A source rejection fails the run; inspect its status and summary.

**Is this FINRA daily short-sale volume?** No. These are Nasdaq settlement-date short-interest observations, a different metric.

**Are repeated runs automatically deduplicated?** Only within each run. Retained snapshots require downstream deduplication by symbol and settlement date.

### Related Actors

For broader current stock-universe discovery, see [Nasdaq Stock Screener Scraper](https://apify.com/automation-lab/nasdaq-stock-screener-scraper). It complements dated short-interest observations; it is not an archive replacement.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/nasdaq-short-interest-records/changelog.md

# Actor input Schema

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

Required list of 1–100 equity ticker strings, for example AAPL and MSFT. Whitespace is trimmed, symbols are uppercased and duplicates are removed. URLs and exchange-prefixed symbols are not supported. Symbols are processed sequentially in input order; an unavailable or invalid symbol can fail the run with partial output.

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

Global cap on unique accepted symbol-and-settlement-date rows after date filtering, across all symbols. Default 100, range 1–2500; zero is invalid, not unlimited. Earlier symbols take priority; rows within each symbol are newest first. Billing limits can reduce output further. A larger cap cannot expand source-available history.

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

Optional inclusive lower bound YYYY-MM-DD on source settlement dates, applied locally to every symbol. Must be a real calendar date and cannot exceed endDate. Does not request archived history beyond the returned table.

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

Optional inclusive upper bound YYYY-MM-DD on source settlement dates, applied locally to every symbol. Must be a real calendar date and cannot precede startDate. Omit both dates to export all available observations within maxItems.

## Actor input object example

```json
{
  "symbols": [
    "AAPL",
    "MSFT"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing accepted dated observations.

## `summary` (type: `string`):

Per-symbol available date bounds and saved row counts.

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

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nasdaq-short-interest-records").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",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nasdaq-short-interest-records").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"
  ],
  "maxItems": 20
}' |
apify call automation-lab/nasdaq-short-interest-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nasdaq-short-interest-records"
        }
    }
}
```

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/jMgfmpzcTrSmaBrqy/builds/ejp1WjhagqGlM3v8D/openapi.json