# SEC EDGAR Scraper: 10-K, 10-Q & 8-K Filings + Full-Text Search (`api-co/sec-edgar-filings`) Actor

Get SEC EDGAR filings for any ticker or CIK: 10-K annual reports, 10-Q, 8-K (with item descriptions), Form 4 insider filings, S-1 and more. Run SEC full-text search across all filings and extract clean document text for LLMs. Official SEC data, no API key.

- **URL**: https://apify.com/api-co/sec-edgar-filings.md
- **Developed by:** [Emilio Cisneros](https://apify.com/api-co) (community)
- **Categories:** AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 filings

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?

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

## SEC EDGAR Scraper: 10-K, 10-Q & 8-K Filings + Full-Text Search

Pull **SEC EDGAR filings for any public company** by ticker or CIK, or run **EDGAR full-text search** across every filer since 2001 — and optionally get the **clean text of each filing** ready for LLMs, RAG and NLP.

### How to use

1. Enter tickers or CIKs in **Companies** (e.g. `AAPL`, `TSLA`), or type an **EDGAR full-text search** query.
2. Pick form types (10-K, 10-Q, 8-K, Form 4, S-1...) and an optional date range. Turn on *Include document text* to get clean filing text for LLMs.
3. Click **Start** and export the filings as JSON, CSV or Excel.

### What you get

- **Company filings** (submissions API): form, filing date, period, acceptance time, accession number, primary document, XBRL flags, file number, company metadata (name, tickers, exchange, SIC/industry, state of incorporation, fiscal year end) and direct links to the document and filing index.
- **8-K item decoding** — items like `2.02`, `5.02`, `1.05` come with human-readable descriptions ("Results of Operations", "Departure/Election of Directors or Officers", "Material Cybersecurity Incidents").
- **Full-text search** — exact phrases like `"going concern"`, `"material weakness"`, `"tariff"`, filtered by form type, date range and companies; one result per filing with the list of matching documents.
- **Document text (optional)** — the primary document converted to clean, structured text (inline-XBRL headers stripped), with a configurable character cap.
- **Official SEC endpoints**, rate-limited under SEC's fair-access guidance. No proxies, no blocking.
- **Fails loudly**: unknown tickers produce free error records; a run with zero results fails with an explanation.

### Example inputs

Latest annual/quarterly reports and 8-Ks for two companies:

```json
{ "companies": ["AAPL", "TSLA"], "formTypes": ["10-K", "10-Q", "8-K"], "dateFrom": "2025-01-01", "maxItems": 200 }
```

Every 8-K mentioning a material weakness this quarter, with text:

```json
{ "fullTextQuery": "\"material weakness\"", "formTypes": ["8-K"], "dateFrom": "2026-07-01", "includeDocumentText": true, "maxItems": 100 }
```

Insider-trading filings (Form 4) for a company:

```json
{ "companies": ["NVDA"], "formTypes": ["4"], "dateFrom": "2026-09-01" }
```

### Output example

```json
{
  "cik": 320193, "companyName": "Apple Inc.", "tickers": ["AAPL"], "sic": "3571", "sicDescription": "Electronic Computers",
  "accessionNumber": "0000320193-26-000105", "form": "10-K", "filingDate": "2026-10-31", "reportDate": "2026-09-26",
  "items": [], "itemDescriptions": [], "primaryDocument": "aapl-20260926.htm", "isXBRL": true,
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/…/aapl-20260926.htm", "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/…-index.htm",
  "documentText": "UNITED STATES SECURITIES AND EXCHANGE COMMISSION …"
}
```

### Use cases

Event-driven investing and alerts (schedule daily for new 8-Ks), due diligence, compliance and audit research, insider-trading monitoring, building financial datasets, and feeding LLM/RAG pipelines with primary-source filings.

### Pricing

Pay per result: **$2.00 per 1,000 filings**; optional document text **+$4.00 per 1,000 documents**. Error records are free.

### How much does it cost?

You only pay for results, never for compute time:

| You get | You pay (Starter/Bronze plan price) |
|---|---|
| 100 filings | $0.20 |
| 1,000 filings | $2.00 |
| 10,000 filings | $20.00 |

Apify's **free plan includes $5 of usage every month**, and free-plan users pay **half price** on this Actor, so that covers about **5,000 filings** at no cost. Paid plans get volume discounts (Silver -10%, Gold -20%). Set a *maximum cost per run* and the Actor stops cleanly at your limit.

### Notes

Data is public information published by the U.S. SEC. This Actor is not affiliated with the SEC. It identifies itself with a contact User-Agent and stays below SEC's 10 requests/second guidance; you can set your own contact email in the input.

### Run it from code (API, Python, JavaScript)

```bash
curl -X POST "https://api.apify.com/v2/acts/api-co~sec-edgar-filings/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" -d '{"companies": ["AAPL", "TSLA"], "formTypes": ["10-K", "8-K"], "maxItems": 50}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("api-co/sec-edgar-filings").call(run_input={"companies": ["AAPL", "TSLA"], "formTypes": ["10-K", "8-K"], "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('api-co/sec-edgar-filings').call({"companies": ["AAPL", "TSLA"], "formTypes": ["10-K", "8-K"], "maxItems": 50});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

It also works from **AI agents through the Apify MCP server**, and with Zapier, Make, n8n, Google Sheets and webhooks. You can schedule it in the Apify Console.

### FAQ

**Do I need an SEC API key?**
No. It uses the SEC's official public endpoints (submissions API and EDGAR full-text search), with the SEC's fair-access rate limits respected.

**Can I get the text of a 10-K for an LLM?**
Yes. Set `includeDocumentText: true` and each filing includes the clean text of its primary document, ready for chunking and RAG.

**Insider trades (Form 4) and 13F?**
Yes. Filter `formTypes` to `4` or `13F-HR` for any ticker or CIK.

**How fresh is the data?**
Live. Filings appear as soon as EDGAR publishes them, so a scheduled run picks up new 8-Ks on its next run.

# Actor input Schema

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

E.g. AAPL, MSFT, 0001318605. Returns each company's filings from the SEC submissions API.

## `fullTextQuery` (type: `string`):

EDGAR full-text search (filings since 2001). Use quotes for exact phrases, e.g. "going concern" or "material weakness". Results are collapsed to one item per filing.

## `fullTextCompanies` (type: `array`):

Optional tickers/CIKs to restrict the full-text search.

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

E.g. 10-K, 10-Q, 8-K, 4, 13F-HR, S-1, DEF 14A. Empty = all forms.

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

Include amendments (e.g. 10-K/A).

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

Filed on or after (YYYY-MM-DD).

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

Filed on or before (YYYY-MM-DD).

## `includeOlderFilings` (type: `boolean`):

Fetches the company's full filing history (slower).

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

Downloads the main document and converts it to clean text (great for LLMs/RAG). Charged as an extra event.

## `maxDocumentChars` (type: `integer`):

Max characters of document text.

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

Max filings.

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

SEC asks automated tools to identify themselves. Leave empty to use the Actor's default contact.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "TSLA"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "includeAmendments": true,
  "includeOlderFilings": false,
  "includeDocumentText": false,
  "maxDocumentChars": 200000,
  "maxItems": 20
}
```

# Actor output Schema

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

SEC filings (one item per filing) with metadata, links and optional document text.

# 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",
        "TSLA"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-co/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 = {
    "companies": [
        "AAPL",
        "TSLA",
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("api-co/sec-edgar-filings").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",
    "TSLA"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxItems": 20
}' |
apify call api-co/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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

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/Rd36eL0HlpE8Pu1Yb/builds/jaPjeTiExk6ur2gYd/openapi.json