# SEC Filing Monitor (`arched_friend/sec-filing-monitor`) Actor

Track new SEC filings for any list of companies. 8-K, 10-K, 10-Q, insider Form 4 and more, by ticker or CIK, with every event item spelled out in plain language and a direct link to the document.

- **URL**: https://apify.com/arched\_friend/sec-filing-monitor.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 filing returneds

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 Filing Monitor: Know What A Company Filed, The Day It Files It

**Track every SEC filing for the companies you care about — by ticker, CIK or name — with the event spelled out in plain English and a direct link to the document.**

An 8-K lands and the raw feed tells you `2.02,9.01`. That is a company reporting results, plus exhibits. Nobody should have to memorise the item table to know that.

This Actor reads EDGAR directly, resolves whatever you paste into the right company, and gives you one row per filing with the form named, the items translated, the exact acceptance timestamp, and a link straight to the filing.

Built for investors watching a portfolio, analysts covering a sector, compliance teams tracking their own filings, and anyone who needs to know about a material event before it reaches the news.

### How it works

```mermaid
flowchart LR
    A[Your list of companies] --> B{What did they type?}
    B -->|AAPL| C[Ticker lookup]
    B -->|320193| D[Use the CIK directly]
    B -->|Apple Inc.| E[Name lookup]
    C --> F[CIK]
    D --> F
    E --> F
    F --> G[EDGAR submissions API]
    G --> H[Read the parallel arrays<br/>into one row per filing]
    H --> I{Form and date filters}
    I --> J[Translate 8-K item codes<br/>into plain language]
    J --> K[(One row per filing,<br/>newest first)]
```

Everything comes from the JSON endpoints the SEC publishes itself. No scraping, no API key, no quota. A short one-word name like Tesla or Nvidia looks exactly like a ticker, so when the ticker lookup misses, the name lookup runs before giving up.

### What you get

One row per filing:

```json
{
  "cik": "0000320193",
  "name": "Apple Inc.",
  "ticker": "AAPL",
  "exchange": "Nasdaq",
  "industry": "Electronic Computers",
  "form": "8-K/A",
  "formDescription": "Material event",
  "filingDate": "2026-09-01",
  "reportDate": "2026-08-28",
  "acceptedAt": "2026-09-01T16:31:04.000Z",
  "accessionNumber": "0001140361-26-035325",
  "items": [
    { "code": "5.02", "label": "Departure or appointment of directors and officers" }
  ],
  "itemSummary": "Departure or appointment of directors and officers",
  "indexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/0001140361-26-035325-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126035325/ef20081427_8ka.htm",
  "isXbrl": false
}
```

Plus a `RUN_SUMMARY` record with counts per form and per company, the newest filings, the material 8-K events, and any company that could not be resolved.

### Watching for one kind of event

Set `forms` to narrow it down. Watching `8-K` also returns `8-K/A`, so an amended earnings release still reaches you.

| You want | Set `forms` to | Why |
|---|---|---|
| Material events as they happen | `8-K` | Results, executive changes, acquisitions, cyber incidents |
| Insider buying and selling | `4` | Every officer and director transaction |
| Quarterly and annual numbers | `10-Q`, `10-K` | The full financial picture |
| Someone building a stake | `SC 13D`, `SC 13G` | Anyone crossing 5% ownership |
| An IPO in progress | `S-1` | Registration and its amendments |

### Running it on a schedule

Turn on `onlyNewFilings` and every run returns only what EDGAR has accepted since the last one. Point it at a daily schedule with `days` set to 2 and you get a clean feed with no repeats.

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~sec-filing-monitor/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies":["AAPL","NVDA","TSLA"],"forms":["8-K"],"days":2,"onlyNewFilings":true}'
```

### Pricing

Pay per filing returned. A run that finds nothing costs nothing.

| | This Actor | Typical filing API | Terminal subscription |
|---|---|---|---|
| Price | $0.004 per filing | $50–$300 / month | $2,000+ / month |
| Minimum | None, pay per run | Monthly commitment | Annual contract |
| Free runs | Yes, a run with no new filings is free | No | No |
| Setup | Paste tickers | API key, docs, integration | Sales call |

### Related products

- **Brand Mention Monitor** — track news coverage of the same companies
- **Hacker News Brand Monitor** — what engineers are saying about them
- **Competitor Content Tracker** — what they publish on their own blogs

### Notes

The SEC asks callers to identify themselves with a contact address, and limits everyone to a published fair-access rate. This Actor throttles itself below that limit and sends a contact string on every request. On heavy runs you can supply your own in `userAgent`.

EDGAR's `submissions` endpoint holds roughly the last year of filings inline. Older history lives in separate archive files, so a very long `days` window returns what the recent file covers.

# Actor input Schema

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

Tickers, CIK numbers or company names, one per line. AAPL, 320193 and Apple Inc. all reach the same company, so paste whichever form you already have.

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

Only return these forms, for example 8-K, 10-K, 10-Q or 4. Leave empty for every filing. Watching 8-K also returns 8-K/A, so amendments are never missed.

## `days` (type: `integer`):

How far back to look. Set this to match your schedule, so a daily run looks back one or two days.

## `maxFilingsPerCompany` (type: `integer`):

Cap on how many recent filings to read per company before the date and form filters are applied. Raise it for companies that file constantly.

## `onlyNewFilings` (type: `boolean`):

Report each filing once and never again, so a scheduled run returns only what EDGAR has accepted since the last run. Leave off for a full snapshot every time.

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

The SEC asks every caller to identify itself with a contact address. Optional, but supplying your own is the polite choice on heavy runs.

## `timeoutSeconds` (type: `integer`):

How long to wait for a single EDGAR response before retrying it.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "forms": [
    "8-K"
  ],
  "days": 30,
  "maxFilingsPerCompany": 50,
  "onlyNewFilings": false,
  "timeoutSeconds": 20
}
```

# Actor output Schema

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

One row per filing, newest first, with the form, the plain language event items, the filing and report dates and a direct link to the document on EDGAR.

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

Filing counts per form and per company, the newest filings across the run, the material 8-K events, and any company that could not be resolved.

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

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/sec-filing-monitor").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": [
        "AAPL",
        "NVDA",
    ],
    "forms": ["8-K"],
}

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/sec-filing-monitor").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": [
    "AAPL",
    "NVDA"
  ],
  "forms": [
    "8-K"
  ]
}' |
apify call arched_friend/sec-filing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/sec-filing-monitor"
        }
    }
}
```

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/MNrhiqqRxWdIGJDgo/builds/EDaC3sXWGxHp5cbLA/openapi.json