# SEC Filings Scraper (`publicmoney/sec-filings-scraper`) Actor

Extract SEC EDGAR filings by ticker or CIK, with tickers resolved through the SEC's own list: form type, filing and report dates, 8-K item codes, accession number and a document link. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/publicmoney/sec-filings-scraper.md
- **Developed by:** [Public Money](https://apify.com/publicmoney) (Apify)
- **Categories:** Business
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 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/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

EDGAR is free and complete, and it indexes companies by CIK rather than by ticker, which is the friction. This Actor takes tickers, resolves them through the SEC's own company list, and returns one structured record per filing: form type, filing and report dates, the 8-K item codes, the accession number and a direct link. Filter by form and by date so a run returns the filings you actually want.

### What it does

- Takes **tickers, not CIKs**. `AAPL` is resolved through the SEC's own company list, and a CIK still works if you have one.
- Filters by **form type**, so you can ask for `8-K` material events, `10-Q` quarterlies, `10-K` annuals or `4` insider trades and ignore the rest.
- Filters by **date** with **Filed since**, so a scheduled run reads only what is new.
- Decodes the **8-K item codes** into `items`, which is what tells you whether a material event was a results release, a departure or an acquisition.
- Carries the **accession number** and a direct document link, so a record is enough to fetch or cite the filing itself.
- Distinguishes **filing date from report date**, which differ on periodic reports and matter when you are aligning to a fiscal calendar.

### Use cases

| You need to | How this Actor does it |
| --- | --- |
| Watch for material events | Filter forms to `8-K` and schedule the run hourly |
| Track insider trading | Filter forms to `4` across a watchlist |
| Collect a results season | Filter forms to `10-Q` and set **Filed since** to the quarter start |
| Align to a fiscal calendar | Read `reportDate` rather than `filingDate` |
| Build a filings archive | Schedule the run with **Filed since** and accumulate the dataset |
| Feed a research agent | Call the Actor over MCP and let the model ask for a company's recent filings |

### Quick start

1. Click **Try for free**.
2. Add companies, one per line, as tickers: `AAPL`, `NVDA`, `MSFT`. A CIK such as `0000320193` also works.
3. Set **Form types** to the forms you want: `8-K`, `10-Q`, `10-K`, `4`. Leave it empty for every form.
4. Set **Filed since** as `YYYY-MM-DD` to read only recent filings.
5. Click **Start**. Rows appear within seconds.
6. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

### Input

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `companies` | array | `AAPL` | Tickers or CIKs to read filings for. Tickers are resolved through the SEC company list |
| `formTypes` | array | empty | Only return these forms. Empty returns every form |
| `filingsPerCompany` | integer | `20` | Filings per company, newest first |
| `filedSince` | string | empty | Only filings on or after this date, as `YYYY-MM-DD` |
| `maxItems` | integer | `0` | Caps how many records are written. `0` writes them all |

```json
{
    "companies": [
        "AAPL",
        "NVDA"
    ],
    "formTypes": [
        "8-K",
        "10-Q"
    ],
    "filingsPerCompany": 20,
    "filedSince": "2026-01-01"
}
```

### Output

One dataset item per filing. A ticker the SEC company list does not resolve comes back as a single failure row, so a company with no filings in your window is distinguishable from a wrong ticker.

| Field group | Fields |
| --- | --- |
| Company | `status`, `tickerSymbol`, `companyName`, `cik` |
| Filing | `form`, `filingDate`, `reportDate`, `accessionNumber`, `url` |
| Material events | `items` |
| Timing | `validFrom`, `scrapedAt` |

```json
{
    "status": "ok",
    "tickerSymbol": "AAPL",
    "companyName": "Apple Inc.",
    "cik": "0000320193",
    "form": "8-K",
    "filingDate": "2026-07-31",
    "reportDate": "2026-07-31",
    "items": [
        "2.02 Results of Operations and Financial Condition",
        "9.01 Financial Statements and Exhibits"
    ],
    "accessionNumber": "0000320193-26-000073",
    "validFrom": "2026-09-06T05:30:00.000Z",
    "url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000073/aapl-20260731.htm"
}
```

### Integrations

Run it over the API and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/publicmoney~sec-filings-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["AAPL", "NVDA"], "formTypes": ["8-K", "10-Q"], "filingsPerCompany": 20, "filedSince": "2026-01-01"}'
```

From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/sec-filings-scraper").call(run_input={"companies": ["AAPL", "NVDA"], "formTypes": ["8-K", "10-Q"], "filingsPerCompany": 20, "filedSince": "2026-01-01"})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tickerSymbol"], item["validFrom"])
```

Give an AI agent the Actor over MCP:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/sec-filings-scraper"
        }
    }
}
```

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the
dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

### Cost

Pay per event, so you pay for records rather than compute time.

| Event | Free tier | Top volume tier |
| --- | --- | --- |
| Record with data | $0.002 | $0.0007 |
| Actor start | $0.00005 per GB | Same |

A record that returned no data is published as a failure row and is **never charged**. Six volume tiers apply, so the per-record price falls with monthly volume.

### Troubleshooting

| Issue | Solution |
| --- | --- |
| A ticker returns `failed` | The SEC company list does not carry it. Foreign private issuers and companies that have delisted may be missing. Try the CIK instead. |
| A company returns no filings | Nothing matched your form and date filters. Widen **Filed since** or clear **Form types**. |
| `items` is empty on an 8-K | The filing declared no item codes, which happens on amendments. The document link still works. |
| `reportDate` differs from `filingDate` | By design. A quarterly report covers a period that ended before it was filed. Use `reportDate` for fiscal alignment. |
| Fewer filings than EDGAR shows | **Filings per company** caps it, newest first, and the default is 20. Raise it for a fuller history. |

### FAQ

#### Does the SEC have a free EDGAR API?

Yes, and this Actor reads it. What it adds is ticker to CIK resolution so you never look up an identifier, form and date filtering, decoded 8-K item codes, the same record shape as the other 29 Actors in this fleet, and the platform's scheduling and integrations. For one query against one CIK, use EDGAR directly.

#### Do I need to know a company's CIK?

No. Send the ticker and the Actor resolves it through the SEC's own company list. A CIK still works if you already have one, with or without leading zeros.

#### Which forms can I filter to?

Any EDGAR form type. The common ones are `8-K` for material events, `10-Q` and `10-K` for periodic reports, `4` for insider transactions, and `13F-HR` for institutional holdings.

#### Does it return the filing text?

No. It returns the filing metadata and a direct link to the document, so you can fetch or cite the filing itself. Parsing filing bodies is a separate job.

#### How do I only get new filings on a schedule?

Set **Filed since** to the date of your last run, or deduplicate on `accessionNumber`, which is unique per filing.

#### Do I need a SEC EDGAR API key?

No. You need an Apify token to call the Actor over the API. No SEC EDGAR credential is involved anywhere.

#### Can I get this data in Python?

Yes, with the `apify-client` package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

#### Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

#### Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

#### Is it legal to scrape SEC EDGAR?

SEC EDGAR filings are public records that the SEC publishes for exactly this purpose, and the Actor reads them as published while respecting the SEC's access guidance. Filings do contain named individuals, such as officers on Form 4, so handle those as personal data under your own obligations.

### Changelog

- **0.0.2** Added form and date filtering and decoded 8-K item codes.
- **0.0.1** First release. Filings by ticker or CIK.

### Feedback

Found a field SEC EDGAR publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.

# Actor input Schema

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

Companies to read filings for, one per line. A ticker ('AAPL', 'NVDA') is resolved through the SEC's own company list; a CIK ('0000320193' or '320193') is used directly.

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

Only return these EDGAR form types, one per line. Leave the field empty to return every form a company filed in your window. Examples: '8-K' material events, '10-Q' quarterly, '10-K' annual, '4' insider trades.

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

How many filings to return per company, newest first, applied after the form and date filters. A company that files often will hit this cap quickly, so raise it when you are backfilling a history rather than watching for new filings. Examples: 5, 20, 100. Default is 20.

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

Only return filings submitted on or after this date, written YYYY-MM-DD. Set it to the date of your last run so a scheduled Actor reads only what is new. Leave it empty for no date floor. Examples: '2026-01-01', '2026-07-31'.

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

Maximum number of filings to read, counted from the top of the list. Use it to cap spend on a long list without editing the list itself. Examples: 10, 50, 200. Default is 0, which reads every filing given.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "formTypes": [],
  "filingsPerCompany": 20,
  "maxItems": 0
}
```

# Actor output Schema

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

One item per requested input, in the default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "AAPL",
        "NVDA"
    ],
    "formTypes": [],
    "filingsPerCompany": 20,
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicmoney/sec-filings-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 = {
    "companies": [
        "AAPL",
        "NVDA",
    ],
    "formTypes": [],
    "filingsPerCompany": 20,
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("publicmoney/sec-filings-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 '{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "formTypes": [],
  "filingsPerCompany": 20,
  "maxItems": 0
}' |
apify call publicmoney/sec-filings-scraper --silent --output-dataset

```

## MCP server setup

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