# SEC EDGAR Filings Monitor (8-K, 10-K, 10-Q, Form 4) (`unrealevents22/sec-edgar-filings-monitor`) Actor

Track SEC EDGAR filings (8-K, 10-K, 10-Q, Form 4, 13D/G and more) for any tickers or CIKs from the official SEC API. Monitor mode delivers only new filings, so scheduled runs cost almost nothing when nothing new is filed.

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

## Pricing

from $1.00 / 1,000 results

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/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 EDGAR Filings Monitor: 8-K, 10-K, 10-Q, Form 4, 13D/G alerts from the official SEC API

Give it **tickers or CIKs**. It returns their **SEC EDGAR filings**, one clean row per filing, straight from the
SEC's official **data.sec.gov** API: form type, filed and report dates, accession number, links to the main
document and the filing index, and **8-K item numbers with plain-English descriptions**.

Turn on **monitor mode** and schedule it. Each run delivers **only filings it hasn't delivered before**.
Runs with nothing new cost only the $0.00005 start fee, so you can watch a list of companies every
15 minutes for about **$0.15 a month in start fees**, plus $0.001 per new filing.

- ✅ **Built for frequent schedules:** pay only for new filings, and a near-zero cost when there are none.
- ✅ **Safe monitor state:** if a run is cut short (max items, spending limit, SEC hiccup), the undelivered filings come back next run. Nothing is silently lost or double-billed.
- ✅ **Official SEC data only:** data.sec.gov submissions + company_tickers.json. No scraping, no API key, no proxies.
- ✅ **8-K items decoded:** filter for earnings (2.02), executive changes (5.02), cybersecurity incidents (1.05), material agreements (1.01) and more.
- ✅ **One row per filing, nothing else.** No summary or error rows in your dataset.

### What can I use it for?

- **Event alerts:** 8-K item 2.02 (results), 5.02 (CEO/CFO/director changes), 1.05 (cyber incidents), 1.01/2.01 (deals), sent to Slack, email, Sheets or a webhook through Apify integrations.
- **Insider activity:** Form 4 filings on a watchlist.
- **Ownership changes:** Schedule 13D / 13G (activist and 5%+ holder) filings.
- **Research and compliance archives:** every 10-K/10-Q for a list of companies in a date window, with direct document links.

### Input

| Field | Type | Description |
|---|---|---|
| `companies` (required) | array | Tickers (`AAPL`, `BRK.B`) or CIKs (`320193`, `0000320193`) |
| `forms` | array | e.g. `8-K`, `10-K`, `10-Q`, `4`, `S-1`, `SC 13D`, `SC 13G`, `DEF 14A`. Default `8-K`, `10-K`, `10-Q` (add `4` for Form 4). Empty list = all forms |
| `includeAmendments` | boolean (default `true`) | `8-K` also matches `8-K/A`, `10-K` matches `10-K/A`, and so on |
| `items8K` | array | Keep only 8-Ks with at least one of these items (e.g. `2.02`, `5.02`). Other forms are unaffected |
| `dateFrom` / `dateTo` | string | Filing-date window, inclusive: `YYYY-MM-DD` or relative `30d`, `12w`, `1y` |
| `onlyNewSinceLastRun` | boolean | **Monitor mode:** deliver only filings not delivered before |
| `stateKey` | string | Monitor name, one per schedule/watchlist (default `default`) |
| `skipExistingOnFirstRun` | boolean | Monitor mode: the first run records existing filings without delivering or charging for them |
| `maxItemsPerCompany` | integer (default 100) | Newest N matching filings per company per run |
| `maxItems` | integer | Hard cap per run. **Use it to control cost** |
| `userAgent` | string | Optional SEC User-Agent, e.g. `Your Name your@email.com`. Default: `BrainBait unrealevents22@gmail.com` |

**Amendments:** a base form matches its amendments by default (`8-K` → `8-K` and `8-K/A`). Every row has
`isAmendment` and `baseForm`, so you can split them later. Set `includeAmendments: false` to drop
amendments, or list `8-K/A` to get **only** amendments.
**Schedules 13D/13G:** EDGAR renamed these from `SC 13D`/`SC 13G` to `SCHEDULE 13D`/`SCHEDULE 13G` in December 2024. Either spelling (or `13D`, `13G`, `13D/G`) matches both.

Examples:

```json
{ "companies": ["AAPL", "MSFT", "TSLA"], "forms": ["8-K", "10-K", "10-Q"], "dateFrom": "2026-01-01" }
```

```json
{ "companies": ["NVDA", "JPM", "BRK.B"], "forms": ["8-K"], "items8K": ["5.02", "1.05"],
  "onlyNewSinceLastRun": true, "skipExistingOnFirstRun": true, "stateKey": "exec-and-cyber-alerts" }
```

### Output

One dataset item per filing:

```json
{
  "type": "filing",
  "companyName": "Apple Inc.",
  "cik": "0000320193",
  "ticker": "AAPL",
  "form": "8-K",
  "baseForm": "8-K",
  "isAmendment": false,
  "filedDate": "2026-07-30",
  "acceptedAt": "2026-07-31T00:30:28.000Z",
  "reportDate": "2026-07-30",
  "accessionNumber": "0000320193-26-000018",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
  "description": "8-K",
  "items": ["2.02", "9.01"],
  "itemDescriptions": ["Results of Operations and Financial Condition", "Financial Statements and Exhibits"],
  "fileNumber": "001-36743",
  "act": "34",
  "sizeBytes": 417360,
  "isXBRL": true,
  "isInlineXBRL": true,
  "exchanges": ["Nasdaq"],
  "input": "AAPL",
  "scrapedAt": "2026-10-08T13:15:37.210Z"
}
```

| Field | Notes |
|---|---|
| `filedDate` | EDGAR filing date (YYYY-MM-DD) |
| `acceptedAt` | EDGAR acceptance timestamp, exactly as published by the SEC |
| `reportDate` | Period of report (10-K/10-Q) or event date (8-K); `null` when the form has none |
| `items`, `itemDescriptions` | 8-K / 8-K/A only; empty for other forms. Pre-2004 legacy item numbers have a `null` description |
| `description` | The SEC's description of the primary document, when provided |
| `primaryDocumentUrl` | Main document. For Forms 3/4/5 and new Schedules 13D/G, this is the SEC's rendered (XSL) view |
| `changeType`, `firstSeenAt` | Monitor mode only (`"new"`) |
| `input` | The ticker/CIK you entered |

Each run also writes an **`OUTPUT`** record to the default key-value store (free, not a dataset row): per company,
the resolved CIK and name, matched and delivered counts, already-delivered and capped counts, older pages used,
monitor baseline/state status, and errors such as "Unknown ticker" or "CIK not found".

### Monitor mode

Set `onlyNewSinceLastRun: true` and schedule the Actor.

- **First run** = baseline: matching filings in your window are delivered with `changeType: "new"`. Or set `skipExistingOnFirstRun: true` to start silently and pay nothing for history.
- **Later runs** deliver only matching filings this monitor hasn't delivered yet. Each company + filter combination has its own history, keyed by your `stateKey`. Relative windows like `30d` keep the same history from run to run.
- **Cut-short safe:** if `maxItems`, your spending limit or an SEC error stops a run, the undelivered filings are offered again next run. A company whose data failed to load keeps its previous state.
- Filings beyond `maxItemsPerCompany` are skipped on purpose and not delivered later (the cap is your window). `OUTPUT` reports how many.
- State lives in the named key-value store `sec-edgar-filings-monitor-state` and holds only accession numbers and dates.
- New filings usually appear in the SEC API within seconds to minutes of being accepted. EDGAR accepts filings on business days, 6:00 a.m.–10:00 p.m. ET.

### Pricing

**$1 per 1,000 results ($0.001 per result), plus a $0.00005 start fee per run.**

- One result = one filing = one dataset row. Nothing else is ever written to the dataset.
- Errors, unknown tickers, duplicates, already-delivered filings and baseline-skipped filings produce no rows and cost nothing.

Examples:

- 10 companies × all 10-K/10-Q/8-K filings for a year (≈ 150 filings) ≈ **$0.15**.
- A 25-company watchlist checked every 15 minutes (≈ 2,900 runs a month) costs ≈ **$0.15/month in start fees**, plus $0.001 per new filing delivered. 200 new filings a month ≈ **$0.35/month in total**.

Use `maxItems` and `maxItemsPerCompany` to cap any run. The Actor also stops cleanly at your run's maximum charge limit.

### Limits

- A company's filing list on EDGAR includes filings where it is the **filer or the subject**. So you get Form 4s filed by its insiders and 13D/G filed by its holders, and also 13D/G or Form 4 filings the company itself made about *other* issuers (e.g. Berkshire Hathaway). Check `primaryDocumentUrl` when that distinction matters.
- Tickers are resolved with SEC's `company_tickers.json`, which covers current exchange-listed tickers. For delisted companies, funds or individuals, use the CIK (find it with [EDGAR company search](https://www.sec.gov/search-filings)).
- This Actor returns filing metadata and links, not the document text or XBRL financials.
- Full-text search (searching inside filings) isn't included yet.

### Data source and compliance

- Uses only the SEC's free, official APIs: `https://data.sec.gov/submissions/CIK##########.json` (plus its older-filings pages when your window needs them) and `https://www.sec.gov/files/company_tickers.json` ([EDGAR APIs](https://www.sec.gov/search-filings/edgar-application-programming-interfaces)).
- Follows SEC's [fair-access policy](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data): a declared User-Agent with a contact email (SEC asks heavy users to identify themselves, so if you run large or frequent jobs, set `userAgent` to your own name and email), and at most **5 requests per second** with 2 at a time across all SEC hosts (SEC's ceiling is 10 per second). It backs off on 403/429/5xx and downloads only what you ask for.
- SEC: "Information presented on sec.gov is considered public information and may be copied or further distributed by users of the web site without the SEC's permission" ([SEC privacy and dissemination](https://www.sec.gov/about/privacy-information)). This Actor is not affiliated with or endorsed by the SEC.

### FAQ

**My ticker wasn't found.** It isn't in SEC's current ticker file. Use the CIK instead.

**Why do I see filings by other companies under Berkshire (or another investor)?** EDGAR lists filings where the company is the filer *or* the subject. See Limits.

**How fast are new filings picked up?** The SEC API updates in real time as filings are disseminated. Your schedule sets the delay.

**A run reported "SEC is rate-limiting this IP".** SEC blocks an IP for about 10 minutes after more than 10 requests per second. The Actor stays well below that on its own, but other traffic from the same IP counts too. Re-run later.

### Contact

Questions, bugs or feature requests: **unrealevents22@gmail.com**, or open an issue on the Actor's Issues tab.

### Run locally (no Apify account needed)

```bash
npm install
mkdir -p storage/key_value_stores/default
echo '{"companies":["AAPL","MSFT"],"forms":["8-K"],"dateFrom":"90d"}' > storage/key_value_stores/default/INPUT.json
node src/main.js     # results in storage/datasets/default, OUTPUT in storage/key_value_stores/default
npm test             # offline tests on recorded SEC responses
```

# Actor input Schema

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

Tickers (AAPL, BRK.B) or SEC CIK numbers (320193 or 0000320193). Tickers are resolved with SEC's company_tickers.json.

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

e.g. 8-K, 10-K, 10-Q, 4, S-1, SC 13D, SC 13G, DEF 14A. Default: 8-K, 10-K, 10-Q. Form 4 (insider trades, very high volume) is not included by default; add '4' to get it. An empty list means all forms. A base form also matches its amendments (8-K matches 8-K/A) unless you turn off 'Include amendments'. Write 8-K/A to get only amendments. SC 13D / SC 13G also match the newer SCHEDULE 13D / SCHEDULE 13G names.

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

When a base form like 8-K is listed, also return its amendments (8-K/A).

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

Keep only 8-Ks reporting at least one of these items, e.g. 2.02 (results), 5.02 (officer/director changes), 1.05 (cybersecurity incident), 1.01 (material agreement). Other forms are not affected.

## `dateFrom` (type: `string`):

YYYY-MM-DD, or relative: 30d, 12w, 1y. Older filing pages are fetched only when needed.

## `dateTo` (type: `string`):

YYYY-MM-DD or relative (30d, 12w, 1y).

## `onlyNewSinceLastRun` (type: `boolean`):

Each run delivers only matching filings this monitor hasn't delivered before (changeType = 'new'). Schedule it (e.g. every 15 minutes). State lives in the named key-value store 'sec-edgar-filings-monitor-state'.

## `stateKey` (type: `string`):

Use a different name per schedule/watchlist. Letters, digits, '-' and '\_'.

## `skipExistingOnFirstRun` (type: `boolean`):

Monitor mode only. The first run records existing filings without delivering (or charging for) them; later runs deliver only new ones.

## `maxItemsPerCompany` (type: `integer`):

Newest N matching filings per company per run.

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

Hard cap on results in this run (one result = one filing = one dataset row). Leave empty for no cap beyond your spending limit.

## `userAgent` (type: `string`):

SEC asks automated tools to identify themselves with a name and contact email, e.g. 'Your Name your@email.com'. Heavy users should supply their own. If empty, the Actor's default ('BrainBait unrealevents22@gmail.com') is used.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "TSLA"
  ],
  "forms": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "onlyNewSinceLastRun": false,
  "stateKey": "default",
  "skipExistingOnFirstRun": false,
  "maxItemsPerCompany": 100
}
```

# Actor output Schema

## `results` (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 = {
    "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("unrealevents22/sec-edgar-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("unrealevents22/sec-edgar-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 unrealevents22/sec-edgar-filings-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,unrealevents22/sec-edgar-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/5rp6cHiMuYKC99TWY/builds/zjVy4jmrYocF3Q25b/openapi.json