# 📄 SEC EDGAR Filings Scraper (`skootle/sec-edgar-filings`) Actor

Scrape SEC EDGAR filings for any public company by ticker or CIK. 10-K, 10-Q, 8-K, S-1, DEF 14A, Form 4, 13F. Normalized JSON, ISO dates, form-category enum, AI-ready markdown. Watchlist mode emits only new filings. Export, run via API, schedule, or integrate with other tools.

- **URL**: https://apify.com/skootle/sec-edgar-filings.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** AI, Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 sec filing records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/sec-edgar.png)

### TL;DR

Monitor SEC EDGAR filings for any public company by ticker or CIK. 10-K, 10-Q, 8-K, S-1, DEF 14A, Form 4, 13F, and every other form. Returns clean structured JSON with form-category enum, ISO 8601 dates, direct primary-document URLs, and a 300-500 character markdown summary per filing. Watchlist mode emits only NEW filings since the previous run, so daily schedules become a clean diff feed of new disclosures. Built on SEC's official EDGAR submissions API. No authentication beyond a contact email in the User-Agent (SEC's own requirement).

---

<!-- skootle:review-cta -->
> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/sec-edgar-filings/reviews).

---

### What does SEC EDGAR Filings Monitor do?

SEC EDGAR Filings Monitor extracts SEC filings for any public company. You give it a list of stock tickers (or SEC CIKs for filers without tickers — funds, insiders, foreign issuers); it returns one record per filing with: form name, normalized form-category enum, accession number, filing date, period date, primary document URL, file metadata, items list (8-K item codes like `2.02`, `5.02`), XBRL flags, plus a joined snapshot of company metadata (name, ticker, exchange, SIC code, SIC description, fiscal year end).

The actor pulls from SEC's official `data.sec.gov/submissions/CIK<cik>.json` endpoint and the public ticker → CIK map, with a compliant User-Agent containing your contact email per SEC's API guidelines. Built on the same SEC infrastructure that powers the EDGAR website itself, so reliability matches SEC's own uptime.

Watchlist mode (`watchlistMode: true`) makes this scraper schedulable. State persists across runs in the actor's key-value store, so a daily cron only emits filings NEW since the last run.

### Why scrape SEC EDGAR?

SEC EDGAR is the canonical source of public-company financial disclosures. Every 10-K, 10-Q, 8-K, S-1, proxy filing, insider Form 4, and 13F holdings disclosure flows through EDGAR within minutes of being accepted by the SEC. Buy-side analysts, equity researchers, compliance teams, M&A advisors, and AI-powered investment platforms all need a live feed of new filings.

The official EDGAR API is free and public, but it's columnar (parallel arrays per filing field) and returns the most recent 1,000 filings per company in a peculiar shape. This actor handles the normalization: each filing becomes one well-typed record with ISO timestamps, a form-category enum (so you don't have to map 200+ form names client-side), and the company joined per row.

### Who needs this?

- **Equity research analysts** monitoring a portfolio of tickers for new 10-K, 10-Q, and 8-K disclosures
- **Insider-trading signal pipelines** filtering `formCategory: 'insider_transaction'` (Form 4, 5, 3) on watchlist tickers
- **13F-tracking quants** monitoring institutional holders (Berkshire, Renaissance, Citadel, hedge funds)
- **IPO and capital-markets desks** filtering `formCategory: 'registration'` and `prospectus` for S-1, S-1/A, 424B filings
- **Compliance and corporate-actions desks** watching 8-K events for material developments
- **Proxy-season governance researchers** filtering DEF 14A across the S&P 500 in March-May
- **AI agents and LLM apps** ingesting filings as a structured feed for downstream summarization, sentiment, or alerting
- **Financial-news aggregators** breaking stories minutes after EDGAR posts

### How to use SEC EDGAR Filings Monitor

1. Open the **Input** tab on the actor page
2. Add tickers (e.g., `AAPL`, `MSFT`, `NVDA`) to the `tickers` field, OR raw CIKs to `ciks` for filers without tickers
3. Optionally set `formFilter` to specific forms (e.g., `["10-K", "10-Q", "8-K"]`) or `formCategoryFilter` to category enums (e.g., `["annual_report", "current_report"]`)
4. Set `filingsPerCompany` (default 20) and `maxItems` (default 50, conservative for the 5-minute auto-test)
5. Optionally set `daysLookback` to limit to recent filings (e.g., `daysLookback: 30` for last 30 days)
6. Optionally enable `watchlistMode` for daily scheduled runs that only return new filings
7. Click **Start** or call via the Apify REST API or CLI

You can run on demand from the Console, schedule it with Apify's cron, call via API, or integrate with Make, Zapier, n8n, Slack, Google Sheets.

### How much will scraping SEC EDGAR cost?

This actor is priced per event:

- **Actor Start**: $0.01 once per run
- **SEC filing record**: tiered, charged per record written

| Apify plan | $/1000 records |
|---|---|
| FREE | $30.00 |
| BRONZE | $25.50 |
| SILVER | $21.00 |
| GOLD | $18.00 |
| PLATINUM | $18.00 |
| DIAMOND | $16.20 |

A typical daily portfolio watchlist on 25 tickers with `filingsPerCompany: 20` returns ~50-100 records on day 1, then 5-20 per day in watchlist mode. Roughly $0.90-$1.80 per daily run on the GOLD plan. Premium tier matches the value: this is real-time financial intelligence, not a commodity scrape.

### Is it legal to scrape SEC EDGAR?

Yes, EDGAR is explicitly designed for public access. The SEC publishes [API access guidelines](https://www.sec.gov/os/accessing-edgar-data) requesting only that callers send a User-Agent with a contact email and stay under 10 requests/second. This actor honors both: the User-Agent includes the maintainer's email by default (override via `contactEmail` input), and rate-limiting keeps it well under the 10/s ceiling.

There is no copyright on the filings themselves — they are public-record disclosures filed by registrants with the SEC, and federal law explicitly puts them in the public domain. Use the data freely for research, analytics, AI training, or commercial products.

### Examples

#### Example 1: Daily watchlist on Apple

```json
{
  "tickers": ["AAPL"],
  "filingsPerCompany": 20,
  "watchlistMode": true,
  "maxItems": 20
}
````

#### Example 2: 10-K and 10-Q filings only across the FAANG portfolio

```json
{
  "tickers": ["META", "AMZN", "AAPL", "NFLX", "GOOGL"],
  "formFilter": ["10-K", "10-K/A", "10-Q", "10-Q/A"],
  "filingsPerCompany": 10,
  "maxItems": 50
}
```

#### Example 3: Insider Form 4 monitoring on the S\&P-50 mega-caps

```json
{
  "tickers": ["AAPL", "MSFT", "NVDA", "GOOGL", "AMZN", "META", "TSLA", "BRK.B", "JPM", "JNJ"],
  "formCategoryFilter": ["insider_transaction"],
  "filingsPerCompany": 50,
  "watchlistMode": true,
  "maxItems": 500
}
```

#### Example 4: 13F holdings disclosures for top hedge funds (CIKs)

```json
{
  "ciks": ["1067983", "1029160", "1336528", "1167483"],
  "formFilter": ["13F-HR", "13F-HR/A"],
  "filingsPerCompany": 5,
  "maxItems": 20
}
```

CIK `1067983` is Berkshire Hathaway. Use SEC's [EDGAR full-text search](https://efts.sec.gov/LATEST/search-index?q=\&forms=13F-HR) to find any filer's CIK.

#### Example 5: 8-K material-events monitoring (M\&A, exec changes, restatements)

```json
{
  "tickers": ["MSFT", "GOOGL", "META", "AAPL", "NVDA", "TSLA"],
  "formCategoryFilter": ["current_report"],
  "watchlistMode": true,
  "filingsPerCompany": 30
}
```

#### Example 6: IPO-pipeline monitoring (S-1 and S-1/A across recent filers)

```json
{
  "tickers": ["RDDT", "ARM", "INSM", "BRK.B"],
  "formCategoryFilter": ["registration", "prospectus"],
  "daysLookback": 365,
  "filingsPerCompany": 20
}
```

#### Example 7: Proxy-season DEF 14A scrape

```json
{
  "tickers": ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "JPM", "BAC", "WFC"],
  "formCategoryFilter": ["proxy"],
  "daysLookback": 120,
  "filingsPerCompany": 5
}
```

#### Example 8: Last 7 days of any filings, any company, premium token

```json
{
  "tickers": ["AAPL"],
  "daysLookback": 7,
  "filingsPerCompany": 100
}
```

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `tickers` | string\[] | `["AAPL"]` | Stock tickers. Resolved to CIK via SEC's official ticker map. |
| `ciks` | string\[] | `[]` | Use for filers without tickers (private filers, funds, insiders). |
| `formFilter` | string\[] | `[]` | Exact-match form names. Empty = all. |
| `formCategoryFilter` | string\[] | `[]` | Filter by category enum. Empty = all. |
| `filingsPerCompany` | int | `20` | 1-1000 |
| `daysLookback` | int | `0` | 0 = no date filter; otherwise only filings on or after (today - N days). |
| `watchlistMode` | bool | `false` | Idempotent diff against KV-stored seen accession numbers. |
| `maxItems` | int | `50` | Hard cap on total filings. |
| `contactEmail` | string | maintainer | Sent in the SEC User-Agent header per SEC requirements. |

### Form category enum

Each filing carries `formCategory` from this enum (so you don't have to map 200+ form names downstream):

| Category | Forms it covers |
|---|---|
| `annual_report` | 10-K, 10-K/A, 20-F, 40-F |
| `quarterly_report` | 10-Q, 10-Q/A |
| `current_report` | 8-K, 8-K/A, 6-K |
| `registration` | S-1, S-1/A, S-3, S-4, F-1 |
| `prospectus` | 424B1, 424B2, 424B3, 424B4, 424B5 |
| `proxy` | DEF 14A, DEFA14A, PRE14A |
| `insider_transaction` | 3, 4, 4/A, 5 |
| `institutional_holdings` | 13F-HR, 13F-HR/A, 13D, 13G, SC13D, SC13G |
| `amendment` | any form ending in `/A` not classified above |
| `other` | every other form on EDGAR |

### SEC EDGAR output format

#### `sec_filing`

| Field | Type | Description |
|---|---|---|
| `outputSchemaVersion` | string | Versioned literal (`'2026-05-08'`) |
| `recordType` | literal | `'sec_filing'` |
| `recordId` | string | `sec:filing:<accession-clean>` (idempotent, cross-run dedupe-friendly) |
| `accessionNumber`, `accessionNumberClean` | string | SEC's official ID (with dashes + cleaned) |
| `url`, `primaryDocumentUrl`, `filingIndexUrl` | string | Direct links to the document and EDGAR index |
| `form`, `formCategory`, `isAmendment` | string/enum/bool | Form identity + classification |
| `filingDate`, `reportDate`, `acceptanceDateTime` | ISO 8601 | All timestamps standardized |
| `primaryDocument`, `primaryDocDescription` | string | Filename + SEC-supplied description |
| `fileNumber`, `filmNumber` | string | EDGAR file/film IDs |
| `items` | string\[] | 8-K item codes (e.g., `["2.02", "9.01"]`) |
| `isXBRL`, `isInlineXBRL` | bool | XBRL availability flags |
| `size` | int | Bytes |
| `company` | object | Joined company metadata: `cik`, `cikPadded`, `name`, `ticker`, `exchange`, `sicCode`, `sicDescription`, `fiscalYearEnd` |
| `fieldCompletenessScore` | int 0-100 | Self-filtering signal |
| `agentMarkdown` | string | 300-500 char LLM-ready summary |

#### SEC EDGAR scraper output example

```json
{
  "outputSchemaVersion": "2026-05-08",
  "recordType": "sec_filing",
  "recordId": "sec:filing:000032019325000118",
  "accessionNumber": "0000320193-25-000118",
  "form": "10-K",
  "formCategory": "annual_report",
  "isAmendment": false,
  "filingDate": "2025-11-01",
  "reportDate": "2025-09-28",
  "primaryDocDescription": "10-K",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000118/aapl-20250928.htm",
  "items": [],
  "isXBRL": true,
  "company": {
    "cik": "320193",
    "cikPadded": "0000320193",
    "name": "Apple Inc.",
    "ticker": "AAPL",
    "exchange": "Nasdaq",
    "sicCode": "3571",
    "sicDescription": "Electronic Computers",
    "fiscalYearEnd": "0928"
  },
  "fieldCompletenessScore": 100,
  "agentMarkdown": "**📄 10-K · $AAPL · Apple Inc.**\n> 10-K\n- 🗂 form: 10-K (annual_report)\n- 📅 filed: 2025-11-01 · period: 2025-09-28\n- 🏢 Electronic Computers · Nasdaq\n- 🔗 https://www.sec.gov/Archives/edgar/data/320193/000032019325000118/aapl-20250928.htm"
}
```

### During the Actor run

The actor first fetches SEC's ticker → CIK map (one call) if you provided tickers. Then for each CIK it calls `data.sec.gov/submissions/CIK<cik>.json`, which returns the most recent ~1,000 filings in a columnar shape. The actor normalizes each filing into a record, applies your filters (`formFilter`, `formCategoryFilter`, `daysLookback`), validates against a Zod schema, and pushes.

Each request carries `User-Agent: Skootle Apify Actors <contactEmail>` per SEC requirements. Inter-request delay: 110ms (well under SEC's 10/s ceiling).

The actor writes three things to its key-value store:

1. **`OUTPUT`** — compact run summary: companies queried, filings saved, watchlist deltas, error counts
2. **`AGENT_BRIEFING`** — markdown digest with form-mix counts and the top 10 material filings
3. **`WATCHLIST_STATE`** — (only when `watchlistMode: true`) seen accession numbers, capped at 10,000

### FAQ

#### How does SEC EDGAR Filings Monitor work?

The actor calls SEC's official EDGAR submissions API (`data.sec.gov/submissions/CIK<cik>.json`) for each CIK in your input, normalizes the columnar response into one record per filing, applies your filters, and pushes the dataset.

#### Can I monitor filings for new disclosures only?

Yes. Set `watchlistMode: true`. The first run emits everything; subsequent runs emit only filings new since the previous run. Schedule with the Apify cron scheduler.

#### Can I filter to specific form types?

Two ways: `formFilter` for exact-match form names (e.g., `["10-K", "10-Q"]`), or `formCategoryFilter` for category groupings (e.g., `["annual_report", "quarterly_report"]`). Combine both for narrow filters.

#### Can I use this with the Apify API?

Yes. POST to `https://api.apify.com/v2/acts/skootle~sec-edgar-filings/runs` with your input as JSON body and your Apify token as the `Authorization: Bearer` header.

#### Can I integrate with Make / Zapier / n8n / Slack?

Yes. From the actor page, click **Integrations** and pick your destination.

#### Can I get filings from before EDGAR's recent window?

This actor returns the most recent ~1,000 filings per company (the `submissions/recent` window EDGAR exposes). For deeper historical pulls, use SEC's full-index files at `https://www.sec.gov/Archives/edgar/full-index/`.

#### Can I get the full text of each filing?

This actor returns metadata + a direct URL to the primary document. To download document contents, pipe the `primaryDocumentUrl` to a downstream HTTP fetcher (e.g., the Apify Web Crawler or a Make.com HTTP step).

#### Can I find a CIK by company name?

This actor accepts both tickers and CIKs as input. To look up a CIK by name, use SEC's [EDGAR full-text search](https://efts.sec.gov/LATEST/search-index?q=) or the `company_tickers.json` map (also fetched by this actor when you supply tickers).

#### Is the data delayed?

No — EDGAR exposes filings as soon as the SEC accepts them, typically within minutes of the filer's submission. This actor reads the live API, not a delayed cache.

#### Why does this actor cost more than free EDGAR scrapers?

Free actors trade reliability and feature depth for cost. This actor ships a versioned schema, idempotent record IDs, the joined company metadata, the `formCategory` enum (saves you from mapping 200+ form names), `agentMarkdown` per filing, watchlist diff mode, and continuous maintenance. If you're feeding the data into a portfolio-monitoring pipeline or AI agent, those features pay back the per-record cost in saved engineering time.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/sec-edgar-filings/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose SEC EDGAR Filings Monitor

- **Form-category enum** — `annual_report`, `quarterly_report`, `current_report`, `registration`, `proxy`, `insider_transaction`, `institutional_holdings`, `prospectus`, `amendment`, `other`. No need to maintain a 200+ form-name lookup table.
- **Joined company metadata per filing** — every record has `company.{cik, name, ticker, exchange, sicCode, sicDescription, fiscalYearEnd}`. No second query needed.
- **Watchlist diff mode** — only emits NEW filings since the last run. Schedule daily without paying for duplicates.
- **SEC-compliant from day one** — User-Agent with contact email, sub-second rate limit, follows SEC's published API guidelines.
- **Versioned schema** — `outputSchemaVersion: '2026-05-08'` literal on every record; downstream pipelines never break silently.
- **Idempotent record IDs** — `sec:filing:<accession>` stable across runs.
- **Agent-grade output** — `agentMarkdown` (300-500 chars) drop-into-LLM ready; `fieldCompletenessScore` for self-filtering.
- **Continuous maintenance** — when EDGAR's API changes (rare), the actor adapts within 24-48 hours.

### Other Skootle actors you might want to check

- **[Hacker News Watchlist](https://apify.com/skootle/hackernews-watchlist)** — same agent-grade pattern for tech discourse
- **[Reddit Subreddit Scraper](https://apify.com/skootle/reddit-subreddit-monitor)** — sentiment + brand monitoring on subreddits
- **[GitHub Trending Repos](https://apify.com/skootle/github-trending)** — daily/weekly/monthly trending dev repos with API enrichment
- **[Apple App Store Reviews Monitor](https://apify.com/skootle/app-store-reviews)** — App Store reviews with watchlist mode
- **[Shopify App Store Scraper](https://apify.com/skootle/shopify-app-store-scraper)** — Shopify app listings with rating + pricing tiers
- **[SAM.gov + USAspending Federal Contracts](https://apify.com/skootle/sam-gov-federal-contracts)** — federal contract opportunities + historical award context

### Support and contact

File issues on this actor's page (Issues tab) — replies within 48 hours. For feature requests, drop them in the same tracker tagged `enhancement`.

# Actor input Schema

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

Stock tickers (e.g., AAPL, MSFT, TSLA). Resolved to CIK via SEC's official ticker map.

## `ciks` (type: `array`):

SEC Central Index Keys (with or without leading zeros). Use this for entities without tickers (private filers, funds, insiders).

## `formFilter` (type: `array`):

Filter to specific forms (e.g., '10-K', '10-Q', '8-K', 'S-1', 'DEF 14A', '4'). Empty = all.

## `formCategoryFilter` (type: `array`):

Filter by category. Empty = all. Categories: annual\_report, quarterly\_report, current\_report, registration, proxy, insider\_transaction, institutional\_holdings, prospectus, amendment, other.

## `filingsPerCompany` (type: `integer`):

How many recent filings to fetch per company.

## `daysLookback` (type: `integer`):

Only return filings on or after (today - N days). 0 means no date filter.

## `watchlistMode` (type: `boolean`):

When true, only emit filings NEW since the previous run. State persists in the key-value store.

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

Hard cap on total filings saved. Conservative default for the 5-minute auto-test.

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

SEC requires a contact email in the User-Agent header. Defaults to the actor maintainer.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "formFilter": [],
  "formCategoryFilter": [],
  "filingsPerCompany": 20,
  "daysLookback": 0,
  "watchlistMode": false,
  "maxItems": 50,
  "contactEmail": "jamie.kester@gmail.com"
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All filings from this run.

## `agentBriefing` (type: `string`):

Markdown digest with form mix and top 10 material filings.

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

Compact OUTPUT object with row counts and per-stage error counts.

# 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"
    ],
    "ciks": [],
    "formFilter": [],
    "formCategoryFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/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 = {
    "tickers": ["AAPL"],
    "ciks": [],
    "formFilter": [],
    "formCategoryFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/sec-edgar-filings").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "ciks": [],
  "formFilter": [],
  "formCategoryFilter": []
}' |
apify call skootle/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=skootle/sec-edgar-filings",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📄 SEC EDGAR Filings Scraper",
        "description": "Scrape SEC EDGAR filings for any public company by ticker or CIK. 10-K, 10-Q, 8-K, S-1, DEF 14A, Form 4, 13F. Normalized JSON, ISO dates, form-category enum, AI-ready markdown. Watchlist mode emits only new filings. Export, run via API, schedule, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "Ut4Zm5Zr6r8okyLiF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~sec-edgar-filings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-sec-edgar-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/skootle~sec-edgar-filings/runs": {
            "post": {
                "operationId": "runs-sync-skootle-sec-edgar-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/skootle~sec-edgar-filings/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-sec-edgar-filings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tickers": {
                        "title": "Tickers to monitor",
                        "type": "array",
                        "description": "Stock tickers (e.g., AAPL, MSFT, TSLA). Resolved to CIK via SEC's official ticker map.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIKs to monitor",
                        "type": "array",
                        "description": "SEC Central Index Keys (with or without leading zeros). Use this for entities without tickers (private filers, funds, insiders).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formFilter": {
                        "title": "Specific form types (exact match)",
                        "type": "array",
                        "description": "Filter to specific forms (e.g., '10-K', '10-Q', '8-K', 'S-1', 'DEF 14A', '4'). Empty = all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formCategoryFilter": {
                        "title": "Form categories",
                        "type": "array",
                        "description": "Filter by category. Empty = all. Categories: annual_report, quarterly_report, current_report, registration, proxy, insider_transaction, institutional_holdings, prospectus, amendment, other.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "filingsPerCompany": {
                        "title": "Max filings per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many recent filings to fetch per company.",
                        "default": 20
                    },
                    "daysLookback": {
                        "title": "Days lookback (0 = no limit)",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only return filings on or after (today - N days). 0 means no date filter.",
                        "default": 0
                    },
                    "watchlistMode": {
                        "title": "Watchlist mode (idempotent diff)",
                        "type": "boolean",
                        "description": "When true, only emit filings NEW since the previous run. State persists in the key-value store.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max total filings",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on total filings saved. Conservative default for the 5-minute auto-test.",
                        "default": 50
                    },
                    "contactEmail": {
                        "title": "Contact email (sent to SEC in User-Agent)",
                        "type": "string",
                        "description": "SEC requires a contact email in the User-Agent header. Defaults to the actor maintainer.",
                        "default": "jamie.kester@gmail.com"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```