# Nasdaq Short Interest Scraper (`parseforge/nasdaq-short-interest-scraper`) Actor

Scrapes Nasdaq short interest history for a given symbol and asset class. Returns each record as a flat row with settlement date, short interest, days to cover, and average daily volume.

- **URL**: https://apify.com/parseforge/nasdaq-short-interest-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Integrations
- **Stats:** 9 total users, 3 monthly users, 82.2% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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.
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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Nasdaq Short Interest Scraper - History, Days to Cover & API

**Scrape the full semi-monthly short interest history for any Nasdaq-listed stock or ETF.** Every settlement period comes with short interest shares, average daily volume, days to cover, and the period-over-period change already computed. No login, no API key. Export to CSV, JSON, Excel, or XML.

Nasdaq publishes short interest twice a month on a web page that is awkward to parse and impossible to join against anything. This reads the same public data straight from Nasdaq's quote endpoint and returns it as a flat time series with ISO dates, ready for a spreadsheet, a database, or a backtest.

| Who uses it | What they use short interest for |
|---|---|
| Retail and swing traders | Which tickers are building a crowded short position |
| Quant researchers | Short interest and days-to-cover as a factor in a backtest |
| Fund and risk analysts | Squeeze exposure across a watchlist, refreshed every settlement |
| Financial media and newsletters | The change since the last settlement, with a citable source |
| Fintech builders | A keyless short-interest feed behind a dashboard or alert |

### What it does

This Actor collects the short interest table Nasdaq publishes for a single symbol and returns each settlement period as a flat row. Every row carries:

- 🧾 **Reported figures:** settlement date, short interest in shares, average daily share volume, and days to cover.
- 📅 **Two date formats:** Nasdaq's own `MM/DD/YYYY` string plus an ISO `YYYY-MM-DD` field that sorts and joins correctly.
- 🔁 **Period-over-period change:** the shares added or removed since the previous settlement, and the same figure as a percentage.
- ⏮️ **The comparison baseline:** the previous settlement date each change was measured against.

Nasdaq reports short interest **semi-monthly for the trailing 12 months**, so a symbol returns **at most 24 rows**. Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with short interest data

**📈 Track a short position building or unwinding.**

Pull the full 24-period history for a ticker and read `change` down the column to see whether shorts have been adding or covering across the last year.

**🎯 Screen a watchlist for squeeze setups.**

Run the Actor per symbol on a schedule and sort by `days_to_cover` and `change`. A high days-to-cover with short interest still rising is the classic crowded-short profile.

**🧪 Backtest short interest as a factor.**

`settlement_date_iso` joins cleanly against a price series, so you can line up each settlement with forward returns without parsing dates by hand.

**🔔 Alert on a jump between settlements.**

`short_interest_change` and `change` are computed for you, so an alert is a threshold on one field rather than a diff you have to maintain.

### Why choose this scraper

| | What you get |
|---|---|
| **Change already computed** | Both the absolute share change and the percentage, on every row but the oldest. No manual diffing. |
| **Dates that actually import** | `settlement_date_iso` in `YYYY-MM-DD` next to Nasdaq's raw string, so Excel, pandas, and BigQuery read it as a date. |
| **Stocks and ETFs** | Nasdaq-listed equities and ETFs both return a table, with the same fields. |
| **Numbers, not strings** | Share counts and ratios are cast to numbers, with thousands separators stripped. |
| **It tells you when it finds nothing** | A ticker with no Nasdaq short interest returns a row explaining why, instead of an empty dataset you have to debug. |
| **Four export formats** | CSV, JSON, Excel, and XML, from the dashboard or the API. |

### How it compares

Several Actors read the same public short interest data. The differences that matter are where the data comes from, whether the change between settlements is computed for you, and what a record costs.

| | ParseForge | scrapesmith | nexgendata | bovi |
|---|---|---|---|---|
| Source | Nasdaq quote endpoint | Nasdaq | FINRA + stock statistics pages | Nasdaq quote endpoint |
| Period-over-period change | Computed, every row | Not stated | Squeeze score & % of float | Computed |
| ISO settlement date | Yes | Not stated | Not stated | Not stated |
| Explicit no-data record | Yes | Not stated | Not stated | Not stated |
| Price per record | $0.0085, $0.0075 at volume | $0.006 | $0.05 | $0.007 |
| Run-start fee | $0.005 | $0.001 | $0.01 | $0.00005 |

Competitor rows are read from their public Apify listings on 20 August 2026. This one is not the cheapest per record; it is the one that hands you the change column and an ISO date instead of leaving both as homework.

### What a short interest record looks like

Every settlement period returns as one flat JSON row. Here is a real record, unedited:

```json
{
  "symbol": "AAPL",
  "settlement_date": "07/31/2026",
  "settlement_date_iso": "2026-07-31",
  "short_interest": 141606163,
  "avg_daily_volume": 58400983,
  "days_to_cover": 2.424722,
  "previous_settlement_date": "2026-07-15",
  "short_interest_change": -4941621,
  "change": -3.372,
  "scrapedAt": "2026-08-20T13:57:18.563Z",
  "error": null
}
```

Rows come back newest settlement first. On the oldest row of the table `previous_settlement_date`, `short_interest_change`, and `change` are `null`, because there is no earlier period to compare against.

### Configure the run

Give it a ticker and an asset class. The Input tab lists every parameter.

Full 12-month history for a Nasdaq-listed stock:

```json
{ "symbol": "AAPL", "assetClass": "stocks", "maxItems": 24 }
```

A quick look at the last few settlements:

```json
{ "symbol": "TSLA", "assetClass": "stocks", "maxItems": 6 }
```

A Nasdaq-listed ETF. Nasdaq returns the same table whichever `assetClass` you send, so this is equivalent to leaving it on `stocks`:

```json
{ "symbol": "QQQ", "assetClass": "etf", "maxItems": 24 }
```

### Pricing

Pay-per-event: **$0.0085 per record**, dropping to $0.0075 at higher volume. A **$0.005 run-start fee** applies from 28 August 2026. You pay only for records written to your dataset.

| What you run | Approximate cost |
|---|---|
| One symbol, last 10 settlements | $0.090 |
| One symbol, full 24-period history | $0.209 |
| A 100-symbol watchlist, full history | $20.90 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 records as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect the full 24-period history in one run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Nasdaq Short Interest Scraper](https://apify.com/parseforge/nasdaq-short-interest-scraper?fpr=vmoqkp).
3. Enter a `symbol`, pick `stocks` or `etf`, set `maxItems`, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Nasdaq short interest through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/nasdaq-short-interest-scraper"
```

Then prompt it in plain language:

- *"Get the short interest history for TSLA and tell me whether shorts have been adding or covering this quarter."*
- *"Compare days to cover for AAPL, NVDA, and AMD at the latest settlement date."*
- *"Pull QQQ short interest for the past year and chart the period-over-period change."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/nasdaq-short-interest-scraper" to collect Nasdaq short interest history. Input: { "symbol": "<TICKER>", "assetClass": "<stocks|etf>", "maxItems": <n> }. It returns settlement_date, settlement_date_iso, short_interest, avg_daily_volume, days_to_cover, short_interest_change, and change per settlement period, newest first. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

The ticker is almost certainly not Nasdaq-listed. This reads Nasdaq's own short interest table, so NYSE and NYSE-Arca tickers such as `IBM` or `SPY` return nothing. The Actor writes a row explaining exactly that, with the symbol and asset class it tried. Check the ticker on nasdaq.com.

**Does `assetClass` change what I get?**

No. Measured across eight symbol/asset-class combinations on 20 August 2026, Nasdaq returns the same short interest table for `stocks` and `etf`, ETFs included. The parameter is passed through and kept for compatibility, but switching it will not turn an empty result into rows.

**Why only 24 rows when I asked for more?**

That is the whole table. Nasdaq publishes short interest twice a month and keeps the trailing 12 months, so 24 records is the maximum that exists for any symbol.

**Why is `change` empty on one row?**

Only on the oldest row in the table. The change is measured against the previous settlement period, and the first one has none.

**Why is `days_to_cover` a long decimal?**

It is Nasdaq's own figure, passed through unrounded so you can round it yourself.

**A field stopped filling.**

Nasdaq changed its public response shape. Email us with your run ID so we can update the parser.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Nasdaq account or API key? | No. It reads Nasdaq's public quote endpoint, so there is nothing to register or authenticate. |
| Which tickers work? | Nasdaq-listed stocks and ETFs. NYSE and NYSE-Arca tickers such as `IBM` or `SPY` have no Nasdaq short interest table, in either asset class. |
| How far back does the history go? | 12 months, reported semi-monthly, which is 24 settlement periods. |
| How often is it updated? | Nasdaq publishes twice a month, a few business days after each settlement date. |
| Is the change field Nasdaq's or yours? | Ours. Nasdaq's endpoint returns only the four reported figures, so the change is computed from consecutive settlement periods. |
| Can I get several tickers in one run? | Not yet. One symbol per run; loop the Actor over a watchlist or schedule one run per ticker. |
| How many records per run? | Free plan: 10. Paid: as many as `maxItems` asks for, up to the full 24 that Nasdaq publishes. |
| Is short interest the same as fails-to-deliver? | No. Short interest is the reported open short position; FTDs are settlement failures published separately by the SEC. |
| Is this an official Nasdaq product? | No. It is unofficial and reads only publicly available Nasdaq data. |

### Related actors

- [Pitchbook Scraper | Investor Data](https://apify.com/parseforge/pitchbook-investors-scraper?fpr=vmoqkp): investor profiles and contact data for deal research.
- [Pitchbook Scraper | Fund Data](https://apify.com/parseforge/pitchbook-scraper-fund-data?fpr=vmoqkp): fund-level data for private market coverage.
- [UK Companies House Scraper](https://apify.com/parseforge/uk-companies-house-scraper?fpr=vmoqkp): registered company records and officers.
- [Sunbiz Florida Business Scraper](https://apify.com/parseforge/sunbiz-florida-business-scraper?fpr=vmoqkp): Florida corporate registrations and officers.
- [FEC Campaign Finance Contributions Scraper](https://apify.com/parseforge/fec-campaign-finance-contributions-scraper?fpr=vmoqkp): US federal campaign contributions by donor and committee.
- [Reddit Posts Scraper](https://apify.com/parseforge/reddit-posts-scraper?fpr=vmoqkp): retail sentiment from any subreddit, with virality signals.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Nasdaq, Inc. It collects only publicly available data. Short interest figures are reported by Nasdaq and are provided as data, not as investment advice. You are responsible for using the data in compliance with Nasdaq's terms and applicable laws.

# Actor input Schema

## `symbol` (type: `string`):

Ticker symbol (e.g. AAPL, MSFT, TSLA). Nasdaq-listed securities only — NYSE / NYSE-Arca tickers such as IBM or SPY return no short-interest data here.

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

Asset class sent to Nasdaq. Measured on 2026-08-20: Nasdaq returns the same short-interest table for both values, including for ETFs, so this does not change the result. Kept for compatibility with existing runs.

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

How many short interest records to collect per run. Nasdaq publishes short interest semi-monthly for the trailing 12 months, so a symbol has at most 24 records — a higher value simply returns everything available. Free-plan runs are capped at 10.

## Actor input object example

```json
{
  "symbol": "AAPL",
  "assetClass": "stocks",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "symbol": "AAPL",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nasdaq-short-interest-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 = {
    "symbol": "AAPL",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nasdaq-short-interest-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 '{
  "symbol": "AAPL",
  "maxItems": 10
}' |
apify call parseforge/nasdaq-short-interest-scraper --silent --output-dataset

```

## MCP server setup

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