# SEC EDGAR Scraper — Filings, Financials, Insider & Form D (`brilliant_gum/sec-edgar-scraper`) Actor

SEC EDGAR via the official free SEC APIs (no login/key): company filings, full-text search, XBRL financials & raw XBRL facts, insider Form 4, 13F institutional holdings, 13D/13G activist stakes, Form D funding leads, and 8-K material events.

- **URL**: https://apify.com/brilliant\_gum/sec-edgar-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Developer tools, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Scraper

![SEC EDGAR Scraper](https://api.apify.com/v2/key-value-stores/IuFu0Cw6PpOkNkDV7/records/sec_edgar_banner.png)

**SEC EDGAR Scraper — filings, financials, insider (Form 4), 13F holdings, 13D/G activist, Form D funding leads (official API).**

Pull U.S. Securities and Exchange Commission data straight from the **official, free EDGAR APIs** — no API key, no login, no scraping tricks. One actor, **10 modes**, covering company filings, full-text search, XBRL financials, insider trades, institutional 13F holdings, activist stakes, private-placement funding leads, and 8-K material events.

Built for **finance and investment research, funding-lead generation, compliance, and quant** workflows that need clean, structured SEC data on demand or on a schedule.

The actor only does two things the SEC asks of every API consumer: it sends a descriptive `User-Agent` with contact info, and it stays under the SEC's 10-requests/second fair-access limit (throttled to ~8 req/s).

***

### Key features

- **10 modes, one actor** — switch behavior with the `mode` field:

  | Mode | Record type | What you get |
  |---|---|---|
  | `company-filings` | `filing` | A company's full filing history by ticker / CIK / name, filtered by form type and date. |
  | `search` | `searchHit` | EDGAR full-text search across every filer (document text, 2001→), with relevance scores. |
  | `financials` | `financials` | Normalized XBRL statements per fiscal period (revenue, net income, assets, EPS, cash flow, …), in the company's reporting currency. |
  | `xbrl-facts` | `xbrlFact` | Raw XBRL — one record per reported datapoint, exactly as tagged (the un-normalized companion to `financials`). |
  | `form-4-insider` | `insider` | Insider (director / officer / 10% owner) Form 3/4/5 transactions: who, role, code, shares, price, holdings after. |
  | `form-13f` | `holding13F` | Institutional-manager 13F-HR holdings — one record per position (CUSIP, shares, value, portfolio %). |
  | `activist` | `activistStake` | Schedule 13D/13G beneficial-ownership stakes — subject vs. filer, % owned, shares, event date, 13D purpose. |
  | `form-d-funding-leads` | `fundingLead` | Reg D private-placement offerings — issuer, contacts, amount raised/remaining, industry, related persons. |
  | `eight-k-events` | `eightKEvent` | 8-K material events with parsed item codes/labels, per-item body text, exhibits, press-release text, event flags. **Deep-parse on by default.** |
  | `latest-filings-feed` | `filing` | Newest filings across all of EDGAR, by form type. |

- **Ticker / CIK / name resolution** — `companies` accepts stock tickers (`AAPL`), CIKs (`320193` or `CIK0000320193`), or company names (`Apple`), resolved both directions via the official `company_tickers.json` map.

- **Incremental & scheduled runs** — `sinceAccessionNumber` skips everything at or older than a given accession, so a scheduled run only emits what's new. Date presets (`last7Days`, `last30Days`, `yearToDate`, …) and `startDate`/`endDate` bounds are supported everywhere.

- **8-K deep parsing** — item codes → human labels, per-item body text (`itemBodies`), the full exhibit list, extracted press-release text (EX-99.x), plus boolean event flags (`earningsFlag`, `officerDepartureFlag`, `mAndAFlag`, `cyberIncidentFlag`, …).

- **Market-wide or company-scoped** — `form-d-funding-leads`, `eight-k-events`, and `activist` run either for specific `companies` or across all of EDGAR over a date range.

- **Nothing to set up** — no API key, no login, no proxy, no account anywhere. Pick a mode, press start. The SEC's endpoints are public and this actor talks to them directly, staying under the SEC's 10 requests/second fair-access limit with automatic retry and backoff.

***

### Input

Set `mode` and the fields relevant to it. All other fields have sensible defaults.

| Field | Type | Default | Applies to | Description |
|---|---|---|---|---|
| `mode` | select (enum) | `company-filings` | all | Which of the 10 modes to run. |
| `companies` | string\[] | `["AAPL"]` | company-filings, financials, xbrl-facts, form-4, form-13f, activist, form-d, 8-K | Tickers, CIKs, or company names. For `form-13f` this is the institutional manager (e.g. `0001067983` = Berkshire Hathaway); for `activist` it's the subject issuer. In `form-d-funding-leads`, `eight-k-events` and `activist` you can sweep all of EDGAR instead — switch on `marketWide` and this list is ignored. |
| `marketWide` | boolean | `false` | form-d, 8-K, activist | Sweep **every filer** in the date range instead of the companies above. Turn it on and the companies list is ignored — no need to empty it. |
| `formTypes` | string\[] | `[]` | company-filings, search, feed | Filter to these EDGAR form types (`10-K`, `8-K`, `4`, `D`, `13F-HR`, …). Empty = all. Prefix match, so `10-K` also matches `10-K/A` when amendments are on. |
| `query` | string | `""` | search | Full-text query. Wrap in double quotes for an exact phrase. |
| `queryMode` | select | `asTyped` | search | `asTyped` / `exactPhrase` / `allTerms`. |
| `entityFilter` | string | `""` | search | Restrict full-text search to a single entity (name / ticker / CIK). |
| `datePreset` | select | `""` | all | Convenience range (`last7Days`, `last30Days`, `last90Days`, `lastQuarter`, `lastYear`, `yearToDate`) — overrides start/end when set. |
| `startDate` / `endDate` | string | `""` | all | Filed-on/after and filed-on/before bounds, `YYYY-MM-DD`. |
| `transactionCodes` | string\[] | `[]` | form-4 | Keep only these SEC codes (`P` purchase, `S` sale, `A` award, `M` exercise, `F` tax, `G` gift, …). |
| `minTransactionValue` | integer | `0` | form-4 | Drop insider transactions whose shares × price is below this USD value. |
| `eightKItemCodes` | string\[] | `[]` | 8-K | Keep only 8-Ks reporting at least one of these item codes (`2.02`, `5.02`, `1.01`, …). |
| `eventCategories` | select\[] | `[]` | 8-K | Keep only these mapped categories (`earnings`, `exec_change`, `m_and_a`, `bankruptcy`, `cyber_incident`, …). |
| `eightKDeepParse` | boolean | `true` | 8-K | Fetch primary doc + exhibits for `itemBodies`, exhibit list, press-release text. Off = faster, headline-only. |
| `statementTypes` | select\[] | `[]` | financials | `income_statement` / `balance_sheet` / `cash_flow`. Empty = all. |
| `financialsFrequency` | select | `both` | financials | `annual` (FY) / `quarterly` (Qn) / `both`. |
| `financialsConcepts` | string\[] | `[]` | financials, xbrl-facts | Extra XBRL tags to include (e.g. `InventoryNet`, `LongTermDebtNoncurrent`). |
| `minOfferingAmount` | integer | `0` | form-d | Drop offerings whose total offering amount is below this USD value. |
| `formDIndustry` | string | `""` | form-d | Keep one SEC industry group (e.g. `Technology`, `Biotechnology`). |
| `formDKeyword` | string | `""` | form-d | Keep only issuers whose legal name contains this keyword. |
| `sinceAccessionNumber` | string | `""` | company-filings, form-4, 8-K | Skip filings at or older than this accession (e.g. `0000320193-25-000079`). For incremental scheduled runs. |
| `includeAmendments` | boolean | `true` | all | Include amended forms (`10-K/A`, `4/A`, `D/A`, …). |
| `includeDocumentText` | boolean | `false` | company-filings, search | Fetch the primary doc and attach a plain-text excerpt (`documentExcerpt`). Slower. |
| `maxFilingsPerCompany` | integer | `1000` | company-filings, form-4, form-13f | Cap filings pulled per company. |
| `maxItems` | integer | `50` | all | Max records output across the whole run (1–100000). |
| `contactEmail` | string | `""` | all | **Your email — the SEC requires a descriptive contact in the `User-Agent`.** See below. |
| `proxyConfiguration` | object | off | all | Leave it alone — the actor needs no proxy. Present only as an escape hatch if you ever hit a collective rate limit. |

#### About `contactEmail` (SEC User-Agent policy)

The SEC's fair-access policy requires every automated API consumer to identify itself with a descriptive `User-Agent` containing contact information. Set `contactEmail` to a real address you monitor. If you leave it blank, the actor falls back to a generic identifier, which the SEC **may rate-limit more aggressively** or block. This is the only "credential-like" input — it is not a login and grants no access; it simply identifies you as a good citizen of a free public API.

#### Input examples

**1. Company filings — Apple & Microsoft 10-K / 10-Q / 8-K since 2023**

```json
{
  "mode": "company-filings",
  "companies": ["AAPL", "MSFT"],
  "formTypes": ["10-K", "10-Q", "8-K"],
  "startDate": "2023-01-01",
  "maxItems": 100,
  "contactEmail": "you@example.com"
}
```

**2. Financials — Apple annual income statement + balance sheet**

```json
{
  "mode": "financials",
  "companies": ["AAPL"],
  "financialsFrequency": "annual",
  "statementTypes": ["income_statement", "balance_sheet"],
  "contactEmail": "you@example.com"
}
```

**3. Form D funding leads — market-wide technology offerings ≥ $1M in a month**

```json
{
  "mode": "form-d-funding-leads",
  "marketWide": true,
  "startDate": "2026-08-01",
  "endDate": "2026-08-31",
  "formDIndustry": "Technology",
  "minOfferingAmount": 1000000,
  "maxItems": 200,
  "contactEmail": "you@example.com"
}
```

**4. 13F holdings — Berkshire Hathaway's latest reported portfolio**

```json
{
  "mode": "form-13f",
  "companies": ["0001067983"],
  "maxItems": 500,
  "contactEmail": "you@example.com"
}
```

***

### Output

One record per result is pushed to the dataset. Field names below are exactly what the actor emits. Samples are trimmed for readability — real records carry the full field set.

#### Filing (`company-filings`, `latest-filings-feed`)

```json
{
  "recordType": "filing",
  "mode": "company-filings",
  "cik": "320193",
  "cikPadded": "0000320193",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "formType": "10-K",
  "baseFormType": "10-K",
  "isAmendment": false,
  "accessionNo": "0000320193-24-000123",
  "filedDate": "2024-11-01",
  "reportDate": "2024-09-28",
  "period": "2024-09-28",
  "acceptanceDateTime": "2024-11-01T06:01:36.000Z",
  "act": "34",
  "fileNumber": "001-36743",
  "items": [],
  "itemsDescriptions": [],
  "size": 8123456,
  "isXBRL": true,
  "isInlineXBRL": true,
  "primaryDocument": "aapl-20240928.htm",
  "primaryDocDescription": "10-K",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/0000320193-24-000123-index.htm",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "stateOfIncorporation": "CA",
  "exchanges": ["Nasdaq"],
  "scrapedAt": "2026-09-03T12:00:00.000Z"
}
```

Full field list: `recordType, mode, cik, cikPadded, ticker, companyName, formType, baseFormType, isAmendment, coreType, accessionNo, filedDate, reportDate, period, acceptanceDateTime, act, fileNumber, filmNumber, items, itemsDescriptions, size, isXBRL, isInlineXBRL, primaryDocument, primaryDocDescription, documentUrl, filingIndexUrl, filingDetailsUrl, sic, sicDescription, stateOfIncorporation, exchanges, scrapedAt`. In `latest-filings-feed` an `updated` timestamp from the feed entry is added, and the fields that require a company lookup (`sic`, `exchanges`, …) may be `null`. With `includeDocumentText`, a `documentExcerpt` field is added.

#### Financials (`financials`)

Metrics are grouped per fiscal period. Trimmed to a few metrics here:

```json
{
  "recordType": "financials",
  "cik": "320193",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "entityName": "Apple Inc.",
  "fiscalYear": 2024,
  "fiscalPeriod": "FY",
  "form": "10-K",
  "periodStart": "2023-10-01",
  "periodEnd": "2024-09-28",
  "filed": "2024-11-01",
  "accessionNo": "0000320193-24-000123",
  "frame": "CY2024",
  "currency": "USD",
  "metrics": {
    "revenue": 391035000000,
    "netIncome": 93736000000,
    "operatingIncome": 123216000000,
    "epsDiluted": 6.08,
    "totalAssets": 364980000000,
    "totalLiabilities": 308030000000,
    "stockholdersEquity": 56950000000,
    "operatingCashFlow": 118254000000,
    "sharesOutstanding": 15115823000
  },
  "metricUnits": {
    "revenue": "USD",
    "netIncome": "USD",
    "epsDiluted": "USD/shares",
    "sharesOutstanding": "shares"
  },
  "metricAsOf": null,
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "scrapedAt": "2026-09-03T12:00:00.000Z"
}
```

Available `metrics` keys: `revenue, costOfRevenue, grossProfit, operatingIncome, netIncome, incomeBeforeTax, epsBasic, epsDiluted, researchAndDevelopment, totalAssets, totalLiabilities, stockholdersEquity, cashAndEquivalents, operatingCashFlow, capitalExpenditures, longTermDebt, sharesOutstanding` — plus any tags you add via `financialsConcepts`. A metric absent from a given filing is simply omitted from `metrics`.

Reading the numbers correctly:

- **`currency` is the company's own reporting currency**, not always USD. Foreign private issuers filing 20-F/40-F are covered under both accounting standards, so a European filer comes back in EUR and a Japanese one in JPY, with the same metric names. `metricUnits` carries the unit of every individual metric (`USD`, `EUR`, `USD/shares` for per-share figures, `shares` for counts), so a figure is never left to be guessed at.
- **`fiscalYear` / `fiscalPeriod` describe the period itself**, matched to `periodStart`/`periodEnd`, and follow the company's own fiscal calendar — for a retailer whose year closes in January, or a filer whose year closes in March, the quarter numbering starts at the beginning of *its* year, not in January.
- **A record's figures come from one filing wherever they can.** `form`, `filed` and `accessionNo` name that filing — the one reporting this period most completely, the most recent when several are equally complete. It may be an annual report, an amended one, or an earnings release. Keeping a period together matters: figures drawn from different filings would put an EPS restated for a stock split next to a share count that was not.
- **A metric keeps the same accounting concept across every year, so a series stays comparable.** Where a company restates a period — adopting a new revenue standard, for instance — the restated figure is used, which can differ from the number printed in that year's original annual report. That is also why a small share of figures (around 2% in our checks) is drawn from a filing other than the one named: it is where the comparable version of that metric lives.
- **Figures are as reported — the SEC's data is reproduced, not corrected.** Share counts and per-share figures are only split-adjusted insofar as the filings themselves adjust them, so a long series can cross a split. Where a company mis-tagged a figure in its own filing, that figure is what the SEC publishes and what you get.
- **`metricAsOf`** appears (otherwise `null`) when a metric is dated differently from the period — a share count taken from a filing's cover page is as of the filing date, a few weeks after the period closed.

#### 13F holding (`form-13f`)

One record per position in the manager's INFORMATION TABLE:

```json
{
  "recordType": "holding13F",
  "managerCik": "1067983",
  "managerCikPadded": "0001067983",
  "managerName": "BERKSHIRE HATHAWAY INC",
  "managerTicker": null,
  "periodOfReport": "2024-06-30",
  "cusip": "037833100",
  "issuerName": "APPLE INC",
  "titleOfClass": "COM",
  "shareCount": 400000000,
  "sshPrnamtType": "SH",
  "value": 84248000000,
  "valueUnit": "dollars",
  "valueUsd": 84248000000,
  "putCall": null,
  "investmentDiscretion": "DFND",
  "otherManager": "4,8,11",
  "votingAuthoritySole": 400000000,
  "votingAuthorityShared": 0,
  "votingAuthorityNone": 0,
  "portfolioPercent": 30.15,
  "portfolioValueTotal": 279969000000,
  "portfolioValueTotalUsd": 279969000000,
  "holdingsCount": 41,
  "formType": "13F-HR",
  "accessionNo": "0000950123-24-008740",
  "filedDate": "2024-08-14",
  "acceptanceDateTime": "2024-08-14T16:20:11.000Z",
  "infoTableDocument": "infotable.xml",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1067983/000095012324008740/infotable.xml",
  "scrapedAt": "2026-09-03T12:00:00.000Z"
}
```

Reading the values: the SEC changed the reporting scale, so `value` alone is not comparable across
years — filings from **2023-01-03** onward report whole dollars, earlier ones report thousands. `value`
is the figure exactly as filed, `valueUnit` says which scale it is on (`dollars`, `thousands`, or
`unknown` when the filing date is missing), and **`valueUsd` is the figure converted to dollars** —
use that one to compare or rank positions across periods. `portfolioValueTotalUsd` is the same
conversion applied to the portfolio total. When the scale cannot be established, the converted fields
are `null` rather than a guess.

#### Form D funding lead (`form-d-funding-leads`)

```json
{
  "recordType": "fundingLead",
  "cik": "2147185",
  "issuerName": "Valhalla Sports Collectibles Fund I, LP",
  "entityType": "Limited Partnership",
  "jurisdictionOfInc": "DELAWARE",
  "yearOfInc": "2026",
  "address": {
    "street1": "7952 NW 115TH WAY",
    "street2": null,
    "city": "PARKLAND",
    "stateOrCountry": "FLORIDA",
    "zipCode": "33076"
  },
  "phone": "561-300-6534",
  "industryGroup": "Pooled Investment Fund",
  "revenueRange": "Decline to Disclose",
  "isAmendment": true,
  "dateOfFirstSale": "2026-07-16",
  "minimumInvestment": 100000,
  "totalOfferingAmount": 10000000,
  "totalOfferingAmountRaw": "10000000",
  "totalAmountSold": 550000,
  "totalRemaining": 9450000,
  "numberOfInvestors": 4,
  "relatedPersons": [
    {
      "name": "Stuart Lieblein",
      "firstName": "Stuart",
      "lastName": "Lieblein",
      "relationships": [
        "Executive Officer",
        "Promoter"
      ],
      "city": "Parkland",
      "state": "FLORIDA"
    },
    {
      "name": "Medon Michaelides",
      "firstName": "Medon",
      "lastName": "Michaelides",
      "relationships": [
        "Executive Officer",
        "Promoter"
      ],
      "city": "Parkland",
      "state": "FLORIDA"
    }
  ],
  "formType": "D/A",
  "fileNumber": "021-592198",
  "filedDate": "2026-09-11",
  "accessionNo": "0002147185-26-000002",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/2147185/000214718526000002/primary_doc.xml"
}
```

Full field list also includes: `investmentFundType, isAmendment, isMoreThanOneYear, isBusinessCombination, salesCommissions, findersFees, grossProceedsUsed, acceptanceDateTime, filingIndexUrl`. When the offering amount is `"Indefinite"`, `totalOfferingAmount` is `null` and the literal value is preserved in `totalOfferingAmountRaw`.

#### Other record shapes (field lists)

- **`insider`** (`form-4-insider`): `recordType, cik, ticker, issuerName, insiderName, insiderCik, insiderTitle, isDirector, isOfficer, isTenPercentOwner, isOther, insiderCity, insiderState, formType, accessionNo, filedDate, acceptanceDateTime, periodOfReport, transactionCount, transactions[], documentUrl, filingIndexUrl, scrapedAt`. Each entry in `transactions[]`: `derivative, securityTitle, transactionDate, code, codeLabel, formType, acquiredDisposed, shares, pricePerShare, value, sharesOwnedAfter, directOrIndirect` (+ `conversionOrExercisePrice, exerciseDate, expirationDate, underlyingSecurity, underlyingShares` for derivative rows).
- **`activistStake`** (`activist`): `recordType, schedule (13D/13G), formType, isAmendment, isPassive, filingType, subjectCompany, subjectCik, subjectTicker, filer, filerCik, allFilers[], cusip, percentOwned, sharesOwned, purpose (13D only), eventDate, accessionNo, filedDate, acceptanceDateTime, fileNumber, documentUrl, filingIndexUrl, scrapedAt`.
- **`xbrlFact`** (`xbrl-facts`): `recordType, cik, cikPadded, ticker, companyName, entityName, taxonomy, concept, label, description, unit, value, periodStart, periodEnd, instant, fiscalYear, fiscalPeriod, form, accn, filed, frame, scrapedAt`.

  In this mode `fiscalYear`/`fiscalPeriod` are passed through exactly as the SEC tags them — they identify the **filing** a datapoint was printed in, not the period it covers, so an annual report's comparative figures all carry that report's year. Use `periodStart`/`periodEnd` for the period itself, or use `financials` mode, which resolves this for you.
- **`searchHit`** (`search`): `recordType, mode, cik, ticker, companyName, allFilers[], formType, rootForms[], accessionNo, fileNumber, filedDate, period, fileType, fileDescription, items[], sic, businessLocation, businessState, incState, relevanceScore, documentUrl, filingIndexUrl, scrapedAt`.
- **`eightKEvent`** (`eight-k-events`): the `filing` fields plus `itemCodes[], itemLabels[], eventCategories[]`, boolean flags (`cyberIncidentFlag, auditorChangeFlag, restatementFlag, bankruptcyFlag, delistingFlag, officerDepartureFlag, materialAgreementFlag, earningsFlag, mAndAFlag, hasFinancialStatements`), and — when `eightKDeepParse` is on — `itemBodies{}, exhibits[], pressReleaseText, bodyTextLength`.

***

### Pricing

This actor is **pay-per-event**: you are charged for each record it writes to the dataset, priced by
what that record costs to produce. Bulk index rows are cheap; records that required fetching and
parsing a separate document cost more.

| You get | Price each | Per 1,000 |
| --- | --- | --- |
| Filing row (`company-filings`, `latest-filings-feed`) | $0.008 | $8 |
| Full-text search hit (`search`) | $0.008 | $8 |
| Financial period (`financials`) | $0.05 | $50 |
| Raw XBRL fact (`xbrl-facts`) | $0.0008 | $0.80 |
| Insider transaction (`form-4-insider`) | $0.02 | $20 |
| 13F holding (`form-13f`) | $0.015 | $15 |
| Activist stake (`activist`) | $0.08 | $80 |
| Form D funding lead (`form-d-funding-leads`) | $0.08 | $80 |
| 8-K event (`eight-k-events`) | $0.04 | $40 |
| Actor start | $0.01 per run | — |

What that means in practice: a company's full annual financial history is about **$0.96**, Berkshire's
complete 13F portfolio about **$1.82**, a 50-filing default run **$0.41**.

Use `maxItems` and the date/form/value filters to cap spend precisely — `maxItems` is a hard stop, so
the most a run can cost is your item limit times the price above, plus the start fee.

The underlying data comes from the SEC's free public APIs — there are no third-party data fees, no subscription, and no key to buy. You pay only for the compute and the results you actually pull through Apify.

***

### Use cases

- **Fundamental research** — build a normalized time series of revenue, margins, EPS, and balance-sheet items across companies (`financials`), or pull the raw XBRL facts for your own modeling (`xbrl-facts`).
- **Insider & institutional tracking** — monitor Form 4 buys/sells by executives and 10% owners (`form-4-insider`) and reconstruct any institutional manager's quarterly portfolio and position changes (`form-13f`).
- **VC / funding-lead generation** — enumerate fresh Reg D private placements market-wide by industry, geography, and offering size, with issuer contacts and named executives/directors (`form-d-funding-leads`).
- **Activist monitoring** — track new 13D (active) and 13G (passive) beneficial-ownership stakes in a target issuer, including the 13D Item 4 purpose narrative (`activist`).
- **Compliance & disclosure surveillance** — watch a watchlist of companies for new filings and material 8-K events (restatements, auditor changes, delistings, cyber incidents, exec departures) on a schedule using `sinceAccessionNumber` for clean incrementals.

***

### Honest limitations

We'd rather set expectations correctly than oversell.

- **All data is the SEC's official public data.** Every field is derived from the SEC's free, keyless dissemination APIs (submissions, XBRL companyfacts, full-text search, the Atom feed, and the filing archives). It's reliable and authoritative, but it's exactly what the SEC publishes — no more, no less.
- **No AI "summaries" or "scores."** Some competing actors advertise AI-generated filing summaries, sentiment, or risk scores. Those are *derived UX layers* that require you to bring your own LLM API key, and they are not raw SEC data — they are out of scope here by design. This actor returns the underlying structured facts you'd feed such a layer, not a synthesized opinion about them.
- **Some fields are legitimately absent on specific filings, and we surface that as `null` rather than guessing.** Examples: a Form D offering marked `"Indefinite"` yields `totalOfferingAmount: null` (the raw string is kept in `totalOfferingAmountRaw`, and `minOfferingAmount` then judges it by `totalAmountSold` instead, so an indefinite raise still has to clear your threshold); an older 13D/13G whose cover page isn't cleanly machine-readable may return `percentOwned`/`sharesOwned`/`cusip` as `null` (structured `primary_doc.xml` on post-2024 filings is preferred when present); a company that doesn't file XBRL has no `financials`/`xbrl-facts` output.
- **Full-text `search` covers filings from 2001 onward** (an EDGAR limitation) and is hard-capped by EDGAR at **10,000 results per query** — narrow with form types and date ranges for complete coverage. Company filing *history* via `company-filings` goes back to a company's earliest EDGAR submission.
- **Throughput is bounded by the SEC's fair-access policy** (~8 req/s here, under the 10 req/s limit). Very large pulls take proportionally longer — this is intentional and keeps you in good standing with the SEC.

***

### FAQ

**Do I need an API key?**
No. SEC EDGAR's APIs are free and keyless. The SEC does require a descriptive `User-Agent` with contact information — provide your address in `contactEmail`. That's not a login and grants no special access; it just identifies you.

**Which companies and regions are covered?**
U.S. SEC registrants — any entity that files with EDGAR (domestic and foreign private issuers that report to the SEC).

**How fresh is the data?**
As fresh as EDGAR itself. Filings appear through the same real-time dissemination endpoints the SEC publishes to; the `latest-filings-feed` mode reflects the newest accepted filings.

**Do I need a proxy?**
No. The SEC APIs are public and work fine over a direct connection — the SEC actually wants you identified, not hidden. An optional Apify datacenter proxy is available only if you hit collective rate limits.

**How do I run this on a schedule and only get new filings?**
Set a schedule in Apify, and pass the last accession number you processed as `sinceAccessionNumber` (supported in `company-filings`, `form-4-insider`, and `eight-k-events`). The run will skip everything at or older than that accession. Date presets like `last7Days` are also handy for recurring runs.

**Can I get several companies at once?**
Yes — put multiple tickers/CIKs/names in `companies`. For full-text `search`, use `companies` to scope to several filers, or `entityFilter` for a single one.

**Why is a metric or field missing?**
Because the SEC filing didn't contain it. Absent values are returned as `null` (or omitted from `metrics`) rather than invented — see *Honest limitations*.

# Actor input Schema

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

What to scrape. company-filings = a company's filing history by ticker/CIK/name. search = EDGAR full-text search across all filers. financials = normalized XBRL financial statements by period. xbrl-facts = raw XBRL facts (one record per reported datapoint) from companyfacts. form-4-insider = insider (director/officer/10%) transactions. form-13f = institutional-manager 13F-HR holdings (one record per position). activist = Schedule 13D/13G beneficial-ownership stakes. form-d-funding-leads = private-placement Form D offerings (funding leads). eight-k-events = 8-K material events with parsed item codes/labels, body text, exhibits and event flags. latest-filings-feed = newest filings across EDGAR by form type.

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

Companies to pull. Accepts stock tickers (AAPL), CIK numbers (320193 or CIK0000320193), or company names (Apple). Used by company-filings, financials, xbrl-facts, form-4-insider, form-13f (the institutional manager, e.g. 0001067983 for Berkshire Hathaway), and activist (the subject issuer). In form-d-funding-leads, eight-k-events and activist you can scan every filer instead — switch on "Scan all of EDGAR" below and this list is ignored.

## `marketWide` (type: `boolean`):

Turn this on in form-d-funding-leads, eight-k-events or activist to sweep every filer in the date range instead of the companies listed above. The companies list is then ignored, so you do not have to empty it. Other modes are unaffected.

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

Filter to these EDGAR form types, e.g. 10-K, 10-Q, 8-K, 4, D, S-1, 13F-HR. Empty = all forms. Matching is prefix-based, so 10-K also matches 10-K/A when Include amendments is on. In latest-filings-feed mode each form type is fetched as its own feed. Leave empty to use each mode's natural forms (3/4/5 for insider, D for funding leads, 8-K for events, 13F-HR for holdings) — setting it overrides that for every mode.

## `query` (type: `string`):

Search phrase for mode=search (EDGAR full-text search, covers filings from 2001 onward). Wrap in double quotes for an exact phrase, e.g. "artificial intelligence".

## `entityFilter` (type: `string`):

Optional. Restrict full-text search to a single entity by company name, ticker, or CIK. To scope to several companies use the Companies field instead.

## `queryMode` (type: `string`):

How to interpret the full-text query. asTyped = pass through as-is; exactPhrase = wrap in quotes for an exact phrase; allTerms = require every word.

## `datePreset` (type: `string`):

Convenience date range that overrides Start/End date when set. Relative to today.

## `transactionCodes` (type: `array`):

Filter insider transactions to these SEC codes, e.g. P (purchase), S (sale), A (award), M (option exercise), F (tax), G (gift), D (disposition). Empty = all.

## `minTransactionValue` (type: `integer`):

Drop insider transactions whose shares x price is below this USD value. 0 = keep all (including $0 awards).

## `formDIndustry` (type: `string`):

Form D funding-leads: filter to one SEC industry group (e.g. Technology, Biotechnology, Commercial Real Estate). Empty = all industries.

## `formDKeyword` (type: `string`):

Form D funding-leads: only keep issuers whose legal name contains this keyword (case-insensitive).

## `eightKItemCodes` (type: `array`):

8-K events mode: keep only 8-K filings that report at least one of these item codes, e.g. 2.02, 5.02, 1.01. Empty = all items.

## `eventCategories` (type: `array`):

8-K events mode: keep only these material-event categories (mapped to item codes).

## `eightKDeepParse` (type: `boolean`):

8-K events mode: fetch each filing's primary document and exhibits to populate per-item body text (itemBodies), the exhibit list, and the press-release text. On by default. Turn off for a faster, headline-only run (item codes/labels and event flags still populate).

## `statementTypes` (type: `array`):

Financials mode: which normalized statements to compute. Empty = all.

## `sinceAccessionNumber` (type: `string`):

Incremental company-filings/form-4/8-K: skip filings at or older than this accession number (e.g. 0000320193-25-000079). Useful for scheduled runs.

## `startDate` (type: `string`):

Only include filings filed on or after this date. Format YYYY-MM-DD. Leave blank for no lower bound.

## `endDate` (type: `string`):

Only include filings filed on or before this date. Format YYYY-MM-DD. Leave blank for no upper bound.

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

Maximum number of records to output across the whole run.

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

Include amended forms (e.g. 10-K/A, 4/A, D/A) when filtering by form type.

## `includeDocumentText` (type: `boolean`):

Fetch each filing's primary document and attach a plain-text excerpt (company-filings and search modes). Slower and uses more requests.

## `financialsFrequency` (type: `string`):

Which periods to return in financials mode: annual (FY), quarterly (Qn), or both. Periods follow the company's own fiscal calendar, so quarter numbering starts at the beginning of its fiscal year.

## `financialsConcepts` (type: `array`):

Optional additional XBRL tags to include in financials output beyond the built-in metric set, e.g. InventoryNet, LongTermDebtNoncurrent. Tags are matched in the company's own taxonomy.

## `minOfferingAmount` (type: `integer`):

Form D funding-leads only: drop offerings whose total offering amount is below this USD value. 0 = no minimum.

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

Cap the number of filings pulled per company (company-filings and form-4-insider modes).

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

Your email address. The SEC requires a descriptive User-Agent with contact info for its APIs. If left blank a generic identifier is used, which the SEC may rate-limit more aggressively. Must be plain ASCII — HTTP headers cannot carry Cyrillic, umlauts or other non-Latin characters; anything else is stripped and reported in the log.

## `proxyConfiguration` (type: `object`):

You do not need this. The SEC APIs are public and the actor connects to them directly — nothing to configure, nothing to sign up for. It is here only as an escape hatch in case you ever hit a collective rate limit; if it is enabled and stops working, the run carries on directly rather than failing.

## Actor input object example

```json
{
  "mode": "company-filings",
  "companies": [
    "AAPL"
  ],
  "marketWide": false,
  "formTypes": [
    "10-K",
    "8-K"
  ],
  "query": "",
  "entityFilter": "",
  "queryMode": "asTyped",
  "datePreset": "",
  "transactionCodes": [],
  "minTransactionValue": 0,
  "formDIndustry": "",
  "formDKeyword": "",
  "eightKItemCodes": [],
  "eventCategories": [],
  "eightKDeepParse": true,
  "statementTypes": [],
  "sinceAccessionNumber": "",
  "startDate": "",
  "endDate": "",
  "maxItems": 50,
  "includeAmendments": true,
  "includeDocumentText": false,
  "financialsFrequency": "both",
  "financialsConcepts": [],
  "minOfferingAmount": 0,
  "maxFilingsPerCompany": 1000,
  "contactEmail": "you@example.com",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

No description

## `runStats` (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 = {
    "mode": "company-filings",
    "companies": [
        "AAPL"
    ],
    "formTypes": [
        "10-K",
        "8-K"
    ],
    "contactEmail": "you@example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/sec-edgar-scraper").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 = {
    "mode": "company-filings",
    "companies": ["AAPL"],
    "formTypes": [
        "10-K",
        "8-K",
    ],
    "contactEmail": "you@example.com",
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/sec-edgar-scraper").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 '{
  "mode": "company-filings",
  "companies": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "8-K"
  ],
  "contactEmail": "you@example.com"
}' |
apify call brilliant_gum/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/YuwLUSu3AchBHCg1D/builds/L6pLbWQlFQOojT8SH/openapi.json