# SEC EDGAR Filings Scraper: 10-K, 10-Q, 8-K & Form D (`lepidata/sec-edgar-filings`) Actor

Search SEC EDGAR filings by ticker, CIK, form type and date (10-K, 10-Q, 8-K and more) with document links. Form D mode lists new private placements and startup funding rounds. Unofficial.

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

## Pricing

from $0.20 / 1,000 sec 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 Filings Scraper

*Unofficial tool. Not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission.*

*Not investment advice. Confirm filings at sec.gov.*

Look up company filings from SEC EDGAR and get one row per filing, with links to the filing documents. It's for analysts, investors, journalists, compliance teams and developers who need filing lists without writing their own EDGAR client.

**Filings mode, input:** a ticker, CIK or company name, or full-text search words, plus form types (10-K, 10-Q, 8-K, S-1, Form 4 and others), business states, a date range and a maximum number of results. **Output:** company name, CIK, tickers, form type, filing date, period, accession number, and links to the filing index and main (or matched) document. Filing metadata only, no person data.

**Form D mode:** new Regulation D private placements and startup funding rounds by date, company, full text, business state or industry group. **Output:** issuer name, CIK, entity type, jurisdiction, issuer business address, industry group, offering amount, amount sold, exemptions, investor counts, date of first sale and filing links. No executive, director, promoter or sales-recipient names.

Data comes from the SEC's public EDGAR APIs (data.sec.gov submissions, efts.sec.gov full-text search, and filing documents on sec.gov). The Actor stays well under SEC fair-access limits (about 4 requests a second) and identifies itself in every request.

### SEC filings input

- `mode`: `filings` (default) or `formD`
- `ticker`, `cik` or `company`: one company. A ticker or CIK alone reads the company's recent filings list (about the last 1,000 filings).
- `query`: full-text search words (EDGAR full-text search covers 2001 onward)
- `formTypes`: e.g. 10-K, 10-Q, 8-K, S-1, 4. Ignored in formD mode (D and D/A are used).
- `states`: business-address states, 2-letter codes
- `industryGroups`: formD only, e.g. `Other Technology`, `Pooled Investment Fund`, `Biotechnology`. Applied after each Form D is read, so it uses more requests. With an industry filter a run reads at most 200 Form Ds (2,000 otherwise, including state-only searches); if that limit stops a run early you get a free `read-cap-reached` row.
- `includeAmendments`: include 10-K/A, D/A and so on (default true)
- `dateFrom` / `dateTo`: filing dates, YYYY-MM-DD
- `lastNDays`: optional, filings from the last N days through today, using UTC dates worked out when the run starts. Overrides `dateFrom` / `dateTo`. In formD mode with an `industryGroups` filter and no dates at all, the last 30 days are used.
- `maxResults`: up to 10,000 (EDGAR full-text search returns at most 10,000 hits per query)

### EDGAR filings output fields

`accessionNumber`, `cik`, `companyName`, `tickers`, `form`, `fileDate`, `periodOfReport`, `items` (8-K items), `description`, `matchedDocument`, `matchedDocumentType`, `sic`, `businessLocation`, `stateOfIncorporation`, `fileNumber`, `documentUrl`, `filingIndexUrl`, `source`

### Form D output fields (issuer and offering only)

`accessionNumber`, `form` (D or D/A), `fileDate`, `cik`, `issuerName`, `entityType`, `jurisdictionOfIncorporation`, `yearOfIncorporation`, `issuerStreet1`, `issuerStreet2`, `issuerCity`, `issuerState`, `issuerZip`, `industryGroup`, `investmentFundType`, `revenueRange`, `aggregateNetAssetValueRange`, `federalExemptions`, `isAmendment`, `dateOfFirstSale`, `durationMoreThanOneYear`, `securitiesOffered`, `isBusinessCombination`, `minimumInvestment`, `totalOfferingAmount`, `totalAmountSold`, `totalRemaining`, `hasNonAccreditedInvestors`, `investorsAlreadyInvested`, `salesCommissionsUsd`, `findersFeesUsd`, `proceedsPaidToInsidersUsd` (dollar amount only), `signatureDate`, `filingIndexUrl`, `formDUrl`

The Form D related-persons list, sales-compensation recipients, signer names and issuer phone number are never read into results.

Free status rows (not charged): `no-results`, `invalid-input`, `api-error`, `rate-limited`, `free-plan-limit`, `charge-limit-reached`, `read-cap-reached`.

**Examples:** `{"ticker":"AAPL","formTypes":["10-K","10-Q"],"maxResults":10}` · `{"mode":"formD","states":["CA"],"dateFrom":"2026-10-19","dateTo":"2026-10-23","maxResults":10}`

### Ready-made examples

- [Form D Filings This Week: Private Offerings](https://apify.com/lepidata/sec-edgar-filings/examples/form-d-filings-this-week): Form D notices filed in the last 7 days, with total offering amount, amount sold so far and the exemption used.
- [SEC 8-K Filings: Last 7 Days](https://apify.com/lepidata/sec-edgar-filings/examples/sec-8k-filings-last-7-days): material-event reports (8-Ks) filed in the past week, with their 8-K item codes.

Unofficial examples. Not affiliated with or endorsed by any company or agency named above.

### Limits and compliance

- Paced at about 4 requests a second with a contact User-Agent, per the SEC's fair-access policy. On 403/429 it backs off 10, 30 and 60 seconds, then stops with a free `rate-limited` row.
- No SEC seal or logos are used.
- Free-plan accounts get up to 100 results per run.

**Pricing.** Pay per result: $0.20 per 1,000 filings ($0.0002 each), the same price on every plan, no start fee. Free status rows are never charged.

# Actor input Schema

## `mode` (type: `string`):

filings = one row per filing. formD = one row per Form D with offering details read from the filing (amount raised, amount sold, investors, exemptions). In filings mode, give at least one of query, company, ticker, CIK or form types; with none, the run returns a free invalid-input row and nothing is charged.

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

Words or "exact phrases" searched inside filing text (EDGAR full-text search, 2001 onward). Leave empty to list filings by company or form.

## `company` (type: `string`):

Company name to match, e.g. Apple. Ignored when a ticker or CIK is given.

## `ticker` (type: `string`):

Stock ticker, e.g. AAPL. Looked up in SEC's ticker list.

## `cik` (type: `string`):

SEC Central Index Key, e.g. 320193.

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

Only these forms, e.g. 10-K, 10-Q, 8-K, S-1, 4, 13F-HR. Ignored in formD mode.

## `states` (type: `array`):

Only companies whose business address is in these states, as 2-letter codes, e.g. CA, NY, TX.

## `industryGroups` (type: `array`):

formD mode only. Keep offerings whose industry group contains any of these words, e.g. Other Technology, Pooled Investment Fund, Biotechnology. Applied after each Form D is read, so it uses more requests. With an industry filter, a run reads at most 200 Form Ds (2,000 otherwise, including state-only searches).

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

formD mode only. On (default): include amended Form D notices (D/A) as well as new ones. Off: new Form D notices only.

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

Earliest filing date to include, YYYY-MM-DD (e.g. 2026-10-01). Ignored when Filed in the last N days is set.

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

Latest filing date to include, YYYY-MM-DD (e.g. 2026-10-27). Leave empty for today. Ignored when Filed in the last N days is set.

## `lastNDays` (type: `integer`):

Optional, e.g. 7. Filings from today minus N days through today (UTC dates, worked out when the run starts). Overrides Filed from / Filed to. Leave empty to use the fixed dates. In formD mode with an industry filter and no dates at all, the last 30 days are used.

## `maxResults` (type: `integer`):

Up to 10,000 (EDGAR full-text search limit per query). With only a ticker or CIK, the company's latest ~1,000 filings are searched.

## Actor input object example

```json
{
  "mode": "filings",
  "query": "\"artificial intelligence\"",
  "formTypes": [
    "10-K"
  ],
  "includeAmendments": true,
  "maxResults": 10
}
```

# Actor output Schema

## `items` (type: `string`):

All rows from this run.

# 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 = {
    "query": "\"artificial intelligence\"",
    "formTypes": [
        "10-K"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lepidata/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 = {
    "query": "\"artificial intelligence\"",
    "formTypes": ["10-K"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lepidata/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 '{
  "query": "\\"artificial intelligence\\"",
  "formTypes": [
    "10-K"
  ],
  "maxResults": 10
}' |
apify call lepidata/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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