# 📉 SEC Fails-to-Deliver Tracker — Short Squeeze Data (`nexgendata/sec-fails-to-deliver-tracker`) Actor

SEC fails-to-deliver (FTD) data by security: settlement date, fails quantity, CUSIP, symbol, price — from the SEC's bi-monthly FTD files. For short-squeeze, momentum traders, and market-microstructure analysts. Pay-per-record JSON.

- **URL**: https://apify.com/nexgendata/sec-fails-to-deliver-tracker.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 12 total users, 1 monthly users, 97.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 📉 SEC Fails-to-Deliver Tracker — Short Squeeze Data

**Pay-per-result fails-to-deliver (FTD) data straight from the SEC's official bi-monthly settlement files. No Bloomberg terminal, no Ortex seat, no S3-subscriber paywall.**

Every clearing fail in the U.S. equity market lands in one official place: the SEC's bi-monthly Fails-to-Deliver file. The catch is the SEC ships it as a pipe-delimited fixed-format dump with no API, no ticker index, and a quirky YYYYMMa/b half-month naming convention — so you download the whole-market file, write a parser, and repeat every two weeks. This actor does that for you and turns FTD into a queryable JSON feed: filter by ticker, CUSIP, minimum fails quantity, or file period and get back clean rows — settlement date, fails quantity, price — straight from the regulator's published figures, pay-per-record.

FTD data is one of the few hard, official, free signals about settlement stress and short-side pressure in U.S. equities. This actor reads the SEC's `cnsfails` files directly, parses them into clean JSON, and lets you surface the names with persistent, climbing fail positions that quant desks, short-squeeze researchers, and market-structure analysts actually care about.

### Why use this

- **It is the primary source, not a reseller's interpretation.** Records come from the SEC's own fails-to-deliver publication. No vendor smoothing, no proprietary "synthetic short interest" model between you and the regulator's published figures.
- **It is queryable.** The raw SEC files are monolithic whole-market dumps. This actor filters by `symbol`, `cusip`, `minQuantity`, and `period` so you get only the rows you need.
- **It is pay-per-result.** No monthly minimum, no seat license, no annual contract — pull five records or five thousand and pay for exactly what you use.
- **It handles the SEC's quirks.** The half-month `YYYYMMa` / `YYYYMMb` naming, the pipe-delimited layout, and the required `User-Agent` contact header are all handled internally.
- **It is schedulable.** Point a schedule at this actor and get a fresh feed of new fails the moment the SEC publishes the next half-month file.

> **One file per run.** Each run processes a single half-month file (the most recent, or the one matching `period`). To build history, loop over consecutive `period` tags.

### What you get

Each record is one fail position for one security on one settlement date, parsed from the official SEC file:

- **`settlementDate`** — the settlement date the fail applies to, in `YYYYMMDD` format (e.g. `20260515`).
- **`cusip`** — the 9-character CUSIP identifier, the key the SEC files are organized around and the most reliable way to track a security across name/ticker changes.
- **`symbol`** — the ticker symbol associated with the security.
- **`failsQuantity`** — the number of shares that failed to deliver and remained open on the settlement date. The core metric.
- **`description`** — the issuer/security name as carried in the SEC file.
- **`price`** — the price associated with the fail record as published in the source file.
- **`sourceFile`** — the exact SEC source file the record was parsed from (e.g. `cnsfails202605b.zip`), so every row is traceable. `b` = second half of the month; `a` = first half.

Every field comes directly from the SEC publication. We parse and structure — we do not augment, model, or estimate.

### Use cases

- **Short-squeeze / persistent-fails watchlist** — track climbing `failsQuantity` by symbol across consecutive periods to surface names with rising open fail positions.
- **Market-microstructure research** — study settlement stress, T+1 impact, and how fail positions build and clear over time, traced by `sourceFile` and `settlementDate`.
- **Quant feature pipeline** — fold FTD persistence in as a systematic factor, joined on `cusip`.
- **ETF-level fails monitoring** — track fails for ETF tickers alongside their constituents.
- **Compliance / regulatory reporting** — ingest each new bi-monthly file automatically without manual fixed-width parsing.

### Sample input

```json
{
  "symbol": "GME",
  "minQuantity": 10000,
  "maxResults": 5000
}
````

### Sample output

```json
{
  "settlementDate": "20260515",
  "cusip": "36467W109",
  "symbol": "GME",
  "failsQuantity": 245310,
  "description": "GAMESTOP CORP",
  "price": 28.41,
  "sourceFile": "cnsfails202605b.zip"
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `symbol` | string | No | — | Filter by ticker symbol. |
| `cusip` | string | No | — | Filter by CUSIP. The most reliable identifier across name/ticker changes. |
| `minQuantity` | integer | No | — | Only return records with `failsQuantity` greater than or equal to this value. |
| `period` | string | No | most recent | Optional file-period filter using the SEC `YYYYMM` plus half-month tag convention (e.g. `202605b`). Blank returns the most recent published file. |
| `maxResults` | integer | No | `5000` | Maximum number of records to return. |
| `userAgentContact` | string | No | — | Contact info for the SEC `User-Agent` header. |

### How to use it

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "symbol": "GME",
    "minQuantity": 10000,
    "period": "202605b",
    "maxResults": 5000,
    "userAgentContact": "your-name your-email@example.com",
}

run = client.actor("nexgendata/sec-fails-to-deliver-tracker").call(run_input=run_input)

for record in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(record["settlementDate"], record["symbol"], record["failsQuantity"])
```

#### cURL (run-sync-get-dataset-items)

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~sec-fails-to-deliver-tracker/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
        "symbol": "GME",
        "minQuantity": 10000,
        "period": "202605b",
        "maxResults": 5000,
        "userAgentContact": "your-name your-email@example.com"
      }'
```

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — you pay only for results returned, not run-time. Per-record pricing and any per-run charge are shown on the actor's pricing tab. No monthly fee, no minimum commitment, no seat license. Use `maxResults` to cap spend precisely.

### How this compares to Bloomberg / Ortex / S3 Partners

- **Source.** This actor delivers the SEC's own published fails-to-deliver figures, parsed but otherwise untouched. Ortex and S3 Partners sell *modeled* short-interest and squeeze metrics — proprietary estimates layered on top of underlying data. FTD data here is the regulator's primary-source record.
- **Cost.** The major terminals are subscription products, typically four to five figures per year per seat. This actor is pay-per-use — for a researcher, journalist, or small desk that needs FTD data specifically, the difference is large.
- **Scope.** A terminal is a vast integrated platform; this actor does one thing — official US-equity FTD data — and does it cleanly, as a cheap scriptable complement.
- **Access model.** Terminals are interactive and license-bound; this actor is API-first and built to feed datasets, notebooks, and downstream actors.

### FAQ

**How current is FTD data?**
The SEC publishes FTD files on a bi-monthly cadence (first and second half of each month) and the data itself lags roughly 2-4 weeks. With `period` blank, the actor returns the most recently published file.

**What is the `YYYYMMa` / `YYYYMMb` period convention?**
The SEC publishes one FTD file per half-month: `a` for the first half, `b` for the second. For example, `202605b` is the second-half-of-May-2026 file, which appears in `sourceFile` as `cnsfails202605b.zip`. Pass this format in `period`.

**Does one run cover history?**
No — each run processes a single half-month file. Loop over `period` tags to backfill a longitudinal panel.

**Is this real short interest?**
No. FTD figures record open settlement failures — a complementary signal to short interest, not the same thing. A fail can occur for several operational reasons; interpreting `failsQuantity` as naked-short activity is an analytical judgment.

**Why CUSIP, not just ticker?**
CUSIP is the file's key and stays stable across ticker and name changes. You can filter by `symbol` or `cusip`, and combine either with `minQuantity`.

**Why do I need a `userAgentContact`?**
The SEC requests automated access include a `User-Agent` header with contact information.

### Schema stability & versioning

The output fields — `settlementDate`, `cusip`, `symbol`, `failsQuantity`, `description`, `price`, and `sourceFile` — are stable and safe to build against. New fields are additive; breaking changes are versioned and documented.

### Compliance & legal

This actor retrieves and parses publicly available fails-to-deliver data published by the U.S. Securities and Exchange Commission. The data is provided for informational purposes only and is not investment advice. FTD figures reflect recorded settlement failures and should not be read, on their own, as confirmation of naked shorting. Always verify figures against the original SEC source when accuracy is material. NexGenData is not affiliated with or endorsed by the SEC.

### Related actors

- [SEC Form NT Late Filing Tracker](https://apify.com/nexgendata/sec-form-nt-late-filing-tracker?fpr=2ayu9b)
- [SEC Form 4 Insider Monitor](https://apify.com/nexgendata/sec-form-4-insider-monitor?fpr=2ayu9b)
- [Stock Buyback Announcement Tracker](https://apify.com/nexgendata/stock-buyback-announcement-tracker?fpr=2ayu9b)
- [SEC 8-K Event Monitor](https://apify.com/nexgendata/sec-8k-event-monitor?fpr=2ayu9b)
- [SEC Comment Letter Monitor](https://apify.com/nexgendata/sec-comment-letter-monitor?fpr=2ayu9b)
- [SEC Exec-Comp & Proxy Tracker](https://apify.com/nexgendata/sec-exec-comp-proxy-tracker?fpr=2ayu9b)

Browse the full catalog at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

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

Filter by ticker symbol.

## `cusip` (type: `string`):

Filter by CUSIP.

## `minQuantity` (type: `integer`):

Only records with fails >= this.

## `period` (type: `string`):

Optional file period filter (e.g. 202605b). Blank = most recent.

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

Max records.

## `userAgentContact` (type: `string`):

SEC requires a UA with contact info.

## Actor input object example

```json
{
  "maxResults": 5000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sec-fails-to-deliver-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sec-fails-to-deliver-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call nexgendata/sec-fails-to-deliver-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/sec-fails-to-deliver-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📉 SEC Fails-to-Deliver Tracker — Short Squeeze Data",
        "description": "SEC fails-to-deliver (FTD) data by security: settlement date, fails quantity, CUSIP, symbol, price — from the SEC's bi-monthly FTD files. For short-squeeze, momentum traders, and market-microstructure analysts. Pay-per-record JSON.",
        "version": "0.0",
        "x-build-id": "d854I0s3PGX8ioc1s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sec-fails-to-deliver-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sec-fails-to-deliver-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~sec-fails-to-deliver-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sec-fails-to-deliver-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~sec-fails-to-deliver-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sec-fails-to-deliver-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "title": "Symbol",
                        "type": "string",
                        "description": "Filter by ticker symbol."
                    },
                    "cusip": {
                        "title": "CUSIP",
                        "type": "string",
                        "description": "Filter by CUSIP."
                    },
                    "minQuantity": {
                        "title": "Min fails quantity",
                        "type": "integer",
                        "description": "Only records with fails >= this."
                    },
                    "period": {
                        "title": "Period (YYYYMM or file tag)",
                        "type": "string",
                        "description": "Optional file period filter (e.g. 202605b). Blank = most recent."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Max records.",
                        "default": 5000
                    },
                    "userAgentContact": {
                        "title": "SEC User-Agent contact",
                        "type": "string",
                        "description": "SEC requires a UA with contact info."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
