# SEC EDGAR Filings Scraper (8-K, Form D, 10-K) (`knotty_mistveil/sec-edgar-filings`) Actor

Every SEC EDGAR filing by form type and date, straight from the SEC: 8-K item codes, Form D, 10-K, company, CIK, ticker, SIC, state and document links.

- **URL**: https://apify.com/knotty\_mistveil/sec-edgar-filings.md
- **Developed by:** [Jason](https://apify.com/knotty_mistveil) (community)
- **Categories:** Business, Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 filing returneds

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 EDGAR Filings Scraper (8-K, Form D, 10-K)

Pulls filings from **SEC EDGAR**, the US Securities and Exchange Commission's electronic filing system, through the SEC's own public endpoints: EDGAR full-text search, the daily dissemination index and the `data.sec.gov` submissions API. No API key, no account, no browser automation. You get one flat JSON record per filing with the form type, filing date and reporting period, the filer's name, CIK, tickers, SIC industry, state of incorporation and business location, the 8-K item codes or Form D exemptions **turned into readable English**, the file and film numbers, and direct links to both the filing index page and the primary document - filtered by form type, filing-date window, full-text keyword, company name, SIC code and state. Measured on 8 September 2026: a business day of EDGAR holds about **165 8-K** filings, **220 Form D** filings and **2,900 to 3,300 filings across all forms**, and this Actor delivered **2,037 8-K and Form D filings covering five business days in 43 seconds**.

The one thing the SEC does ask for is that you say who you are: see *Fair access and the User-Agent* below.

### What you get

Every record contains:

| Field | Description |
| --- | --- |
| `id` | The accession number, EDGAR's identifier for the filing, e.g. `0001477932-26-005420` |
| `source` | `sec-edgar`, constant |
| `url` | The filing index page on sec.gov - the human-readable landing page for the whole submission |
| `documentUrl` | The primary document itself. XML forms (Form D, Forms 3/4/5) link EDGAR's rendered view rather than the raw XML. `null` on an index-sourced record until `includeCompanyDetails` names the document |
| `submissionUrl` | The complete submission text file: every document in the filing concatenated. This is the one EDGAR path that keeps the dashes in the accession number, and the Actor builds it that way |
| `formType` | The EDGAR form type exactly as filed: `8-K`, `8-K/A`, `D`, `D/A`, `10-K`, `SCHEDULE 13D`, ... |
| `isAmendment` | `true` when the form type ends in `/A` |
| `filedAt` | Filing date, `YYYY-MM-DD` |
| `periodEnding` | The period the filing reports on, `YYYY-MM-DD`, or `null` for forms that have none (every Form D) |
| `acceptedAt` | EDGAR's acceptance timestamp, to the second (details only) |
| `companyName` | The filer's name, with the ticker and CIK stripped off EDGAR's display string |
| `cik` | Central Index Key, zero-padded to ten digits |
| `tickers` | Trading symbols EDGAR has on file, e.g. `["SOUN", "SOUNW"]`; `[]` for a private filer |
| `exchanges` | Exchanges the filer is listed on, e.g. `["Nasdaq"]`, `["OTC"]` (details only) |
| `coFilerCiks` / `coFilerNames` | The other registrants on a joint filing - a parent and its financing subsidiary file one 8-K between them. Empty on a single-filer filing (98.7% of them) |
| `sicCode` | Standard Industrial Classification code, e.g. `7990` |
| `sicDescription` | The industry in words, e.g. `Services-Miscellaneous Amusement & Recreation`. Resolved from the SEC's own SIC code list, embedded in the Actor, so it is filled with no extra request |
| `stateOfIncorporation` | EDGAR two-character code, e.g. `DE`, `WY`, `X0` |
| `businessLocation` / `businessState` | The filer's business address as EDGAR prints it, e.g. `Santa Monica, CA`, and just the code |
| `businessAddress` | The full street address (details only) |
| `phone` | The filer's telephone number as registered with EDGAR (details only) |
| `entityType` | `operating`, `other`, `investment company`, ... (details only) |
| `fileNumber` / `filmNumber` | The SEC file number (`000-08962`, `021-596555`) and the film number |
| `items` | The item codes on the filing: 8-K event codes (`["1.01", "9.01"]`) or the Form D exemptions claimed (`["06C", "3C.7"]`) |
| `itemDescriptions` | The same codes in English: `Entry into a Material Definitive Agreement`, `Rule 506(c)`, ... |
| `description` | EDGAR's own description of the primary document, e.g. `FORM 8-K`, `CURRENT REPORT` |
| `sizeBytes` / `isXBRL` | Size of the whole submission, and whether it carries XBRL data (details only) |
| `documentSequence` | Which document in the filing `documentUrl` points at; `1` is the primary document |
| `retrievedFrom` | `full-text-search` or `daily-index` - see *Limits and freshness* |
| `fetchedAt` | ISO timestamp of the run that produced the record |

Fields marked *details only* come from the `data.sec.gov` submissions call and are `null` when `includeCompanyDetails` is `false`. The keys are always present either way, so a CSV export is a rectangle. The dataset has three views: **Overview** (date, form, company, ticker, industry, items, link), **8-K events and Form D exemptions** (the item codes and what they mean) and **Companies** (address, phone, exchange, entity type).

### Input

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `userAgent` | string | **required** | Your name and a contact email, as `Company Name contact@example.com`. The SEC requires it; see below. |
| `formTypes` | string\[] | `["8-K", "D"]` | Pick from a list of 24 common forms. Empty = every form EDGAR disseminated in the window - 2,644 filings across 108 root forms on 4 September 2026 - read from the daily dissemination index rather than full-text search (see *Limits and freshness*). |
| `otherFormTypes` | string\[] | none | Any other EDGAR form type, spelled as EDGAR spells it: `10-D`, `1-A`, `ABS-15G`, `N-PX`, `485BPOS`, `SD`, `C`, `POS AM`. |
| `includeAmendments` | boolean | `true` | Keep `8-K/A`, `D/A`, `10-K/A` and the rest alongside the originals. |
| `daysBack` | integer | `3` | Look-back window in days on the filing date, ending today. Ignored when `dateFrom`/`dateTo` are set. EDGAR files on US business days only, so use **4 or more on a schedule** - the examples below do - or a Monday run can span nothing but a weekend. A run that comes back empty says why in the log and in `SUMMARY.hint`. |
| `dateFrom` | string | - | Start of the filing-date window, `YYYY-MM-DD`, inclusive. |
| `dateTo` | string | today | End of the filing-date window, `YYYY-MM-DD`, inclusive. A future date is clamped to today. |
| `keywords` | string\[] | none | Search the full text of the filing **and its exhibits**. Each term is an exact phrase, the terms are ORed. |
| `companies` | string\[] | all | Keep filings whose filer name contains one of these, case-insensitively. |
| `sicCodes` | string\[] | all | SIC codes or prefixes: `2836` biological products, `28` all chemicals and pharma, `6798` REITs, `7372` software. Needs a form type or a keyword selected, or `includeCompanyDetails` - see *Limits and freshness*. |
| `states` | string\[] | all | EDGAR two-character codes. A filing matches on **either** its state of incorporation or its business address. Same requirement as `sicCodes`. |
| `includeCompanyDetails` | boolean | `false` | One `data.sec.gov` call per company per day for the address, phone, exchanges, entity type, acceptance timestamp, size and XBRL flag. |
| `maxItems` | integer | `500` | Stop after this many filings. You are charged per filing, so this is also the cost cap. Days are read newest first, so a value below the window's volume drops the **oldest** filings in it. |

Example - a daily 8-K and Form D watch, run on a schedule:

```json
{
  "userAgent": "Acme Research deals@acme.com",
  "formTypes": ["8-K", "D"],
  "daysBack": 4,
  "maxItems": 2000
}
```

Example - California and New York private placements from the last month, with the issuer's address and phone:

```json
{
  "userAgent": "Acme Research deals@acme.com",
  "formTypes": ["D"],
  "includeAmendments": false,
  "daysBack": 30,
  "states": ["CA", "NY"],
  "includeCompanyDetails": true,
  "maxItems": 3000
}
```

Example - every 8-K mentioning a merger or an acquisition agreement in the last week:

```json
{
  "userAgent": "Acme Research deals@acme.com",
  "formTypes": ["8-K"],
  "keywords": ["definitive merger agreement", "agreement and plan of merger"],
  "daysBack": 7,
  "maxItems": 500
}
```

Example - a biotech watch on activist stakes and insider buying:

```json
{
  "userAgent": "Acme Research deals@acme.com",
  "formTypes": ["SC 13D", "4"],
  "sicCodes": ["2834", "2836", "8731"],
  "daysBack": 5,
  "maxItems": 1000
}
```

Bad input fails fast: a missing or malformed `userAgent`, a non-numeric SIC code, a state code that is not two characters, or a malformed date stops the run with the validation message as its status, before any request is made.

### Output example

A real record from a live run on 8 September 2026 (`{"formTypes": ["8-K"], "dateFrom": "2026-09-04", "dateTo": "2026-09-04", "maxItems": 100, "includeCompanyDetails": true}`), unedited:

```json
{
  "id": "0001477932-26-005420",
  "source": "sec-edgar",
  "url": "https://www.sec.gov/Archives/edgar/data/55234/000147793226005420/0001477932-26-005420-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/55234/000147793226005420/gamg_8k.htm",
  "submissionUrl": "https://www.sec.gov/Archives/edgar/data/55234/0001477932-26-005420.txt",
  "formType": "8-K",
  "isAmendment": false,
  "filedAt": "2026-09-04",
  "periodEnding": "2026-08-28",
  "acceptedAt": "2026-09-04T16:44:22.000Z",
  "companyName": "Global Asset Management Group, Inc.",
  "cik": "0000055234",
  "tickers": ["GAMG"],
  "exchanges": ["OTC"],
  "coFilerCiks": [],
  "coFilerNames": [],
  "sicCode": "7990",
  "sicDescription": "Services-Miscellaneous Amusement & Recreation",
  "stateOfIncorporation": "WY",
  "businessLocation": "Rockville, MD",
  "businessState": "MD",
  "businessAddress": "1505 MONROE STREET, SUITE 1505, ROCKVILLE, MD, 20852",
  "phone": "312-372-6900",
  "entityType": "operating",
  "fileNumber": "000-08962",
  "filmNumber": "261361302",
  "items": ["1.01", "2.01", "2.03", "3.02", "3.03", "5.02", "8.01", "9.01"],
  "itemDescriptions": [
    "Entry into a Material Definitive Agreement",
    "Completion of Acquisition or Disposition of Assets",
    "Creation of a Direct Financial Obligation or an Obligation under an Off-Balance Sheet Arrangement of a Registrant",
    "Unregistered Sales of Equity Securities",
    "Material Modifications to Rights of Security Holders",
    "Departure of Directors or Certain Officers; Election of Directors; Appointment of Certain Officers: Compensatory Arrangements of Certain Officers",
    "Other Events",
    "Financial Statements and Exhibits"
  ],
  "description": "FORM 8-K",
  "sizeBytes": 2563762,
  "isXBRL": true,
  "documentSequence": 1,
  "retrievedFrom": "full-text-search",
  "fetchedAt": "2026-09-08T05:43:28.540Z"
}
```

A Form D private placement from the same day looks like this - no reporting period, no ticker, no SIC, and the item codes are the exemptions the issuer claimed:

```json
{
  "id": "0002140437-26-000001",
  "source": "sec-edgar",
  "url": "https://www.sec.gov/Archives/edgar/data/2140437/000214043726000001/0002140437-26-000001-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/2140437/000214043726000001/xslFormDX01/primary_doc.xml",
  "formType": "D",
  "filedAt": "2026-09-04",
  "periodEnding": null,
  "acceptedAt": "2026-09-04T21:20:37.000Z",
  "companyName": "Sound Ventures V, L.P.",
  "cik": "0002140437",
  "tickers": [],
  "coFilerCiks": ["0002140395"],
  "coFilerNames": ["Sound Ventures Feeder V, L.P."],
  "sicCode": null,
  "stateOfIncorporation": "DE",
  "businessLocation": "Santa Monica, CA",
  "businessAddress": "3130 WILSHIRE BLVD., #600, SANTA MONICA, CA, 90403",
  "phone": "310-867-7169",
  "entityType": "other",
  "fileNumber": "021-596555",
  "items": ["06C", "3C", "3C.7"],
  "itemDescriptions": [
    "Rule 506(c)",
    "Investment Company Act Section 3(c)",
    "Investment Company Act Section 3(c)(7)"
  ],
  "sizeBytes": 13002,
  "isXBRL": false,
  "retrievedFrom": "full-text-search",
  "fetchedAt": "2026-09-08T05:45:53.276Z"
}
```

Every run also writes a `SUMMARY` record to the key-value store with the resolved window, the filters used and how many filings each dropped, the days read, the search and detail request counts, which source the run used (`sourceMode`) and any days that fell back to the daily index, the completeness flags `limitReached` and `windowExhausted` (see *Limits and freshness*), and a plain-English `hint` when a run comes back empty because the window held no filing day.

### Pricing

Pay per result: **US$0.003 per filing delivered** (US$3 per 1,000 filings). You are charged only for records pushed to the dataset; a run that returns nothing - a window that lands on a weekend, a filter that matches nothing - costs nothing. Runs on the Apify free plan are limited by the platform's free-tier usage allowance.

### Fair access and the User-Agent

The SEC asks every automated caller to identify itself. From the SEC's Webmaster FAQ (<https://www.sec.gov/about/webmaster-frequently-asked-questions>, read 8 September 2026): "Please declare your **user agent** in request headers", with the sample `User-Agent: Sample Company Name AdminContact@<sample company domain>.com`, and "Our current maximum access rate is 10 requests per second."

So this Actor **requires** a `userAgent` input and sends it on every single request to `efts.sec.gov`, `www.sec.gov` and `data.sec.gov`. Put your own organisation or project name and a mailbox someone reads in it. A request with no declared agent is answered with an HTTP 403 and an SEC page headed "Your Request Originates from an Undeclared Automated Tool"; if EDGAR ever answers that way the run stops with that explanation rather than grinding through retries. The `userAgent` field is prefilled with a placeholder so the Store's Try button works, and the run logs a warning when the contact domain is one of the reserved placeholder domains (`example.com` and friends) - replace it before running at any volume.

On the rate: the Actor paces itself at **5 requests per second across all three hosts**, half the documented ceiling, using a single shared throttle so concurrent enrichment cannot push it over.

### Data source and licence

- **Search:** `GET https://efts.sec.gov/LATEST/search-index` - the endpoint behind <https://www.sec.gov/edgar/search/>. **Daily index:** `https://www.sec.gov/Archives/edgar/daily-index/YYYY/QTRn/form.YYYYMMDD.idx`. **Company profiles:** `https://data.sec.gov/submissions/CIK##########.json`. All three are public and need no key; the SEC documents them at <https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data> (read 8 September 2026).
- **Licence.** The SEC's Website Dissemination policy (<https://www.sec.gov/about/privacy-information>, read 8 September 2026) states: "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." Commercial reuse is permitted. Attribute as "Source: U.S. Securities and Exchange Commission, EDGAR" and link to the filing.
- **What that policy does restrict:** you may not use the SEC seal, logos or other artwork from the site, and you may not use the SEC's or EDGAR's names or trademarks in a trade name, trademark or domain name of an SEC- or EDGAR-related business without a licence from the SEC.
- **This Actor publishes EDGAR's index metadata, not the filings.** Every field above comes from EDGAR's own catalogue of the filing - form type, dates, filer identity, classification codes, item codes, file numbers - plus URLs. The text of a filing is written by the filer, not the SEC, and this Actor never copies it into the dataset; `documentUrl` and `submissionUrl` link to the SEC's copy so you fetch it yourself if you need it. Keyword searching runs on the SEC's index, not on text this Actor stores.
- **Personal data.** Most filers are companies, but not all, and some of the fields are personal data. The individual reporting-owner forms - **3, 4 and 5** - and often **SC 13D** and **SC 13G** are filed by named human beings, so `companyName` on those records is a person's name and `businessAddress` and `phone` may be a personal or advisor's address. Small `D` issuers, single-property LLCs and family partnerships routinely register a home address and a mobile number with EDGAR. These are details the filer submitted to a public regulator and the SEC publishes, but using them - for marketing in particular - is the buyer's responsibility under the applicable regime (CAN-SPAM and the TCPA in the US, GDPR/PECR if you are contacting from or into the EU or UK). `businessAddress` and `phone` are only fetched at all when you set `includeCompanyDetails`.

### Limits and freshness

- **Coverage and how it is read.** The Actor walks the filing-date window **one calendar day at a time, newest day first**, reading each day's filings in full before moving on. The primary source is EDGAR full-text search, which covers **2001-01-01 onwards** (2000-12-29 returns zero hits). For a day before that, and for any day the search endpoint refuses, the Actor falls back to the SEC's **daily dissemination index**, which it can read back to **1995-01-01** - EDGAR renamed those files at the start of 1999, so both `form.YYYYMMDD.idx` and the older `form.YYMMDD.idx` are tried. A record says which route produced it in `retrievedFrom`, and `SUMMARY.sourceMode` says which route the run as a whole used. Index-sourced records carry only what the index publishes - form type, company, CIK, filing date and the filing link - so switch `includeCompanyDetails` on to fill the rest.
- **Asking for every form reads the daily index, by necessity.** EDGAR's search endpoint will not run a query that names neither a form type nor a keyword: it answers `Blank search not valid` - and it answers it with HTTP **200** and an empty hit list, which is indistinguishable from a quiet day unless you look for the error. So a run with `formTypes: []` and no `keywords` skips the search entirely and reads each day's **daily dissemination index**, the SEC's own complete list of what it published that day. Verified on 4 September 2026: 2,644 filings across 108 root forms, `windowExhausted: true` - and its per-form counts match full-text search exactly (8-K 164 + 5 amendments = the 169 the search reports; Form D 152 + 101 = 253). The price is that those records carry no reporting period, SIC, state, item codes or document link, because the index does not publish them; `includeCompanyDetails` fills most of it from the company profile. `sicCodes` and `states` filter on fields the index has not got, so with no form type and no keyword the run refuses that combination up front rather than returning an empty dataset - select a form type or a keyword, or switch `includeCompanyDetails` on.
- **Completeness, cross-checked against the SEC's own dissemination feed.** On 8 September 2026 every root form disseminated on 2 and 3 September 2026 was counted in the daily index (de-duplicated by accession number, and restricted to rows actually filed that day) and compared with what full-text search returns for the same form and day: **176 form/day combinations covering 6,178 filings, of which 173 matched exactly.** Of the three that did not, two were cases where search held **one filing more** than the index for that day - a filing dated on the day but disseminated the next - and one was a single `N-14 8C` that search did not hold. That is the measured basis for treating full-text search as the primary source.
- **Volumes, measured 8 September 2026.** Per business day: **8-K** 165 to 202 filings, **Form D (with amendments)** 193 to 264, **Form 4** 394 to 971, **Schedule 13D and 13G** 62 on the day sampled, **10-K** 4 to 12, **10-Q** 16 to 25, and **2,919 to 3,259 filings a day across every form type (89 different root forms on 3 September 2026)**. A five-business-day window of 8-K and Form D delivered **2,037 records**.
- **Speed, measured 8 September 2026.** One business day of 8-K and Form D - 422 filings - took **5.6 seconds** and 5 requests. Five business days - 2,037 filings - took **43.1 seconds** and 24 requests, about 47 records a second. With `includeCompanyDetails` on, 100 8-K filings took **35.3 seconds** (96 submissions calls, one per company), about 2.8 records a second, so switch it on when you want the contact fields and off when you want throughput.
- **Size `maxItems` to the window, and check `windowExhausted`.** `maxItems` counts records *kept after filtering* and days are read newest first, so a value below the window's volume drops the **oldest** filings in it - but never silently. The run warns `maxItems (N) reached before the window was exhausted` and the `SUMMARY` record carries `limitReached: true` with `windowExhausted: false`. `windowExhausted: true` is the guarantee that you hold the complete window: it is set only when every calendar day in it was read to the end and every record kept was delivered. A run that is capped stops the moment the cap is full and reads no page it cannot deliver - `maxItems: 5` over an eight-day window cost exactly one request per day and no second page.
- **The 10,000-per-day search ceiling.** EDGAR's search refuses `from + size > 10000`, so at most 10,000 filings a day can be read through it. Reading a day at a time keeps every ordinary run far below that - the busiest single form-day measured was 971 Form 4 filings, and all forms together came to 3,259 - but selecting many high-volume forms over a historically busy day could reach it. The run then warns, names the day in `SUMMARY.truncatedDays` and sets `windowExhausted: false`; select fewer forms to read that day in full.
- **Weekends and holidays return nothing, and that is not an error.** EDGAR disseminates on business days, and the current day's feed fills through the afternoon US Eastern time. A `daysBack: 2` run started on the Tuesday after Labor Day 2026 covered 6, 7 and 8 September - a Sunday, the holiday and a morning - and correctly returned **0 filings with `windowExhausted: true`**, costing nothing. A run that EDGAR returns nothing for now says why, in the log and in `SUMMARY.hint` - naming the window and whether it was the form types or the keywords that were asked for - rather than leaving you with a bare zero. The input default is `daysBack: 3`, which is enough midweek; use **4 or more for a daily schedule** so the window always spans a filing day whichever day it starts on, and overlap your runs rather than abutting them.
- **Amendments come with the form.** EDGAR's search groups a form and its amendments under one root form, so asking for `8-K` returns `8-K/A` too. That is usually what you want - and it is a large share of some forms: of the 1,088 Form D filings in the five-business-day run measured below, 381 were amendments. Set `includeAmendments: false` to drop them; it filters after the fact, so it saves cost per record but not requests.
- **A keyword search matches exhibits too, and the Actor de-duplicates.** EDGAR indexes every document in a filing, so `"material definitive agreement"` over 1-4 September 2026 returned 142 document hits for 137 distinct filings. You are charged once per filing: hits are de-duplicated by accession number and the primary document is the one `documentUrl` points at. Note that a `SUMMARY` hit count of that shape counts documents, which is why the Actor reports filings instead.
- **Field completeness, measured over the 2,037-filing five-day run.** `documentUrl`, `fileNumber`, `items` and `itemDescriptions` were present on **100%** of records and `businessLocation` on 99.9%. The rest depends on the form: for the 949 8-K records, `periodEnding` 100%, `sicCode` 96.3%, `stateOfIncorporation` 92.0%, `tickers` 79.1%; for the 1,088 Form D records, `stateOfIncorporation` and `businessLocation` 100% but `sicCode` only 2.4%, `tickers` 1.7% and `periodEnding` 0% - private issuers have no ticker, EDGAR classifies few of them, and a Form D reports no period. Those are absent at source and stay `null` rather than being guessed at.
- **The industry name costs nothing extra.** The SEC's Division of Corporation Finance SIC code list (all 444 codes, <https://www.sec.gov/corpfin/division-of-corporation-finance-standard-industrial-classification-sic-code-list>) is embedded in the Actor, so `sicDescription` is filled from `sicCode` without a second request - and is filled even for the codes where EDGAR's own company record leaves the description blank (`3812`, `3944`, `5122` and `6199` all came back empty from `data.sec.gov`). Checked against 11 live company records, 10 matched the SEC's own spelling character for character.
- **Item codes are resolved, not passed through.** All 47 distinct item codes across those 2,037 filings resolved to text; a code the table does not know is left out of `itemDescriptions` rather than guessed at, and `items` always keeps the raw codes. The 8-K wording is EDGAR's own, captured from its current-filings feed and filing index pages; the Form D codes are the "Federal Exemptions and Exclusions Claimed" boxes from Form D Item 6.
- **Two EDGAR spellings are handled for you.** EDGAR's indexes call the Williams Act schedules `SCHEDULE 13D` and `SCHEDULE 13G`, while everyone else calls them `SC 13D` and `SC 13G` - asking the search for `SC 13D` returns zero hits. Type either; the Actor translates.
- **Company, SIC and state filters are applied locally**, on what the search returns, so they cut the record count and the cost but not the number of requests. That is deliberate: EDGAR's own company-name parameter is not a substring match (`nergy` returns nothing where 15 filers have it in their name) and its location parameter covers only the business address, not the state of incorporation.
- **Older filings and the detail call.** `includeCompanyDetails` reads `filings.recent` from the submissions document, which holds a company's most recent 1,000 filings. For a filing older than that the company profile still merges but the per-filing extras (`acceptedAt`, `sizeBytes`, `isXBRL`) stay `null`.
- **Freshness.** EDGAR full-text search had 2026-09-04 filings indexed and searchable on 2026-09-08, and its counts for that day matched the daily index exactly, so the indexing lag is under one business day. Dates are the filing dates EDGAR publishes, with no time component; `acceptedAt` is the only timestamp, and it is EDGAR's acceptance time.

### Use cases

- **M\&A and corporate-event monitoring:** a scheduled daily run over `8-K` with `keywords` such as "agreement and plan of merger", or filtered on `items` in the output for `1.01` (material agreement), `2.01` (completed acquisition) or `5.02` (officer departure) - the event is already spelled out in `itemDescriptions`, so an alert needs no document parsing.
- **Private-placement lead generation:** `Form D` names companies that have just raised money and, with `includeCompanyDetails`, their business address and phone. Filter by `states` and `sicCodes` to get a territory list, and use `includeAmendments: false` to see only first-time raises - 707 of them in the five business days measured, so roughly 700 a week.
- **Compliance, research and dataset building:** point it at any form type and any window back to 2001 (or 1995 through the daily index) to build a filing history - `13F-HR` holdings reports, `SC 13D` activist stakes, `10-K` annual reports by industry - with the CIK, file number and document link you need to fetch and parse the filings themselves.

### Support

Open an issue on the Actor's Issues tab on Apify Store. Replies within 14 days. Bug reports that name the run id and the input used are fixed fastest.

# Actor input Schema

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

REQUIRED by the SEC. Every automated caller must identify itself in the shape "Company Name contact@example.com"; EDGAR answers requests without one with HTTP 403. Put your own organisation or project name and a mailbox someone actually reads - the prefill uses a placeholder domain and only exists so the Try button works.

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

EDGAR form types to collect. Amendments are included by default (asking for 8-K also returns 8-K/A). Empty = every form EDGAR disseminated in the window (2,644 filings on 4 September 2026, across 108 root form types); with no form type and no keyword the window is read from the SEC's daily dissemination index instead of full-text search, so those records carry only form type, company, CIK, filing date and the filing link unless you also switch Fetch company details on. Default: 8-K and Form D.

## `otherFormTypes` (type: `array`):

Any EDGAR form type not on the list above, spelled exactly as EDGAR spells it: 10-D, 1-A, ABS-15G, N-PX, 485BPOS, SD, 25-NSE, C, IRANNOTICE, 11-K, POS AM. Case does not matter. Added to whatever is selected above.

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

Keep amended filings (8-K/A, 10-K/A, D/A, ...) alongside the originals. EDGAR's search groups a form and its amendments together, so turning this off filters them out after the fact rather than making the run cheaper in requests. Amendments are a large share of some forms: on 3 September 2026, 15 of 21 Schedule 13D filings and 75 of 224 Form D filings were amendments.

## `daysBack` (type: `integer`):

Look-back window in days on the filing date, ending today. Ignored when Date from / Date to are set. EDGAR disseminates on business days only and the current day's feed fills through the afternoon (US Eastern), so the default 3 covers a normal midweek run but a window that lands on a weekend or a federal holiday returns nothing and says so in the log. Raise it to 4 or more for a scheduled daily run, so the window always spans a filing day whichever day it starts on.

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

Start of the filing-date window, YYYY-MM-DD (inclusive). Overrides Days back. Full-text search covers 2001-01-01 onwards; earlier dates are read from the daily dissemination index, which this Actor can read back to 1995-01-01.

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

End of the filing-date window, YYYY-MM-DD (inclusive). Defaults to today; a date in the future is clamped to today.

## `keywords` (type: `array`):

Search the full text of the filing and every exhibit attached to it. Each term is matched as an exact phrase and the terms are ORed: \["material definitive agreement", "letter of intent"] keeps filings containing either. A term that already contains a double quote is passed to EDGAR untouched, so its own operators still work (-"excluded phrase", trunc\*). Empty = no keyword filter, which returns every filing of the selected forms.

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

Keep only filings whose filer name contains one of these strings, case-insensitively ("bancorp", "acquisition corp"). Matched on the filing's own filer names, including co-registrants. Empty = all companies.

## `sicCodes` (type: `array`):

Standard Industrial Classification codes or prefixes: 2836 keeps biological products, 28 keeps all of chemicals and pharmaceuticals, 6798 REITs, 7372 software, 6189 asset-backed issuers. The Actor turns every code into a readable industry name in sicDescription. Empty = all industries. About 4% of filers carry no SIC code and are dropped when this filter is set. The SIC comes from EDGAR's full-text search index, so filtering on it needs at least one form type or keyword selected - or Fetch company details switched on, which reads the code from the company profile instead.

## `states` (type: `array`):

EDGAR two-character state or country codes (CA, NY, TX, DE, MA; X0 Canada, U0 Singapore, L2 UK). A filing is kept when the code matches EITHER the filer's state of incorporation OR the state of its business address. Empty = everywhere. Like the SIC filter, this reads a field from EDGAR's full-text search index, so it needs at least one form type or keyword selected - or Fetch company details switched on.

## `includeCompanyDetails` (type: `boolean`):

Call the data.sec.gov submissions API once per company per day to add the business address, phone number, entity type, stock exchanges, the EDGAR acceptance timestamp, the filing's size and its XBRL flag, and to fill the tickers and SIC for filers the search index leaves blank. Costs one extra request per company, so a run of 500 filings by 500 different companies roughly doubles in length.

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

Stop after this many filings. You are charged per filing delivered, so this is also the cost cap. Days are read newest first, so a value below the window's volume drops the OLDEST filings in the window. Measured 8 September 2026: a business day holds about 165 8-K and 220 Form D filings, so the default 3-day window with the default forms is roughly 1,100 filings.

## Actor input object example

```json
{
  "userAgent": "OpenDataOperator research contact@example.com",
  "formTypes": [
    "8-K",
    "D"
  ],
  "otherFormTypes": [],
  "includeAmendments": true,
  "daysBack": 3,
  "keywords": [],
  "companies": [],
  "sicCodes": [],
  "states": [],
  "includeCompanyDetails": false,
  "maxItems": 500
}
```

# Actor output Schema

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

All filings returned by the run, one JSON object each. Append ?format=csv or ?format=xlsx to download a spreadsheet.

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

Counts, the filing-date window used, the filters applied and how many filings each dropped, which source the run read (sourceMode: full-text-search or daily-index) and any days that fell back to the daily index, the windowExhausted completeness flag, and a hint explaining an empty run. Written at the end of the run.

# 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 = {
    "userAgent": "OpenDataOperator research contact@example.com",
    "formTypes": [
        "8-K",
        "D"
    ],
    "otherFormTypes": [],
    "includeAmendments": true,
    "daysBack": 3,
    "keywords": [],
    "companies": [],
    "sicCodes": [],
    "states": [],
    "includeCompanyDetails": false,
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("knotty_mistveil/sec-edgar-filings").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 = {
    "userAgent": "OpenDataOperator research contact@example.com",
    "formTypes": [
        "8-K",
        "D",
    ],
    "otherFormTypes": [],
    "includeAmendments": True,
    "daysBack": 3,
    "keywords": [],
    "companies": [],
    "sicCodes": [],
    "states": [],
    "includeCompanyDetails": False,
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("knotty_mistveil/sec-edgar-filings").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 '{
  "userAgent": "OpenDataOperator research contact@example.com",
  "formTypes": [
    "8-K",
    "D"
  ],
  "otherFormTypes": [],
  "includeAmendments": true,
  "daysBack": 3,
  "keywords": [],
  "companies": [],
  "sicCodes": [],
  "states": [],
  "includeCompanyDetails": false,
  "maxItems": 500
}' |
apify call knotty_mistveil/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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

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/Kvaoci6sfkD8wrbmY/builds/cI2T95lIqMTcdw9Hj/openapi.json