# SEC Insider Intelligence — Form 4 Trading Signals (`lokki/sec-insider-intelligence`) Actor

Track SEC insider-trading disclosures and turn Form 4 filings into structured market-intelligence signals: issuer, insider, role, transaction type, shares, value, dates, and URLs for financial research workflows.

- **URL**: https://apify.com/lokki/sec-insider-intelligence.md
- **Developed by:** [Ian Dikhtiar](https://apify.com/lokki) (community)
- **Categories:** Automation, Lead generation, News
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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?

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

One API call turns any US public company ticker into scored insider trading signals, parsed SEC filings, and a composite health rating.

### Who this is for

- **VC analysts** screening portfolio companies for red flags before board meetings
- **PE due diligence teams** validating targets before term sheets
- **Hedge fund researchers** tracking insider behavior across positions
- **Competitive intelligence firms** monitoring company health at scale
- **M\&A advisors** flagging risk patterns during deal evaluation

### What you get

Enter a ticker or company name. The actor returns three row types in a single dataset:

| Row type | Contents |
|---|---|
| `filing` | SEC filing metadata with 8-K event classification |
| `insider_trade` | Parsed Form 4 data: insider name, title, shares, price, total value |
| `signal` | Scored intelligence signal (0-100) with direction, confidence, and narrative |

A health score summary is stored in the key-value store under the `SUMMARY` key.

### The 5 intelligence signals

#### 1. Filing Velocity

Quarter-over-quarter filing trend. Acceleration often precedes major corporate events -- new products, restructurings, acquisitions. Slowdown may signal operational retreat. Direction: bullish or bearish.

#### 2. 8-K Event Risk

Detects high-risk 8-K items: leadership departures, financial restatements, material impairments, delisting notices, auditor changes. More events and higher severity produce higher scores. This is the earliest public signal of corporate distress.

#### 3. Insider Net Sentiment

Dollar-weighted buy/sell ratio from Form 4 filings. Insider buying is the strongest bullish indicator in public markets -- executives put their own money at risk. Heavy net selling tells the opposite story.

#### 4. Insider Concentration

Flags when a single insider accounts for 40%+ of total sell volume. C-suite concentrated selling scores highest. When the CFO sells more than the rest of the board combined, pay attention.

#### 5. Insider Selling Before Events

Cross-references insider sales against high-risk 8-K filings within a 90-day window. Three insiders sold $2.8M of GE stock before 8-K risk events. This sell-before-event pattern is what regulators watch most closely.

### Sample output

#### Signal row

```json
{
  "row_type": "signal",
  "source": "intelligence",
  "company_name": "GENERAL ELECTRIC CO",
  "signal_name": "Insider Selling Before Events",
  "signal_category": "cross_reference",
  "signal_score": 90,
  "signal_direction": "alert",
  "confidence": "high",
  "data_points": 3,
  "narrative": "3 insider sale(s) totaling $2,789,435 occurred within 90 days before high-risk 8-K filings. This sell-before-event pattern is closely watched by regulators.",
  "supporting_evidence": [
    "Stokes Russell sold $2,381,680 on 2025-11-19, 57d before 8-K on 2026-01-15",
    "Ali Mohamed sold $306,701 on 2025-08-05, 57d before 8-K on 2025-10-01"
  ]
}
```

#### Insider trade row

```json
{
  "row_type": "insider_trade",
  "source": "sec_edgar",
  "company_name": "GENERAL ELECTRIC CO",
  "cik": "0000040545",
  "filing_date": "2026-02-03",
  "insider_name": "Stokes Russell",
  "insider_title": "Senior Vice President",
  "is_officer": true,
  "transaction_type": "sale",
  "transaction_code": "S",
  "shares": 8894.0,
  "price_per_share": 306.51,
  "total_value": 2726099.94,
  "shares_owned_after": 150434.0,
  "transaction_date": "2026-01-30"
}
```

### Tested on 20 companies

Results from real runs against SEC EDGAR (2-year lookback, default settings):

| Company | Filings | Insider Trades | Signals | Health Score |
|---|---|---|---|---|
| Apple | 30 | 38 | 4 | 31/100 (warning) |
| Tesla | 30 | 72 | 5 | 62/100 (stable) |
| Boeing | 30 | 33 | 4 | 80/100 (strong) |
| NVIDIA | 30 | 181 | 4 | 17/100 (critical) |
| Snowflake | 30 | 92 | 5 | 25/100 (warning) |
| GE | 30 | 29 | 5 | 41/100 (caution) |

NVIDIA's 181 insider trades and 17/100 health score tell a clear story. Boeing's 80/100 shows the signals can read both directions. The data speaks for itself.

### Input reference

| Field | Required | Default | Description |
|---|---|---|---|
| `companyName` | Yes | -- | Ticker or company name ("AAPL" or "Apple Inc") |
| `includeInsiderTrades` | No | `true` | Parse Form 4 insider trades. Set `false` for faster, cheaper filing-only runs. |
| `dateFrom` | No | 2 years ago | Start date (YYYY-MM-DD) |
| `dateTo` | No | Today | End date (YYYY-MM-DD) |
| `maxFilingResults` | No | 200 | Maximum filing rows (max 1000) |
| `formTypes` | No | All major types | SEC form types to include |
| `secUserAgent` | No | Default agent | SEC EDGAR requires a User-Agent with name and email |
| `proxyConfig` | No | None | Apify proxy settings |

**Default form types:** 8-K, 10-K, 10-Q, Form 4, SC 13D/G, S-1, DEF 14A (and amendments).

### Pricing

**$0.005 per result row** (pay-per-event).

| Scenario | What you get | Rows | Cost |
|---|---|---|---|
| Quick scan (filings only) | Filing metadata + 8-K classification | ~35 | ~$0.18 |
| Standard run | Filings + insider trades + all 5 signals | ~70 | ~$0.35 |
| Large-cap deep dive | Full analysis, high-activity company | ~200 | ~$1.00 |

Set `includeInsiderTrades` to `false` for filing-only runs. This skips Form 4 parsing and disables the three insider signals, cutting cost and runtime.

### How the health score works

The composite score (0-100) is a weighted average of all generated signals. Each signal's weight equals its data point count -- signals backed by more evidence count more.

- **Bullish** signals contribute their score directly (higher = healthier)
- **Bearish** signals contribute the inverse (high bearish score = low health)
- **Alert** signals penalize the score (sell-before-event patterns, concentrated selling)
- **Neutral** signals anchor toward 50

Score labels: **critical** (0-19) | **warning** (20-39) | **caution** (40-59) | **stable** (60-79) | **strong** (80-100)

The health score is stored in the key-value store under `SUMMARY` alongside an executive summary and top signal narratives.

### Data source

All data comes from SEC EDGAR -- the official public filing database of the US Securities and Exchange Commission. No paid data feeds. No scraped paywalled sources. Free, official, public records.

The actor resolves CIK numbers automatically from either a name or ticker. Form 4 XML documents are parsed directly for insider trade details that the EDGAR JSON API does not expose.

### Limitations

- **US public companies only.** Covers SEC-registered companies. No foreign-only or private companies.
- **Non-derivative Form 4 transactions only.** Derivative transactions (options, warrants) are not yet parsed.
- **SEC rate limit.** EDGAR allows 10 requests/second. Large runs take 30-60 seconds.
- **Pattern detection, not prediction.** Signals are quantitative patterns from filed data. They are not buy/sell recommendations.
- **Historical coverage depends on filings.** If a company hasn't filed it, the actor can't find it.
- **Not investment advice.** This is a research tool. Use it as a starting point for your own analysis.

# Actor input Schema

## `companyName` (type: `string`):

The company to investigate. Enter a company name (e.g. 'Apple Inc') or ticker symbol (e.g. 'AAPL'). The actor resolves the SEC CIK automatically.

## `dateFrom` (type: `string`):

Start date (YYYY-MM-DD). Defaults to 2 years ago.

## `dateTo` (type: `string`):

End date (YYYY-MM-DD). Defaults to today.

## `includeInsiderTrades` (type: `boolean`):

Parse Form 4 XML filings for insider trade details (name, shares, price, value). When enabled, produces insider trade rows and unlocks 3 additional signals (Insider Sentiment, Insider Concentration, Sell-Before-Event). Disable for faster, cheaper runs with filing data only.

## `maxFilingResults` (type: `integer`):

Maximum number of SEC filing rows to return.

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

Which SEC form types to include. Default covers 8-K, 10-K, 10-Q, Form 4, SC 13D/G, S-1, and DEF 14A.

## `secUserAgent` (type: `string`):

SEC EDGAR requires a User-Agent header with a company/app name and email address. Example: 'MyApp admin@example.com'.

## `proxyConfig` (type: `object`):

Optional Apify proxy settings.

## Actor input object example

```json
{
  "companyName": "Tesla",
  "includeInsiderTrades": true,
  "maxFilingResults": 30,
  "formTypes": [
    "8-K",
    "8-K/A",
    "10-K",
    "10-K/A",
    "10-Q",
    "10-Q/A",
    "4",
    "4/A",
    "SC 13D",
    "SC 13D/A",
    "SC 13G",
    "SC 13G/A",
    "S-1",
    "S-1/A",
    "DEF 14A"
  ],
  "secUserAgent": "CorporateIntelMonitor admin@example.com"
}
```

# Actor output Schema

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

All structured records produced by this Actor in the default dataset.

## `overview` (type: `string`):

Open the default dataset in Apify Console. If the Actor defines dataset views, Console will render them here.

## `input` (type: `string`):

The JSON input used for this run, stored in the default key-value store under INPUT.

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

Optional machine-readable run summary when the Actor writes an OUTPUT record to the default key-value store.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lokki/sec-insider-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lokki/sec-insider-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 '{}' |
apify call lokki/sec-insider-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lokki/sec-insider-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/8235PW6isdEcymawd/builds/1qzsqg5YBHMda1dZD/openapi.json