# SEC 8-K Corporate Change Signals (`afkdigital/sec-8k-corporate-change-signals`) Actor

Extract evidence-backed corporate change sections from official SEC 8-K and 8-K/A filings. Filter companies, dates and item numbers; preserve source text, distinguish amendments, and deduplicate sections before billing. $12 per 1,000 unique event sections.

- **URL**: https://apify.com/afkdigital/sec-8k-corporate-change-signals.md
- **Developed by:** [AFK Digital](https://apify.com/afkdigital) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$12.00 / 1,000 unique event sections

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 8-K Corporate Change Signals

Extract evidence-backed corporate event sections from official SEC EDGAR **8-K and 8-K/A** filings. Search company CIKs or tickers, filter filing dates and item numbers, and export one JSON/CSV row per supported item section. No SEC API key or paid LLM is required.

Use it for corporate monitoring, research queues and source-linked CRM workflows. Classifications describe the filed item, not a prediction of buying intent. This is neither investment advice nor a comprehensive legal/compliance service.

### Quick start

```json
{
  "cikList": ["0000320193"],
  "filingDateFrom": "2026-08-01",
  "filingDateTo": "2026-11-05",
  "maxResults": 10
}
```

Without company inputs, Apple is used. Without dates, the window is the last 90 calendar days through today (UTC). The default example is bounded and is intended to complete within five minutes. Narrow dates and explicit CIKs reduce requests. Results are processed newest filing first.

### Inputs

| Field | Meaning |
| --- | --- |
| `cikList` | Up to 50 SEC CIK strings; leading zeros optional. |
| `tickers` | Up to 50 current SEC tickers, case insensitive. Resolution uses SEC's current ticker list, not historical symbol mapping. |
| `filingDateFrom` / `filingDateTo` | Inclusive `YYYY-MM-DD` filing dates. Omitted bounds use 90 days ago and today. These filter filing date, not report date. |
| `itemNumbers` | Optional supported item codes, such as `1.01`, `2.01`, `2.05`, `5.02`. |
| `eventTypes` | Optional exact category names in the mapping below. With itemNumbers, both filters must match. |
| `maxResults` | Maximum unique output sections, default 10, range 1–1,000. This is a ceiling, not a promise of coverage. |

Invalid dates, reversed ranges, unsupported items and invalid company identifiers fail validation. An unknown ticker is reported in the `SUMMARY` record; valid companies can still run.

### Output and evidence

Each default Dataset row includes:

- `cik`, `company_name`, `accession_number`, `form_type`
- `filing_date`, `report_date` (nullable)
- `item_number`, `event_type`, `evidence_excerpt`, `filing_url`
- `section_text` (the full normalized extracted section), `section_sha256`, `event_key`
- `is_amendment`, `original_accession_number`, `amendment_link_status`
- `metadata_source_url`, `classification_basis`

Company name and dates are taken directly from SEC submissions metadata, whose URL is retained. Company name is the current SEC entity name and may differ from the historical filing name. No person names, transaction dates or counterparties are guessed or generated. Any such details remain in the verbatim normalized section evidence. `report_date` is SEC's report-period field, not a generated date for every event in the section. `evidence_excerpt` is the first 1,200 characters; inspect `section_text` and the source filing for full context.

A filing with multiple sections produces separate rows. Item 5.02 includes director/officer changes **and compensation arrangements**, so the category does not by itself establish a departure or hire. Item 2.01 covers acquisitions **or dispositions**. Item 2.05 concerns exit/disposal costs, not proof of a specific purchase or restructuring transaction.

8-K/A rows are marked as amendments. Version 0.1 does not resolve the original accession: `original_accession_number` remains null and `amendment_link_status` is `not_resolved`. An amendment may supplement a filing, not necessarily correct an error. The Actor never guesses the relationship from a matching report date.

### Price and uniqueness

**$0.012 per successful unique event section — $12 per 1,000 sections.** The sole billing event is `apify-default-dataset-item`. There is no Actor start fee, external API/LLM fee, or separate run platform-usage surcharge. Apify's standard post-run storage/read costs may still apply outside the run.

A primary event key is `CIK:accession_number:item_number`. Within one run, duplicate companies, repeated accessions/item sections and identical normalized section content for the same CIK are suppressed before writing or charging. A section referenced by two items with identical text is billed once. A changed 8-K/A section is a distinct documented section and may be billed; an identical repeated section is suppressed. This is section-level deduplication, not semantic identification of every real-world event across differently worded filings. Separate user-initiated runs are separate purchases. When the same run resumes, already stored Dataset rows seed deduplication.

Only successful extracted sections go into the default Dataset. Missing sections, source errors and duplicates are not billable output rows. Set Apify's **maximum charge per run** alongside maxResults. The SDK respects the platform budget before writing each row. At the list price, 10 rows cost at most $0.12 in event charges. No results means no event charge.

### Coverage, limits and diagnostics

The Actor reads recent SEC company submissions and date-overlapping historical submission files, then primary filing HTML. Bare item numbers without a recognizable title are conservatively skipped. It supports explicit single-item headings in text paragraphs and table rows, including inline XBRL HTML. Exhibits are not recursively parsed, and unnumbered, combined, unusual or PDF-only sections may be skipped. Incorporation-by-reference text is preserved rather than replaced by invented details. Item metadata alone never creates an event row.

Limits per run: 100 filing documents scanned, 20 historical submission files per company, 20 MB decoded response, three HTTP attempts and a 180-second source-request budget. Apify's default run timeout is 240 seconds and memory is 256 MB (allowed 256–512 MB). A maximum-result, scan, time or budget limit can produce partial coverage. This is not a whole-market firehose. Use smaller company/date batches for larger histories.

Read the **SUMMARY** key-value record for source errors, skipped filings, duplicate count, scanned count, elapsed time and `coverage_status`. Empty results are not proof that no corporate event occurred. If all sources fail, the run fails instead of claiming successful coverage. A forbidden response stops access immediately; the Actor does not rotate proxies or evade SEC controls. A failed or aborted run can retain already delivered, billable successful rows.

### SEC access and official references

Verified on 2026-11-05:

- [SEC fair access and archive structure](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data): declared company/contact User-Agent and maximum 10 requests/second across a user/application.
- [SEC submissions API](https://www.sec.gov/search-filings/edgar-application-programming-interfaces): `data.sec.gov/submissions/CIK##########.json`, recent columnar arrays plus historical files.
- [Official Form 8-K and item instructions](https://www.sec.gov/files/form8-k.pdf).
- [SEC content reuse FAQ](https://www.sec.gov/about/webmaster-frequently-asked-questions).
- [Apify pay-per-event documentation](https://docs.apify.com/actors/monetize/pay-per-event).

Requests identify `AFK Data Team SEC8KSignals/0.1 afkinform@gmail.com`. This Actor requests serially at no more than 1 request/second, uses bounded retries and honors Retry-After. SEC can still restrict access. Coordinate parallel runs and other SEC applications so your aggregate traffic stays within SEC policy; this Actor does not control other runs or applications sharing an IP.

### Supported item categories

| Item | event_type |
| --- | --- |
| 1.01 | `material_agreement` |
| 1.02 | `agreement_termination` |
| 1.03 | `bankruptcy_receivership` |
| 1.04 | `mine_safety` |
| 1.05 | `cybersecurity_incident` |
| 2.01 | `acquisition_or_disposition` |
| 2.02 | `financial_results` |
| 2.03 | `financial_obligation` |
| 2.04 | `obligation_trigger` |
| 2.05 | `exit_or_disposal_costs` |
| 2.06 | `material_impairment` |
| 3.01 | `listing_notice` |
| 3.02 | `unregistered_equity_sale` |
| 3.03 | `security_holder_rights` |
| 4.01 | `auditor_change` |
| 4.02 | `financial_statement_nonreliance` |
| 5.01 | `control_change` |
| 5.02 | `executive_director_or_compensation` |
| 5.03 | `charter_bylaws_or_fiscal_year` |
| 5.04 | `benefit_plan_trading_suspension` |
| 5.05 | `ethics_code_change` |
| 5.06 | `shell_status_change` |
| 5.07 | `shareholder_vote` |
| 5.08 | `shareholder_director_nomination` |
| 6.01 | `abs_material` |
| 6.02 | `abs_servicer_trustee_change` |
| 6.03 | `abs_credit_support_change` |
| 6.04 | `abs_distribution_failure` |
| 6.05 | `abs_securities_act_update` |
| 7.01 | `regulation_fd` |
| 8.01 | `other_event` |
| 9.01 | `financial_statements_exhibits` |

Version 0.1.0. Local verification: `python -m unittest discover -s tests`. Real SEC fixtures and run evidence are kept with the project, excluded from the production image.

# Actor input Schema

## `cikList` (type: `array`):

SEC CIK strings, 1–10 digits. Duplicate companies are resolved once.

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

Current SEC ticker lookup. Unknown tickers are reported in SUMMARY.

## `itemNumbers` (type: `array`):

Optional official item filter, e.g. 1.01, 2.01, 2.05, 5.02. Intersects eventTypes.

## `eventTypes` (type: `array`):

Optional item-based categories. Intersects itemNumbers. See README for full mapping.

## `filingDateFrom` (type: `string`):

Inclusive YYYY-MM-DD filing date. Omit for 90 days ago.

## `filingDateTo` (type: `string`):

Inclusive YYYY-MM-DD filing date. Omit for today (UTC).

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

Successful unique sections per run. Maximum 1,000; 100 filing and 180 second limits may return fewer. $0.012 per output row.

## Actor input object example

```json
{
  "cikList": [
    "0000320193"
  ],
  "tickers": [],
  "itemNumbers": [],
  "eventTypes": [],
  "maxResults": 10
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "cikList": [
        "0000320193"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("afkdigital/sec-8k-corporate-change-signals").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 = {
    "cikList": ["0000320193"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("afkdigital/sec-8k-corporate-change-signals").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 '{
  "cikList": [
    "0000320193"
  ],
  "maxResults": 10
}' |
apify call afkdigital/sec-8k-corporate-change-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,afkdigital/sec-8k-corporate-change-signals"
        }
    }
}
```

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/L4SvJdZQ18uNMZ7i7/builds/k9avcow7LXEeOjOqS/openapi.json