# SEC EDGAR Scraper: 8-K, 10-K, Form 4 Filings (`heaped_qualm/sec-edgar-monitor`) Actor

SEC EDGAR scraper for 8-K, 10-K, 10-Q and Form 4 filings by ticker, CIK or name. Each run returns only new filings (8-K items decoded), insider trades and XBRL financials (revenue, net income, EPS). Official SEC data, no API key.

- **URL**: https://apify.com/heaped_qualm/sec-edgar-monitor.md
- **Developed by:** [Artem Kulyk](https://apify.com/heaped_qualm) (community)
- **Categories:** Business, News, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 16.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 filing 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 Scraper: 8-K, 10-K, Form 4 Filings

This **SEC EDGAR scraper** exports and monitors SEC filings (8-K, 10-K, 10-Q, Form 4) for any US public company. Watch US public companies by **ticker, CIK or company name** using only **official SEC EDGAR data**. Each run returns what is **new since the last run**: filings with decoded 8-K items (2.02 = results, 5.02 = executive change), **insider trades parsed from Form 4** (insider, role, buy or sell, shares, price, value, holdings after, 10b5-1 flag) and **key financials from XBRL** (revenue, net income, EPS, cash and more). No API key.

**Why this actor:** most EDGAR scrapers list filing links. This one tells you what is new, explains 8-K items in plain English, and turns Form 4 XML and XBRL facts into ready-to-use rows.

🇩🇪 [Deutsche Version](#deutsch)

### Contents

[Key features](#key-features) · [Use cases](#use-cases) · [Quick start](#quick-start) · [Input](#input) · [Output](#output) · [Pricing](#pricing) · [Integrations](#integrations) · [Limits](#limits) · [FAQ](#faq) · [Legal and data source](#legal-and-data-source) · [Changelog](#changelog) · [Related actors](#related-actors) · [Support](#support)

### Key features

- Official sources only: EDGAR submissions, the XBRL companyfacts API and Form 4 XML on sec.gov. No HTML scraping, no key.
- **Three record types** in one dataset: `filing`, `insiderTrade` and `financials`, each with its own view.
- **8-K items decoded** to plain English, with an 8-K item filter (for example only 2.02 and 5.02).
- **Form 4 insider trades:** one row per transaction, derivative and non-derivative, with SEC transaction codes explained.
- **Key financials:** revenue, gross profit, operating and net income, EPS, operating cash flow, assets, liabilities, equity, cash, debt and shares, with fiscal year and period.
- Monitor mode remembers filings, Form 4s and financial periods per Monitor name.
- Respects SEC fair-access rules: declared User-Agent, at most 5 requests per second, retries with backoff.

### Use cases

- **Investors and analysts:** a daily list of new 8-Ks, earnings releases and 10-Qs for a watchlist.
- **Insider-trading signals:** CEO and director buys and sells as soon as the Form 4 is filed.
- **Sales and business development:** executive changes (8-K item 5.02) as trigger events.
- **Compliance and IR teams:** track peers and competitors.
- **Quant and AI pipelines:** clean, typed rows for models, agents and spreadsheets.

### Quick start

1. Click **Try for free** / **Start**. The form is prefilled (Apple, Microsoft and NVIDIA, 8-K, 10-K and 10-Q from the last 90 days, with financials and insider trades), so the first run works without changes.
2. Replace the example with your own tickers, CIKs or company names and adjust the filters.
3. Open the **Output** tab. Use the views (Overview, Filings, Insider trades, Financials) or export JSON, CSV, Excel or HTML.
4. To monitor: switch on **Only new filings since last run**, give the watch a **Monitor name**, save it as a task and add a **schedule** (for example daily at 07:00). From the second run you receive only changes.

### Input

Enter companies, choose form types and a date range. Financials and insider trades are on by default.

```json
{
  "companies": [
    "TSLA",
    "AMZN",
    "0000320193",
    "Palantir"
  ],
  "formTypes": [
    "8-K",
    "10-Q",
    "4"
  ],
  "eightKItems": [
    "2.02",
    "5.02"
  ],
  "lastDays": 30,
  "includeFinancials": true,
  "includeInsiderTrades": true,
  "maxInsiderFilingsPerCompany": 20,
  "onlyNew": true,
  "stateKey": "big-tech"
}
```

Tips: tickers and CIKs match exactly; a company name is matched against SEC's official ticker list. Add your contact e-mail: SEC asks automated tools to identify themselves, and it is only sent in the User-Agent header to SEC, never stored in the output.

### Output

Each row is one row. `changeType` tells you why it is in the dataset: `BASELINE` (first run), `NEW` (filing, Form 4 or financial period not seen before) and `SEEN` (only when monitor mode is off). `recordType` says whether the row is a `filing`, an `insiderTrade` or `financials`.

Real rows from a run on 1 November 2026:

| Type | Ticker | Form | Filed | 8-K items | Meaning | Change |
|---|---|---|---|---|---|---|
| filing | AAPL | 8-K/A | 2026-09-01 | 5.02 | Director/officer departure or appointment | BASELINE |
| filing | AAPL | 10-Q | 2026-07-31 |  |  | BASELINE |
| filing | AAPL | 8-K | 2026-07-30 | 2.02, 9.01 | Results of operations (earnings); Financial statements and exhibits | BASELINE |

One full record (long values shortened):

```json
{
  "recordType": "filing",
  "changeType": "BASELINE",
  "query": "AAPL",
  "cik": "320193",
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "tickers": "AAPL",
  "exchange": "Nasdaq",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "stateOfIncorporation": "CA",
  "form": "8-K/A",
  "baseForm": "8-K",
  "isAmendment": true,
  "filingDate": "2026-09-01",
  "reportDate": "2026-04-17",
  "acceptedAt": "2026-09-01T20:30:35.000Z",
  "accessionNumber": "0001140361-26-035325",
  "items": "5.02",
  "itemDescriptions": "Director/officer departure or appointment",
  "primaryDocDescription": "8-K/A",
  "fileNumber": "001-36743",
  "isXBRL": true,
  "sizeBytes": 241262,
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/ef20081427_8ka.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/0001140361-26-035325-index.htm",
  "edgarCompanyUrl": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=320193",
  "scrapedAt": "2026-11-01T20:34:27.376Z"
}
```

<details><summary>All output fields</summary>

| Field | Description |
|---|---|
| `recordType` | Row type: filing, financials or insiderTrade. |
| `changeType` | BASELINE on the first run of a monitor, NEW afterwards; SEEN only when monitor mode is off. |
| `query` | The company entry from your input that produced this row. |
| `cik` | SEC Central Index Key (without leading zeros). |
| `companyName` | Company name as registered with the SEC. |
| `ticker` | Primary ticker. |
| `tickers` | All tickers, comma-separated. |
| `exchange` | Primary exchange. |
| `sic` | Standard Industrial Classification code. |
| `sicDescription` | SIC industry description. |
| `stateOfIncorporation` | State or country of incorporation. |
| `form` | Form type, e.g. 8-K, 10-Q, 4, 10-K/A. |
| `baseForm` | Form type without the /A suffix. |
| `isAmendment` | True for amendments (/A). |
| `filingDate` | Filing date (YYYY-MM-DD). |
| `reportDate` | Period of report (YYYY-MM-DD). |
| `acceptedAt` | EDGAR acceptance timestamp (UTC). |
| `accessionNumber` | EDGAR accession number, unique per filing. |
| `items` | 8-K item codes, e.g. 2.02, 9.01. |
| `itemDescriptions` | Plain-English meaning of the 8-K items. |
| `primaryDocDescription` | Description of the primary document. |
| `fileNumber` | SEC file number. |
| `isXBRL` | Filing includes XBRL data. |
| `sizeBytes` | Filing size in bytes. |
| `documentUrl` | Link to the primary document. |
| `filingIndexUrl` | Link to the EDGAR filing index page. |
| `edgarCompanyUrl` | Link to the company page on EDGAR. |
| `fiscalYear` | Fiscal year of the report. |
| `fiscalPeriod` | FY, Q1, Q2, Q3 or Q4. |
| `periodEnd` | Period end date. |
| `periodStart` | Period start date of the revenue/net income figures. |
| `periodMonths` | Length of the income-statement period in months. |
| `filedDate` | Date the report was filed. |
| `currency` | Reporting currency, e.g. USD. |
| `operatingCashFlowMonths` | Months covered by operating cash flow (10-Qs are often year-to-date). |
| `revenue` | Revenue. |
| `grossProfit` | Gross profit. |
| `operatingIncome` | Operating income (loss). |
| `netIncome` | Net income (loss). |
| `epsBasic` | Earnings per share, basic. |
| `epsDiluted` | Earnings per share, diluted. |
| `operatingCashFlow` | Net cash from operating activities. |
| `totalAssets` | Total assets. |
| `totalLiabilities` | Total liabilities. |
| `stockholdersEquity` | Stockholders' equity. |
| `cash` | Cash and cash equivalents. |
| `longTermDebt` | Long-term debt. |
| `sharesOutstanding` | Shares outstanding (cover page). |
| `netMargin` | Net income / revenue (0.27 = 27%). |
| `xbrlTags` | Which XBRL tag each figure came from. |
| `sourceUrl` | SEC API URL the figures came from. |
| `transactionIndex` | Position of this transaction in the Form 4. |
| `documentType` | Ownership document type (3, 4, 5, 4/A). |
| `periodOfReport` | Form 4 period of report. |
| `issuerTradingSymbol` | Issuer ticker as written in the Form 4. |
| `insiderName` | Reporting person(s). |
| `insiderCik` | Reporting person CIK(s). |
| `insiderRole` | Director, Officer (title), 10% owner, Other. |
| `isDirector` | Reporting person is a director. |
| `isOfficer` | Reporting person is an officer. |
| `isTenPercentOwner` | Reporting person owns 10% or more. |
| `officerTitle` | Officer title. |
| `is10b5_1Plan` | Trade made under a Rule 10b5-1 plan (checkbox or footnote). |
| `isDerivative` | From the derivative table (options, RSUs). |
| `securityTitle` | Security, e.g. Common Stock. |
| `transactionDate` | Transaction date. |
| `transactionCode` | SEC transaction code: P buy, S sell, A grant, M exercise, F tax withholding, ... |
| `transactionCodeDescription` | Meaning of the transaction code. |
| `acquiredDisposed` | Acquired or Disposed. |
| `shares` | Number of shares. |
| `pricePerShare` | Price per share. |
| `transactionValue` | Shares × price. |
| `sharesOwnedAfter` | Shares owned after the transaction. |
| `directOrIndirect` | Direct or Indirect ownership. |
| `underlyingSecurity` | Underlying security (derivatives). |
| `exercisePrice` | Exercise or conversion price (derivatives). |
| `xmlUrl` | Link to the Form 4 XML. |
| `scrapedAt` | When this run fetched the data (UTC). |

</details>

A run summary is saved as `RUN_SUMMARY` in the run's key-value store (counts per change type, companies resolved, filings, insider trades and financial rows).

### Pricing

Pay per result: **$0.40 per 1,000 rows** plus **$0.003 per run**. Apify platform usage is included, so there is nothing else to pay. Check the **Pricing** tab for the current price.

| Scenario | Volume | Cost |
|---|---|---|
| Try it: prefilled Apple, Microsoft, NVIDIA | 90 rows, 1 run | **$0.039** |
| Daily watch of 50 tickers, about 10 new rows a day | 300 rows, 30 runs | **$0.21** |
| Backfill 2,000 filings | 2,000 rows, 1 run | **$0.80** |

Monitor mode keeps a schedule cheap: after the first run you pay only for new filings, trades and reports. Apify's free plan includes $5 of monthly credit, which covers small monitors.

### Integrations

- **Schedules:** Console → Schedules → add this actor's saved task (daily or hourly). Keep the same **Monitor name** so each run compares with the previous one.
- **Webhooks:** on the Integrations tab add a webhook for *Run succeeded* to POST the run to your own endpoint, then fetch rows from `https://api.apify.com/v2/datasets/{datasetId}/items?format=json`.
- **Slack and email:** add the Slack or Email integration on the Integrations tab to get a message after each run.
- **Zapier, Make and n8n:** use the official Apify app ("Watch actor runs" trigger, then "Get dataset items"). Filter on `changeType` to forward only new insider trades or 8-K items.
- **Google Sheets:** connect through Make or Zapier, or export the dataset as CSV and import it.
- **MCP and AI agents:** add `https://mcp.apify.com?tools=heaped_qualm/sec-edgar-monitor` to Claude, Cursor or any MCP client. The flat rows are easy for agents to read.

**Python** (`pip install apify-client`):

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("heaped_qualm/sec-edgar-monitor").call(run_input={"companies": ["TSLA", "AMZN", "0000320193", "Palantir"], "formTypes": ["8-K", "10-Q", "4"], "eightKItems": ["2.02", "5.02"], "lastDays": 30, "includeFinancials": true, "includeInsiderTrades": true, "maxInsiderFilingsPerCompany": 20, "onlyNew": true, "stateKey": "big-tech"})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["changeType"], item["recordType"], item.get("form"))
```

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('heaped_qualm/sec-edgar-monitor').call({"companies": ["TSLA", "AMZN", "0000320193", "Palantir"], "formTypes": ["8-K", "10-Q", "4"], "eightKItems": ["2.02", "5.02"], "lastDays": 30, "includeFinancials": true, "includeInsiderTrades": true, "maxInsiderFilingsPerCompany": 20, "onlyNew": true, "stateKey": "big-tech"});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items);
```

**HTTP** (waits for the run and returns the rows):

```bash
curl -X POST "https://api.apify.com/v2/acts/heaped_qualm~sec-edgar-monitor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["TSLA", "AMZN", "0000320193", "Palantir"], "formTypes": ["8-K", "10-Q", "4"], "eightKItems": ["2.02", "5.02"], "lastDays": 30, "includeFinancials": true, "includeInsiderTrades": true, "maxInsiderFilingsPerCompany": 20, "onlyNew": true, "stateKey": "big-tech"}'
```

### Limits

- Up to 2,000 filings and 200 Form 4s per company per run; up to 12 financial periods.
- Financials come from XBRL as filed: 10-Q figures cover the quarter, 10-K figures the year; operating cash flow in a 10-Q is year-to-date (`operatingCashFlowMonths`).
- US SEC registrants only. Foreign private issuers that file 20-F or 6-K work with **Other form types**.
- Speed is capped at 5 requests per second to respect SEC limits, so very large backfills take a few minutes.

### FAQ

**Is it legal to scrape SEC EDGAR?**
EDGAR is public information. This actor uses SEC's official data endpoints and follows the [fair-access policy](https://www.sec.gov/os/webmaster-faq#developers): a declared User-Agent and at most 5 requests per second, half of the 10 per second limit.

**Where do the financials come from?**
From SEC's XBRL companyfacts API (data.sec.gov), as filed by the company. The XBRL tag used is in `xbrlTags`.

**How are insider trades parsed?**
From the Form 4 XML (ownershipDocument): one row per transaction with insider, role, code, shares, price, value, shares owned after, direct or indirect, and the 10b5-1 flag.

**Can I filter 8-Ks by item?**
Yes, with **8-K item filter**. For example 2.02 (results of operations) and 5.02 (officer or director change).

**How do I get a full export instead of only changes?**
Switch off **Only new filings since last run**, or use a new **Monitor name**.

**Why are all rows BASELINE on the first run?**
The first run has nothing to compare with, so everything it finds is the baseline. Later runs with the same Monitor name report only changes.

**The run failed or returned nothing. What now?**
Read the status message and the `RUN_SUMMARY` record. An unknown ticker is listed under `unknown` in the summary; try the CIK instead. If it still looks wrong, open an issue on the **Issues** tab with the run link.

### Legal and data source

Data source: [SEC EDGAR](https://www.sec.gov/edgar) (U.S. Securities and Exchange Commission) via official endpoints on sec.gov and data.sec.gov. EDGAR filings are public. Each row links to the original document. Requests follow SEC's fair-access policy. Not investment advice.

This actor is independent and not affiliated with or endorsed by the U.S. Securities and Exchange Commission. Data is provided as is, without warranty.

### Changelog

- 0.4 (Nov 2026): automated test suite (unit, integration, input and schema tests, 100% line coverage); a truncated or malformed SEC response is now retried instead of failing the company (bug fix); input form grouped into sections with examples; documented output schema with four views; monitor mode starts switched off in the form so test runs always show results.
- 0.3: key financials from XBRL; Form 4 insider transactions; change detection for financial periods and Form 4s.
- 0.2: zero-config defaults, 8-K item filter and descriptions, company-name lookup, older history paging.
- 0.1: first release.

### Related actors

More free monitors by the same author, built on official APIs:

- [ClinicalTrials.gov Scraper & Trial Monitor](https://apify.com/heaped_qualm/clinicaltrials-monitor): ClinicalTrials.gov scraper and trial monitor
- [PubMed Scraper & New Article Monitor](https://apify.com/heaped_qualm/pubmed-monitor): PubMed scraper and new article monitor
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/heaped_qualm/job-board-monitor): Greenhouse, Lever & Ashby jobs scraper and monitor
- [Hacker News Scraper & Keyword Monitor](https://apify.com/heaped_qualm/hackernews-monitor): Hacker News scraper and keyword monitor

### Support

Open an issue on the **Issues** tab of this page. Please include the run link and what you expected to see. Feature requests are welcome.

**More monitors from the same author:** [ClinicalTrials.gov Scraper & Trial Monitor](https://apify.com/heaped_qualm/clinicaltrials-monitor) · [PubMed Scraper & New Article Monitor](https://apify.com/heaped_qualm/pubmed-monitor) · [Greenhouse, Lever, Ashby & Recruitee Jobs Monitor](https://apify.com/heaped_qualm/job-board-monitor)

***

<a name="deutsch"></a>

### 🇩🇪 Deutsch: SEC-EDGAR-Monitor: 8-K, 10-K, 10-Q und Form 4

Überwacht US-Börsenunternehmen per **Ticker, CIK oder Name** ausschließlich mit **offiziellen SEC-EDGAR-Daten** und liefert pro Lauf nur **Neues**: Einreichungen mit erklärten 8-K-Items, **Insider-Trades aus Form 4** und **Kennzahlen aus XBRL**.

**Funktionen**

- Nur offizielle SEC-Endpunkte, kein API-Schlüssel
- Drei Datensatztypen: Einreichung, Insider-Trade, Finanzkennzahlen
- 8-K-Items im Klartext und filterbar
- Insider-Transaktionen mit Rolle, Kauf/Verkauf, Stückzahl, Preis
- Einhaltung der SEC-Fair-Access-Regeln (max. 5 Anfragen/s)

**Anwendungsfälle**

- Investoren und Analysten: tägliche Liste neuer 8-K und 10-Q
- Insider-Signale: Käufe und Verkäufe von Vorständen
- Vertrieb: Personalwechsel im Management (Item 5.02)
- Quant- und KI-Pipelines

**Schnellstart**

1. **Start** klicken. Das Formular ist vorausgefüllt, der erste Lauf funktioniert ohne Änderungen.
2. Eigene Ticker, CIKs oder Firmennamen eintragen und Filter anpassen.
3. Ergebnisse im Tab **Output** ansehen oder als JSON, CSV oder Excel exportieren.
4. Für die Überwachung **Only new filings since last run** einschalten, einen **Monitor-Namen** vergeben, als Task speichern und einen **Zeitplan** anlegen. Ab dem zweiten Lauf kommen nur noch Änderungen.

**Eingabebeispiel:** siehe JSON oben (vier Unternehmen, 8-K-Items 2.02 und 5.02, Form 4).

**Ausgabe:** eine Zeile pro Zeile. `changeType` zeigt den Grund: BASELINE (erster Lauf), NEW, SEEN (nur ohne Monitor-Modus); `recordType` = filing, insiderTrade oder financials.

**Preis:** $0.40 pro 1.000 Zeilen plus $0.003 pro Lauf, Plattformkosten inklusive. Beispiel: täglich 50 Ticker mit etwa 10 neuen Zeilen pro Tag ≈ $0.21 im Monat. Den aktuellen Preis zeigt der Tab **Pricing**.

**Integrationen:** Zeitpläne, Webhooks, Slack, E-Mail, Zapier, Make, n8n, Google Sheets, API (Python, JavaScript, HTTP) und MCP für KI-Agenten (`https://mcp.apify.com?tools=heaped_qualm/sec-edgar-monitor`).

**Grenzen:** bis 2.000 Einreichungen und 200 Form 4 pro Unternehmen und Lauf; nur bei der SEC registrierte Unternehmen.

**Rechtliches und Datenquelle:** Quelle: SEC EDGAR (U.S. Securities and Exchange Commission), offizielle Endpunkte, öffentliche Daten, Link zum Originaldokument je Zeile. Keine Anlageberatung. Kein Bezug zu und keine Unterstützung durch the U.S. Securities and Exchange Commission. Daten ohne Gewähr.

**Support:** Tab **Issues** auf dieser Seite, bitte mit Link zum Lauf.

# Actor input Schema

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

One per line: ticker (AAPL, BRK.B), numeric CIK (320193) or part of the company name ("tesla"). Names are matched against SEC's official company_tickers.json; the first, largest match wins, so prefer tickers or CIKs.

## `formTypes` (type: `array`):

Pick the forms to watch. Empty = all forms. Amendments (/A) are included unless switched off below.

## `customFormTypes` (type: `array`):

Any form code not in the list above, e.g. N-PORT, 425, ARS.

## `eightKItems` (type: `array`):

Keep only 8-Ks that report at least one of these item codes, e.g. 2.02 (earnings), 5.02 (director or officer change), 1.01 (material agreement), 1.05 (cybersecurity incident). Format: digit, dot, two digits. Empty = all 8-Ks.

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

Also match 10-K/A, 8-K/A etc. when 10-K / 8-K is selected.

## `lastDays` (type: `integer`):

Only filings from the last N days. Ignored when 'Filed since' is set. 0 = no limit.

## `filedSince` (type: `string`):

Earliest filing date (YYYY-MM-DD). When set, it replaces "Look back (days)".

## `filedUntil` (type: `string`):

Latest filing date (YYYY-MM-DD). Leave empty for no upper limit.

## `includeFinancials` (type: `boolean`):

Adds a "financials" row per company for the latest periodic report (10-K, 10-Q, 20-F, 40-F) from SEC's XBRL companyfacts API: revenue, gross profit, operating and net income, EPS (basic and diluted), operating cash flow, assets, liabilities, equity, cash, long-term debt and shares outstanding, with fiscal year, period and period dates. In monitor mode a row appears only when a new report is filed.

## `financialPeriods` (type: `integer`):

How many of the latest periodic reports (10-K/10-Q/20-F) to return figures for. 1 = latest only.

## `includeInsiderTrades` (type: `boolean`):

Parses Form 4 XML filed in the look-back window into one row per transaction: insider name, role/title, transaction code (P buy, S sell, A grant, M exercise, F tax …), shares, price, value, shares owned after, direct/indirect, 10b5-1 plan flag. Monitor mode only parses Form 4s not seen before.

## `maxInsiderFilingsPerCompany` (type: `integer`):

Newest Form 4 filings to parse per company per run. Each one is one extra SEC request; the Actor stays at or below 5 requests per second.

## `onlyNew` (type: `boolean`):

Monitor mode: return only filings, reports and Form 4s not seen before under the same monitor name. The first run returns everything in range as BASELINE. Switch off to return every match (already seen ones are marked SEEN). It starts switched off in the form, so a manual test run always shows results. Switch it on in the task you schedule. API calls that omit this field get monitor mode on.

## `maxFilingsPerCompany` (type: `integer`):

Cap per company per run (newest first). Older history pages are fetched automatically when needed.

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

Name of this monitor's memory (letters, digits and dashes; other characters become dashes). Use a different name for each watchlist or schedule.

## `contactEmail` (type: `string`):

Added to the User-Agent header, because SEC's fair-access policy asks automated tools to identify themselves. It is sent only to sec.gov and is not saved in the output.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "formTypes": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "customFormTypes": [
    "N-PORT",
    "425"
  ],
  "eightKItems": [
    "2.02",
    "5.02"
  ],
  "includeAmendments": true,
  "lastDays": 90,
  "filedSince": "2026-01-01",
  "filedUntil": "2026-12-31",
  "includeFinancials": true,
  "financialPeriods": 1,
  "includeInsiderTrades": true,
  "maxInsiderFilingsPerCompany": 10,
  "onlyNew": false,
  "maxFilingsPerCompany": 20,
  "stateKey": "default",
  "contactEmail": "you@example.com"
}
```

# Actor output Schema

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

All new/changed filings found in this run (default dataset, all fields).

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

Default dataset, 'overview' view.

## `filings` (type: `string`):

Default dataset, 'filings' view.

## `insiderTrades` (type: `string`):

Default dataset, 'insiderTrades' view.

## `financials` (type: `string`):

Default dataset, 'financials' view.

## `runSummary` (type: `string`):

JSON summary of this run (counts, first-run flag, finishedAt) in the default key-value store record RUN_SUMMARY. Monitoring state persists separately in the named key-value store sec-edgar-monitor-state under STATE-<stateKey>.

# 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",
        "NVDA"
    ],
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q"
    ],
    "onlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("heaped_qualm/sec-edgar-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",
        "NVDA",
    ],
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q",
    ],
    "onlyNew": False,
}

# Run the Actor and wait for it to finish
run = client.actor("heaped_qualm/sec-edgar-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",
    "NVDA"
  ],
  "formTypes": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "onlyNew": false
}' |
apify call heaped_qualm/sec-edgar-monitor --silent --output-dataset

```

## MCP server setup

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