# SEC EDGAR Scraper (`constructive_calm/sec-edgar-scraper`) Actor

Fetches SEC EDGAR filings, normalized financial statements, XBRL facts, insider trades (Form 4), institutional holdings (13F), activist stakes (13D/G), full-text search hits, and parsed 8-K items via official SEC APIs. Zero anti-bot. Optional AI summaries.

- **URL**: https://apify.com/constructive_calm/sec-edgar-scraper.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** News, Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 81 total users, 18 monthly users, 100.0% runs succeeded, 6 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 1,000 filing fetcheds

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

### What does SEC EDGAR Scraper do?

SEC EDGAR Scraper fetches structured data directly from the U.S. Securities and Exchange Commission's official [EDGAR](https://www.sec.gov/edgar) system — every public filing, every XBRL financial fact, every insider trade, every institutional holding — and delivers it as clean JSON or CSV you can feed straight into a pipeline.

It uses the SEC's official data APIs (`data.sec.gov`, `efts.sec.gov`, `www.sec.gov/Archives/edgar`), which are public-domain, zero-auth, and fully commercial-safe. No CAPTCHAs, no scraping fragility — just the same data that Bloomberg, FactSet, and sec-api.io resell, delivered cheaper and on your own Apify schedule.

Built with TypeScript on the Apify SDK. Respects SEC fair-use limits automatically, so it never gets throttled.

### Why use SEC EDGAR Scraper?

- **Financial analysts** — pull normalized income statements, balance sheets, and cash flows for any U.S. public company with one call. No more wrestling with XBRL.
- **Hedge funds & quants** — monitor insider trades (Form 4), institutional position changes (13F), and activist stake accumulations (13D/G) as filings land.
- **M\&A / PE dealmakers** — auto-parse 8-K item codes (2.01 acquisitions, 5.02 exec changes, 4.01 auditor changes) to surface deal signals the moment they're filed.
- **Investment research & AI/LLM teams** — pipe 20+ years of filings into your model with structured metadata, AI-generated filing summaries, and full-text search.
- **Compliance & governance teams** — track peer filings, proxy statements, and disclosure trends with date-range filters and scheduled runs.

### How to use SEC EDGAR Scraper

1. Pick a **mode**: `filings`, `xbrl_facts`, `financials`, `full_text_search`, `form4`, `form13f`, `activist`, `latest_feed`, or `eight_k_items`.
2. For company-scoped modes, add one or more **tickers** (e.g. `AAPL`, `TSLA`) — or CIKs, company names, or domains. The actor auto-resolves to canonical SEC CIK.
3. Optional filters: `forms` (10-K, 10-Q, 8-K, etc.), `dateFrom` / `dateTo`, `maxItems`, form-specific filters.
4. Run the actor. Results land in the default dataset.
5. Export as **JSON, CSV, Excel, or XML** from the Apify Console — or pipe into a webhook / pull via API.
6. Want daily updates? Enable **incremental mode** and schedule the actor to run daily — only new or changed items are emitted.

### Input

The simplest possible input — fetch Apple's recent 10-K and 10-Q filings:

```json
{
    "mode": "filings",
    "tickers": ["AAPL"],
    "forms": ["10-K", "10-Q"],
    "maxItems": 20
}
```

Get normalized income statements for Microsoft over the past 5 fiscal years:

```json
{
    "mode": "financials",
    "tickers": ["MSFT"],
    "statementTypes": ["income_statement"],
    "fiscalPeriods": ["FY"],
    "dateFrom": "2020-01-01",
    "maxItems": 10
}
```

Find every 10-K that mentions "artificial intelligence" in 2025:

```json
{
    "mode": "full_text_search",
    "searchQuery": "artificial intelligence",
    "forms": ["10-K"],
    "dateFrom": "2025-01-01",
    "dateTo": "2025-12-31",
    "maxItems": 500
}
```

Track recent insider buying at Tesla worth at least $100,000:

```json
{
    "mode": "form4",
    "tickers": ["TSLA"],
    "transactionCodes": ["P"],
    "minTransactionValue": 100000,
    "dateFrom": "2025-01-01",
    "maxItems": 50
}
```

Pull 13F institutional holdings for Berkshire Hathaway (CIK 1067983):

```json
{
    "mode": "form13f",
    "tickers": ["1067983"],
    "maxItems": 500
}
```

Get activist (Schedule 13D) stake accumulations for any ticker under pressure:

```json
{
    "mode": "activist",
    "tickers": ["DIS"],
    "activistOnly": true,
    "maxItems": 20
}
```

Generate AI-powered summaries of a company's 8-K earnings releases:

```json
{
    "mode": "eight_k_items",
    "tickers": ["NVDA"],
    "eightKItemCodes": ["2.02"],
    "enableAiSummary": true,
    "maxItems": 8
}
```

### Output

Example output from `filings` mode:

```json
{
    "type": "filing",
    "cik": "320193",
    "ticker": "AAPL",
    "companyName": "Apple Inc.",
    "form": "10-K",
    "accessionNumber": "0000320193-25-000079",
    "filingDate": "2025-10-31",
    "reportDate": "2025-09-27",
    "acceptanceDateTime": "2025-10-31T18:04:43.000Z",
    "primaryDocument": "aapl-20250927.htm",
    "primaryDocDescription": "10-K",
    "items": null,
    "isXBRL": true,
    "isInlineXBRL": true,
    "size": 6391250,
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm",
    "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm",
    "aiSummary": null,
    "scrapedAt": "2026-04-19T20:05:49.147Z"
}
```

Example output from `financials` mode (normalized income statement):

```json
{
    "type": "financial_statement",
    "cik": "320193",
    "ticker": "AAPL",
    "companyName": "Apple Inc.",
    "statementType": "income_statement",
    "period": "2025-FY",
    "periodStart": "2024-09-29",
    "periodEnd": "2025-09-27",
    "fiscalYear": 2025,
    "fiscalPeriod": "FY",
    "form": "10-K",
    "filedDate": "2025-10-31",
    "accessionNumber": "0000320193-25-000079",
    "currency": "USD",
    "lineItems": [
        { "label": "Revenue", "concept": "RevenueFromContractWithCustomerExcludingAssessedTax", "value": 416161000000, "unit": "USD" },
        { "label": "Cost of Revenue", "concept": "CostOfGoodsAndServicesSold", "value": 220960000000, "unit": "USD" },
        { "label": "Gross Profit", "concept": "GrossProfit", "value": 195201000000, "unit": "USD" },
        { "label": "Operating Income", "concept": "OperatingIncomeLoss", "value": 133050000000, "unit": "USD" },
        { "label": "Net Income", "concept": "NetIncomeLoss", "value": 112010000000, "unit": "USD" },
        { "label": "EPS Diluted", "concept": "EarningsPerShareDiluted", "value": 7.46, "unit": "USD/shares" }
    ],
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm"
}
```

How statement rows are built:

- **One period per row.** Every value belongs to the row's own period (`periodStart` → `periodEnd`). Each `(statementType, period)` appears once per company.
- **Fiscal labels follow the company's calendar.** `fiscalYear` is the company's own fiscal-year convention (Apple's FY2025 ends 2025-09-27; Target's FY2023 ends 2024-02-03; Walmart's FY2025 ends 2025-01-31). Quarters are numbered by their position in that fiscal year.
- **As originally reported.** All values in a row come from the single filing in `accessionNumber` / `filingUrl`: the 10-K (fiscal years) or 10-Q (quarters) for that period — or its amendment, if a 10-K/A or 10-Q/A restated it. Later restatements and split adjustments show up in later filings (and in `xbrl_facts` mode), not in an older row. Periods older than a company's first XBRL filing come from the earliest filing that disclosed them (a 10-K for fiscal years).
- **Quarter shapes.** Quarterly income statements are the 3-month quarter; quarterly cash-flow statements are year-to-date as filed (`periodStart` shows the window); balance sheets are as of `periodEnd` (`periodStart` is `null`). **Q4** has an income statement only (the Q4 balance sheet and year-to-date cash flow are the FY rows). When the 10-K does not report the fourth quarter separately, its money lines are computed as fiscal year minus the nine-month year-to-date and marked `"derived": true`; per-share and share-count lines are never derived.
- **IFRS filers** (20-F / 40-F, e.g. TSMC) are supported for the same line items, in the reporting currency (`currency`, e.g. `TWD`); their `concept` values carry an `ifrs-full:` prefix. Companies whose SEC data has no US-GAAP or IFRS statements get 0 rows and a status message saying so.
- **Incremental mode** re-emits a statement only when its values change (e.g. a 10-K/A restatement). If your incremental state was written by a version before value tracking (October 2026), each statement it covers is re-sent once with `"correction": true` at no charge — older versions could have delivered another year's figures under that period.
- **Quarter numbering** follows each company's own calendar, including uneven ones (Kroger's first quarter is 16 weeks). Every value in a row is in the row's `currency` — foreign filers' US-dollar convenience translations are never mixed in.
- **Derived Q4** lines are only computed when the fiscal year and the nine months come from filings on the same basis (both original or both amended); a computed revenue or expense line that would be negative is left out.

Example output from `activist` mode (structured Schedule 13D, filed since December 2024):

```json
{
    "type": "activist_filing",
    "cik": "92380",
    "ticker": "LUV",
    "companyName": "SOUTHWEST AIRLINES CO",
    "form": "SCHEDULE 13D/A",
    "isActivist": true,
    "filerNames": ["Elliott Investment Management L.P."],
    "filerCiks": ["1791786"],
    "percentOwnership": 4.9,
    "sharesOwned": 24308000,
    "eventDate": "2026-04-02",
    "filingDate": "2026-04-03",
    "accessionNumber": "0000902664-26-001872",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/92380/000090266426001872/0000902664-26-001872-index.htm"
}
```

Example output from `form4` mode (insider trade):

```json
{
    "type": "form4_transaction",
    "cik": "320193",
    "ticker": "AAPL",
    "companyName": "Apple Inc.",
    "insiderName": "Borders Ben",
    "insiderCik": "0002100523",
    "insiderTitle": "Principal Accounting Officer",
    "isOfficer": true,
    "isDirector": false,
    "isTenPercentOwner": false,
    "transactionType": "other",
    "transactionCode": "F",
    "shares": 892,
    "pricePerShare": 266.43,
    "totalValue": 237655.56,
    "sharesOwnedAfter": 39987,
    "transactionDate": "2026-04-15",
    "filingDate": "2026-04-17"
}
```

#### Data fields

| Field | Type | Description |
|---|---|---|
| `type` | enum | Discriminator: `filing`, `xbrl_fact`, `financial_statement`, `full_text_hit`, `form4_transaction`, `form13f_holding`, `activist_filing`, `eight_k_parsed` |
| `cik` | string | SEC Central Index Key (company identifier) |
| `ticker` | string? | Stock ticker, when known |
| `companyName` | string | Registrant name as filed |
| `form` | string | Form type (10-K, 10-Q, 8-K, 4, 13F-HR, SC 13D / SCHEDULE 13D, etc.) |
| `filingDate` | date | When the filing was submitted to SEC |
| `reportDate` | date? | Period the filing reports on (e.g. fiscal year-end) |
| `accessionNumber` | string | Unique SEC filing identifier |
| `filingUrl` | url | Deep link to the primary filing document |
| `filingIndexUrl` | url | Deep link to the filing's index page (all exhibits) |
| `scrapedAt` | timestamp | When this record was emitted by the actor |
| `aiSummary` | object? | AI-generated structured summary (only when `enableAiSummary` is on) |

Mode-specific fields (line items, transactions, XBRL facts) are documented inside each mode's output rows — see the examples above.

### How much does it cost to scrape SEC EDGAR?

Pay only for what you use. Each chargeable event has its own price:

| Event | Price | When it fires |
|---|---|---|
| `filing-fetched` | **$0.40 per 1,000** | Any filing, insider trade, 8-K item, activist stake, or 13F holding emitted |
| `xbrl-fact-fetched` | **$0.15 per 1,000** | Raw XBRL financial fact (one revenue data point, one EPS number, etc.) |
| `fulltext-hit-fetched` | **$0.30 per 1,000** | A filing matched by your full-text search query |
| `change-detected` | **$0.30 per 1,000** | A new or updated item surfaced via incremental mode |
| `ai-summary-generated` | **$0.05 each** | An AI structured summary (premium; only when `enableAiSummary` is on) |

Normalized financial statements (`financials` mode) currently carry **no per-statement charge** — a `financials` run costs only the Actor start fee.

**Actor start fee:** every run is charged one **$0.01** start event per GB of memory (default 4 GB → **$0.04 per run**). Lower the run memory to pay less.

**Free trial:** The first **50 chargeable events per run are free.** Test any mode, see real output, pay nothing until you're confident.

**Typical event costs** (list price, before the per-run free events and the start fee):

| Task | Events | Cost |
|---|---|---|
| Fetch 500 recent filings for 5 tickers | 500 filings | **$0.20** |
| Pull 10 years of quarterly financials for a single ticker | 120 statements | **$0.00** |
| Full-text search "AI" across 2025 10-Ks (top 1000 hits) | 1,000 hits | **$0.30** |
| 500 insider trades at 20 S\&P 500 companies | 500 filings | **$0.20** |
| Track 13F holdings for 3 hedge funds (8000 holdings) | 8,000 filings | **$3.20** |
| AI-summarize 50 earnings 8-Ks | 50 filings + 50 summaries | **$2.52** |

Compared to sec-api.io ($100/mo minimum) and Bloomberg terminals ($24k/user/year), this actor pays off even at heavy use.

### Tips & advanced options

- **Incremental mode** — set `incrementalMode: true` and schedule the actor (e.g. daily at 09:00 EST). On each run, only new or changed items are emitted, so your downstream systems see a clean delta stream.
- **Combining filters** — all company-scoped modes accept `forms` and `dateFrom` / `dateTo` together. Example: recent 10-Q filings from the past 90 days for a watchlist of 50 tickers.
- **Custom XBRL concepts** — in `xbrl_facts` mode, provide the exact US-GAAP concept names (e.g. `StockholdersEquity`, `LongTermDebtNoncurrent`). See [SEC's XBRL taxonomy](https://www.sec.gov/dera/data/financial-statement-data-sets) for the full catalog.
- **Multi-ticker runs** — the `tickers` field accepts an array. One run for 100 companies is cheaper than 100 runs for 1 company each (fewer actor-start charges).
- **AI summaries on long filings** — set `aiSummaryMaxChars` to truncate input. For 10-Ks (often 100k+ chars), 60k is usually enough to catch all material items.
- **Chaining with Apify webhooks** — pipe results into Make.com, Zapier, Power BI, or a Slack channel using Apify's integrations.

### Legal disclaimer

EDGAR is a U.S. government system operated by the Securities and Exchange Commission. Data returned by this actor is public-domain and subject to the [SEC.gov Privacy and Security Policy](https://www.sec.gov/privacy). This actor operates within SEC's [published fair-use guidelines](https://www.sec.gov/os/accessing-edgar-data) (≤10 requests/second, User-Agent header with contact info). You are responsible for complying with any downstream redistribution terms (e.g. GDPR if you're processing EU-linked data, or your local data-handling laws).

### FAQ & support

**Does this actor require an SEC API key?**
No. SEC EDGAR APIs are public-domain and unauthenticated. This actor sends a compliant User-Agent header automatically.

**How fresh is the data?**
Filings appear in the submissions API within seconds of SEC acceptance. XBRL fact APIs can lag by a minute during 8-K peak hours. Full-text search index lags by 15–30 minutes on average.

**What if my ticker isn't resolving?**
The SEC ticker list covers ~8,000 U.S.-listed public companies. For foreign filers (20-F issuers), closed-end funds, and some OTC stocks, pass the CIK directly in `tickers` (e.g. `"1067983"` for Berkshire Hathaway).

**Can I run this on a schedule?**
Yes. Set `incrementalMode: true` and use Apify's scheduler. Daily runs after 6pm ET (after daily SEC close) catch the full day's filings.

**What about 10-K amendments and restatements?**
Amendments (`10-K/A`, `10-Q/A`) are returned as separate filings with the amendment form code. Use `forms: ["10-K", "10-K/A"]` to get both originals and amendments.

**Something's wrong / I have a feature request.**
Open an issue on the actor's Issues tab or email the maintainer. Common requests (peer benchmarking, risk-factor diffing, proxy statement parsing) are on the roadmap.

### Known limitations

- `activist` mode skips 13D/13G filings the company submitted itself, without downloading them (these are almost always stakes the company holds in other issuers). A rare issuer-filed Schedule 13G about its own shares on behalf of an insider (e.g. NIKE, 2016) is therefore not returned.
- Statement periods older than the company's first XBRL filing come from later filings' comparatives and may include a different line-item set.

### Changelog

- **2026-10 (fixes, round 3)** — Fiscal years of 52/53-week calendars that end in the first days of January (Domino's, Kraft Heinz) are labelled correctly and no longer dropped. Per-share values on non-USD rows use the reporting currency (TSMC, Alibaba). Uneven quarters (Kroger) are kept. Derived Q4 values no longer mix amended and original filings. Incremental state from older versions triggers one uncharged correction per statement.
- **2026-10 (fixes, round 2)** — `financials` mode: fiscal-year and quarter labels no longer depend on the per-filing year/period tags SEC stores (wrong for some NVIDIA, GE, Target and Walmart filings), so each label appears once and points at the right period. Every value in a row now comes from the filing it links to (as originally reported). Q4 rows are income statements only (computed from the 10-K when it does not report Q4 separately). IFRS filers such as TSMC are supported. In incremental mode a statement only counts as changed when its values change, so re-runs no longer report phantom changes. `activist` mode: 13D/13G filings in which the requested company is the holder of another company's shares are skipped, including older `SC 13D/G` filings (matched on the issuer named on the cover page). Filings the company submitted itself are skipped before download, and each run fetches at most max(60, 4 × maxItems) documents.
- **2026-10 (fixes)** — `financials` mode: every statement row now holds the values of its own period. Previously a row could mix in a prior year's comparatives (e.g. a "2025-FY" row with 2023 numbers), because SEC tags every comparative in a 10-K with the filing's fiscal year. Rows now also carry `periodStart`, the correct `periodEnd`, and link to the filing that first reported that period. `activist` mode: reporting-person names and event dates are parsed cleanly (no more truncated fragments), `eventDate` is always `YYYY-MM-DD`, and the structured `SCHEDULE 13D` / `SCHEDULE 13G` filings EDGAR has used since 2024-12-18 are now included (with `filerCiks`). Filings where the requested company is itself the holder of another company's shares are no longer reported as stakes in that company.
- **2026-10** — AI summaries (`enableAiSummary`) move from Gemini 2.5 Flash (retired by the provider on 2026-10-20) to **Gemini 3.5 Flash Lite**. The `aiSummary.model` output value changes from `google/gemini-2.5-flash` to `google/gemini-3.5-flash-lite`; every other field keeps its name and meaning. AI calls now retry transient failures (timeouts, rate limits, server errors, malformed answers) before giving up, and a summary is charged only when a complete answer comes back. If the AI provider reports a credit or key problem, AI stops for the rest of the run with a clear status message; filings are still delivered with `aiSummary: null` and no AI summary is charged.

# Actor input Schema

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

What to fetch. 'filings' returns all filings for a company. 'xbrl_facts' returns raw XBRL data points (e.g. revenue history). 'financials' returns normalized income statements / balance sheets / cash flows. 'full_text_search' searches the EDGAR full-text index. 'form4' returns insider trades. 'form13f' returns institutional fund holdings. 'activist' returns 13D/G activist positions. 'latest_feed' returns the newest filings across all companies (filterable by form type). 'eight_k_items' parses 8-K item codes (acquisitions, exec changes, auditor changes, etc.).

## `tickers` (type: `array`):

One or more tickers (AAPL), company names (Apple Inc), domains (apple.com), or CIKs (0000320193). The actor auto-resolves to canonical CIK. Used by all company-scoped modes.

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

Filter filings by form type. Leave empty for all forms. Examples: 10-K (annual), 10-Q (quarterly), 8-K (current report), S-1 (IPO), 20-F (foreign), DEF 14A (proxy), 4 (insider), 13F-HR (institutional holdings), SC 13D / SC 13G (activist positions), 10-K/A (amendment).

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

Maximum number of items to return. Varies by mode: in filings mode this is total filings across all tickers; in xbrl_facts mode this caps the number of fact rows; in full_text_search mode this caps the number of hits.

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

Only return filings filed on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

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

Only return filings filed on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `xbrlConcepts` (type: `array`):

US-GAAP or DEI XBRL concept names to fetch in 'xbrl_facts' mode. Common examples: Revenues, NetIncomeLoss, CashAndCashEquivalentsAtCarryingValue, Assets, Liabilities, StockholdersEquity, EarningsPerShareBasic. Leave empty to fetch all available concepts for the company (high volume).

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

Which normalized statements to generate in 'financials' mode.

## `fiscalPeriods` (type: `array`):

Filter normalized statements by fiscal period. FY = full fiscal year (from 10-K), Q1/Q2/Q3/Q4 = quarters (from 10-Q). Leave empty for all.

## `searchQuery` (type: `string`):

Keyword or phrase to search in EDGAR full-text index. Required when mode is 'full_text_search'. Supports quotes for exact phrases, e.g. "artificial intelligence". Supports operators: AND, OR, NOT. Example: "climate risk" AND "supply chain".

## `searchCiks` (type: `array`):

Restrict full-text search to specific company CIKs. Leave empty to search all companies.

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

Filter Form 4 insider trades by transaction code. P = open-market purchase, S = open-market sale, A = grant/award, M = option exercise, F = tax withhold, G = gift, D = disposition to issuer. Leave empty for all codes.

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

Skip Form 4 insider transactions with a total value below this amount. 0 = no filter. Useful for filtering out noise.

## `activistOnly` (type: `boolean`):

If enabled, activist mode returns only SC 13D filings (active campaigns) and excludes SC 13G (passive 5%+ holdings). Default returns both.

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

Filter 8-K filings by item code. Common items: 1.01 (material agreement), 2.01 (acquisition completion), 2.02 (earnings release), 4.01 (auditor change), 5.02 (exec departure/appointment), 5.07 (shareholder vote), 7.01 (Reg FD), 8.01 (other material). Leave empty for all.

## `incrementalMode` (type: `boolean`):

If enabled, the actor saves a fingerprint of the last run and, on the next run with the same input, only emits items that are new or changed. Ideal for scheduled daily runs.

## `enableAiSummary` (type: `boolean`):

If enabled, an AI-powered structured summary is generated for each filing via Gemini 3.5 Flash Lite. Adds $0.05 per summary. Summaries include key financial highlights, material risks, tone analysis, and notable changes.

## `aiSummaryMaxChars` (type: `integer`):

Cap the filing text fed to the AI at this many characters (from the start of the filing body). Longer filings are truncated. Lower values = cheaper, faster, but may miss tail content.

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

The SEC EDGAR API does not require proxies (no anti-bot, only fair-use rate limits). Leave empty in most cases. If you have a specific network policy, configure proxies here.

## Actor input object example

```json
{
  "mode": "filings",
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxItems": 100,
  "dateFrom": "",
  "dateTo": "",
  "xbrlConcepts": [
    "Revenues",
    "NetIncomeLoss",
    "Assets"
  ],
  "statementTypes": [
    "income_statement",
    "balance_sheet",
    "cash_flow"
  ],
  "fiscalPeriods": [],
  "searchQuery": "artificial intelligence",
  "searchCiks": [],
  "transactionCodes": [
    "P",
    "S"
  ],
  "minTransactionValue": 0,
  "activistOnly": false,
  "eightKItemCodes": [
    "2.02",
    "5.02"
  ],
  "incrementalMode": false,
  "enableAiSummary": false,
  "aiSummaryMaxChars": 40000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset of SEC filings, XBRL facts, financial statements, and related items.

# 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 = {
    "tickers": [
        "AAPL"
    ],
    "forms": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "maxItems": 100,
    "xbrlConcepts": [
        "Revenues",
        "NetIncomeLoss",
        "Assets"
    ],
    "searchQuery": "artificial intelligence",
    "transactionCodes": [
        "P",
        "S"
    ],
    "eightKItemCodes": [
        "2.02",
        "5.02"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/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 = {
    "tickers": ["AAPL"],
    "forms": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "maxItems": 100,
    "xbrlConcepts": [
        "Revenues",
        "NetIncomeLoss",
        "Assets",
    ],
    "searchQuery": "artificial intelligence",
    "transactionCodes": [
        "P",
        "S",
    ],
    "eightKItemCodes": [
        "2.02",
        "5.02",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/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 '{
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxItems": 100,
  "xbrlConcepts": [
    "Revenues",
    "NetIncomeLoss",
    "Assets"
  ],
  "searchQuery": "artificial intelligence",
  "transactionCodes": [
    "P",
    "S"
  ],
  "eightKItemCodes": [
    "2.02",
    "5.02"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call constructive_calm/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,constructive_calm/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/Cx29Vg35C28yv5QmS/builds/dJ6k9T8RYWwDN5Tcz/openapi.json