# SEC Filing Watchlist — 10-K, 10-Q & 8-K Monitor (`apivault_labs/sec-filing-watchlist`) Actor

Collect recent SEC filing metadata for ticker/CIK watchlists, or track unseen accessions across sequential runs. Includes amendments, acceptance timestamps and official document links. No source API key. First watch run creates a baseline.

- **URL**: https://apify.com/apivault_labs/sec-filing-watchlist.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 useful sec filing rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## SEC Filing Watchlist — 10-K, 10-Q & 8-K Monitor

**Turn a company watchlist into a structured feed of SEC filings.** Find recent annual, quarterly and current reports, or collect newly observed filings on repeat runs. Each result includes the company, form, filing date, acceptance time and links to the original SEC document.

Use it to maintain a research queue, update a company dashboard, or send filing records into your own automation. The source is **official SEC EDGAR**. You do not need a SEC API key or proxy configuration.

| At a glance | What you get |
| --- | --- |
| Companies | Up to 20 ticker or CIK entries per run |
| Forms | 10-K, 10-Q, 8-K and their `/A` amendments |
| Modes | Recent filing snapshot or persistent watch for unseen accessions |
| Output | Structured Dataset, official document links, JSON / CSV / Excel export |
| Price | **$1 per 1,000 delivered filing rows + Apify resources. No startup fee.** |
| Coverage | SEC's recent submissions feed; observed coverage is reported per company |

### Get your first filings

1. Open **Input** and paste the JSON below, or edit the form.
2. Replace `AAPL` and `MSFT` with your tickers. Numeric CIKs must be strings, for example `"0000789019"`.
3. Start the run and open **Dataset → Filings**. Use **Export** for JSON, CSV or Excel.

```json
{
  "mode": "snapshot",
  "companies": ["AAPL", "MSFT"],
  "forms": ["10-K", "10-Q", "8-K"],
  "includeAmendments": true,
  "lookbackDays": 90,
  "maxResults": 5,
  "maxCostUsd": 0.005
}
```

This returns up to **five matching filings across the whole watchlist**, newest acceptance time first. The result fee is at most **$0.005**, plus resources. Fewer matches mean fewer paid rows; a valid scan with no matches returns an empty Dataset.

Open `SUMMARY` for delivered counts, source coverage and truncation. Open `ERRORS` if a company was missing or the scan was partial. These records are linked in the run's Output.

### What a result looks like

Excerpt from an actual verified result. This is a historical example; your run returns the records available in the selected date window. Other output fields are omitted here for readability.

```json
{
  "eventId": "0000789019:0001193125-26-436149",
  "cik": "0000789019",
  "companyName": "MICROSOFT CORP",
  "tickers": ["MSFT"],
  "form": "8-K",
  "isAmendment": false,
  "accessionNumber": "0001193125-26-436149",
  "filingDate": "2026-10-28",
  "reportDate": "2026-10-28",
  "acceptedAt": "2026-10-28T20:11:03+00:00",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/789019/000119312526436149/msft-20261028.htm",
  "items": "8.01,9.01",
  "source": "SEC EDGAR",
  "documentContentFetched": false
}
```

`eventId` identifies the filing as `CIK:accession`. Use it as your downstream deduplication key. `documentUrl` opens the primary document; `filingIndexUrl` in the full result opens its filing index. The Actor collects metadata and links; it does not download or parse document text.

### Choose snapshot or watch

| | `snapshot` | `watch` |
| --- | --- | --- |
| Use it for | Getting a current list of matching recent filings | Collecting unseen filings across repeated runs |
| First successful scan | Returns matching rows up to the limit | Creates a baseline for each successful company; no historical rows |
| Unchanged repeat | Can return the same filings again | Returns zero rows with `NO_NEW_FILINGS` |
| Order | Newest accepted filing first | Oldest unseen filing first, to drain a backlog |
| Saved state | None | Your named Key-value store |
| Result billing | Each delivered row, including snapshot repeats | Each delivered unseen filing; baseline and empty repeats have no result fee |

#### Set up a watchlist

1. Choose `watch` and enter the companies and forms you want to track.
2. Set **your own unique** `stateStoreName`, starting with `sec-watch-`. Replace the example name below.
3. Run once. `BASELINE_CREATED` with an empty Dataset is the expected first result: existing matching filings were recorded as the starting point.
4. Run again with the **same name and filter settings**. Newly observed matching accessions are returned; an unchanged source produces `NO_NEW_FILINGS`.

```json
{
  "mode": "watch",
  "companies": ["AAPL", "MSFT"],
  "forms": ["10-K", "10-Q", "8-K"],
  "includeAmendments": true,
  "lookbackDays": 90,
  "stateStoreName": "sec-watch-my-company-filings",
  "maxResults": 20,
  "maxCostUsd": 0.02
}
```

The named store belongs to the account running the Actor. **Run one job at a time for that store.** You can start runs manually or configure your own Apify schedule or integration; this Actor does not create a schedule or send notifications itself.

Keep the companies, forms, amendments and date-window settings unchanged for an existing watch. To change them, choose a new store name and establish a new baseline. You can change `maxResults` and `maxCostUsd` without resetting the watch.

If a result limit stops a backlog partway through, only delivered filings are marked as seen. Remaining filings can be delivered on the next run while they are still in the source and selected date window. A company that initially failed gets its baseline on its first successful scan; its old filings are not treated as newly detected events.

### Example: annual reports for one company

Use a CIK to identify the company directly, select `10-K`, and disable amendments if you want only original filings.

```json
{
  "mode": "snapshot",
  "companies": ["0000789019"],
  "forms": ["10-K"],
  "includeAmendments": false,
  "lookbackDays": 365,
  "maxResults": 3,
  "maxCostUsd": 0.003
}
```

Form guide: **10-K** is an annual report, **10-Q** a quarterly report, and **8-K** a current report about company events or information. `/A` marks an amendment. See the SEC's [guide to researching filings](https://www.investor.gov/introduction-investing/getting-started/researching-investments/using-edgar-research-investments). Select the base form in `forms`; use `includeAmendments` to control its `/A` variants.

### Pricing and spending limits

**$0.001 per delivered filing row ($1 / 1,000), at every plan tier. No startup event. Apify resources are billed separately.** A filing and an amendment with separate accession numbers are separate results. There is no additional result fee for company lookup or saving watch history.

| Outcome | Filing result fee |
| --- | --- |
| 5 delivered rows | $0.005 |
| 100 delivered rows | $0.10 |
| First watch baseline | $0 |
| Watch repeat with no unseen filings | $0 |
| Empty result or error-only run | $0 |

The zero-result outcomes still consume platform resources. Snapshot repeats can return and charge the same filings again; use watch for persistent accession tracking.

- `maxResults` caps delivered rows across the entire run.
- `maxCostUsd` caps **filing result fees only**. For example, `0.005` allows at most five rows at the current price. A value below `0.001` allows no rows; `0` skips processing.
- A lower Apify event-charge limit can reduce delivery further. Neither input caps compute, storage or other platform costs; use your account's platform controls for those costs.

The underlying SEC information is free to access. You pay for the Actor's collection, filtering and watch processing. The Actor's Pricing tab shows the current tariff.

### Run through the API

Set `APIFY_TOKEN` in your own environment. Keep it in the authorization header, not the URL. This starts an asynchronous run with a $0.005 platform event-charge cap:

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/apivault_labs~sec-filing-watchlist/runs?maxTotalChargeUsd=0.005' \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header 'Content-Type: application/json' \
  --data '{"mode":"snapshot","companies":["AAPL","MSFT"],"lookbackDays":90,"maxResults":5,"maxCostUsd":0.005}'
```

The response contains `data.id`, `data.defaultDatasetId` and `data.defaultKeyValueStoreId`. Use these values in place of the uppercase placeholders below. Check the run until it finishes; a successful HTTP response to the start request does not mean the scan has completed.

```bash
## Check run status; wait for completion before exporting.
curl 'https://api.apify.com/v2/actor-runs/RUN_ID' \
  --header "Authorization: Bearer ${APIFY_TOKEN}"

## Read the delivered rows. Use format=csv or format=xlsx for other exports.
curl 'https://api.apify.com/v2/datasets/DATASET_ID/items?format=json' \
  --header "Authorization: Bearer ${APIFY_TOKEN}"

## Inspect coverage, limits and watch status.
curl 'https://api.apify.com/v2/key-value-stores/STORE_ID/records/SUMMARY' \
  --header "Authorization: Bearer ${APIFY_TOKEN}"
```

For a failed or partial run, also read `ERRORS` from the same store. Before forwarding results to a spreadsheet, database or your own alert workflow, deduplicate by `eventId`.

### Input reference

| Field | Default | Accepted values and behavior |
| --- | --- | --- |
| `mode` | `snapshot` | `snapshot` or `watch` |
| `companies` | `["AAPL", "MSFT"]` | 1–20 ticker or numeric CIK strings. Aliases resolving to the same CIK are queried once |
| `forms` | `["10-K", "10-Q", "8-K"]` | Nonempty selection of these base forms |
| `includeAmendments` | `true` | Include `/A` variants of the selected forms |
| `lookbackDays` | `90` | 1–365 calendar days, inclusive of the end date |
| `sinceDate` | Derived from lookback | Optional `YYYY-MM-DD`, inclusive. Overrides the lookback-derived start |
| `untilDate` | Today in UTC | Optional `YYYY-MM-DD`, inclusive; cannot be in the future. The requested span is at most 365 days |
| `maxResults` | `20` | Integer 0–1000, global delivered-row limit; 0 skips processing |
| `maxCostUsd` | No input fee cap | Optional nonnegative number in USD, at most 1000; caps result fees, not resources |
| `stateStoreName` | None | Required for watch; omit in snapshot. `sec-watch-` followed by 3–61 lowercase letters, digits or hyphens, starting with a letter/digit |

Date filters use the SEC-reported **`filingDate`**, not `acceptedAt` or `reportDate`. Explicit dates can select a past interval, but the Actor still only searches records present in the recent submissions response.

### Output reference

One Dataset row represents one filing. The **Filings** view shows the main fields; **Full provenance** exposes the complete record.

| Fields | Meaning |
| --- | --- |
| `eventId`, `cik`, `accessionNumber` | Stable `CIK:accession` key, zero-padded company CIK and SEC submission identifier |
| `companyName`, `tickers` | Current company metadata supplied by SEC |
| `form`, `baseForm`, `isAmendment` | Actual form, base form without `/A`, amendment flag |
| `filingDate` | SEC-reported filing date; used for filtering |
| `reportDate` | Reporting period date, or `null` if not supplied |
| `acceptedAt`, `fetchedAt` | SEC acceptance time and Actor retrieval time, both UTC |
| `primaryDocument`, `documentUrl`, `filingIndexUrl` | Source document path and official document/index links |
| `primaryDocumentDescription`, `items` | SEC description and item string, nullable; `items` is not a parsed array |
| `source`, `sourceUrl` | Source attribution and reference link |
| `documentContentFetched` | Always `false`: document content is not collected |

`SUMMARY` reports delivered/matching counts, truncation, requests and per-company observed coverage. Watch adds baseline CIKs, watch-history store ID and the number of previously observed filings. `ERRORS` contains diagnostics rather than paid result rows.

### Empty results and troubleshooting

Find the summary status in `SUMMARY`; detailed source/input codes may appear in `ERRORS`.

| Status or code | Meaning and next step |
| --- | --- |
| `COMPLETE` | Matching results were delivered without reported omissions |
| `BASELINE_CREATED` | Expected first successful watch scan. Keep the same store/settings and run again later |
| `NO_NEW_FILINGS` | No unseen filings in the successful scan's source/date window. An empty Dataset is expected |
| `NO_MATCHES` | Snapshot had no matching filings. Check company, forms and date range |
| `LIMIT_REACHED` | A row or result-fee cap stopped delivery. Inspect `truncated` and your limits |
| `PARTIAL` | Some companies/rows could not be processed. Inspect `ERRORS` and company coverage before treating the scan as complete |
| `UNKNOWN_TICKER` | The official ticker directory did not resolve the ticker. Check the symbol or use the company's CIK |
| `CHECKPOINT_SCOPE_MISMATCH` | Existing watch settings differ. Restore them or choose a new store name for a fresh baseline |
| `NO_COMPANY_DATA` | No company could be processed. Inspect the underlying codes in `ERRORS`; an invalid CIK or SEC failure can cause this |
| `SEC_HTTP_403` / `SEC_HTTP_429` | SEC rejected or limited access. This scan stops further processing; check the error and try again later |
| `CHECKPOINT_CAPACITY_EXCEEDED` | The 50,000-ID state limit would be exceeded. Establish a new baseline in a new store |

### Coverage and reliable use

Results cover recent SEC filings available for your selected companies and dates. Each company's summary shows the observed date range and any missing or unavailable results. A 365-day filter does not guarantee a complete year of filings. A full historical archive is outside this product's coverage.

Document links point to official filings. SEC corrections, removals and access restrictions can affect their availability. Amendments are separate filings; the Actor does not identify their original filing or notify you about edits or deletions within an already observed accession.

Run watches frequently enough for your chosen date window. Filings that leave the available records or selected window between runs can be missed. Use one run at a time for each watch-history store and deduplicate by `eventId` in your own workflow. An interrupted run may return some filings again on the next attempt. Each watch history supports up to 50,000 filing IDs; at that limit, choose a new store name and create a fresh baseline.

Avoid overlapping jobs. Access may be limited temporarily by SEC; a rejected scan reports the error and stops further processing. Partial results and interruptions are explained in `SUMMARY` and `ERRORS`.

This product returns filing metadata and links. Full report text, extracted financial statements, Form 4 transactions, keyword search and trading signals are outside its scope. It does not create schedules or send notifications. There is no SEC affiliation or guaranteed publication-to-detection delay. See SEC's [reuse guidance](https://www.sec.gov/about/webmaster-frequently-asked-questions) and [access guidance](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data) for the underlying public service.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/sec-filing-watchlist/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Snapshot returns recent matches; watch seeds a baseline on first success, then emits unseen accessions on sequential runs.

## `companies` (type: `array`):

One to twenty ticker or CIK strings. Multiple symbols for the same company count as one company.

## `forms` (type: `array`):

Select base forms 10-K, 10-Q and/or 8-K; amendments are controlled separately.

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

Include /A variants of your selected base forms as separate accession events.

## `lookbackDays` (type: `integer`):

Calendar-day window including the end date. Coverage is limited to available recent filings, not a full historical archive.

## `sinceDate` (type: `string`):

Inclusive ISO date; overrides the lookback-derived start.

## `untilDate` (type: `string`):

Inclusive ISO date; default today UTC.

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

Global maximum delivered filing rows across the whole watchlist. Zero skips processing.

## `maxCostUsd` (type: `number`):

Maximum result fees only; platform resources are billed separately. Zero skips processing.

## `stateStoreName` (type: `string`):

Watch only. Choose a unique name and run one job at a time with that name. Changed companies or filters require a new history.

## Actor input object example

```json
{
  "mode": "snapshot",
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "forms": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "includeAmendments": true,
  "lookbackDays": 90,
  "maxResults": 20
}
```

# Actor output Schema

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

No description

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/sec-filing-watchlist").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("apivault_labs/sec-filing-watchlist").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 '{}' |
apify call apivault_labs/sec-filing-watchlist --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/sec-filing-watchlist"
        }
    }
}
```

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/eBkSMdZBjqQolZ34n/builds/xVMQBKL1L5nDWcvft/openapi.json