# SEC EDGAR Filings Scraper & API: Full-Text Search, Alerts (`stazis/sec-edgar-filings-api`) Actor

SEC EDGAR full-text search or latest filings by ticker/CIK: 8-K, 10-K, 10-Q, Form D and more. New-only monitoring, lastDays window and webhook alerts. If SEC throttles, the run says so instead of returning an empty result.

- **URL**: https://apify.com/stazis/sec-edgar-filings-api.md
- **Developed by:** [Stanislav](https://apify.com/stazis) (community)
- **Categories:** Business, Developer tools, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## SEC EDGAR Scraper & API: Full-Text Search, Filing Alerts

Search **SEC EDGAR** the way analysts do: **full-text search** across all filings (exact phrases, forms, dates, states), or the **latest filings of any ticker or CIK**. Built for monitoring: return only filings you haven't seen, over a rolling `lastDays` window, and post them to your **webhook**.

- **Who it's for:** investors and analysts, compliance and risk teams, journalists, deal sourcing (Form D), anyone who wants SEC filing alerts.
- **Source:** SEC EDGAR full-text search and submissions APIs (official public data), with SEC's fair-access rules respected. No API key, no login.
- **Honest failures:** SEC 403/429 responses are retried; if SEC keeps blocking, the run fails with that reason instead of an empty dataset that looks like "no filings".
- **Output:** JSON, CSV or Excel with filing URLs; pay per filing returned (see the Pricing tab).

### Quick start (one click)

Open the Actor and press **Start**: the form is prefilled with this input.

```json
{
  "query": "\"going concern\"",
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "10-Q"
  ],
  "lastDays": 30,
  "maxResults": 20
}
```

Sample output (one row, more fields in the dataset):

| accessionNumber | form | fileType | fileDescription | filedAt |
|---|---|---|---|---|
| 0001477932-26-006367 | 10-Q | 10-Q | FORM 10-Q | 2026-10-21 |

### Use cases

**Risk-phrase screening.** Filings that mention a phrase in the last 30 days.

```json
{"mode": "search", "query": "\"going concern\"", "forms": ["10-Q", "10-K"], "lastDays": 30}
```

**8-K alerts for a watchlist.** Schedule hourly; new filings only, pushed to your webhook.

```json
{"mode": "company", "tickers": ["AAPL", "MSFT", "NVDA"], "forms": ["8-K"], "onlyNew": true, "webhookUrl": "https://example.com/hook"}
```

**IPO pipeline from S-1 filings.** New S-1 registration statements in the last 30 days.

```json
{"mode": "search", "query": "\"initial public offering\"", "forms": ["S-1"], "lastDays": 30}
```

**Research datasets.** All 10-K filings matching a topic in a date range.

```json
{"mode": "search", "query": "\"artificial intelligence\"", "forms": ["10-K"], "dateFrom": "2025-01-01", "dateTo": "2025-12-31", "maxResults": 500}
```

### How it compares

Checked against the most-used SEC EDGAR actors in the Apify Store (their Store pages, input forms, reviews and Issues tabs, 23 Oct 2026). Alternatives are described generically; every claim about them is visible on their public pages.

| | This actor | Common in the alternatives |
|---|---|---|
| When SEC blocks or throttles | Retries 403/429/5xx with backoff; if SEC still refuses, the run says so ("SEC rate limiting, NOT 'no filings found'") and fails instead of returning an empty dataset | The only review of one alternative is "Does not work"; its developer explained the run had mistaken an SEC block for "no filings found" |
| Monitoring | `onlyNew` (skip filings already seen in earlier runs) + `lastDays` rolling window + optional `webhookUrl` that receives the new filings as JSON | Some offer an incremental mode or watchlists; webhook delivery is rare |
| Search | EDGAR full-text search (phrases, forms, dates, states) or latest filings by ticker/CIK | Often one of the two |
| Stop reason | Status message says how many filings, since when, and why it stopped (`maxResults` or cost limit) | Not described on their Store pages |
| Price | $2 per 1,000 filings + $0.005 per run (see the Pricing tab) | From free to $2 per 1,000; some charge extra for financials or AI summaries |
| Not included | XBRL financial statements, AI summaries | Offered by at least one alternative |

#### Ready-to-copy inputs

Daily alert for new 8-Ks mentioning "material weakness", posted to your webhook (schedule it once a day):

```json
{"mode": "search", "query": "\"material weakness\"", "forms": ["8-K"], "lastDays": 2, "onlyNew": true, "webhookUrl": "https://example.com/hooks/sec"}
```

Latest filings of two companies:

```json
{"mode": "company", "tickers": ["AAPL", "MSFT"], "forms": ["10-K", "10-Q", "8-K"], "maxResults": 50}
```

### Features and details of this SEC EDGAR API

Get US SEC filings as clean JSON straight from the **official free SEC EDGAR APIs**. No API key, no login, no proxies.

**Two modes**

- **Full-text search**: find every 8-K, 10-K, 10-Q, S-1, Form D and more that mentions a phrase ("going concern", "artificial intelligence", "material weakness"). Filter by form type, filing date and business state.
- **Company filings**: list the recent filings of any ticker or CIK (AAPL, MSFT, 320193), filtered by form and date.

**Output per filing:** accession number, form, filed date, period of report, company name, ticker, CIK, SIC, business state and location, state of incorporation, 8-K item numbers, a direct document URL and the filing index URL.

**Only new:** turn on `onlyNew` and schedule the actor. Each run then returns only filings you haven't seen, which makes it a cheap alert feed (for example new 8-K item 1.01 or 5.02 filings about your watchlist).

#### Notes

- Data: SEC EDGAR (efts.sec.gov full-text search, data.sec.gov submissions). US federal government data is public domain. The actor follows SEC fair-access rules: it declares its User-Agent and sends about 4 requests per second (the limit is 10).
- Full-text search covers filings from 2001 on, up to 10,000 hits per query (an SEC limit). Narrow the dates for more.
- No personal data: insider-transaction forms 3, 4, 5 and 144, which individuals file, are excluded.
- Not affiliated with the SEC.

### How to use the SEC EDGAR API

1. Open the Actor, fill in the input form (or paste the JSON below).
2. Click **Start**. Results land in the dataset as JSON, CSV, Excel or via the Apify API.
3. For alerts or regular refreshes, add an Apify **Schedule**. You can cap spend with "Max charge per run".

### Input example

Real input of cloud run `ZxUmaxKyYJFmtZV6v` (2026-10-22/23):

```json
{
  "mode": "search",
  "query": "\"going concern\"",
  "forms": [
    "10-Q"
  ],
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-21",
  "maxResults": 15
}
```

### Output example

Real rows from that run (15 results, 4.2 s) (long titles shortened in the table):

| filed | company | ticker | SIC | location |
|---|---|---|---|---|
| 2026-10-21 | Tech Tonic Group Corp. | THTG | 7371 | Krefeld, 2M |
| 2026-10-01 | NaturalShrimp Inc | — | 0900 | Boca Raton, FL |
| 2026-10-15 | Loop Industries, Inc. | LOOP | 2800 | Terrebonne, A8 |
| 2026-10-13 | Zhanling International Ltd | ZLME | 1000 | Carson City, NV |
| 2026-10-14 | Blue Chip Capital Group Inc. | BCCG | 6199 | Beverly Hills, CA |
| 2026-10-14 | Jubilant Flame International, Ltd | JFIL, JFILD | 7371 | Shanghai |

One full record:

```json
{
  "accessionNumber": "0001477932-26-006367",
  "form": "10-Q",
  "fileType": "10-Q",
  "fileDescription": "FORM 10-Q",
  "filedAt": "2026-10-21",
  "periodOfReport": "2026-09-30",
  "companyName": "Tech Tonic Group Corp.",
  "ticker": "THTG",
  "cik": "2029303",
  "sic": "7371",
  "businessState": "2M",
  "businessLocation": "Krefeld, 2M",
  "stateOfIncorporation": "WY",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/2029303/000147793226006367/techtonic_10q.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2029303/000147793226006367/0001477932-26-006367-index.htm",
  "source": "efts"
}
```

A full-text hit means the phrase appears somewhere in the filing (it can be boilerplate). Open `documentUrl` to read the context. `2M`/`A8` are EDGAR codes for Germany and Quebec.

### FAQ

#### How far back does EDGAR full-text search go?

To 2001, with at most 10,000 hits per query (an SEC limit). Narrow the date range to get more.

#### Are Form 4 insider trades included?

No. Forms 3, 4, 5 and 144, which individuals file, are excluded on purpose.

#### Does it respect SEC rate limits?

Yes. It declares a User-Agent and sends about 4 requests per second; the SEC limit is 10.

#### How much does it cost?

$2 per 1,000 filings plus $0.005 per run.

#### Are there limits I should know about?

Yes. Results are only as complete and current as the official source. If a source is down, the run logs the error instead of returning made-up data. Report problems in the Issues tab.

### Use it from code, AI agents and automations

The same input as the form above works everywhere. Results are the run's dataset (JSON, CSV, Excel). You need an Apify API token (Console → Settings → API & Integrations).

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("stazis/sec-edgar-filings-api").call(run_input={
  "query": "\"going concern\"",
  "forms": [
    "10-Q"
  ],
  "lastDays": 30,
  "maxResults": 20
})
for item in client.dataset(run.default_dataset_id).iterate_items():  # apify-client < 3: run["defaultDatasetId"]
    print(item)
```

**JavaScript / TypeScript** (`npm i apify-client`)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('stazis/sec-edgar-filings-api').call({
  "query": "\"going concern\"",
  "forms": [
    "10-Q"
  ],
  "lastDays": 30,
  "maxResults": 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP, one call** (waits for the run, up to 5 minutes, and returns the items)

```bash
curl -X POST "https://api.apify.com/v2/acts/stazis~sec-edgar-filings-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"query": "\"going concern\"", "forms": ["10-Q"], "lastDays": 30, "maxResults": 20}'
```

**AI agents (MCP).** This Actor runs with limited permissions, so AI agents can use it through the hosted Apify MCP server (Claude, Cursor, VS Code, Codex and other MCP clients). Add this to your MCP client config and sign in with Apify on first use:

```json
{ "mcpServers": { "sec-edgar-filings-api": { "url": "https://mcp.apify.com?tools=stazis/sec-edgar-filings-api" } } }
```

Agents without an Apify account can pay per run in USDC through [agi.apify.com](https://agi.apify.com) (x402). Pricing is pay-per-event, so an agent pays only for the results it gets.

**LangChain** (`pip install langchain-apify`, set `APIFY_TOKEN`): `from langchain_apify import ApifyActorsTool` and `tool = ApifyActorsTool("stazis/sec-edgar-filings-api")` gives your agent this Actor as a tool.

**No-code and scheduling:** use the Apify app in Make, n8n or Zapier ("Run an Actor", then pick `stazis/sec-edgar-filings-api`), or create a Schedule in Apify Console to run it daily and send results to a webhook, Slack or Google Drive through Apify integrations.

### Other data APIs by stazis

- [Greenhouse, Lever & Ashby Jobs Scraper API](https://apify.com/stazis/ats-jobs-api): Scrape job postings from company career sites via official Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee job-board APIs.
- [UK Companies House Search API: Bulk Company Data](https://apify.com/stazis/companies-house-api): Search all ~5.
- [Grants.gov & SAM.gov API: US Federal Grants and Contracts](https://apify.com/stazis/gov-opportunities-api): Get US federal grant opportunities from Grants.
- [Bulk WHOIS & RDAP Domain Lookup API: Expiry, DNS](https://apify.com/stazis/domain-rdap-api): Bulk domain lookup via official RDAP (the WHOIS successor) plus live DNS: registrar, status, created/updated/expiry dates, nameservers, DNSSEC, A/AAAA/MX/NS/TXT records.
- [OpenAlex API: Scholarly Paper Search, Citations, Abstracts](https://apify.com/stazis/openalex-works-api): Search 250M+ scholarly papers from OpenAlex (CC0): title, DOI, year, venue, open-access link, citation count, authors, institutions, topics and abstract.

# Actor input Schema

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

'search' = EDGAR full-text search across all filings (uses Query, Forms, dates, states). 'company' = latest filings of the tickers/CIKs below.

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

Full-text search phrase. Use double quotes for an exact phrase, e.g. "going concern" or "material weakness". Search mode only.

## `tickers` (type: `array`):

Company mode: tickers or CIK numbers, e.g. AAPL, MSFT, 320193.

## `forms` (type: `array`):

Form types to include, e.g. 8-K, 10-K, 10-Q, S-1, D. Empty = all forms (insider forms 3/4/5/144 are always excluded).

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

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

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

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

## `lastDays` (type: `integer`):

Only filings from the last N days (sets 'Filed from' automatically when it is empty). Handy with a daily schedule: lastDays 1 or 2.

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

Search mode: two-letter US state codes of the company's business address, e.g. CA, NY.

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

Maximum filings returned. Full-text search returns at most 10,000 hits per query (SEC limit). Also caps the cost.

## `onlyNew` (type: `boolean`):

Monitor mode: return only filings not returned by earlier runs. Use with a daily schedule for alerts.

## `stateStoreName` (type: `string`):

Name of the key-value store that 'Only new' uses. Use a different name per saved search.

## `webhookUrl` (type: `string`):

When the run returns filings, POST one JSON message ({text, count, filings\[]}) here, e.g. a Slack or Discord incoming webhook or a Zapier/Make hook. Combine with 'Only new' and a schedule for filing alerts.

## Actor input object example

```json
{
  "mode": "search",
  "query": "\"going concern\"",
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "10-Q"
  ],
  "lastDays": 30,
  "maxResults": 20,
  "onlyNew": false,
  "stateStoreName": "sec-edgar-state"
}
```

# Actor output Schema

## `results` (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 = {
    "query": "\"going concern\"",
    "tickers": [
        "AAPL"
    ],
    "forms": [
        "10-Q"
    ],
    "lastDays": 30,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stazis/sec-edgar-filings-api").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": "\"going concern\"",
    "tickers": ["AAPL"],
    "forms": ["10-Q"],
    "lastDays": 30,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stazis/sec-edgar-filings-api").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": "\\"going concern\\"",
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "10-Q"
  ],
  "lastDays": 30,
  "maxResults": 20
}' |
apify call stazis/sec-edgar-filings-api --silent --output-dataset

```

## MCP server setup

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

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/GyYyKRac63yLT6do9/builds/6yMJT4YBEZzhA9Fvs/openapi.json