# SEC Event Intelligence (`gtm_solutions/sec-event-intelligence`) Actor

Extract material business events from SEC filings for the companies you track. Every event is classified by 8-K item, quotes the filing's own words, and links to the primary document on sec.gov. Built for account research, sales prep, and signal feeds.

- **URL**: https://apify.com/gtm\_solutions/sec-event-intelligence.md
- **Developed by:** [Clance Hoskin](https://apify.com/gtm_solutions) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 cited sec events

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 Event Intelligence

**Evidence-linked business events from SEC filings — classified, quoted, and cited — for the companies you track.**

Every result is one material event from a company's 8-K (or periodic) filing: what happened, which SEC item it was filed under, the exact section of the filing that says so, and a link to the primary document on sec.gov. No scraping, no summarisation, no speculation. The evidence is the SEC's own words.

![SEC Event Intelligence — filings in, cited events out](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-event-intelligence-cover.png)

### Who it's for

- **Sales and account-research teams** who need to know what changed at an account before the next call — a new CFO, an acquisition, a restructuring charge, a cybersecurity incident.
- **Investment-research teams** who want a clean, structured feed of material events instead of reading every filing.
- **Data and RevOps teams** building account-signal pipelines who need a source they can cite, not a summary they have to trust.

If you have ever opened EDGAR, searched a company, opened five 8-Ks, and skimmed each one for the item that mattered — this Actor does that step for you, for any company you ask about, and keeps the answer current.

### What you get

One dataset item per event. Every field is populated from the filing itself; the `evidence` excerpt is the text of the specific item section, and `primaryDocumentUrl` opens the filing on sec.gov.

| Field | What it holds |
|---|---|
| `eventId` | Stable identifier: CIK, accession number, category, item — safe to de-duplicate on |
| `companyName`, `ticker`, `cik` | The registrant as SEC names it |
| `form`, `filedAt`, `acceptedAt` | Form type and the SEC filing and acceptance timestamps |
| `eventTypes` | One or more of the 11 categories below |
| `items` | The 8-K item numbers that triggered the event (e.g. `2.02`) |
| `headline` | A fixed, category-level headline — never generated text |
| `accessionNumber`, `filingUrl`, `primaryDocumentUrl` | Where to verify it, on sec.gov |
| `evidence[]` | The quoted item section (`text`), its `locator`, and its `sourceUrl` |
| `retrievedAt`, `classifierVersion` | When the evidence was captured and which classifier produced the category, so results are reproducible |

#### Sample item

```json
{
  "eventId": "0000320193:000032019326000018:financial-update:2.02",
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "form": "8-K",
  "filedAt": "2026-07-30",
  "acceptedAt": "2026-07-30T20:30:28+00:00",
  "eventTypes": ["financial-update"],
  "items": ["2.02"],
  "headline": "Financial update",
  "accessionNumber": "0000320193-26-000018",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "evidence": [
    {
      "text": "Item 2.02 Results of Operations and Financial Condition. On July 30, 2026, Apple Inc. (“Apple”) issued a press release regarding Apple’s financial results for its third fiscal quarter ended June 27, 2026. A copy of Apple’s press release is attached hereto as Exhibit 99.1. …",
      "locator": "item-2.02",
      "sourceUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm"
    }
  ],
  "retrievedAt": "2026-07-30T20:30:28+00:00",
  "classifierVersion": "sec-classifier-v2"
}
```

![Sample event card](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-event-intelligence-sample.png)

#### Freshness

Alongside the dataset, the run's `OUTPUT` record carries a `freshness` object reporting what the cache did for each company this run:

```
{
  source: 'cache' | 'mixed',
  stale,
  lastSuccessfulRefresh?,
  companies: [{ cik, outcome: fresh | refreshed | first_fetch | stale_served | unavailable, lastCheckedAt, detail? }]
}
```

| Field | Notes |
|---|---|
| `source` | `cache` if every requested company was already fresh; `mixed` if at least one was refreshed, first fetched, or could not be refreshed this run. |
| `stale` | `true` if any company fell back to a cached answer, or came back empty because it could not be fetched, or a first fetch stopped at the filing cap before reaching the newest filings (`companies[].detail` says so). |
| `lastSuccessfulRefresh` | The most recent refresh timestamp among the companies checked this run, when there was one. |
| `companies[]` | Per requested company: `cik`, `outcome`, `lastCheckedAt`, and an optional `detail` explaining a `stale_served` or `unavailable` outcome. |

### Event categories

Every current Form 8-K item maps to exactly one category, so nothing material is silently dropped. Periodic filings (10-K, 10-Q, 20-F, 6-K) are classified as `periodic-filing`.

| Category | 8-K items | What it usually means |
|---|---|---|
| `financial-update` | 2.02, 2.03, 2.04, 4.01, 4.02 | Results announced, new debt or obligations, auditor change, restatement |
| `executive-change` | 5.01, 5.02 | Directors or officers appointed, departed, or changed compensation; change of control |
| `material-agreement` | 1.01, 1.02 | A material contract signed or terminated |
| `acquisition-disposition` | 2.01 | An acquisition or disposal of assets completed |
| `impairment-restructuring` | 1.03, 2.05, 2.06 | Restructuring costs, impairments, bankruptcy |
| `cybersecurity` | 1.05 | A material cybersecurity incident |
| `listing-compliance` | 3.01 | Delisting notice or listing-standard failure |
| `regulation-fd` | 7.01 | Regulation FD disclosure |
| `other-8k` | 1.04, 3.02, 3.03, 5.03–5.08, 6.xx, 8.01 | Governance housekeeping, securities changes, "other events" |
| `periodic-filing` | — | Annual and quarterly reports |
| `insider-transaction` | — | Reserved for Form 4 coverage |

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-event-intelligence-how-it-works.png)

1. **A run checks SEC for each company you ask about.** The first request for a company fetches its 8-Ks from the last 12 months (up to 60 filings) and takes longer; after that a company is refreshed on request when its last check is older than a day, and served from the cache otherwise. One refresh at a time per company, at most 25 companies refreshed per run, the longest-unchecked first.
2. **A deterministic classifier** maps the filing's items to categories and quotes the item section — from its heading to the next heading, cross-references excluded.
3. **Events are stored in a cache** with the filing date, accession number, and a content-addressed copy of the source.
4. **A run serves the cache and refreshes what is out of date.** Companies checked within the last day come straight from the cache; the others are refreshed from SEC first, inside your run, one company at a time and inside SEC's request limits — and every result carries `freshness` metadata saying which happened for each company.

The Actor identifies itself to SEC with a descriptive User-Agent and stays inside SEC's published request limits. Nothing is scraped from HTML search pages; everything comes from SEC's documented submissions JSON and archive URLs.

### Input

```json
{
  "companies": [{ "cik": "0000320193", "ticker": "AAPL" }],
  "forms": ["8-K"],
  "startDate": "2025-01-01",
  "endDate": "2026-09-12",
  "eventCategories": ["financial-update", "executive-change"],
  "includeExcerpts": true,
  "latestOnly": false,
  "maxEventsPerCompany": 100,
  "maxTotalEvents": 500
}
```

| Field | Notes |
|---|---|
| `companies` | One or more SEC CIKs (1–10 digits; normalised to ten). Ticker and legal name are display hints. Find a CIK with SEC's [company search](https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany). |
| `forms` | Optional. Default is every form in the cache; `["8-K"]` for current reports only. |
| `startDate`, `endDate` | Optional inclusive `YYYY-MM-DD` bounds on the filing date. |
| `eventCategories` | Optional filter from the table above. |
| `includeExcerpts` | Attach the quoted item section to each event (default `true`). |
| `latestOnly` | Return only the newest event per company — for "what changed?" checks. |
| `maxEventsPerCompany`, `maxTotalEvents` | Caps; the run summary reports `truncated: true` if a cap was hit. |

#### Three ways people use it

- **Account list, on your schedule.** Schedule the Actor with your account list and `latestOnly: true`; each run refreshes what is older than a day — up to 25 companies, the longest-unchecked first, so a bigger list converges over a few runs.
- **Pre-call prep.** One company, `startDate` a year back, all categories — read the `headline` column and click through the `primaryDocumentUrl`s that matter.
- **Signal feed.** `eventCategories: ["executive-change", "acquisition-disposition", "impairment-restructuring"]` across your whole territory, exported by API into a CRM field.

### Pricing

Pay per event: **US$0.008 per event returned** (`event`). A run that returns nothing costs nothing beyond Apify's minimal compute.

If the run reaches the spend limit you set when starting it, the dataset holds only the events you were charged for, and the run summary reports `charging.limitReached: true` with the counts.

| Use | Events | Cost |
|---|---|---|
| Pre-call prep on one company, one year | ~10 | ~$0.08 |
| Scheduled `latestOnly` check on 25 accounts | ≤25 | ≤$0.20 |
| Two-year history for a 20-company territory | ~450 | ~$3.60 |

### Limits — please read

- **Coverage is any US filer with 8-Ks on EDGAR.** The first request for a company fetches its last 12 months (up to 60 filings) and takes longer; after that a company is refreshed on request when its last check is older than a day, and served from the cache otherwise.
- **At most 25 companies are refreshed per run**, never-checked and longest-unchecked first; the rest are served from the cache as `stale_served` with `detail: 'per-run refresh cap reached'`. Split a larger list across runs or let a schedule work through it.
- **If SEC is unavailable during a run you get the cached events** with `freshness.stale = true` and the reason per company in `freshness.companies`. A company that has never been fetched and cannot be fetched returns no events and is named in `summary.emptyReason`.
- **8-K items are the unit.** A filing with three items yields one event with three items and the categories they map to; the quoted excerpt is the first classified item's section.
- **Excerpts are item sections, not whole filings.** Use `primaryDocumentUrl` for the full document and exhibits.
- **No interpretation.** Headlines are fixed category labels; nothing in the output is generated text or a prediction.
- **History depth** is 12 months from the first request; deeper history is added by the operator's backfill.

### Compared with doing it by hand

| | EDGAR by hand | Generic "SEC scraper" | SEC Event Intelligence |
|---|---|---|---|
| Time to find what changed at 20 accounts | hours | minutes, then reading | one run, read the `headline` column |
| Source access | manual | HTML scraping, brittle | SEC's documented JSON + archive, rate-limited, identified |
| Evidence | you find it | usually none | quoted item section + `primaryDocumentUrl` on every event |
| Reproducible | no | no | `eventId`, `retrievedAt`, `classifierVersion` on every event |

### FAQ

**Does it read the exhibits (the press release itself)?** No — it quotes the 8-K item section and links the primary document. Exhibits are one click away on sec.gov.

**Can I get any company?** Any US filer with 8-Ks. Give its CIK (ticker and name optional). The first run for it takes longer.

**Is anything generated by an AI?** No. This Actor is deterministic. If you want a written brief with cited sentences, see the companion Actor, **SEC Account Briefs**, which builds on this data.

**How current is "current"?** At most a day old when served from the cache; `freshness.companies[]` says when each company was last checked and whether this run refreshed it.

**What about Form 4 insider transactions?** The `insider-transaction` category is reserved; Form 4 coverage is not part of this version.

### Support

Issues and coverage requests: use the Actor's **Issues** tab. Include the CIK and, for a wrong classification, the accession number — every event carries both.

### Changelog

- **0.1** — Private build. Every current Form 8-K item classified; item-section excerpts; 21-company pilot, cache filled on demand.

# Actor input Schema

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

One or more SEC CIKs. CIKs may be 1–10 digits and are normalized to ten digits.

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

Optional SEC forms such as 8-K, 10-K, or 10-Q.

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

Inclusive YYYY-MM-DD date.

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

Inclusive YYYY-MM-DD date.

## `eventCategories` (type: `array`):

Optional event categories to keep. Leave empty for all categories.

## `includeExcerpts` (type: `boolean`):

Attach the quoted item section of the filing as evidence on each event.

## `latestOnly` (type: `boolean`):

Return only the most recent event for each company.

## `maxEventsPerCompany` (type: `integer`):

Cap on events returned per company (1–1000).

## `maxTotalEvents` (type: `integer`):

Cap on events returned in the whole run (1–5000).

## Actor input object example

```json
{
  "companies": [
    {
      "cik": "0000320193",
      "ticker": "AAPL"
    }
  ],
  "includeExcerpts": true,
  "latestOnly": false,
  "maxEventsPerCompany": 100,
  "maxTotalEvents": 500
}
```

# Actor output Schema

## `events` (type: `string`):

The events, one item each: eventId, company, form, filedAt, eventTypes, items, headline, filingUrl, primaryDocumentUrl, evidence.

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

Companies resolved, filings processed, events emitted, the charging block and the cache freshness.

# 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": [
        {
            "cik": "0000320193",
            "ticker": "AAPL"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gtm_solutions/sec-event-intelligence").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": [{
            "cik": "0000320193",
            "ticker": "AAPL",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("gtm_solutions/sec-event-intelligence").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": [
    {
      "cik": "0000320193",
      "ticker": "AAPL"
    }
  ]
}' |
apify call gtm_solutions/sec-event-intelligence --silent --output-dataset

```

## MCP server setup

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

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/HPwpluWTJr9YW28Du/builds/WMKhIDgcrGBPozy2q/openapi.json