# SEC EDGAR Filings Monitor — 10-K, 10-Q, 8-K & Form 4 Feed (`oneshotventure/sec-filings`) Actor

Get new SEC filings for your watchlist of tickers or CIKs since your last run: 10-K, 10-Q, 8-K, Form 4 and any other form type. Official SEC EDGAR data as a watermarked change feed built for scheduled runs and AI agents. Clean JSON with form type, dates and direct document links.

- **URL**: https://apify.com/oneshotventure/sec-filings.md
- **Developed by:** [Nick](https://apify.com/oneshotventure) (community)
- **Categories:** Business, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 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?

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 Monitor — 10-K, 10-Q, 8-K & Form 4 Feed

Get **new SEC filings since your last run** for the public companies you care about. Watch by ticker
or CIK, narrow the feed to the forms that matter — 10-K, 10-Q, 8-K, Form 4 or any other — and
schedule it for clean downstream alerts. Official SEC EDGAR data, no scraping.

### What does this Actor do?

You give it a list of tickers or CIKs. It resolves each to a CIK against the SEC's own company index,
reads that company's official submissions record, and emits one row per filing — with the direct link
to the primary document, not just a landing page.

#### Why this instead of a scraper

This is a **change feed, not a one-shot scrape**. The hard part of a filings feed is not fetching;
it is not re-sending yesterday's filings and not missing today's. EDGAR publishes `filingDate` as a
calendar date, so a naive "newer than my last timestamp" check either re-emits everything filed on
the boundary day or drops the ones that arrive later the same day.

This Actor solves that by remembering two things per company: **the newest filing date it has seen,
and every accession number it already emitted on that date.** A later run emits filings on newer
dates, plus any previously unseen accession number on that same newest date. Multiple 8-Ks filed on
one afternoon each arrive exactly once.

It reads SEC EDGAR's official public submissions data, identifies itself as the SEC's fair-access
policy requires, and shares a limiter of at most eight requests per second across ticker resolution
and filings requests.

### Who is it for?

- **Investors and analysts** watching a portfolio or a competitor set for material events.
- **Compliance and IR teams** who need to know the moment a peer files.
- **Quant and data teams** building an event-driven pipeline off primary documents.
- **Journalists** tracking insider transactions through Form 4.
- **AI agent builders** who want a filings tool with deterministic output and a real document URL.

### Use cases

- Alert on every new 8-K across a watchlist so material events reach Slack the day they land.
- Track insider buying and selling by filtering to `Form 4` for a set of tickers.
- Collect each quarter's 10-Q for a peer group as the filings appear, with links straight to the
  document.
- Trigger a document-summarization workflow whenever a new 10-K arrives.
- Give an agent a tool that answers "what has this company filed recently?" from EDGAR rather than
  from training data.

### What you get

One row per filing. Any value the source does not publish is `null` — the field is always present.

| Field | Type | Description |
|---|---|---|
| `cik` | string | SEC Central Index Key, zero-padded as EDGAR publishes it |
| `company` | string | Registrant name from the SEC submissions record |
| `ticker` | string | Primary ticker symbol where EDGAR lists one |
| `form` | string | Form type, e.g. `10-K`, `10-Q`, `8-K`, `4` |
| `filingDate` | string | Date the filing was submitted (`YYYY-MM-DD`) |
| `reportDate` | string | Period the filing reports on, where EDGAR publishes it |
| `accessionNumber` | string | EDGAR accession number — the unique ID for this filing |
| `primaryDocument` | string | Filename of the filing's primary document |
| `documentUrl` | string | Direct URL to the primary document in the EDGAR archives |
| `newSinceLastRun` | boolean | Whether this filing is new relative to the saved watermark |
| `retrievedAt` | string | ISO 8601 timestamp of when this row was fetched |

#### Sample output record

```json
{
  "cik": "0001318605",
  "company": "Tesla, Inc.",
  "ticker": "TSLA",
  "form": "8-K",
  "filingDate": "2026-07-22",
  "reportDate": "2026-07-22",
  "accessionNumber": "0001628280-26-049213",
  "primaryDocument": "tsla-20260722.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/0001318605/000162828026049213/tsla-20260722.htm",
  "newSinceLastRun": true,
  "retrievedAt": "2026-08-22T14:37:17.082Z"
}
```

### How to use it

#### Watch a list of companies for specific forms

Tickers and CIKs can be mixed freely in the same list.

```json
{
  "companies": ["TSLA", "0000320193"],
  "formTypes": ["8-K", "10-Q"],
  "maxResults": 100
}
```

#### Every form type

Leave `formTypes` empty to receive all forms.

```json
{
  "companies": ["MSFT", "NVDA"],
  "maxResults": 200
}
```

#### Track insider transactions

```json
{
  "companies": ["AAPL"],
  "formTypes": ["4"],
  "maxResults": 100
}
```

### Input parameters

| Input | Type | Description |
|---|---|---|
| `companies` | array | **Required.** Ticker symbols or SEC CIKs to monitor |
| `formTypes` | array | SEC forms to include, e.g. `["8-K"]`. Empty means all forms |
| `filedSince` | string | ISO 8601 start time. Overrides the watermark for this run |
| `maxResults` | integer | Maximum records per run (1–1000). Default: `100` |

### How monitoring works (first run and scheduling)

The first run establishes a baseline and returns the current window of filings. To get only-new
records on every subsequent run, **schedule this Actor as a saved Task** so runs share the same
storage — the watermark lives in the task's key-value store. A fresh unsaved run starts a fresh
baseline.

The watermark advances only after records and `RUN_SUMMARY` have been saved, so a failed upstream
request leaves it unchanged rather than silently skipping a window.

### Honest limitations

- **The watermark is keyed on the identifier string you pass.** Watching `TSLA` and then switching
  that entry to `0001318605` starts a fresh baseline for that company, because they are different
  keys. Pick one form of identifier per watchlist and keep it stable.
- **`filedSince` is strictly after.** Filings dated exactly on the `filedSince` date are excluded;
  pass the day before if you want that date included.
- **Coverage is EDGAR's recent-submissions window.** The SEC's submissions record holds a company's
  most recent filings, not its complete history. This Actor is built for monitoring what is new, not
  for backfilling a decade of archives.
- **Ticker resolution can fail.** An unknown ticker produces a structured failure in `RUN_SUMMARY`
  rather than a silent empty result. CIKs always resolve.
- **`amount`, sentiment and parsed financials are not returned.** This Actor gives you the filing
  metadata and the document URL; extracting the contents of the document is a separate job.

### Reliability

The Actor writes diagnostics to the `RUN_SUMMARY` key-value record — never into the dataset. It
identifies itself to SEC EDGAR as the fair-access policy requires and shares a limiter of at most
eight requests per second across ticker resolution and filings requests. The company-ticker index is
cached for 24 hours so repeat runs do not re-fetch it.

Every record carries `retrievedAt` and a `documentUrl` pointing at the SEC's own archive, so you can
check any row against the source yourself.

Maintained against the upstream API. If EDGAR changes its schema or an endpoint moves, report it
through the Issues tab and it gets fixed.

### Integrations

Connect this Actor to Make, Zapier, n8n, Slack, Google Sheets, Airtable or any HTTP endpoint through
Apify integrations. A scheduled run can post new 8-Ks to a channel or fire a webhook so a downstream
summarization job starts the moment a filing lands. Datasets export as JSON, CSV, Excel, XML, RSS or
HTML.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/oneshotventure~sec-filings/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["TSLA", "0000320193"], "formTypes": ["8-K", "10-Q"], "maxResults": 100}'
```

Python, JavaScript, PHP and CLI clients are documented under
[Apify API clients](https://docs.apify.com/api/client).

### Use with AI agents (MCP)

This Actor is callable from any MCP-compatible client — Claude, Cursor, VS Code or your own agent —
through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). The input schema is
fully described and every record uses one stable, flat JSON shape, so an agent can call it and read
the result without a parsing step. Because it reads the official SEC EDGAR API rather than a rendered
page, the answer an agent gets is the same one the source publishes — and `documentUrl` gives the
agent a primary document to fetch and read.

### Frequently asked questions

#### Is there a free SEC EDGAR API?

Yes — the SEC publishes company submissions as open JSON, with no key, subject to a fair-access rate
limit and a requirement that clients identify themselves. This Actor is the scheduling, watchlist and
change-feed layer on top of it.

#### How do I get alerts when a company files an 8-K?

Set `companies` to your tickers, `formTypes` to `["8-K"]`, save the Actor as a Task, and schedule it.
Connect the Task to Slack or a webhook through Apify integrations.

#### How do I track insider trading with Form 4 filings?

Set `formTypes` to `["4"]`. Each row gives you the filing date, accession number and a direct
`documentUrl` to the Form 4 itself. Parsing the transaction details out of that document is a
separate step this Actor does not perform.

#### Can I monitor a whole watchlist of tickers in one run?

Yes. `companies` takes as many tickers or CIKs as you need, and the watermark is tracked per company
so one noisy filer does not crowd out the others.

#### Can I use a CIK instead of a ticker?

Yes, and CIKs are more reliable — they never change and never fail to resolve. Tickers are resolved
against the SEC's own company-ticker index.

#### How current is EDGAR data?

The Actor reads EDGAR live at run time, so results are as current as the SEC's own submissions
record. Schedule it hourly or daily depending on how quickly you need to know.

#### Why did my first run return so many filings?

The first run has no watermark, so it establishes a baseline over the current window. Save it as a
Task and schedule it; later runs return only what is new.

### Related actors

- [Business Entity Search API](https://apify.com/oneshotventure/entity-search) — resolve a company
  name to its official SEC, UK or Australian registry identifier.
- [CourtListener RECAP Docket Watch](https://apify.com/oneshotventure/recap-watch) — new federal
  litigation and bankruptcy filings by party name.
- [Federal Register Monitor](https://apify.com/oneshotventure/fedreg-watch) — new rules and proposed
  rules from the SEC and other agencies.

### Disclaimer

Unofficial independent tool. Not affiliated with or endorsed by the U.S. Securities and Exchange
Commission. Data is retrieved from SEC EDGAR's official public API.

# Actor input Schema

## `companies` (type: `array`):

Ticker symbols or SEC CIKs to monitor.

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

SEC forms to include, e.g. \["8-K"]. Empty = all forms.

## `filedSince` (type: `string`):

ISO-8601 start time. Defaults to the previous successful run watermark.

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

Maximum records per run (1-1000).

## Actor input object example

```json
{
  "companies": [
    "TSLA"
  ],
  "formTypes": [
    "8-K"
  ],
  "maxResults": 10
}
```

# Actor output Schema

## `records` (type: `string`):

New SEC filing records in the default dataset.

## `runSummary` (type: `string`):

Run diagnostics stored as RUN\_SUMMARY in the key-value store.

# 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 = {
    "companies": [
        "TSLA"
    ],
    "formTypes": [
        "8-K"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("oneshotventure/sec-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 = {
    "companies": ["TSLA"],
    "formTypes": ["8-K"],
    "maxResults": 10,
}

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

```

## MCP server setup

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