# SEC 8-K Filings Scraper & Material Event Alerts (`openwell-data/sec-8k-event-monitor`) Actor

Alerts on SEC 8-K filings, classified by item: cyber incidents, auditor changes, bankruptcy, M\&A, delisting, executive changes and more. Official EDGAR data, no API key.

- **URL**: https://apify.com/openwell-data/sec-8k-event-monitor.md
- **Developed by:** [Openwell Data](https://apify.com/openwell-data) (community)
- **Categories:** Business, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 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?

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

Turn SEC EDGAR 8-K "current reports" into a clean, classified alert feed. **8-Ks are how public companies disclose material events**: cybersecurity incidents, auditor changes, bankruptcy, acquisitions, delisting notices, restatements, leadership changes and more. This Actor reads the official SEC EDGAR data, tags every filing by 8-K item and event category, rates how often that kind of event matters, and delivers only the filings you ask for.

Use it as an **SEC 8-K API and EDGAR 8-K alert feed**: search 8-K filings by ticker, CIK, item number and event type, and get JSON, CSV or Excel out.

**No API key and no SEC account needed.** It uses only official SEC endpoints (EDGAR daily indexes, the latest-filings feed and the data.sec.gov submissions API), a declared User-Agent, and a slow, polite request rate that stays far below the SEC fair-access limit.

### Who uses 8-K material event alerts

- Investors, analysts and researchers who want alerts on specific events (for example Item 4.02 "non-reliance on previously issued financials").
- Risk, procurement and vendor-management teams watching suppliers, customers or counterparties for distress (bankruptcy, auditor resignation, delisting notice, cyber incident).
- Journalists, compliance teams and data engineers who want structured 8-K events in JSON, CSV or Excel, on a schedule.

### What you get: SEC 8-K filings as structured data

One dataset row per 8-K (or 8-K/A) filing that matches your filters, for example:

```json
{
  "accessionNumber": "0001104659-26-111403",
  "companyName": "Example Corp",
  "tickers": ["EXPL"],
  "form": "8-K",
  "filedDate": "2026-09-28",
  "signal": "high",
  "itemCodes": ["4.01", "9.01"],
  "categories": ["audit", "exhibits"],
  "items": [{ "code": "4.01", "label": "Change in certifying accountant (auditor)", "category": "audit", "signal": "high" }],
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/.../...-index.htm"
}
```

Also included: CIK, acceptance time, report date, SIC code, state of incorporation, business city and state, and the link to the primary 8-K document. See `docs/sample_output.json` for real output.

### How to monitor SEC 8-K filings by company, item code or event

1. **Watch specific companies:** enter tickers or CIKs in **Companies to watch** (up to 50). The Actor checks each company's official filing history, up to 90 days back.
2. **Or scan the whole market:** leave companies empty. The Actor covers today's latest filings and the last few business days (up to 10).
3. Narrow it down with **8-K item codes** (such as `1.05`, `4.02`, `4.01`, `1.03`, `3.01`), **event categories**, or a **minimum signal** (`routine`, `medium`, `high`).
4. Set **Maximum filings**. This is your cost cap: newest filings first, and you pay per delivered filing.
5. For a scheduled alert feed, give the run a **watchlist name** and tick **Only new filings**. The Actor remembers what it already delivered under that name in your own account.
6. Send results anywhere with Apify integrations, webhooks, Zapier, Make or the API (see "Use with AI agents and the API" below).

### Track specific 8-K items: cybersecurity incidents, auditor changes, bankruptcy and more

Common item codes to filter on: `1.05` material cybersecurity incidents, `4.01` change of auditor, `4.02` non-reliance on previously issued financials (restatement), `1.03` bankruptcy or receivership, `3.01` delisting notice, `2.01` completed acquisition or disposal, `5.02` departure or appointment of directors and officers, `2.05` exit or restructuring costs. Combine them with a ticker watchlist for supplier and counterparty risk monitoring, or run them across the whole market for a daily "who just disclosed a cyber incident" list.

### Pricing (pay per event)

You pay only for what is delivered:

| Event | Price | When |
|---|---|---|
| Actor start | $0.0001 | Each run |
| Result delivered | $0.02 | Each filing that matched your filters and was added to your dataset |

**What $0.02 buys:** one classified 8-K filing: company, ticker, CIK, filing and acceptance dates, every item code with a plain-English label and category, a signal rating, SIC and location, and direct links to the filing on sec.gov. Nothing else is billed for the filing, and there are no subscription or seat fees.

Examples: a daily watchlist that finds 3 new matching filings costs about $0.0601 ($0.0001 + 3 x $0.02). A one-off pull of 100 filings costs $2.0001. Filings that do not match are free, and **Maximum filings** plus the run's maximum-cost setting stop spending at your limit.

### Use with AI agents and the API

Every run is a plain Apify Actor, so anything that can call the Apify API can use it.

- **REST API.** Start a run and get the results in one call (replace `YOUR_TOKEN` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/sec-8k-event-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies":["AAPL","MSFT"],"daysBack":30,"itemCodes":["1.05","4.02"],"maxFilings":20}'
```

(Use the Actor's full `username~actor-name` ID from its API tab if the short name does not resolve.) The same input works with the Apify JavaScript and Python clients.

- **MCP (Model Context Protocol).** Apify's MCP server (`https://mcp.apify.com`) exposes any Store Actor as a tool, so Claude, Cursor and other MCP clients can ask "did any of my watchlist companies file a cybersecurity 8-K this week?" in plain language. Add this Actor to the server's tool list (for example with the `actors` URL parameter, `https://mcp.apify.com?actors=USERNAME/sec-8k-event-monitor`) and give the agent your Apify token. **Maximum filings** keeps an agent's spend bounded.
- **Scheduled runs and webhooks.** Create a Schedule in Apify Console (for example every weekday evening), set a webhook on the run's success event, and post the dataset to Slack, email or your database. With a watchlist name and **Only new filings**, each run returns just what was not delivered before.
- **Spending control.** Set the run's maximum cost in the run options and **Maximum filings** in the input; the Actor stops at whichever limit comes first.

### Frequently asked questions

**Do I need an SEC account or API key?** No. The Actor uses official public EDGAR endpoints with a declared User-Agent and a polite request rate.

**Can I get alerts when a specific company files an 8-K?** Yes. Put tickers or CIKs in **Companies to watch**, name the watchlist, tick **Only new filings** and put the Actor on a Schedule.

**How do I find cybersecurity incident disclosures?** Filter on item code `1.05`. For restatements use `4.02`, for auditor changes `4.01`, for bankruptcy `1.03`, for delisting notices `3.01`.

**How fresh is the data?** Watchlist mode reads each company's filing history, which the SEC updates as filings are accepted. Market scans use the latest-filings feed for today plus the SEC daily indexes for earlier days. It is not a real-time tick feed.

**Does it read the text of the filing?** No. It reports which items a filing contains and links to the filing. That keeps it fast and avoids repeating text from filings.

**Are officer, director or shareholder names included?** No. The output is company-level only.

**Does it include 8-K/A amendments?** Not by default; switch on **Include 8-K/A amendments** to get them.

**How much does it cost?** $0.0001 per run plus $0.02 per delivered filing. You control the maximum with **Maximum filings** and the run's maximum cost.

**Can I export to CSV or Excel?** Yes. Any Apify dataset can be downloaded as JSON, CSV, Excel, XML or HTML from the Output tab or the API.

**Is the signal rating investment advice?** No. It is the tool's own heuristic for how often an item marks an event people act on.

### How the classification works

Each 8-K lists the "items" it reports under (for example Item 1.05 for a material cybersecurity incident). The Actor maps every item to a plain-English label and an event category. The **signal** rating is the tool's own heuristic for how often an item marks an event people act on. It is not an SEC field and not investment advice. Items the Actor does not recognise are still delivered, labelled as other.

### Important limitations (please read)

- **Item level only.** The Actor reports which items a filing contains, not what the filing says. Follow `filingIndexUrl` to read the filing itself on sec.gov.
- **Market scans are paced on purpose.** Each filing needs one small request, sent at most four times per second, so scanning one full business day of filings takes about a minute. Use item filters and a sensible **Maximum filings** to keep runs short.
- **Today's filings** come from the SEC's latest-filings feed, which lists the most recent 100 filings only. On very busy days earlier filings drop out of it; the SEC daily index completes the picture the next day.
- **Weekends and holidays** have no filings and no daily index.
- **Company details.** `tickers` come from the SEC's official company\_tickers.json (one request per run), so companies without a listed ticker have an empty list. SIC, state, location and the `documentUrl` link come from the SEC's submissions data, at most one extra request per company that appears in your results (market scans) or one per watched company. They are blank only when the SEC has no value (for example funds and trusts with no SIC code) or when a filing is too old to appear in a company's recent filings.
- Not real time. Use watchlist mode for the quickest updates on companies you care about.
- Convenience feed, not legal, tax or investment advice. Always confirm details on sec.gov.

### Data source and attribution

Data: public filings on SEC EDGAR (sec.gov), accessed through official EDGAR endpoints in line with the SEC's fair-access guidance. This Actor is an independent tool and is **not affiliated with, endorsed by or operated by the U.S. Securities and Exchange Commission.**

### Privacy and terms

This Actor collects no personal data about individuals. It reports company-level filing facts only: it does not output names of officers, directors or shareholders, and it does not track individuals' trades or positions. It does not read the text of filings. It sends no data to third parties and uses no AI or LLM at run time. It declares itself to the SEC with a User-Agent that includes the publisher's contact address.

### Support

Issues and feature requests go through the Actor's Issues tab. Contact: claudefarmceo@gmail.com. Support is AI-assisted, on behalf of the publisher.

### Technical notes

Node.js 22, Apify SDK 3, no browser. Runs in seconds for watchlists and about a minute per business day for market scans, on 256 MB. The publisher sets the `CONTACT_EMAIL` environment variable on the Actor (used only in the SEC User-Agent). Run locally: `npm install`, set `CONTACT_EMAIL`, put your input in `storage/key_value_stores/default/INPUT.json`, then `npm start` (or `apify run`). Tests: `npm test`.

# Actor input Schema

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

Up to 50 stock tickers (for example AAPL) or SEC CIK numbers. Leave empty to scan all companies' recent 8-K filings.

## `itemCodes` (type: `array`):

Only filings that include at least one of these items, for example 1.05 (cybersecurity incident), 4.02 (non-reliance on financials), 4.01 (auditor change), 1.03 (bankruptcy), 3.01 (delisting notice), 2.01 (acquisition or disposal). Leave empty for all items.

## `categories` (type: `array`):

Alternative to item codes: deals, distress, cyber, financials, financing, securities, audit, governance, abs, disclosure, exhibits, other.

## `minSignal` (type: `string`):

This tool's own rating of how often an item marks an event people act on. 'high' = bankruptcy, cyber incident, auditor change, non-reliance, delisting, change in control, impairment, agreement termination, acceleration. 'medium' adds agreements, acquisitions, financing, restructuring, officer changes.

## `daysBack` (type: `integer`):

How far back to look. Market-wide scans allow 1 to 10; company watchlists 1 to 90.

## `maxFilings` (type: `integer`):

Your cost cap: newest filings first, you pay per delivered filing. Up to 500.

## `includeAmendments` (type: `boolean`):

Amendments to earlier 8-K filings are off by default.

## `skipExhibitsOnly` (type: `boolean`):

Skip filings whose only item is 9.01 (financial statements and exhibits).

## `includeCurrentFeed` (type: `boolean`):

Adds the most recent 100 filings from SEC's live latest-filings feed. The official daily indexes are only complete after the market day ends.

## `watchlistName` (type: `string`):

Lowercase letters, digits and dashes. With 'Only new filings' the Actor remembers delivered filings under this name.

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

Needs a watchlist name. Skips filings already delivered under that name (for scheduled runs).

## `contactEmail` (type: `string`):

On the Apify platform the publisher's CONTACT\_EMAIL environment variable is used. This field is only for running the Actor locally.

## Actor input object example

```json
{
  "minSignal": "routine",
  "daysBack": 4,
  "maxFilings": 25,
  "includeAmendments": false,
  "skipExhibitsOnly": true,
  "includeCurrentFeed": true,
  "onlyNew": false
}
```

# Actor output Schema

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

Dataset items, one per delivered result

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

Counts, source date and cost-relevant details for this run

# 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 = {
    "daysBack": 4,
    "maxFilings": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("openwell-data/sec-8k-event-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 = {
    "daysBack": 4,
    "maxFilings": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("openwell-data/sec-8k-event-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 '{
  "daysBack": 4,
  "maxFilings": 25
}' |
apify call openwell-data/sec-8k-event-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openwell-data/sec-8k-event-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/e862KW8Rogl8humWv/builds/WeNoscICqDcxonpwc/openapi.json