# SEC 8-K Filings by Ticker with Item Codes (`codecraftco/sec-8k-filings`) Actor

Current-report 8-K filings for any US ticker with parsed item codes and titles, exhibit list, direct EDGAR links, and optional plain-text extraction of the filing body.

- **URL**: https://apify.com/codecraftco/sec-8k-filings.md
- **Developed by:** [Code Craft Colorado](https://apify.com/codecraftco) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 8-k filings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Filings by Ticker with Item Codes

Get every current report (Form 8-K) a US-listed company has filed with the SEC, one row per
filing, with the item codes already parsed and paired with their official titles. Give it a
list of tickers and it returns earnings releases, executive changes, material agreements,
acquisitions, cybersecurity incidents, and every other event companies must disclose within
four business days, each with a direct link to the document on EDGAR. Filter by item code
and date range to get only the filings you care about. Turn on text extraction and each row
also carries the plain text of the filing body and a list of its exhibits, such as the
`EX-99.1` press release attached to an earnings 8-K.

The data comes from the SEC's official EDGAR endpoints over plain HTTP. There is no browser,
no proxy, no API key and no login; the actor identifies itself as the SEC's fair-access
policy requires and stays under the SEC's request-rate limit. Because it reads the SEC's own
submissions feed, a new filing appears in results within minutes of the SEC accepting it.
Amendments (Form 8-K/A) are included and marked in the `form` field.

### At a glance

Three real rows from a run for `AAPL`:

| ticker | form | filingDate | reportDate | items | exhibits |
| --- | --- | --- | --- | --- | --- |
| AAPL | 8-K/A | 2026-09-01 | 2026-04-17 | 5.02 | (none) |
| AAPL | 8-K | 2026-07-30 | 2026-07-30 | 2.02, 9.01 | EX-99.1 |
| AAPL | 8-K | 2026-04-20 | 2026-04-17 | 5.02 | (none) |

The first row is an amendment filed in September to a report about an April event, which
is why `reportDate` and `filingDate` differ. The second is a quarterly earnings release with
the press release attached as exhibit 99.1.

### What data does it extract?

Each row is one 8-K or 8-K/A filing.

**Company**

- `ticker`: the ticker you asked for, upper-cased.
- `cik`: the registrant's 10-digit SEC Central Index Key, zero-padded.
- `companyName`: the registrant name as recorded in the SEC submissions feed. Null if the
  name could not be read.

**Filing identity**

- `form`: `8-K` for an original report, `8-K/A` for an amendment.
- `accessionNumber`: the SEC accession number, unique per filing, in the form
  `0000320193-26-000018`.
- `filingDate`: the date the filing was submitted to the SEC (`YYYY-MM-DD`). Date filters
  and ordering use this field.
- `reportDate`: the date of the earliest event the filing reports, which is often earlier
  than the filing date. Null when the feed has none.
- `acceptanceDateTime`: the EDGAR acceptance timestamp in ISO 8601 UTC, to the second.

**What happened**

- `items`: the item codes reported, for example `["2.02", "9.01"]`. Empty on some older
  filings the SEC never tagged.
- `itemTitles`: the official SEC title for each code in `items`, in the same order. A code
  the actor does not recognize is passed through unchanged as its own title.

**Where to read it**

- `primaryDocument`: file name of the main 8-K document.
- `primaryDocumentUrl`: direct link to that document on EDGAR.
- `filingIndexUrl`: the filing's index page on EDGAR, listing every file in the submission.
- `sourceUrl`: the same index page, kept as the provenance link for the row.

**Text and exhibits (only when `includeText` is on)**

- `text`: plain text of the primary document with scripts, styles, headers and inline XBRL
  metadata removed and paragraph breaks preserved. Null when text was not requested or could
  not be fetched.
- `exhibits`: the other files in the filing, each with `type` (for example `EX-99.1`),
  `filename` and `url`. Derived from the filing index; see the FAQ for how types are
  determined. Empty when text is off.

### 8-K item codes

Every 8-K reports one or more numbered items. The SEC groups them into nine sections. The
`items` input accepts any of these codes, and `itemTitles` in the output carries the
official title shown here.

**Section 1: Registrant's Business and Operations**

| Code | Official title | Plain English |
| --- | --- | --- |
| 1.01 | Entry into a Material Definitive Agreement | The company signed a contract big enough that investors should know: a merger agreement, a major supply deal, a credit facility. |
| 1.02 | Termination of a Material Definitive Agreement | |
| 1.03 | Bankruptcy or Receivership | |
| 1.04 | Mine Safety - Reporting of Shutdowns and Patterns of Violations | |
| 1.05 | Material Cybersecurity Incidents | The company suffered a cyberattack or breach it judged material, and is describing its nature, scope and likely impact. |

**Section 2: Financial Information**

| Code | Official title | Plain English |
| --- | --- | --- |
| 2.01 | Completion of Acquisition or Disposition of Assets | A deal closed: the company bought or sold a business or a significant block of assets. |
| 2.02 | Results of Operations and Financial Condition | Earnings. The quarterly or annual results press release is almost always attached as exhibit 99.1. |
| 2.03 | Creation of a Direct Financial Obligation or an Obligation under an Off-Balance Sheet Arrangement of a Registrant | |
| 2.04 | Triggering Events That Accelerate or Increase a Direct Financial Obligation or an Obligation under an Off-Balance Sheet Arrangement | |
| 2.05 | Costs Associated with Exit or Disposal Activities | |
| 2.06 | Material Impairments | |

**Section 3: Securities and Trading Markets**

| Code | Official title | Plain English |
| --- | --- | --- |
| 3.01 | Notice of Delisting or Failure to Satisfy a Continued Listing Rule or Standard; Transfer of Listing | |
| 3.02 | Unregistered Sales of Equity Securities | |
| 3.03 | Material Modification to Rights of Security Holders | |

**Section 4: Matters Related to Accountants and Financial Statements**

| Code | Official title | Plain English |
| --- | --- | --- |
| 4.01 | Changes in Registrant's Certifying Accountant | The company changed auditors, or the auditor resigned or declined to stand for re-election. |
| 4.02 | Non-Reliance on Previously Issued Financial Statements or a Related Audit Report or Completed Interim Review | Previously published financial statements can no longer be relied on; a restatement is coming or under way. |

**Section 5: Corporate Governance and Management**

| Code | Official title | Plain English |
| --- | --- | --- |
| 5.01 | Changes in Control of Registrant | |
| 5.02 | Departure of Directors or Certain Officers; Election of Directors; Appointment of Certain Officers; Compensatory Arrangements of Certain Officers | An executive or director left, was appointed or elected, or had a compensation arrangement changed. CEO and CFO transitions are reported here. |
| 5.03 | Amendments to Articles of Incorporation or Bylaws; Change in Fiscal Year | |
| 5.04 | Temporary Suspension of Trading Under Registrant's Employee Benefit Plans | |
| 5.05 | Amendment to Registrant's Code of Ethics, or Waiver of a Provision of the Code of Ethics | |
| 5.06 | Change in Shell Company Status | |
| 5.07 | Submission of Matters to a Vote of Security Holders | |
| 5.08 | Shareholder Director Nominations | |

**Section 6: Asset-Backed Securities**

| Code | Official title | Plain English |
| --- | --- | --- |
| 6.01 | ABS Informational and Computational Material | |
| 6.02 | Change of Servicer or Trustee | |
| 6.03 | Change in Credit Enhancement or Other External Support | |
| 6.04 | Failure to Make a Required Distribution | |
| 6.05 | Securities Act Updating Disclosure | |

**Section 7: Regulation FD**

| Code | Official title | Plain English |
| --- | --- | --- |
| 7.01 | Regulation FD Disclosure | Information the company chose to publish to everyone at once, typically investor presentations or guidance, to satisfy fair-disclosure rules. |

**Section 8: Other Events**

| Code | Official title | Plain English |
| --- | --- | --- |
| 8.01 | Other Events | Anything the company considers important that no other item covers: litigation updates, dividends, buyback announcements, product news. |

**Section 9: Financial Statements and Exhibits**

| Code | Official title | Plain English |
| --- | --- | --- |
| 9.01 | Financial Statements and Exhibits | The filing has attachments. It appears alongside another item on most 8-Ks, so it is rarely useful as a filter on its own. |

### Input

| Field | Meaning | Default | When to use it |
| --- | --- | --- | --- |
| `tickers` | One or more stock tickers, for example `["AAPL", "MSFT"]`. Each is resolved to an SEC CIK from the SEC's own ticker registry. Case does not matter. | required | Always. One ticker for a company watch, many for a portfolio or sector. |
| `items` | Keep only filings that report at least one of these item codes. A filing with several items matches if any one of them is in the list. Empty means every filing. | all items | `["2.02"]` for earnings releases, `["5.02"]` for executive changes, `["1.01", "2.01"]` for deals. |
| `startDate` | Earliest `filingDate` to include, `YYYY-MM-DD`. With no dates and no count, the actor returns the last 30 days. | last 30 days | Backfills and anything that should stop at a known date. |
| `endDate` | Latest `filingDate` to include, `YYYY-MM-DD`. | none | Reproducing a historical window. |
| `maxFilingsPerTicker` | Newest filings first. Counts only filings that pass the item filter. Applies only when set, and combines with dates to cap a window. | none | A bounded backfill, or a daily check where you only need the latest few. |
| `includeText` | Fetch each filing's primary document, add its full plain text, and list its exhibits. Charged per filing whose text is delivered, in addition to the row. | `false` | When you need to read or summarize the filing, or need exhibit links. |

Filings within each ticker are returned newest first. When a date range reaches back beyond
the SEC's recent-filings window, the actor fetches the older submission pages it needs.

**Earnings releases for a portfolio, with the text ready to read**

```json
{
    "tickers": ["AAPL", "MSFT", "NVDA"],
    "items": ["2.02"],
    "startDate": "2026-01-01",
    "includeText": true
}
```

**Leadership changes across a sector, metadata only**

```json
{
    "tickers": ["JPM", "BAC", "WFC", "C", "GS", "MS"],
    "items": ["5.02"],
    "maxFilingsPerTicker": 10
}
```

**Full history backfill for one company**

```json
{
    "tickers": ["TSLA"],
    "startDate": "2015-01-01",
    "endDate": "2025-12-31",
    "maxFilingsPerTicker": 1000
}
```

A metadata-only run needs only a few requests per ticker, so it finishes in seconds however
many filings it returns. With `includeText` on, each filing costs two requests to the SEC
(the document and the filing index) at the actor's default pace of five requests per second,
so expect roughly 150 filings a minute: 1,000 filings with text take about seven minutes.

### Output example

One row from the run shown above, with `text` shortened for display.

```json
{
    "ticker": "AAPL",
    "cik": "0000320193",
    "companyName": "Apple Inc.",
    "form": "8-K",
    "filingDate": "2026-07-30",
    "reportDate": "2026-07-30",
    "acceptanceDateTime": "2026-07-30T20:30:28.000Z",
    "accessionNumber": "0000320193-26-000018",
    "items": ["2.02", "9.01"],
    "itemTitles": [
        "Results of Operations and Financial Condition",
        "Financial Statements and Exhibits"
    ],
    "primaryDocument": "aapl-20260730.htm",
    "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
    "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
    "exhibits": [
        {
            "type": "EX-99.1",
            "filename": "a8-kex991q3202606272026.htm",
            "url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/a8-kex991q3202606272026.htm"
        }
    ],
    "text": "UNITED STATES\nSECURITIES AND EXCHANGE COMMISSION\nWashington, D.C. 20549\n\nFORM 8-K\nCURRENT REPORT\nPursuant to Section 13 OR 15(d) of The Securities Exchange Act of 1934\nJuly 30, 2026\nDate of Report (Date of earliest event reported)\n\nApple Inc.\n(Exact name of Registrant as specified in its charter) ...",
    "sourceUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm"
}
```

Rows land in the run's default dataset as they are produced, so you can start reading
before the run finishes. Download it from Console or the API as JSON, JSONL, CSV, Excel or
XML. The Console table view shows the main columns; the full row is in every export.

### Errors and edge cases

When something fails, the actor writes an `ERRORS` record to the run's default key-value
store: a JSON list with one entry per failure. Each entry names the `ticker`, an `error`
message, and, for a filing-level failure, the `accessionNumber` and `sourceUrl`. The
record exists only when at least one thing failed, and the run's status message says how
many errors there were. Nothing that failed is charged.

- **Ticker not in the SEC registry.** Some ETFs, foreign listings, and recently changed
  tickers are not in the SEC's ticker-to-CIK file. The ticker is skipped, recorded in
  `ERRORS` as `Ticker not found in SEC registry`, and the run continues with the next one.
- **A document cannot be fetched or extracted.** With `includeText` on, if the primary
  document cannot be downloaded or parsed, the filing is still delivered as a metadata row
  with `text` null and `exhibits` empty, the failure is recorded in `ERRORS` with the
  accession number, and no text charge is made for that filing. If the document was
  extracted but the filing index could not be read, the text is kept and `exhibits` is
  empty, and the text charge applies, since the text was delivered.
- **Empty `items` on old filings.** The SEC only began tagging item codes in its structured
  feed in the mid-2000s. Older filings come back with `items` empty and documents linked.
  Because the item filter matches on the tagged codes, an `items` filter excludes them.
- **SEC throttling.** The SEC caps traffic at 10 requests per second for everything identifying itself as the same client and answers
  a throttled request with a distinctive response. When that happens the actor pauses (30
  seconds the first time, longer on each consecutive throttle, up to 10 minutes), halves its
  request rate, and retries. The rate climbs back toward the ceiling after a run of
  successful requests. If the cumulative pause time in one run would exceed 20 minutes, the
  actor stops, keeps every row it has already delivered, and ends with a status message
  saying the SEC was still refusing requests.
- **Transient SEC errors.** Server errors and connection failures are retried with
  increasing delays before a request is given up on.
- **Spending limit reached.** If your run's maximum charge is reached, the actor stops
  cleanly with a status message; everything delivered so far stays in the dataset.

### How much does it cost?

You pay per result. One billable unit is one dataset row, and one row is one 8-K or 8-K/A
filing that passed your filters. A ticker that resolves to no filings in your window costs
nothing, and a ticker the SEC does not know costs nothing.

When `includeText` is on, a second event, `filing-text`, is charged once per filing whose
text was actually delivered. A filing whose document could not be fetched yields its
metadata row but no text charge. With `includeText` off, the event is never charged, and
`exhibits` stays empty.

Apify's standard actor start event applies to every run. Current prices for the row, the
`filing-text` event and the start event are on this actor's Pricing tab.

### Use cases

- Watch a portfolio for earnings releases with `items: ["2.02"]` and hand the `EX-99.1`
  exhibit URL or the extracted text to a summarizer.
- Detect CEO, CFO and board changes across an industry with `items: ["5.02"]`.
- Track deal flow by filtering on `1.01` (agreement signed) and `2.01` (deal closed).
- Build a cybersecurity incident dataset from `1.05` filings across the whole market.
- Backfill an event database for research with `startDate`, `endDate` and
  `maxFilingsPerTicker` at its maximum.
- Give an AI agent a dependable answer to "what has this company disclosed recently?" with
  item titles and full text ready to read.

### Run it on a schedule, from the API, or from an agent

Schedule the actor in Apify Console to run every morning after the SEC's filing window
closes, call it from the Apify API or any of the Apify client libraries, or expose it to an
AI agent through Apify's MCP server. The input is the same JSON everywhere, and every run
writes to the same dataset and key-value store layout, so a workflow built in Console moves
to code without changes.

### Related actors

- [SEC Form 4 Insider Trades by Ticker](https://apify.com/codecraftco/sec-insider-trades):
  parsed insider buys, sales, grants and option exercises from Form 4 filings.
- [SEC 13F Holdings by Fund with Quarterly Changes](https://apify.com/codecraftco/sec-13f-holdings):
  every position in a fund's 13F-HR filings with quarter-over-quarter changes.
- [Wayback Machine Snapshots and Archived Page Content](https://apify.com/codecraftco/wayback-snapshots):
  every Internet Archive capture of a URL, host or domain, with optional archived page text.

All four run against official public APIs with no proxies or credentials.

### FAQ

**Is this legal?** Yes. 8-K filings are public records published by the SEC. This actor uses
the SEC's official EDGAR endpoints, identifies itself with an organization name and contact
address as the SEC's fair-access policy requires, and stays under the SEC's request-rate
limit.

**Are amendments included?** Yes. Form 8-K/A filings are always returned and marked with
`form` set to `8-K/A`. An amendment has its own accession number and filing date, while its
`reportDate` usually matches the original filing, so you can pair them by ticker and
`reportDate` or by the item code.

**How does the item filter treat a filing with several items?** It matches if any one of
the filing's items is in your list. Most earnings 8-Ks report `2.02` and `9.01` together, so
filtering on `["2.02"]` returns them and `itemTitles` still lists both.

**Why are exhibits only listed with `includeText`?** Listing exhibits needs an extra request
per filing to read the filing index. It is bundled with text extraction so metadata-only
runs stay fast and are billed as rows alone.

**How are exhibit types determined?** From the file names in the filing index, which EDGAR
filers write in forms like `ex991.htm` or `exhibit10-1.htm`. The actor maps those to
`EX-99.1` and `EX-10.1`. XML, XBRL schema, image and archive files are skipped. It is a
best-effort classification: an exhibit with an unusual file name may be missed or typed
imprecisely. The filing index at `filingIndexUrl` is authoritative.

**What does the extracted text look like?** The primary document's visible text with
paragraph breaks kept. It opens with the SEC cover page (registrant, addresses, checkbox
declarations), so the item narrative starts a page or so in. A press release is a separate
exhibit; its URL is in `exhibits`.

**A ticker returned nothing.** Check the run's `ERRORS` record in the key-value store.
Tickers the SEC does not list are reported there. If the ticker is not in `ERRORS`, it
resolved fine and simply has no 8-K filings matching your item and date filters.

**What happens if the SEC rate-limits the run?** It finishes late rather than failing: the
actor pauses, slows down and retries, and only gives up after 20 minutes of cumulative
cooldown, keeping every row already delivered. Details are under Errors and edge cases.

**Something is missing or wrong?** Open an issue on this actor's Issues tab and it will be
looked at.

# Actor input Schema

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

Stock tickers to fetch 8-K filings for, e.g. AAPL, MSFT. Resolved to SEC CIKs automatically.

## `items` (type: `array`):

Only keep filings that report at least one of these items. Leave empty for all. 2.02 = earnings results, 5.02 = executive or director changes, 1.01 = material agreement, 8.01 = other events.

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

Only include filings filed on or after this date (YYYY-MM-DD). If you set no dates and no count, the actor returns filings from the last 30 days.

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

Only include filings filed on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `maxFilingsPerTicker` (type: `integer`):

Stop after this many filings per ticker, newest first. Only applies when set; combine with dates to cap a window.

## `includeText` (type: `boolean`):

Fetch each filing's primary document and add its full plain text to the row, plus the list of exhibits. Charged per filing whose text is delivered.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "maxFilingsPerTicker": 10,
  "includeText": false
}
```

# Actor output Schema

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

One row per 8-K filing: item codes with titles, dates, document links, exhibits, and optional extracted text.

## `errors` (type: `string`):

Inputs that could not be processed, with the reason. Present only when something failed; no row is charged for a failure.

# 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 = {
    "tickers": [
        "AAPL"
    ],
    "maxFilingsPerTicker": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("codecraftco/sec-8k-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 = {
    "tickers": ["AAPL"],
    "maxFilingsPerTicker": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("codecraftco/sec-8k-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 '{
  "tickers": [
    "AAPL"
  ],
  "maxFilingsPerTicker": 10
}' |
apify call codecraftco/sec-8k-filings --silent --output-dataset

```

## MCP server setup

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