# Sec Edgar Scraper (`cryptosignals/sec-edgar-scraper`) Actor

Pull official SEC filings from EDGAR. Get 10-K, 10-Q, 8-K, S-1, proxy statements, filer name, CIK, filing date, and document URLs. Ideal for financial research, compliance, and investment analysis. PPE pricing — pay only for results.

- **URL**: https://apify.com/cryptosignals/sec-edgar-scraper.md
- **Developed by:** [Web Data Labs](https://apify.com/cryptosignals) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 filing scrapeds

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?

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

### SEC EDGAR Scraper — 10-K, 10-Q, 8-K & Insider Filings (No API Key)

Pull SEC EDGAR filings — 10-K annuals, 10-Q quarterlies, 8-K material events, S-1 IPOs, DEF 14A proxies, Form 4 insider trades, and 13F institutional holdings — by company name, CIK, ticker, or full-text keyword. Get a clean structured dataset (company, CIK, ticker, form type, filed date, reporting period, description, direct document URL) ready to drop into your screener, compliance dashboard, or research pipeline. No registration, no API key, no rate-limit babysitting.

***

### Why Use This Instead of EDGAR Directly?

EDGAR is technically a public dataset — but actually using it at scale is a slog:

- **Three different APIs, three different conventions.** `data.sec.gov`, the EDGAR full-text search endpoint, and the legacy `Archives/` filing tree each return data in their own shape. You glue them together yourself.
- **CIK lookup is its own project.** Companies are keyed by 10-digit Central Index Key, not ticker or name. You have to map names → CIK first, handle subsidiaries, and resolve former tickers.
- **Date filtering is awkward.** The full-text search endpoint paginates oddly and filters dates differently than the company-filings endpoint.
- **Document URLs are buried.** Each filing has an index page, then a primary document, then sometimes amendments. Constructing the canonical document link takes several hops.
- **Rate limits & user-agent rules.** SEC requires a declared `User-Agent` with a contact email and enforces request rate limits. Get it wrong and you're throttled or temporarily blocked.

This actor handles every part of that — name/ticker/CIK resolution, form filtering, date windows, document URL assembly, and polite request pacing — so you get a clean dataset on a single API call.

***

### What Data You Get

Every filing record returns:

- **company\_name** — registrant's display name (e.g. `Apple Inc.`)
- **cik** — 10-digit Central Index Key, zero-padded (e.g. `0000320193`)
- **ticker** — primary ticker symbol when available (e.g. `AAPL`)
- **filing\_type** — form code (e.g. `10-K`, `10-Q`, `8-K`, `S-1`, `DEF 14A`, `4`, `13F-HR`)
- **filed\_date** — date the filing was submitted to EDGAR (`YYYY-MM-DD`)
- **period\_of\_report** — fiscal period the filing covers (`YYYY-MM-DD`)
- **description** — short human-readable description of the filing
- **document\_url** — direct link to the primary filing document on `sec.gov`

***

### Use Cases

**1. Earnings & 10-K monitoring**
Pull every 10-K and 10-Q for a watchlist of tickers as they drop. Pipe straight into your model or note-taking workflow.

**2. 8-K material-event alerts**
Stream 8-K filings (executive changes, M\&A, accounting issues, regulatory actions) for any list of companies — react in minutes, not days.

**3. Insider-trading tracking (Form 4)**
Catch officer and director buys/sells across a portfolio of companies. Build dashboards of insider sentiment by sector.

**4. 13F institutional holdings**
Surface what hedge funds and asset managers reported holding at quarter end. Feed it into clone-portfolio strategies or competitive-intelligence reports.

**5. IPO and S-1 pipeline**
Track new S-1 and S-1/A filings across the market. Build an IPO calendar with company name, filing date, and direct link to the prospectus.

**6. Compliance & risk monitoring**
Run scheduled full-text searches (`"climate change risk"`, `"cybersecurity incident"`, `"going concern"`) across all filings to flag emerging disclosures.

**7. Academic & quantitative research**
Build your own historical filings dataset for NLP, sentiment analysis, or topic modeling without paying for Refinitiv or Bloomberg seats.

***

### How to Use

1. Open the actor on Apify: [apify.com/cryptosignals/sec-edgar-scraper](https://apify.com/cryptosignals/sec-edgar-scraper)
2. Click **Try for free** — no credit card required for small runs.
3. Pick a **searchMode**:
   - `company` — list every filing for a single company (by name, CIK, or ticker).
   - `fulltext` — full-text keyword search across the entire EDGAR corpus.
4. Set `query`, optionally narrow by `forms` (e.g. `10-K,10-Q`), `startDate`, `endDate`, and `maxItems`.
5. Click **Start** and download results as **JSON**, **CSV**, **Excel**, or pull them programmatically via the **Apify API**.

***

### Input Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `searchMode` | string (`company` | `fulltext`) | Optional | `company` looks up all filings for one registrant. `fulltext` searches keywords across all filings. Default: `company`. |
| `query` | string | Yes | Company name, CIK, ticker, or full-text keywords (e.g. `"Apple Inc"`, `"0000320193"`, `"AAPL"`, `"climate change risk"`). |
| `forms` | string | Optional | Comma-separated form types (e.g. `"10-K,10-Q,8-K,S-1"`). Leave empty for all forms. Default: `"10-K"`. |
| `startDate` | string (`YYYY-MM-DD`) | Optional | Earliest filing date. Default: 1 year ago. |
| `endDate` | string (`YYYY-MM-DD`) | Optional | Latest filing date. Default: today. |
| `maxItems` | integer (1-200) | Optional | Maximum filings to return. Default: 20. |

> **Tip:** for `company` mode you can pass a name (`"Tesla"`), a ticker (`"TSLA"`), or a zero-padded CIK (`"0001318605"`). The actor resolves all three.

#### Example input — Company filings

```json
{
  "searchMode": "company",
  "query": "Apple Inc",
  "forms": "10-K,10-Q,8-K",
  "startDate": "2024-01-01",
  "endDate": "2026-05-01",
  "maxItems": 50
}
```

#### Example input — Full-text search

```json
{
  "searchMode": "fulltext",
  "query": "cybersecurity incident",
  "forms": "8-K",
  "startDate": "2025-01-01",
  "maxItems": 100
}
```

***

### Output Example

```json
[
  {
    "company_name": "Apple Inc.",
    "cik": "0000320193",
    "ticker": "AAPL",
    "filing_type": "10-K",
    "filed_date": "2024-11-01",
    "period_of_report": "2024-09-28",
    "description": "Annual report pursuant to Section 13 or 15(d)",
    "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm"
  },
  {
    "company_name": "Apple Inc.",
    "cik": "0000320193",
    "ticker": "AAPL",
    "filing_type": "10-Q",
    "filed_date": "2025-02-01",
    "period_of_report": "2024-12-28",
    "description": "Quarterly report pursuant to Section 13 or 15(d)",
    "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000010/aapl-20241228.htm"
  }
]
```

Datasets export as JSON, CSV, XML, or Excel from the Apify console, or stream programmatically via the dataset API.

***

### Calling the Actor Programmatically

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/cryptosignals~sec-edgar-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchMode": "company",
    "query": "TSLA",
    "forms": "10-K,10-Q,8-K",
    "maxItems": 25
  }'
```

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("cryptosignals/sec-edgar-scraper").call(run_input={
    "searchMode": "company",
    "query": "Microsoft",
    "forms": "10-K,10-Q",
    "startDate": "2024-01-01",
    "maxItems": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["filing_type"], item["filed_date"], "-", item["document_url"])
```

#### Node.js (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('cryptosignals/sec-edgar-scraper').call({
    searchMode: 'fulltext',
    query: 'going concern',
    forms: '10-K,10-Q',
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Pulled ${items.length} filings`);
```

***

### Pricing

This actor uses **Pay-per-event** — you only pay for filings extracted, not for compute time or failed runs.

- **Cost**: $0.01 per filing record
- **Free tier**: Apify's free plan includes $5/month of platform credits — enough to pull ~500 filings to try it out.
- **Typical 10-K monitor run**: 25 filings → about $0.25.
- **Typical full-text sweep**: 200 filings → $2.00.

[See full Apify pricing →](https://apify.com/pricing)

***

### FAQ

**Is scraping SEC EDGAR legal?**

Yes. SEC EDGAR is a public-domain government database — every filing is public record by law. The SEC explicitly publishes the data for reuse and runs official endpoints to support automated access. This actor respects the SEC's published fair-access guidelines (declared `User-Agent`, polite request pacing, no abuse). Always consult your own legal counsel for your specific use case.

**Do I need an SEC account or API key?**

No. EDGAR is fully public. The actor handles everything for you, including the User-Agent header SEC requires.

**How fresh is the data?**

EDGAR publishes filings in near real time as registrants submit them. This actor queries EDGAR live on every run, so results are as fresh as EDGAR itself — typically within seconds of submission.

**Can I get the full filing text, not just metadata?**

This actor returns metadata + the canonical `document_url` for every filing. Pass that URL to your text-extraction pipeline (PDF or HTML parser) to pull the full document. We may add an inline-text mode in a future version — open an issue on the actor page if that's useful for you.

**Can I track a list of tickers on a schedule?**

Yes. Use Apify's built-in scheduler to run on a cron — daily, weekly, or any interval. Pass each ticker as a separate run, or a comma-list, and push results to a webhook, Google Sheets, Airtable, Slack, or your own database.

**What's the difference between `company` and `fulltext` search?**

`company` returns every filing for one registrant — best for monitoring a watchlist of tickers. `fulltext` searches keywords across the entire EDGAR corpus — best for surfacing emerging disclosures (`"climate risk"`, `"restatement"`, `"material weakness"`) across all companies.

**Can I get amendments (e.g. 10-K/A)?**

Yes — pass amendment forms in the `forms` field, e.g. `"10-K,10-K/A,10-Q,10-Q/A"`.

***

### Related Actors

Looking for more financial and company data?

- **[Crunchbase Scraper](https://apify.com/cryptosignals/crunchbase-scraper)** — Funding rounds, investors, founders, and headcount.
- **[LinkedIn Jobs Scraper](https://apify.com/cryptosignals/linkedin-jobs-scraper)** — Job listings from LinkedIn at scale.
- **[G2 Reviews Scraper](https://apify.com/cryptosignals)** — Software reviews, pricing, and competitor mentions.
- **[Capterra Reviews Scraper](https://apify.com/cryptosignals)** — Software category reviews and ratings.

***

### About Web Data Labs

This actor is maintained by [Web Data Labs](https://web-data-labs.com) — we publish a catalog of 100+ production-ready scrapers on the Apify platform covering jobs, e-commerce, social media, software reviews, and company data. Pay-per-result pricing means you only ever pay for data you receive.

Questions or custom data needs? Reach out via the Apify contact form or visit [web-data-labs.com](https://web-data-labs.com).

***

### New to Apify? Start here

Sign up for Apify through [this link](https://apify.com/?fpr=yw6md3) to get $5 in free platform credits — enough to try this actor and many others on the Web Data Labs catalog at no cost.

# Actor input Schema

## `searchMode` (type: `string`):

company = lookup all filings for a specific company by name or CIK. fulltext = full-text search across all filings.

## `query` (type: `string`):

Company name, CIK, or full-text search keywords (e.g. 'Apple Inc', '0000320193', 'climate change risk').

## `forms` (type: `string`):

Comma-separated filing types (e.g. '10-K,10-Q,8-K,S-1'). Leave empty for all forms.

## `startDate` (type: `string`):

Earliest filing date (YYYY-MM-DD). Default: 1 year ago.

## `endDate` (type: `string`):

Latest filing date (YYYY-MM-DD). Default: today.

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

Maximum number of filings to return (default: 20, max: 200).

## Actor input object example

```json
{
  "searchMode": "company",
  "query": "Apple Inc",
  "forms": "10-K",
  "maxItems": 20
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/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 '{}' |
apify call cryptosignals/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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