# SEC EDGAR Filings Watch: Form 4 Insider Trades, 8-K, 10-K, 13F (`mikee368/sec-edgar-filings-watch`) Actor

Monitor SEC EDGAR filings by ticker or CIK. Get new 8-K, 10-K, 10-Q, 13F and Form 4 filings since the last run, with parsed Form 4 insider trades (owner, role, code, shares, price). Official data. Source: SEC EDGAR. Not investment advice.

- **URL**: https://apify.com/mikee368/sec-edgar-filings-watch.md
- **Developed by:** [Mike Berckmoes](https://apify.com/mikee368) (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 $1.00 / 1,000 filings

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 EDGAR Filings Watch: Form 4 insider trades, 8-K, 10-K, 10-Q, 13F

**Get the latest SEC filings for the companies you follow, or only the filings that are new since your last run.** Enter tickers (AAPL, TSLA) or CIK numbers and the form types you care about. Every row links to the filing on sec.gov. Form 4 insider trades are parsed into owner, role, transaction code, shares, price and holdings after the trade. 8-K item codes come with their official titles.

Source: SEC EDGAR (public data). Only the official SEC endpoints are used: `company_tickers.json`, the `data.sec.gov` submissions JSON, the EDGAR latest-filings feed, the filing XML in the EDGAR archive, and `efts.sec.gov` when you set full-text keywords. No scraping of third-party sites. Full-text search runs in this Actor (one shared SEC client). It does not call another Actor.

### What you get

| Field | Example |
|---|---|
| `companyName`, `cik`, `tickers` | Apple Inc., 320193, \[AAPL] |
| `form`, `filingDate`, `reportDate`, `acceptedAt` | 4, 2026-10-01, 2026-09-29 |
| `accessionNumber`, `filingUrl`, `documentUrl` | 0001140361-26-038307, link to the filing index |
| `items`, `itemsDescribed` (8-K) | 2.02 Results of Operations and Financial Condition |
| `insiderName`, `insiderRoles`, `insiderOfficerTitle` (Form 4) | Newstead Jennifer, \[Officer], SVP, GC and Government Affairs |
| `insiderTransactions` (Form 4) | date, code S (sale), 2,399 shares at $336.18, value, shares owned after, direct/indirect |
| `insiderTransactionCodes`, `insiderNetShares`, `rule10b5_1` | \[S], -2399, true |
| `keyword`, `keywords` (full-text) | `"material cybersecurity incident"` |

### How to use it

- **Latest filings (default).** Returns the most recent matching filings per company (*Max filings per company*, default 5). The default input (AAPL and TSLA) always returns data.
- **Watch mode.** Set *Mode* to *New since last run* and schedule the Actor (e.g. every hour on weekdays). Each run returns only filings that this *Monitor ID* has not returned before. The first run looks back *Lookback days* (default 30). Later runs look at filings since the previous run.
- **All companies.** Leave *Tickers* and *CIK numbers* empty to read the SEC latest-filings feed for your form types, e.g. every new Form 4 on EDGAR.
- **Full-text keyword alert.** Add one or more *Full-text keywords*. The Actor searches `efts.sec.gov` and returns matching filings (up to *Max hits per keyword*, default 100). Full-text search covers filings from 2001 onward. The status message always shows that cap, for example `2 new full-text hit(s) (cap 100 per keyword).` **Exact phrase:** wrap the words in double quotes. `"material cybersecurity incident"` is sent to EFTS as a phrase. Without quotes, EFTS treats the text as its normal full-text query. The Actor does not add quotes for you. In *New since last run*, `startdt` is the date of the previous run with the same Monitor ID, and an accession already stored for that Monitor ID is not returned and not charged. The first watch run uses *Lookback days*. Optional tickers or CIKs limit the search to those filers. Form types limit the search only when you set them.
- Funds and filers without a ticker: use *CIK numbers* (e.g. 1067983 for Berkshire Hathaway's 13F-HR).

### How much does it cost?

Pay per filing: **$1 per 1,000 filings** ($0.001 per row), no start fee. Form 4 insider trades are parsed at no extra cost. A watch of 10 companies with about 20 new filings a week costs under $0.10 per month. Runs use 128–256 MB and finish in seconds.

Full-text hits are a separate event, **`fulltext-hit` at $0.001** per new accession this Monitor ID has not returned before. `filing` stays $0.001 and is not used for these rows. Hits past the per-keyword cap are not returned and not charged. If EFTS errors, rows from that run are free.

### Good to know

- **SEC fair access.** The Actor identifies itself with a declared User-Agent and sends at most 5 requests per second (the SEC allows 10), including `efts.sec.gov`. Rate limits (HTTP 429) and server errors are retried with backoff and `Retry-After`. If the SEC refuses requests (HTTP 403), the run stops, still ends successfully, and says so in the status message and `RUN_SUMMARY`. If EFTS itself fails, the run also ends successfully: status `efts-error`, with the reason and the per-keyword cap in the status message. Hits already read are kept. The watch date is not moved forward, so the next run retries the same window.
- **Full-text rows** do not include the Form 4 insider-trade parse. Use tickers or CIKs when you need owner, role, shares and price.
- **Form 4 parsing** reads the ownership XML (non-derivative and derivative transactions). Holdings-only rows are skipped. Reporting-owner addresses and signatures are not output; insider names, roles and trades are part of the public filing.
- **Submissions JSON** covers each company's most recent filings (about 1,000). Older history is not fetched.
- **Feed mode** shows the newest filings per form type (up to 100 per run); a Form 4 appears under the issuer company. The feed has no 8-K item codes or document links; use tickers/CIKs when you need them.
- Form 3/5 and 13D/13G parsing, XBRL financial facts and webhooks are not included yet.

### Not investment advice

This Actor delivers public SEC filings as data. It does not give investment, legal or tax advice. Insider transactions can have many reasons (tax, plans under Rule 10b5-1, gifts). Check the original filing before you rely on it. This Actor is not affiliated with or endorsed by the U.S. Securities and Exchange Commission.

### Data source and licence

Source: SEC EDGAR (public data). Information presented on sec.gov is in the public domain (U.S. government work). Use follows the SEC's Internet Security Policy and fair-access rules for automated access.

### FAQ

**Do I need an API key?** No. EDGAR is open; no SEC account is needed.
**How fresh is the data?** The SEC usually publishes a filing on EDGAR within minutes of acceptance; the Actor reads it on the next run.
**Can I get only insider purchases?** Use form type `4` and filter `insiderTransactionCodes` containing `P` in your integration.
**How do I search an exact phrase?** Put the phrase in double quotes in *Full-text keywords*, for example `"material cybersecurity incident"`. A keyword without quotes is a normal EFTS query, not a phrase.

# Actor input Schema

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

US stock tickers, e.g. AAPL, TSLA, BRK-B. Mapped to SEC CIK numbers with the official SEC ticker list. Empty together with CIKs = watch the SEC latest-filings feed for your form types (all companies).

## `ciks` (type: `array`):

SEC Central Index Keys, e.g. 320193 (Apple) or 0001067983 (Berkshire Hathaway). Use for funds and filers without a ticker.

## `formTypes` (type: `array`):

SEC form types to return, e.g. 8-K, 4, 10-Q, 10-K, 13F-HR, S-1, SC 13D, DEF 14A.

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

Also return amended filings, e.g. 8-K/A or 4/A.

## `mode` (type: `string`):

latest = the most recent matching filings per company (always returns data). newSinceLastRun = only filings not returned by an earlier run with the same Monitor ID (for scheduled alerts). With full-text keywords, newSinceLastRun sets the EFTS startdt to the previous run's date and skips accession numbers already stored for this Monitor ID.

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

Upper limit of filings returned per ticker/CIK per run (1-100).

## `lookbackDays` (type: `integer`):

In newSinceLastRun mode, only filings filed within this many days are considered (the first run returns up to Max filings per company from this window).

## `parseForm4` (type: `boolean`):

Read the Form 4 XML and add reporting owner, role, transaction codes, shares, prices and holdings after the trade. One extra SEC request per Form 4.

## `feedMaxFilings` (type: `integer`):

Only used without tickers and CIKs: how many of the newest filings per form type to read from the SEC latest-filings feed (1-100).

## `monitorId` (type: `string`):

Name of the watch state (seen accession numbers). Use different IDs for different watch lists.

## `resetState` (type: `boolean`):

Forget which filings this Monitor ID has already returned.

## `keywords` (type: `array`):

When set, search filing text on efts.sec.gov instead of the company submissions feed. One keyword per line. Wrap an exact phrase in double quotes, for example "material cybersecurity incident". Quotes are sent as you type them.

## `maxHitsPerKeyword` (type: `integer`):

Upper limit of EFTS hits read per keyword per run (1-100). The run status message always shows this cap.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "TSLA"
  ],
  "ciks": [],
  "formTypes": [
    "8-K",
    "4",
    "13F-HR",
    "10-Q",
    "10-K"
  ],
  "includeAmendments": true,
  "mode": "latest",
  "maxFilingsPerCompany": 5,
  "lookbackDays": 30,
  "parseForm4": true,
  "feedMaxFilings": 40,
  "monitorId": "default",
  "resetState": false,
  "keywords": [],
  "maxHitsPerKeyword": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one row per filing

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

Status, requests and counts

# 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",
        "TSLA"
    ],
    "ciks": [],
    "formTypes": [
        "8-K",
        "4",
        "13F-HR",
        "10-Q",
        "10-K"
    ],
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("mikee368/sec-edgar-filings-watch").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",
        "TSLA",
    ],
    "ciks": [],
    "formTypes": [
        "8-K",
        "4",
        "13F-HR",
        "10-Q",
        "10-K",
    ],
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("mikee368/sec-edgar-filings-watch").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",
    "TSLA"
  ],
  "ciks": [],
  "formTypes": [
    "8-K",
    "4",
    "13F-HR",
    "10-Q",
    "10-K"
  ],
  "keywords": []
}' |
apify call mikee368/sec-edgar-filings-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mikee368/sec-edgar-filings-watch"
        }
    }
}
```

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/MF1zSaqkqx2fIImVj/builds/1ccqhlxybUSTcYdw6/openapi.json