# SEC Form 144 Proposed Sale Scraper (`automation-lab/sec-form-144-proposed-sale-scraper`) Actor

📄 Monitor SEC Form 144 proposed securities sales or parse exact filings into normalized, source-linked records for research and compliance.

- **URL**: https://apify.com/automation-lab/sec-form-144-proposed-sale-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Form 144 Proposed Sale Scraper

Extract SEC EDGAR **Form 144 and 144/A proposed securities sales** into normalized, source-linked JSON. Monitor recent filings or parse specific EDGAR filing URLs without a browser, login, proxy, or paid data API.

A Form 144 is a notice of a proposed sale by an affiliate of an issuer or of restricted securities. It can reveal intended sales before they appear as completed insider transactions. This Actor turns the SEC filing XML into records ready for research, compliance review, spreadsheets, databases, and alerts.

- 📄 Discover recent Form 144 filings from the official SEC feed
- 🎯 Filter issuers by CIK or stock ticker
- 💵 Capture proposed units and aggregate market value
- 👤 Extract seller identity and relationship to the issuer
- 🏦 Preserve broker, acquisition history, and recent-sale details
- 🔁 Checkpoint accessions for scheduled incremental monitoring
- 🔗 Keep the SEC index and source XML URL on every record

### What does the SEC Form 144 scraper do?

The Actor uses the SEC's official current-filings Atom feed and filing XML documents. It deduplicates reporting-owner and subject entries that point to the same accession, validates that each document is Form 144 or 144/A, and emits one record per proposed security-sale row.

You can run it in two ways:

1. Leave `startUrls` empty to scan the latest Form 144 feed.
2. Supply one or more SEC archive index or primary XML URLs to parse exact filings, including older accessions.

The recent feed is a current window, not a complete historical search index. Use direct filing URLs when you already know an older accession.

### Who is it for?

#### Investors and research analysts

Track disclosed sale intentions, compare proposed values, and route notable affiliate-sale notices into an investment-research workflow.

#### Fintech and market-data teams

Build a normalized Form 144 feed without maintaining XML namespaces, repeating sections, amendment handling, SEC pacing, or accession deduplication.

#### Compliance and legal operations

Schedule recurring checks, filter relevant issuers, and retain source URLs for review and audit trails.

#### Alert and automation builders

Connect Apify schedules, webhooks, Zapier, Make, Google Sheets, databases, or custom code to trigger downstream actions when new notices appear.

### Why use this Actor?

Raw Form 144 filings are structured but not analysis-ready. A single filing can contain multiple proposed securities, multiple acquisition rows, multiple sales from the prior three months, broker addresses, amendment identity, remarks, and Rule 10b5-1 adoption dates.

This Actor handles those details consistently:

- ✅ SEC Atom discovery and duplicate-accession removal
- ✅ XML namespace handling and repeating-node normalization
- ✅ strict `144` / `144/A` form validation
- ✅ dates normalized to `YYYY-MM-DD`
- ✅ amounts and unit counts emitted as numbers
- ✅ optional ticker-to-CIK mapping from SEC data
- ✅ bounded retry and conservative SEC request pacing
- ✅ failed extraction causes a failed run instead of a misleading empty success

### What SEC Form 144 data can I extract?

| Field group | Example fields | Why it matters |
| --- | --- | --- |
| Filing identity | `accessionNumber`, `formType`, `filedAt` | Dedupe and timeline analysis |
| Amendment identity | `isAmendment`, `previousAccessionNumber` | Connect corrections to earlier notices |
| Issuer | `issuerName`, `issuerCik`, `secFileNumber` | Join to company and security data |
| Seller | `sellerName`, `relationships` | Identify affiliate role and account |
| Proposed sale | `securityClass`, `unitsToSell`, `aggregateMarketValue` | Measure intended transaction size |
| Market context | `unitsOutstanding`, `exchange` | Compare size and venue |
| Timing | `approximateSaleDate`, `noticeDate` | Build event timelines |
| Broker | `brokerName`, broker address fields | Review execution intermediary |
| Acquisition history | `acquisitionHistoryJson` | Preserve how securities were obtained |
| Recent sales | `recentSalesJson` | See sales reported for the prior three months |
| Rule 10b5-1 | `planAdoptionDates` | Identify supplied plan adoption dates |
| Source | `filingIndexUrl`, `sourceXmlUrl` | Verify every result at the SEC |

### How much does it cost to scrape SEC Form 144 filings?

The Actor uses pay-per-event pricing. A run starts at **$0.005**, then charges for each proposed-sale record saved. The current BRONZE price is **$0.00032553 per record**, with lower unit prices on higher Apify plans and a slightly higher FREE-plan unit price.

Examples at the BRONZE price:

- 10 records: approximately $0.0083 including the start event
- 100 records: approximately $0.0376 including the start event
- 1,000 records: approximately $0.3305 including the start event

The SEC current feed is finite and recent, so many monitoring runs naturally return fewer than 100 records. Direct filing extraction often returns one record. You are never charged for a result that is filtered out or fails before it is saved.

### How to scrape recent Form 144 filings

1. Open the Actor input page.
2. Leave **SEC filing URLs** empty.
3. Set **Maximum proposed-sale records** to a small value such as `10`.
4. Keep **Include Form 144/A amendments** enabled if corrections matter.
5. Optionally add issuer CIKs, tickers, or filing-date filters.
6. Click **Start**.
7. Export the dataset as JSON, CSV, Excel, XML, or another supported format.

Minimal recent-feed input:

```json
{
  "maxItems": 10,
  "includeAmendments": true
}
````

### How to parse a specific Form 144 filing

Add an SEC archive index URL or primary filing XML URL:

```json
{
  "startUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/1730168/000197372726000041/primary_doc.xml"
    }
  ],
  "maxItems": 5,
  "includeAmendments": true
}
```

Only SEC EDGAR archive URLs are accepted. The Actor rejects third-party hosts and rejects documents whose submission type is not `144` or `144/A`.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | empty | SEC filing index or primary XML URLs; empty uses the current feed |
| `maxItems` | integer | `10` | Maximum proposed-sale records to save, from 1 to 1,000 |
| `includeAmendments` | boolean | `true` | Include Form 144/A correction filings |
| `cikFilters` | string array | empty | Match issuer CIKs; leading zeros are optional |
| `tickerFilters` | string array | empty | Map ticker symbols to issuer CIKs through SEC data |
| `filedFrom` | string | empty | Recent-feed lower date bound in `YYYY-MM-DD` |
| `filedTo` | string | empty | Recent-feed upper date bound in `YYYY-MM-DD` |
| `incremental` | boolean | `false` | Skip accessions checkpointed in the default key-value store |

CIK and ticker filters are combined as an allowed issuer set. An unknown ticker fails the run rather than silently returning unrelated companies.

### Output example

```json
{
  "accessionNumber": "0001973727-26-000041",
  "formType": "144/A",
  "isAmendment": true,
  "previousAccessionNumber": "0001973727-26-000037",
  "issuerCik": "0001730168",
  "issuerName": "Broadcom Inc.",
  "sellerName": "H&S INVESTMENTS I LP",
  "relationships": "Chairman of the Board of Broadcom",
  "securityClass": "Common Stock",
  "unitsToSell": 314033,
  "aggregateMarketValue": 120002749.23,
  "unitsOutstanding": 4757580198,
  "approximateSaleDate": "2026-06-24",
  "exchange": "NASDAQ",
  "brokerName": "Northern Trust Securities, Inc.",
  "planAdoptionDates": "2025-12-16",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1730168/000197372726000041/0001973727-26-000041-index.htm",
  "sourceXmlUrl": "https://www.sec.gov/Archives/edgar/data/1730168/000197372726000041/primary_doc.xml"
}
```

Optional fields are omitted when the filer did not supply them. Acquisition and recent-sale sections are JSON strings so they remain portable in CSV and spreadsheet exports.

### Understanding one record per proposed sale

Most filings contain one `securitiesInformation` block, but the SEC format allows repeats. The Actor emits one dataset item for each proposed security row and repeats shared filing metadata on those items.

This makes filtering and aggregation straightforward. Count unique `accessionNumber` values for filing counts; count dataset rows for proposed-sale line counts.

### Monitoring new accessions

Set `incremental` to `true` in a scheduled task. After a filing is processed, its accession is stored under `KNOWN_ACCESSIONS` in the task's default key-value store. Later runs skip that accession.

Recommended monitoring input:

```json
{
  "maxItems": 100,
  "includeAmendments": true,
  "incremental": true
}
```

Use a stable Apify task or integration that reuses the same default storage. Turning incremental mode on during one-off tests can intentionally produce no output when every current accession was already seen.

### Filtering by ticker or CIK

Ticker filters are convenient for watchlists:

```json
{
  "tickerFilters": ["AVGO", "AAPL"],
  "maxItems": 50
}
```

CIK filters avoid ticker ambiguity and are ideal for compliance systems:

```json
{
  "cikFilters": ["1730168", "0000320193"],
  "maxItems": 50
}
```

Filters apply to the **issuer CIK**, not the reporting seller's CIK.

### Data-quality notes

Form 144 is a notice of a proposed sale, not proof that the sale was completed. Do not treat `unitsToSell` as a confirmed transaction.

The Actor preserves supplied values but cannot correct filer omissions. Missing broker details, relationships, remarks, recent sales, or plan dates remain absent. Amendments can revise prior notices, so downstream systems should use `previousAccessionNumber` and `isAmendment`.

### Tips for reliable SEC workflows

- 🔎 Keep `accessionNumber` as your primary source identity.
- 🧩 Join `issuerCik` to SEC company submissions rather than fuzzy company names.
- 📅 Store both filing date and approximate sale date; they describe different events.
- 📝 Review `remarks` because amendments often explain what changed.
- 🔁 Use incremental mode only with stable task storage.
- 🚦 Avoid launching many parallel tasks against SEC endpoints.
- 🔗 Retain source URLs in every downstream warehouse or alert.

### Integrations

#### Google Sheets and Excel

Schedule the Actor, export the default dataset, and maintain a watchlist of issuer, seller, relationship, proposed value, and sale date.

#### Slack, Teams, and email alerts

Use an Apify webhook or Make/Zapier flow to send a notification when `aggregateMarketValue` exceeds a chosen threshold or a watched issuer appears.

#### Data warehouses

Load JSON records into Snowflake, BigQuery, PostgreSQL, or object storage. Parse `acquisitionHistoryJson` and `recentSalesJson` when relational child tables are useful.

#### Compliance case management

Create a review case keyed by accession, attach the SEC filing URL, and update or supersede the case when a `144/A` references the earlier accession.

### Run with the Apify API in Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-form-144-proposed-sale-scraper').call({
  maxItems: 25,
  includeAmendments: true,
  tickerFilters: ['AVGO'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with the Apify API in Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/sec-form-144-proposed-sale-scraper').call(
    run_input={
        'maxItems': 25,
        'includeAmendments': True,
        'cikFilters': ['1730168'],
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sec-form-144-proposed-sale-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":10,"includeAmendments":true}'
```

Fetch items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use the Actor through Apify MCP

Connect AI assistants to the Actor through Apify's MCP server.

Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/sec-form-144-proposed-sale-scraper"
```

Claude Desktop, Cursor, or VS Code MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/sec-form-144-proposed-sale-scraper"
    }
  }
}
```

Example prompts:

- “Extract the latest 20 SEC Form 144 proposed sales and rank them by aggregate market value.”
- “Parse this SEC Form 144 XML URL and summarize the seller, issuer relationship, broker, and 10b5-1 dates.”
- “Return recent Form 144 notices for these issuer CIKs with their source links.”

### Scheduling and webhooks

Create an Apify task with `incremental: true`, attach a schedule, and configure a run-succeeded webhook. A downstream service can read only newly saved dataset rows and create alerts.

If a run fails, inspect its log rather than treating the absence of a webhook as “no new filings.” The Actor deliberately fails when it cannot extract any record, preventing transport or parser errors from looking like a clean empty result.

### Is scraping SEC Form 144 legal?

SEC EDGAR filings are public government records. This Actor accesses official public SEC endpoints and identifies itself through its HTTP User-Agent. It does not bypass authentication, CAPTCHA, or access controls.

You are responsible for complying with SEC fair-access guidance, Apify terms, applicable laws, and your organization's data-use policies. The output is informational and is not investment, legal, or compliance advice.

### Limitations

- The current feed covers recent filings, not all historical Form 144 records.
- Filing content reflects filer-supplied data and can be incomplete or amended.
- Ticker mappings reflect the current SEC company ticker file.
- Proposed sale notices do not establish that a transaction occurred.
- Incremental checkpoints depend on reusing the same default key-value store.
- This Actor does not provide price movement, recommendations, or insider-trading conclusions.

### FAQ

#### Does the Actor include Form 144/A?

Yes. Amendments are included by default. Set `includeAmendments` to `false` to exclude them.

#### Can I scrape an older filing?

Yes. Supply its SEC EDGAR archive index URL or primary XML URL in `startUrls`. Date filters affect recent-feed discovery only.

#### Why do I see two records with one accession?

A filing can disclose more than one proposed security row. Records share accession metadata but differ in security or sale details.

#### Why did an incremental run return no records?

All current accessions may already be checkpointed, or no filing matched your filters. Disable `incremental` for a one-off replay or use a fresh default key-value store.

#### Why did my ticker filter fail?

Ticker symbols are validated against the SEC company ticker mapping. Check spelling and use an issuer CIK when the security is not represented there.

#### Does this show completed insider sales?

No. Form 144 reports a proposed sale. Use an appropriate Form 4 data source for reported insider ownership transactions.

### Related SEC filing scrapers

- [SEC Form D Scraper](https://apify.com/automation-lab/sec-form-d-scraper) — private offering notices
- [SEC Form 4 Insider Transactions Scraper](https://apify.com/automation-lab/sec-form-4-insider-transactions-scraper) — reported insider ownership transactions
- [SEC Form ADV Filing Monitor](https://apify.com/automation-lab/sec-form-adv-filing-monitor) — investment adviser filing changes
- [SEC Form N-PORT Mutual Fund Holdings Scraper](https://apify.com/automation-lab/sec-form-nport-mutual-fund-holdings-scraper) — fund portfolio holdings
- [SEC Form N-PX Proxy Voting Scraper](https://apify.com/automation-lab/sec-form-n-px-proxy-voting-scraper) — institutional proxy votes

### Support

For reproducible issues, include the SEC filing URL, Actor run ID, relevant input, and expected field. Do not send private credentials; this Actor needs none.

# Actor input Schema

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

Add SEC EDGAR archive index pages or primary XML document URLs. Only sec.gov archive URLs are accepted.

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

Stop after saving this many proposed-sale rows. A filing can contain multiple security rows.

## `includeAmendments` (type: `boolean`):

Include amended notices and preserve their previous accession number.

## `cikFilters` (type: `array`):

Return only filings whose issuer CIK matches one of these values. Leading zeros are optional.

## `tickerFilters` (type: `array`):

Return only issuers matching these SEC ticker symbols, for example AVGO or AAPL.

## `filedFrom` (type: `string`):

Filter recent-feed entries by filing date in YYYY-MM-DD format.

## `filedTo` (type: `string`):

Filter recent-feed entries by filing date in YYYY-MM-DD format.

## `incremental` (type: `boolean`):

Save accession checkpoints in the run's default key-value store for scheduled monitoring tasks.

## Actor input object example

```json
{
  "startUrls": [],
  "maxItems": 3,
  "includeAmendments": true,
  "cikFilters": [],
  "tickerFilters": [],
  "incremental": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset table containing issuer, seller, security, value, timing, amendment, broker, history, and SEC source fields.

# 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 = {
    "startUrls": [],
    "maxItems": 3,
    "includeAmendments": true,
    "incremental": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-form-144-proposed-sale-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 = {
    "startUrls": [],
    "maxItems": 3,
    "includeAmendments": True,
    "incremental": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-form-144-proposed-sale-scraper").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 '{
  "startUrls": [],
  "maxItems": 3,
  "includeAmendments": true,
  "incremental": false
}' |
apify call automation-lab/sec-form-144-proposed-sale-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/sec-form-144-proposed-sale-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form 144 Proposed Sale Scraper",
        "description": "📄 Monitor SEC Form 144 proposed securities sales or parse exact filings into normalized, source-linked records for research and compliance.",
        "version": "0.1",
        "x-build-id": "83NfoBbj8b4WLODkA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-form-144-proposed-sale-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-form-144-proposed-sale-scraper",
                "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/automation-lab~sec-form-144-proposed-sale-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-form-144-proposed-sale-scraper",
                "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/automation-lab~sec-form-144-proposed-sale-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-form-144-proposed-sale-scraper",
                "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": {
                    "startUrls": {
                        "title": "SEC filing URLs (optional)",
                        "type": "array",
                        "description": "Add SEC EDGAR archive index pages or primary XML document URLs. Only sec.gov archive URLs are accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum proposed-sale records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after saving this many proposed-sale rows. A filing can contain multiple security rows.",
                        "default": 10
                    },
                    "includeAmendments": {
                        "title": "Include Form 144/A amendments",
                        "type": "boolean",
                        "description": "Include amended notices and preserve their previous accession number.",
                        "default": true
                    },
                    "cikFilters": {
                        "title": "Issuer CIKs",
                        "type": "array",
                        "description": "Return only filings whose issuer CIK matches one of these values. Leading zeros are optional.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tickerFilters": {
                        "title": "Ticker symbols",
                        "type": "array",
                        "description": "Return only issuers matching these SEC ticker symbols, for example AVGO or AAPL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filedFrom": {
                        "title": "Filed on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter recent-feed entries by filing date in YYYY-MM-DD format."
                    },
                    "filedTo": {
                        "title": "Filed on or before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter recent-feed entries by filing date in YYYY-MM-DD format."
                    },
                    "incremental": {
                        "title": "Skip accessions seen in earlier runs",
                        "type": "boolean",
                        "description": "Save accession checkpoints in the run's default key-value store for scheduled monitoring tasks.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
