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

Collect Nasdaq stock and ETF short-interest settlement history, shares short, average daily volume, days to cover, period changes and source URLs.

- **URL**: https://apify.com/khadinakbar/nasdaq-short-interest-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.27 / 1,000 short-interest settlements

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 Data Scraper

Collect settlement-level Nasdaq short-interest history for stock and ETF ticker lists. Each record includes shares short, average daily volume, days to cover, settlement dates, changes versus the preceding available report, the Nasdaq source URL and retrieval timestamp. Analysts and data engineers can compare a watchlist, export JSON or CSV and feed a research pipeline with traceable semi-monthly data.

#### Focused standalone workflow

This Actor works as a focused standalone workflow for Nasdaq settlement history. Use it to retrieve a ticker watchlist and then feed the Dataset to your existing analysis pipeline.

#### Best fit

Use this Actor for public Nasdaq short-interest settlement reports. Nasdaq updates these reports twice monthly. Coverage and available history depend on Nasdaq; daily short-sale volume, live positions, borrowed-share estimates and licensed Nasdaq Data Link products are separate datasets. An unavailable ticker produces a diagnostic in RUN_SUMMARY and no fabricated record.

#### Workflow: from a ticker watchlist to a research table

Start with AAPL and MSFT, collect their recent settlements, then compare changes and days to cover by settlement date. Export the Dataset to your spreadsheet or research pipeline and retain each source URL. Refresh after Nasdaq publishes the next report, and deduplicate by the stable record id.

#### Quick start

Enter ticker symbols, or Nasdaq stock and ETF quote URLs. Start the Actor and open the default Dataset. For example, retrieve the five latest reported settlements for Apple and Microsoft:

```json
{"symbols":["AAPL","MSFT"],"assetClass":"stocks","maxItems":5,"maxResults":500}
```

#### Inputs

| Input | Behavior |
| --- | --- |
| symbols | Up to 100 total symbols and URLs; defaults to AAPL when both are omitted. |
| startUrls | HTTPS Nasdaq stock or ETF quote URLs; URLs determine their own asset class. |
| assetClass | stocks or etf for symbols; defaults to stocks. |
| maxItems | 0–24 settlements per symbol after date filtering; default 5; 0 returns all available, up to 24. |
| maxResults | 1–2400 records across the run; default 500. |
| cacheProjectName | Optional incremental project. Sequential reruns emit new or corrected settlements; unchanged rows incur no result charge. Cache is scoped to caller and Actor, stores up to 100 tickers and 24 fingerprints per ticker. |
| proxyConfiguration | Optional Apify Proxy; direct access is the default. |
| fromDate / toDate | Optional inclusive settlement filters in YYYY-MM-DD format. |

Ticker inputs are normalized and duplicates removed. Requests use bounded retries and processing has a 120-second processing deadline. Limits preserve completed records and return PARTIAL when useful results exist. A total upstream failure returns FAILED with UPSTREAM_FAILED. Invalid requests return INVALID_INPUT and no result charge.

#### Incremental updates

Set a cacheProjectName such as research-watchlist and serialize executions for that project. The first execution collects the selected history; subsequent executions return new settlement dates and source-corrected values. Retrieval timestamps alone do not trigger another record. Each caller has a separate cache, even when project names match. Cached unchanged rows are counted in RUN_SUMMARY.cachedRecordsSkipped. The cache keeps fingerprints of the most recently updated 100 ticker scopes, with 24 settlements each.

#### Output

Each Dataset row represents one ticker and settlement date. The overview and all-fields views show numeric share counts, source-reported days to cover, dates and provenance. shortInterestChange and changePercent are computed against the preceding available report before date filtering; a missing baseline is null.

```json
{"id":"stocks:AAPL:2026-09-30","symbol":"AAPL","assetClass":"stocks","settlementDate":"2026-09-30","settlementDateOriginal":"09/30/2026","shortInterest":120763539,"averageDailyVolume":39858260,"daysToCover":3.029825,"shortInterestChange":-7989553,"changePercent":-6.205328898121014,"previousSettlementDate":"2026-09-15","sourceUrl":"https://www.nasdaq.com/market-activity/stocks/aapl/short-interest","apiUrl":"https://api.nasdaq.com/api/quote/AAPL/short-interest?assetclass=stocks","retrievedAt":"2026-10-14T10:00:00.000Z"}
```

OUTPUT contains the terminal outcome and totals. RUN_SUMMARY shows request attempts, empty symbols, errors and event counts. Export through Apify as JSON, CSV, Excel or other supported Dataset formats.

#### Pricing

Pay per event with platform usage included at launch. One short-interest-record event is charged for each validated settlement persisted to the Dataset, plus the synthetic Actor start event. Empty or unavailable symbols incur no record fee. The creator covers platform compute, storage and transfer in the current launch pricing. The live [Pricing tab](https://apify.com/khadinakbar/nasdaq-short-interest-scraper/pricing) is the authority for effective prices; use it when estimating a retrieval or comparing event fees. The launch prices are $0.00155 per start and $0.00049 per settlement ($0.49 per 1,000 records), with platform usage included for the Free and Starter tiers. Higher tiers pay $0.00044 or $0.00027 per record, with start fees from $0.00127. A five-record Starter retrieval costs $0.004 in total Actor fees.

#### API and automation

Use the Apify API to start an execution and retrieve its Dataset. Keep your token in an environment variable:

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

Poll the returned execution ID, then read its defaultDatasetId and OUTPUT. Connect an existing Apify schedule, webhook or integration for recurring retrievals. This Actor only collects data; it does not create schedules or send messages.

#### AI agent and MCP prompt

> Invoke khadinakbar/nasdaq-short-interest-scraper for AAPL and MSFT, five settlements each. Inspect OUTPUT and RUN_SUMMARY, retrieve the Dataset, compare reported shares short and days to cover, and retain source URLs and settlement dates.

#### Best results and troubleshooting

Choose the correct asset class or supply quote URLs, which distinguish stocks and ETFs. Date filters apply to settlement dates, not retrieval dates. Nasdaq unavailable responses are genuine empty results; network errors, HTTP blocks and schema changes are failures. A mixed watchlist preserves available data and identifies failed or unavailable symbols in RUN_SUMMARY. A spending limit stops further record writes and charges. To collect an incremental refresh, reuse the same cache project; to take a full snapshot, leave the project name empty. Deduplicate downstream by id. If a migrated execution contains an ambiguous prior write, it stops for reconciliation instead of repeating a charge.

#### Builder's note

In my testing, I found that Nasdaq returns unavailable symbols in several response shapes. We distinguish these explicit messages from malformed tables and blocked requests, normalize full records before billing and compute changes from the source history. The native structured endpoint avoids a browser and a separately paid data-provider subscription.

#### Responsible use and support

The Actor reads public Nasdaq data without login or a Nasdaq Data Link subscription. Nasdaq controls availability and data rights; users should review the site terms in the Nasdaq terms for their intended use. This Actor is independently maintained and is not affiliated with Nasdaq. Use the Apify Issues tab with a ticker, asset class and run ID for reproducible problems; exclude tokens and private inputs.

# Actor input Schema

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

Enter up to 100 Nasdaq ticker symbols. Each settlement becomes one record. Defaults to AAPL when no ticker or URL input is supplied.

## `startUrls` (type: `array`):

Use HTTPS Nasdaq stock or ETF quote URLs. Asset class is detected from each URL; duplicate symbols are removed.

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

Choose stocks or ETFs for the symbols input. Quote URLs carry their own asset class.

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

Return newest settlements after date filtering. Use 0 for all available history, up to 24 settlements.

## `maxResults` (type: `integer`):

Stop after this many persisted settlement records across all symbols.

## `fromDate` (type: `string`):

Optional inclusive YYYY-MM-DD settlement-date filter. Omit to include all available dates.

## `toDate` (type: `string`):

Optional inclusive YYYY-MM-DD settlement-date filter. Omit to include the latest available report.

## `cacheProjectName` (type: `string`):

Optional caller-isolated project name. Return only new or corrected settlements on later sequential runs. Empty disables caching; serialize runs sharing a project.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy routing; direct HTTP is the default. Proxy traffic is part of platform usage. Custom proxy URLs are not accepted.

## Actor input object example

```json
{
  "symbols": [
    "AAPL"
  ],
  "startUrls": [],
  "assetClass": "stocks",
  "maxItems": 5,
  "maxResults": 500,
  "fromDate": "2026-01-01",
  "toDate": "2026-12-31",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Validated records as JSON; each record is a billable settlement.

## `output` (type: `string`):

No description

## `runSummary` (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 = {
    "symbols": [
        "AAPL"
    ],
    "startUrls": [],
    "fromDate": "2026-01-01",
    "toDate": "2026-12-31",
    "cacheProjectName": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "symbols": ["AAPL"],
    "startUrls": [],
    "fromDate": "2026-01-01",
    "toDate": "2026-12-31",
    "cacheProjectName": "",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "symbols": [
    "AAPL"
  ],
  "startUrls": [],
  "fromDate": "2026-01-01",
  "toDate": "2026-12-31",
  "cacheProjectName": ""
}' |
apify call khadinakbar/nasdaq-short-interest-scraper --silent --output-dataset

```

## MCP server setup

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