# SEC Filings Monitor & Scraper (8-K, 10-K, 10-Q, S-1, 13F) (`kestreldata/sec-filings-monitor`) Actor

Monitor and scrape new SEC filings (8-K, 10-K, 10-Q, S-1, 13F, Form D...) for a watchlist of tickers/CIKs or for all filers, from official SEC data APIs and daily indexes. 8-K item codes, links, XBRL flags. Only new filings each run. No API key.

- **URL**: https://apify.com/kestreldata/sec-filings-monitor.md
- **Developed by:** [Kestrel Data](https://apify.com/kestreldata) (community)
- **Categories:** Business, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Filings Monitor & Scraper (8-K, 10-K, 10-Q, S-1, 13F)

Track **new SEC filings** for a watchlist of tickers or CIKs, or scan **every filer** for the forms you care about: 8-K current reports, 10-K and 10-Q periodic reports, S-1 IPO registrations, 13F-HR holdings reports, Form D offerings, DEF 14A proxies, 20-F/6-K for foreign issuers, and more. Schedule it and each run returns **only filings you haven't seen before**. That works as an 8-K alert feed, an IPO (S-1) tracker, or an earnings-release (8-K item 2.02) monitor.

Data comes from the SEC's official, free, keyless sources. You don't need an API key, a login or a proxy.

### What you get

| Field | Example |
|---|---|
| `companyName`, `cik`, `tickers`, `exchanges` | Apple Inc., 320193, AAPL, Nasdaq |
| `form`, `isAmendment` | 8-K, false |
| `filingDate`, `acceptanceDateTime`, `reportDate` | 2026-07-30, 2026-07-30T20:30:30Z, 2026-07-30 |
| `items8K`, `items8KDescriptions` | 2.02 "Results of Operations and Financial Condition" |
| `filingIndexUrl`, `documentUrl`, `primaryDocDescription` | links to the filing index and main document |
| `accessionNumber`, `sizeBytes`, `isXBRL`, `isInlineXBRL` | unique filing id and XBRL flags |
| `sic`, `sicDescription`, `stateOfIncorporation`, `fiscalYearEnd` | industry and company details |
| `changeType`, `isFirstRun`, `scrapedAt` | monitor metadata |

The **Filings** table view shows the key columns. A run summary is saved to the `OUTPUT` record: per-company status, counts, and which daily index files weren't available.

### Two modes

1. **Watchlist** (fill in *Companies*): tickers such as `AAPL` and `BRK-B`, or CIK numbers. You get full detail, including 8-K item codes, tickers, the primary document and XBRL flags. Lookback can go up to 365 days.
2. **All filers** (leave *Companies* empty): reads the SEC daily index for every business day in the window, up to 30 days. Filter by form type and by words in the company name (for example *therapeutics*, *bank*, *acquisition corp*). Each daily index is built nightly, around 10 pm US Eastern, so today's filings show up after that. The monitor overlaps runs by 3 days, so nothing is missed.

### Example inputs

8-K earnings releases and executive changes for a watchlist:

```json
{ "companies": ["AAPL", "MSFT", "NVDA"], "forms": ["8-K"], "items8K": ["2.02", "5.02"], "lookbackDays": 30 }
```

New IPO registrations (S-1 / F-1) from all filers:

```json
{ "forms": ["S-1", "F-1"], "includeAmendments": false, "lookbackDays": 7 }
```

Quarterly and annual reports from banks:

```json
{ "forms": ["10-Q", "10-K"], "companyNameKeywords": ["bank", "bancorp"], "lookbackDays": 14 }
```

### Monitoring (schedule it)

Create an Apify **Schedule**, for example daily at 06:00 UTC, with *Output mode* set to "Only filings not seen before". Seen accession numbers are kept in the named key-value store `sec-filings-monitor-<stateName>`. Use a different *Monitor state name* for each independent watchlist. Changing the filters starts a fresh state automatically. Send results anywhere with Apify integrations: webhooks, Slack, email, Google Sheets, Zapier or Make.

### Privacy and fair access

- **No personal data:** insider and ownership filings (Forms 3, 4, 5, 144, and Schedules 13D/13G) are never returned. Filers whose SEC entity type is *individual* are skipped. The Actor returns filing metadata and links only, not document text.
- **Respects SEC fair-access rules:** it sends a declared User-Agent, stays under about 6 requests per second (the SEC limit is 10 per second), and uses only the documented endpoints. Those are `data.sec.gov/submissions`, `/Archives/edgar/daily-index` and `/files/company_tickers.json`, described in [Accessing EDGAR Data](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data). Paths disallowed in robots.txt, such as `/cgi-bin`, are not used.
- **Source and licence:** per the SEC website policy, "information presented on sec.gov is considered public information and may be copied or further distributed" ([sec.gov/privacy](https://www.sec.gov/privacy), Website Dissemination). Source: U.S. Securities and Exchange Commission. This Actor is independent and is **not affiliated with or endorsed by the SEC**. EDGAR® is a registered trademark of the SEC and is mentioned only to describe the data source.

### Cost

It uses lightweight HTTP requests only, with no browser. A typical watchlist run takes a few seconds at 256 MB.

### FAQ

**Why are the ticker and item fields empty in all-filers mode?** The daily index lists only CIK, name, form, date and file. Use watchlist mode for full detail.
**Can I get Form 4 insider trades?** No. They are deliberately excluded because they are personal data about individuals.
**A ticker isn't found.** Use the CIK instead. You can look it up on sec.gov. Class shares use a dash, for example `BRK-B`.

*Not investment advice. Data accuracy depends on the SEC's sources.*

# Actor input Schema

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

Watchlist of tickers (AAPL, BRK-B) or CIK numbers (320193). Leave empty to scan ALL filers via the SEC daily index (form/name filters apply; 8-K item codes and tickers are not available in that mode).

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

Only these forms, e.g. 8-K, 10-K, 10-Q, S-1, 13F-HR, D, DEF 14A, 20-F, 6-K. Empty = all forms. Insider/ownership forms (3, 4, 5, 144, SC 13D/13G) are never returned.

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

Also match amended forms such as 8-K/A when 8-K is selected.

## `items8K` (type: `array`):

Only 8-Ks reporting these items, e.g. 1.01 (material agreement), 2.02 (earnings), 5.02 (executive change), 1.05 (cyber incident). Watchlist mode only.

## `companyNameKeywords` (type: `array`):

All-filers mode: keep filers whose name contains any of these words (case-insensitive), e.g. bank, therapeutics, acquisition corp.

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

First-run window. Max 365 for a watchlist, 30 for all filers. Later monitor runs continue from the last run (with a 3-day overlap).

## `emitMode` (type: `string`):

Monitor mode returns only filings not seen in earlier runs; All returns every matching filing in the window.

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

Cap on dataset items per run (0 = no cap).

## `stateName` (type: `string`):

Use different names to run independent monitors. State is kept in the named key-value store sec-filings-monitor-<name>.

## `resetState` (type: `boolean`):

Forget previously seen filings and start fresh.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "TSLA"
  ],
  "forms": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "lookbackDays": 7,
  "emitMode": "changes",
  "maxResults": 0,
  "stateName": "default",
  "resetState": false
}
```

# Actor output Schema

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

Filings (new ones only in monitor mode).

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

Mode, window, per-company status and counts.

# 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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "TSLA"
    ],
    "forms": [
        "8-K",
        "10-K",
        "10-Q"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kestreldata/sec-filings-monitor").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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "TSLA",
    ],
    "forms": [
        "8-K",
        "10-K",
        "10-Q",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("kestreldata/sec-filings-monitor").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 '{
  "companies": [
    "AAPL",
    "MSFT",
    "TSLA"
  ],
  "forms": [
    "8-K",
    "10-K",
    "10-Q"
  ]
}' |
apify call kestreldata/sec-filings-monitor --silent --output-dataset

```

## MCP server setup

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

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/X22U2eMblQqpRpeJd/builds/J23hlsPJp93eTHwHD/openapi.json