# SEC EDGAR filings - company search + recent filings (API) (`retrainmapdata/sec-edgar-filings`) Actor

SEC EDGAR filings as normalised rows, from the SEC's public APIs (no key): by ticker, CIK or company name (submissions API, filtered by form type and date) or by full-text search (EDGAR FTS, 2001-). CIK, company, ticker, form, dates, accession number, 8-K items, index and document URLs.

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

## Pricing

from $5.00 / 1,000 records

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 filings — company search + recent filings (API)

One row per SEC filing, read live from the SEC's public EDGAR APIs — no key, no scraping.
Two modes:

- **by\_company** — give tickers, CIKs or company names; the Actor resolves them through the
  SEC's ticker file and lists each company's filings from the submissions API, newest first,
  filtered by form type (`10-K`, `8-K`, `S-1`, `4`, …) and filing date. The 1,000 most recent
  filings come in one request and are all that is scanned unless you give a date bound
  (`date_from` / `date_to`), which also reaches the company's older filing files (back to
  1994 for long-listed companies) while your record budget lasts.
- **full\_text** — search the text of filings and exhibits since 2001 with EDGAR full-text
  search (`"workforce reduction"`, boolean operators, wildcards) and get one row per matching
  document, with the filing's index page and the matched document's URL.

**Metadata only.** The rows describe filings as the SEC publishes them; the Actor does not read
or interpret the documents themselves.

### Data source and status

| | |
|---|---|
| Publisher | U.S. Securities and Exchange Commission, EDGAR |
| Ticker / name resolution | `https://www.sec.gov/files/company_tickers.json` (exchange-traded companies; refreshed by the SEC on its own schedule, read live each run) |
| Company filings | `https://data.sec.gov/submissions/CIK##########.json` (+ the older per-company files it lists) — the SEC updates these throughout the day as filings are accepted |
| Full-text search | `https://efts.sec.gov/LATEST/search-index` — the EDGAR full-text search API behind https://efts.sec.gov/LATEST/search-index and https://www.sec.gov/edgar/search/; filings since 2001, indexed within minutes of acceptance; at most 10,000 hits per query |
| Refresh cadence | Live on every run; `fetched_at` is the fetch time |
| Copyright | Works of the United States Government are not subject to copyright in the U.S. (17 U.S.C. §105). Filing metadata is public record; the filings' own documents may contain third-party material — cite the SEC and the filer |
| Known caveats | Form types match exactly as filed (`10-K/A` is listed separately from `10-K`). The ticker file lists exchange-traded companies only — use a CIK for others. In full-text mode `primary_document` is `null`; `matched_document` names the document (often an exhibit) that matched, and `form_type` is the filing's root form |

Identification: the SEC requires a descriptive User-Agent with a contact address. Every request
carries `RetrainMap data actor info@steelyardclinical.com` as User-Agent and the contact
address again in the standard `From:` header. The SEC's fair-access limit is 10 requests per
second; the Actor stays at or below 5 per second (default interval 250 ms).

### Input

| Field | Type | Meaning |
|---|---|---|
| `mode` | `by_company` / `full_text` | Default `by_company` |
| `tickers` | array | Tickers or numeric CIKs (`AAPL`, `0000320193`) |
| `company_names` | array | Resolved against the ticker file: exact name, else a name containing every word given; several matches fail the run and list them |
| `form_types` | array | Optional exact form types. Empty = all |
| `date_from` / `date_to` | `YYYY-MM-DD` | Optional inclusive filing-date bounds. full\_text: empty = 2001-01-01 to today |
| `query` | string | full\_text only (required there). EDGAR full-text syntax: phrases in double quotes, AND / OR / NOT, `*` wildcards |
| `max_records` | integer | Default 300; at most 10,000 (full-text cap per query) |
| `request_interval_ms` | integer | Default 250 (floor 200) |
| `contact_email` | string | Sent in the `From:` header |

Examples:

```json
{ "mode": "by_company", "tickers": ["AAPL", "MSFT"], "form_types": ["10-K", "8-K"], "max_records": 100 }
```

```json
{ "mode": "full_text", "query": "\"workforce reduction\"", "form_types": ["8-K"],
  "date_from": "2026-06-01", "max_records": 500 }
```

### Output (dataset row)

`cik` (10 digits), `company_name`, `ticker`, `form_type`, `filing_date`, `report_date`
(period of report), `accepted_at`, `accession_number`, `primary_document`, `matched_document`
(full-text mode), `document_type` (the form, or the matched document's type such as `EX-99.1`),
`description`, `items` (8-K item numbers as a list, e.g. `["2.05", "9.01"]`), `file_number`,
`film_number`, `all_ciks` (co-registrants), `filing_url` (the filing's index page),
`document_url`, `source` (`submissions-api` / `full-text-search`), `fetched_at`.

A run summary (resolved companies or the search parameters, the search's own match count,
request count) is stored as `RUN_SUMMARY` in the run's key-value store.

### Pricing (pay per event)

| Event | Price |
|---|---|
| `run-start` — once per run | $0.10 |
| `record` — per row written | $0.005 |

A 300-row pull costs $1.60. Rows stop when your run's maximum charge is reached; the run
summary says so.

### Operator

Steelyard Ventures LLC (RetrainMap) — info@steelyardclinical.com. The Actor writes only to its
own dataset and key-value store; it stores no credentials and sends nothing else.

# Actor input Schema

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

by\_company lists the filings of the given companies (newest first). full\_text searches the text of filings and exhibits with the EDGAR full-text search and returns the matching documents.

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

by\_company: exchange tickers (resolved through sec.gov/files/company\_tickers.json) or numeric CIKs, e.g. AAPL, MSFT, 0000320193. An unknown ticker fails the run.

## `company_names` (type: `array`):

by\_company: names resolved against the SEC's ticker file (exact name first, then a name containing every word you give). The file lists exchange-traded companies only; a name matching several companies fails the run and lists them - use a ticker or CIK then.

## `form_types` (type: `array`):

Optional, e.g. 10-K, 10-Q, 8-K, S-1, 4, DEF 14A. Exact match on the form as filed, so list 10-K/A separately when you want amendments. Empty = every form.

## `date_from` (type: `string`):

Optional inclusive lower bound on the filing date. by\_company: without a date bound only each company's 1,000 most recent filings are scanned; a date bound also reaches the older filing files. full\_text: empty = 2001-01-01 (the earliest the full-text index covers).

## `date_to` (type: `string`):

Optional inclusive upper bound on the filing date. Empty = today.

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

full\_text mode only (required there). EDGAR full-text search syntax: phrases in double quotes, e.g. "workforce reduction"; boolean AND/OR/NOT; wildcards with \*.

## `max_records` (type: `integer`):

Stop after this many rows in total. by\_company: rows are written company by company in the order given, so raise this (or narrow form\_types / dates) to reach later companies. The full-text search pages at most 10,000 hits per query - narrow the date range for more.

## `request_interval_ms` (type: `integer`):

Politeness delay towards sec.gov, whose fair-access limit is 10 requests per second; this Actor stays at or below 5 per second (floor 200 ms).

## `contact_email` (type: `string`):

Sent in the standard From: request header so the data owner can reach the operator (RFC 9110 s10.1.2). The User-Agent already carries the operator's address, as the SEC requires.

## Actor input object example

```json
{
  "mode": "by_company",
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "form_types": [
    "10-K",
    "8-K"
  ],
  "max_records": 100,
  "request_interval_ms": 250,
  "contact_email": "info@steelyardclinical.com"
}
```

# Actor output Schema

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

Every matched filing as one row: CIK, company, ticker, form, dates, accession number, items, description, index and document URLs.

## `results_csv` (type: `string`):

The same rows as a CSV file.

# 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 = {
    "mode": "by_company",
    "tickers": [
        "AAPL",
        "MSFT"
    ],
    "form_types": [
        "10-K",
        "8-K"
    ],
    "max_records": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("retrainmapdata/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 = {
    "mode": "by_company",
    "tickers": [
        "AAPL",
        "MSFT",
    ],
    "form_types": [
        "10-K",
        "8-K",
    ],
    "max_records": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("retrainmapdata/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 '{
  "mode": "by_company",
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "form_types": [
    "10-K",
    "8-K"
  ],
  "max_records": 100
}' |
apify call retrainmapdata/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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