# SEC EDGAR Full-Text Search (Official API) (`contented_catwalk/sec-edgar-full-text-search`) Actor

Search every SEC EDGAR filing since 2001 by phrase, form type, ticker and date. Normalized rows with company, ticker, CIK, form, 8-K items, SIC, state and direct document links. Built for AI agents and alerts.

- **URL**: https://apify.com/contented_catwalk/sec-edgar-full-text-search.md
- **Developed by:** [Orvix](https://apify.com/contented_catwalk) (community)
- **Categories:** Business, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Full-Text Search (Official API)

Search the **full text of every SEC EDGAR filing since 2001** — 10-K, 10-Q, 8-K, S-1, proxies, exhibits — for any phrase, and get clean, analyst-ready rows: company, tickers, CIK, form, filing date, 8-K item numbers, SIC, state, and direct links to the document and the filing index.

Uses SEC's own full-text search (efts.sec.gov) — no scraping of HTML, no API key, no proxies.

### What it does better

- **Past SEC's 10,000-hit wall.** EDGAR's search stops at 10,000 results; this Actor automatically splits the date range so you can pull up to 50,000 rows in one run (tested: 32,694 "going concern" documents for 2025 in one run).
- **Ticker or CIK lookups** with or without a search phrase (e.g. "every Apple 10-K").
- **Fails loudly on bad input** — invalid dates, unknown tickers — instead of silently searching everything.
- **No duplicates**, optional one-row-per-filing mode.
- **Fast:** ~1,500 rows in ~7 s, 12,000 rows in ~2 min on 256 MB.
- **Fair to SEC:** max 5 requests/second (SEC's limit is 10), declared User-Agent, exponential backoff on 429/5xx.

### Examples

**Going-concern warnings in 8-Ks this quarter**

```json
{ "query": "\"going concern\"", "forms": ["8-K"], "startDate": "2026-07-01", "endDate": "2026-09-30", "maxResults": 500 }
```

**Boolean: going concern AND material weakness in 2025 10-Ks**

```json
{ "query": "\"going concern\" AND \"material weakness\"", "forms": ["10-K"], "startDate": "2025-01-01", "endDate": "2025-12-31" }
```

**Cybersecurity incident disclosures (Item 1.05)**

```json
{ "query": "\"Item 1.05\" OR \"cybersecurity incident\"", "forms": ["8-K"], "startDate": "2026-01-01" }
```

**Every Apple 10-K (no phrase needed)**

```json
{ "tickers": ["AAPL"], "forms": ["10-K"] }
```

**Tesla 8-Ks by CIK, one row per filing**

```json
{ "ciks": ["1318605"], "forms": ["8-K"], "startDate": "2025-01-01", "dedupeByFiling": true }
```

**New IPO registrations (S-1) since June**

```json
{ "query": "\"initial public offering\"", "forms": ["S-1"], "startDate": "2026-06-01" }
```

### Input

| Field | Description |
|---|---|
| `query` | Full-text query. `"quotes"` = exact phrase. Supports `AND`, `OR`, `NOT`. Optional if you give tickers/CIKs. |
| `forms` | Form types, e.g. `8-K`, `10-K`, `10-Q`, `S-1`, `DEF 14A`. SEC includes amendments (`8-K/A`). Empty = all. |
| `tickers` | Limit to companies by ticker. Unknown tickers are skipped with a warning; if none are valid the run fails. |
| `ciks` | Limit by SEC CIK number (works for companies without tickers). |
| `startDate` / `endDate` | `YYYY-MM-DD`. Default: last 30 days for phrase searches, 2001-01-01 for ticker/CIK lookups. |
| `maxResults` | Stop after N rows (1–50,000, default 100). You pay per row. |
| `dedupeByFiling` | Off: one row per matching document (main doc + exhibits). On: one row per filing. |
| `userAgent` | Optional. SEC asks for a name + email. |

A `SUMMARY` record in the key-value store gives total matches, rows returned and timing.

### Sample output

```json
{
  "companyName": "HEALTHY CHOICE WELLNESS CORP.",
  "tickers": ["HCWC"],
  "cik": "1948864",
  "form": "8-K",
  "rootForm": "8-K",
  "fileDate": "2026-09-17",
  "periodEnding": "2026-09-17",
  "accessionNumber": "0001493152-26-043135",
  "documentType": "EX-99.1",
  "documentDescription": "EX-99.1",
  "items8K": ["1.01", "2.01", "2.02", "9.01"],
  "sic": "5411",
  "state": "FL",
  "location": "Hollywood, FL",
  "stateOfIncorporation": "DE",
  "fileNumber": "001-42274",
  "otherFilers": [],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1948864/000149315226043135/ex99-1.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1948864/000149315226043135/0001493152-26-043135-index.htm",
  "matchScore": 12.39,
  "query": "\"going concern\""
}
```

### Pricing (pay per event)

- $0.005 per run
- $0.001 per filing row ($1 per 1,000). Platform compute is included — you pay only the per-run and per-row fees above.
  If your run hits your spending limit, the Actor stops and never returns unpaid rows.

### Output fields

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Filer name |
| `tickers` | array | Tickers (if any) |
| `cik` | string | SEC Central Index Key |
| `form` / `rootForm` | string | Form as filed (e.g. `8-K/A`) and root form (`8-K`) |
| `fileDate` / `periodEnding` | date | Filing date and period of report |
| `accessionNumber` | string | SEC accession number |
| `documentType` / `documentDescription` | string | Main document or exhibit type (e.g. `EX-99.1`) |
| `items8K` | array | 8-K item numbers (e.g. `1.01`, `2.02`, `1.05`) |
| `sic` | string | Industry SIC code |
| `state` / `location` / `stateOfIncorporation` | string | Business address state, city and incorporation state |
| `fileNumber` | string | SEC file number |
| `otherFilers` | array | Co-filers on the same filing |
| `documentUrl` / `filingIndexUrl` | URL | Direct document link and filing index |
| `matchScore` | number | SEC relevance score |
| `query` | string | Query that matched |

### What it costs (worked examples)

| Run | Rows | Cost |
|---|---|---|
| Daily alert, small | 50 | $0.005 + $0.05 = **$0.055** |
| Quarter of going-concern 8-Ks | 1,000 | $0.005 + $1.00 = **$1.005** |
| Full-year research pull | 50,000 | $0.005 + $50.00 = **$50.005** |

### How it compares

| | This Actor | EDGAR full-text search website |
|---|---|---|
| Max results per search | 50,000 (auto date-splitting) | 10,000 |
| Ticker → CIK lookup | Built in | Manual |
| Output | Normalized rows: tickers, 8-K items, SIC, state, links | Web result list |
| Export / schedule / API | JSON, CSV, Excel, API, schedules, webhooks | Manual |
| Bad input | Fails with a clear message | Silently broad results |

### Use with AI agents (MCP), n8n, Make and Zapier

**MCP (Claude, Cursor, any MCP client):**

```json
{ "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=contented_catwalk/sec-edgar-full-text-search" } } }
```

Ask your agent e.g. *"Find 8-Ks filed this week that mention a cybersecurity incident and list the companies."*
**n8n:** add the **Apify** node → *Run an Actor and get dataset items* → Actor `contented_catwalk/sec-edgar-full-text-search` → paste an example input. Add a Schedule trigger for daily alerts to Slack, email or Sheets.
**Make / Zapier:** Apify app → *Run Actor*, then *Get Dataset Items*.
**API:** `POST https://api.apify.com/v2/acts/contented_catwalk~sec-edgar-full-text-search/run-sync-get-dataset-items?token=<YOUR_TOKEN>` with the input JSON as the body.

### Limits & FAQ

- **Coverage:** SEC full-text search covers 2001 onward. Older filings aren't searchable.
- **Max 50,000 rows per run.** Schedule daily/weekly runs for alerts instead of huge back-fills.
- **Why more rows than filings?** A filing has several documents (main + exhibits); each matching document is a row. Turn on `dedupeByFiling` for one row per filing.
- **Ordering:** by SEC relevance within each date window; newest windows first on very large pulls.
- **Does it download the full text?** No — it returns links to the documents. Pair with a document fetcher if you need text.
- **Is a 10-K/A included when I ask for 10-K?** Yes, SEC treats amendments as the same root form; filter on `form` if you don't want them.
- **Empty results** finish successfully with 0 rows and a warning; invalid input fails with a clear message (and costs nothing beyond the start fee).

### Data source & terms

SEC EDGAR public full-text search and company_tickers.json. SEC data is public; requests follow SEC's fair-access policy. Not affiliated with or endorsed by the U.S. SEC.

# Actor input Schema

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

EDGAR full-text query. Quotes = exact phrase ("going concern"). Boolean: AND, OR, NOT, e.g. "material weakness" AND "restatement". Leave empty to list all filings of the tickers/CIKs below.

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

e.g. 8-K, 10-K, 10-Q, S-1, DEF 14A. Empty = all forms.

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

Limit to these companies (e.g. AAPL, TSLA). Unknown tickers are skipped with a warning; if none are valid the run fails instead of searching everyone.

## `ciks` (type: `array`):

Limit to these SEC CIK numbers (e.g. 320193). Works for companies without tickers.

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

YYYY-MM-DD. Default: 30 days ago when searching a phrase, 2001-01-01 for ticker/CIK-only lookups. Full-text search covers 2001 onward.

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

YYYY-MM-DD. Default: today.

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

Stop after this many rows (you pay per row). Past SEC's 10,000-hit window the Actor splits the date range automatically.

## `dedupeByFiling` (type: `boolean`):

Off: one row per matching document (main doc and exhibits). On: only the best-matching document of each filing.

## `userAgent` (type: `string`):

SEC fair-access asks for a name + email. Optional; a default contact is used.

## Actor input object example

```json
{
  "query": "\"going concern\"",
  "forms": [
    "8-K"
  ],
  "maxResults": 100,
  "dedupeByFiling": false
}
```

# Actor output Schema

## `filings` (type: `string`):

One row per matching filing document.

## `summary` (type: `string`):

Query, total matches and rows returned.

# 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\"",
    "forms": [
        "8-K"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("contented_catwalk/sec-edgar-full-text-search").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\"",
    "forms": ["8-K"],
}

# Run the Actor and wait for it to finish
run = client.actor("contented_catwalk/sec-edgar-full-text-search").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\\"",
  "forms": [
    "8-K"
  ]
}' |
apify call contented_catwalk/sec-edgar-full-text-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,contented_catwalk/sec-edgar-full-text-search"
        }
    }
}
```

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/e3VQ1bq0QAfDm1pv6/builds/Df2EGest46N9bAp3b/openapi.json