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

Scrapes SEC EDGAR filings for any US-listed company — 10-K, 10-Q, 8-K, insider trades — with direct document links and financial figures.

- **URL**: https://apify.com/mina_safwat/sec-filings-scraper.md
- **Developed by:** [Mina](https://apify.com/mina_safwat) (community)
- **Categories:** Business, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

Scrape **SEC filings for any US-listed company**: 10-K annual reports, 10-Q quarterlies, 8-K events, Form 4 insider trades and more. Every row links straight to the filed document, and you can add the company's **latest reported annual financials**.

### What does SEC EDGAR Filings Scraper do?

Give it ticker symbols or CIK numbers. It returns each company's filing history from the SEC's official [EDGAR](https://www.sec.gov/edgar/search/) database: form type, filing and report dates, a description, and a **direct link to the filed document**. It reads the full history, not only the latest 1,000 filings.

Turn on financials and each row also gets the company's **latest fiscal-year** revenue, net income, assets, liabilities, equity, cash, operating income and diluted EPS. These come from the company's own XBRL data, not from estimates. The same figures go on every row of that company, older filings included, and `financials_period_end` says which fiscal year they describe.

Because it runs on Apify, you also get API access, scheduling, integrations (Google Sheets, Slack, Zapier, S3, webhooks) and run monitoring.

### Why use SEC EDGAR Filings Scraper?

- **Investment research.** Pull a company's 10-K and 10-Q history in one run.
- **Compliance and monitoring.** Watch a watchlist for new 8-K material events.
- **Insider trading analysis.** Collect Form 4 and Form 144 filings to see what executives buy and sell.
- **Ownership tracking.** Follow Schedule 13D and 13G stakes above 5%.
- **Competitive intelligence.** Compare reported revenue and margins across an industry.
- **Data pipelines.** Feed filings into AI or analytics workflows with reliable document links.

### How to scrape SEC EDGAR filings

1. Enter **Companies**: tickers like `AAPL`, or CIK numbers like `320193`.
2. Enter **Your email address**. The SEC requires it (see below).
3. Optionally, pick **Form types** and a date range.
4. Click **Start**.

Results appear in the Output tab as they arrive.

#### Why it asks for your email

The SEC requires every automated request to EDGAR to say who is making it, and it refuses anonymous traffic. Your address goes only to the SEC, in the request header. This is the SEC's rule for its free public API, not something this Actor adds.

### Input

Set these fields on the Input tab, or pass them as JSON through the API.

| Field | Description |
| --- | --- |
| `companies` | Tickers or CIK numbers, one per line. Tickers are resolved automatically; `BRK.B` and `BRK-B` both work. Two inputs for the same company (`GOOG` and `GOOGL`, or a ticker and its CIK) are scraped and billed once. |
| `contact_email` | Your email address, required by the SEC. |
| `form_types` | 10-K, 10-Q, 8-K, Form 4, Form 144, Schedule 13D/13G and more. Amendments (such as 10-K/A) are included. Leave empty for all forms. |
| `filed_after` / `filed_before` | Date range, YYYY-MM-DD. |
| `max_filings_per_company` | Cap per company (default 100). Raise it for a full history. |
| `include_financials` | Attach the latest fiscal-year figures. |

```json
{
  "companies": ["AAPL", "MSFT"],
  "contact_email": "you@example.com",
  "form_types": ["10-K"],
  "include_financials": true
}
```

### Output

One row per filing. This is Apple's 10-K for fiscal 2025, with financials turned on:

```json
{
  "cik": "0000320193",
  "company_name": "Apple Inc.",
  "tickers": ["AAPL"],
  "exchanges": ["Nasdaq"],
  "industry": "Electronic Computers",
  "accession_number": "0000320193-25-000079",
  "form": "10-K",
  "filing_date": "2025-10-31",
  "report_date": "2025-09-27",
  "document_description": "10-K",
  "is_xbrl": true,
  "filing_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/aapl-20250927.htm",
  "filing_index_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/",
  "revenues": 416161000000,
  "net_income_loss": 112010000000,
  "assets": 359241000000,
  "earnings_per_share_diluted": 7.46,
  "financials_period_end": "2025-09-27"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
| --- | --- |
| `cik`, `company_name`, `tickers`, `exchanges` | Which company filed. |
| `industry`, `sic`, `entity_type`, `state_of_incorporation`, `fiscal_year_end` | Company classification. |
| `business_city`, `business_state`, `phone` | Registered business address and phone. |
| `form`, `filing_date`, `report_date`, `accepted_at` | What was filed and when. |
| `document_description`, `items`, `size_bytes`, `is_xbrl` | Filing details. `items` lists the 8-K item numbers. |
| `primary_document`, `filing_url`, `filing_index_url` | The main document's file name, a direct link to it, and a link to the full filing folder. |
| `accession_number` | The SEC's unique ID for the filing. |
| `revenues`, `net_income_loss`, `assets`, `liabilities`, `stockholders_equity`, `cash_and_cash_equivalents_at_carrying_value`, `operating_income_loss`, `earnings_per_share_diluted` | Latest fiscal-year figures in USD, when you ask for them. Every row of a company carries the same figures, older filings included. |
| `financials_period_end` | The fiscal year-end those figures belong to. |

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

The Actor uses pay-per-result pricing: **$0.001 per filing row**, plus $0.00005 per run start for each GB of memory (runs use 1 GB by default). **1,000 filings cost about $1.00**. The default example (Apple and Microsoft, 100 filings each) costs about $0.20. Turning on financials adds no charge per row. Inputs that return nothing (a typo, an unknown CIK, a block) are never billed. They are listed in `FAILED_INPUTS` in the run's key-value store, with the reason.

Apify's free plan includes monthly credit, which covers several thousand filings.

### Tips

- **Filter by form type.** Without a filter you get everything, and Form 4 insider filings alone can dominate a large company's history.
- **Need older filings?** Raise `max_filings_per_company`. Filings beyond the latest 1,000 are fetched only when needed.
- **Set a cost limit.** If you set a maximum cost per run, the Actor stops cleanly once it is reached.
- **`filing_url` points at the actual document**, so you can feed it straight into a text or AI pipeline.
- **Schedule it with a short date range** to monitor a watchlist for new 8-K events.
- **CIK works when a ticker does not.** This helps with funds and foreign filers that have no ticker.

### FAQ, disclaimers, and support

**Is this an official source?** Yes. EDGAR is the SEC's own filing database, and this Actor uses its public API.

**Is it legal to scrape SEC filings?** Yes. SEC filings are **public US government data**, published for anyone to use. The Actor follows the SEC's fair-access rules: it identifies itself with your contact email and stays under the SEC's 10-requests-per-second limit.

**Does it need an API key?** No. It only needs your email address, which the SEC requires.

**Why did a company return nothing?** Check `FAILED_INPUTS` and the run's status message. Either the ticker isn't one the SEC lists, the CIK has no filer, or your form-type and date filters excluded everything. If the SEC refused or failed the requests, the reason says so, and the run fails only when no company could be read. When a company's older filings or financial figures could not be read, its other rows are kept and `FAILED_INPUTS` says what is missing.

**Why are some financial figures missing?** The figures come from the company's own XBRL filings. A figure the company didn't tag in its latest 10-K is left out rather than replaced with an older year. Funds, trusts and most foreign filers (20-F, 40-F) don't publish these figures in US-GAAP form.

**Found a bug or need a custom field?** Open an issue on the Actor's Issues tab. Custom SEC data solutions are available on request.

# Actor input Schema

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

Ticker symbols (AAPL) or CIK numbers (320193), one per line. Tickers are resolved automatically.

## `contact_email` (type: `string`):

Required by the SEC. Every automated request to EDGAR must say who is making it, and the SEC refuses anonymous traffic. Your address is sent only to the SEC.

## `form_types` (type: `array`):

Restrict to certain filings — 10-K is the annual report, 10-Q quarterly, 8-K material events, 4 insider trades, 144 planned insider sales. Amendments (10-K/A and so on) are included. Leave empty for all forms.

## `filed_after` (type: `string`):

Only filings on or after this date (YYYY-MM-DD).

## `filed_before` (type: `string`):

Only filings on or before this date (YYYY-MM-DD).

## `max_filings_per_company` (type: `integer`):

Stops after this many filings for each company. Raise it for a full history: filings older than the most recent 1,000 are read only when needed.

## `include_financials` (type: `boolean`):

Attach the latest reported annual revenue, net income, assets, liabilities, equity, cash, operating income, and diluted EPS from the company’s own XBRL data. The same figures go on every row of a company, older filings included; financials_period_end says which fiscal year they describe.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "contact_email": "you@example.com",
  "form_types": [],
  "max_filings_per_company": 100,
  "include_financials": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "companies": [
        "AAPL",
        "MSFT"
    ],
    "contact_email": "you@example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mina_safwat/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",
        "MSFT",
    ],
    "contact_email": "you@example.com",
}

# Run the Actor and wait for it to finish
run = client.actor("mina_safwat/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",
    "MSFT"
  ],
  "contact_email": "you@example.com"
}' |
apify call mina_safwat/sec-filings-scraper --silent --output-dataset

```

## MCP server setup

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