# SEC Form 4 Scraper: Insider Buys, Sells & Cluster Signals (`upward_enterprises/sec-form-4-insider-radar`) Actor

Every insider transaction from SEC Form 4 filings, market-wide or for a ticker watchlist: insider name and role, buy or sell code, shares, price, value, holdings after, 10b5-1 flag, footnotes, links. Free per-company cluster signals: distinct buyers, sellers and net value over 7 and 30 days.

- **URL**: https://apify.com/upward_enterprises/sec-form-4-insider-radar.md
- **Developed by:** [Upward Enterprises](https://apify.com/upward_enterprises) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 insider transactions

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 Form 4 Scraper: Insider Buys, Sells & Cluster Signals

**$1 per 1,000 insider transactions ($0.60 on the Gold tier), no start fee, no API key. Company cluster-signal rows are free, and on a schedule only transactions you have not received before are billed.**

Officers, directors and 10% owners must report every trade in their own company's stock on a Form 4 within two business days. This Actor turns those filings into one row per transaction, market-wide or for a watchlist of tickers, with the insider's role, the transaction code, shares, price, value, holdings after, whether it was a pre-arranged Rule 10b5-1 plan trade, and the footnotes that explain it. For every company with a trade it also delivers a free signal row from a rolling 30-day ledger: how many distinct insiders bought and sold in the last 7 and 30 days and the net dollar value, with `clusterBuy` set when three or more insiders bought within 30 days.

Built on EDGAR's daily index, its live filings feed, and each filing's XML, all public and free. The Actor declares itself to the SEC as its fair-access policy asks and never exceeds eight requests a second.

### What you get

**Transaction rows** (`kind: "transaction"`), newest filings first:

```json
{
  "kind": "transaction",
  "txId": "0001234567-26-000012:n0",
  "accessionNumber": "0001234567-26-000012",
  "form": "4",
  "isAmendment": false,
  "filedDate": "2026-09-09",
  "acceptedAt": "2026-09-09T16:05:12-04:00",
  "periodOfReport": "2026-09-08",
  "issuerName": "Example Corp",
  "ticker": "EXMP",
  "issuerCik": 1234567,
  "insiderName": "Doe Jane",
  "insiderCik": 1000001,
  "roles": ["director"],
  "roleText": "Director",
  "officerTitle": null,
  "coFilers": [],
  "plan10b5_1": false,
  "table": "non-derivative",
  "securityTitle": "Common Stock",
  "transactionDate": "2026-09-08",
  "transactionCode": "P",
  "transactionLabel": "Open market or private purchase",
  "acquiredDisposed": "A",
  "shares": 10000,
  "pricePerShare": 12.4,
  "value": 124000,
  "sharesOwnedAfter": 85000,
  "ownership": "D",
  "ownershipNature": null,
  "footnotes": ["Weighted average price; range $12.30 to $12.50."],
  "submissionUrl": "https://www.sec.gov/Archives/edgar/data/1234567/0001234567-26-000012.txt",
  "viewerUrl": "https://www.sec.gov/Archives/edgar/data/1234567/000123456726000012/xslF345X05/form4.xml",
  "fetchedAt": "2026-09-10T12:00:00.000Z"
}
```

`transactionCode` is the SEC's letter code and `transactionLabel` spells it out: P purchase, S sale, A grant, D disposition to the issuer, F tax withholding, M option exercise, G gift, and so on. `value` is shares times price (null for grants without a price). Derivative rows, when you turn them on, add `conversionOrExercisePrice`, `exerciseDate`, `expirationDate`, `underlyingSecurityTitle` and `underlyingShares`. Insider addresses are not included.

**Company signal rows** (`kind: "issuer"`, free), one per company with a trade this run:

```json
{ "kind": "issuer", "ticker": "EXMP", "issuerName": "Example Corp", "buyers7d": 3, "sellers7d": 0, "buys7d": 4, "sells7d": 0, "buyValue7d": 412000, "sellValue7d": 0, "netValue7d": 412000, "buyers30d": 4, "sellers30d": 1, "buyValue30d": 610000, "sellValue30d": 90000, "netValue30d": 520000, "clusterBuy": true, "clusterSell": false, "tradesInLedger": 9 }
```

The ledger behind these rows is kept in the snapshot's memory and counts every open-market purchase (P) and sale (S) the Actor has read in the last 30 days, whatever your own filters, so a daily schedule builds real cluster history. **One summary row** (`kind: "summary"`, free) reports the window, filings read, transactions seen and filtered, and whether the run hit your spending cap.

### Input

| Field | What it does |
|---|---|
| Transaction codes | Default P and S: real purchases and sales. Empty means every code. |
| Filed within (days) | Look-back by filing date. Default 1. Past days come from the complete daily index; today from the live feed. |
| Watchlist: tickers / CIKs | Restrict to these companies. Form 4 is listed under the issuer's CIK, so the index itself is filtered and watchlists stay cheap even with long look-backs. |
| Insider roles | Officer, director, 10% owner, other. |
| Minimum transaction value | Dollar floor on shares times price. |
| Include derivative transactions | Options, RSUs, warrants, convertibles. |
| Exclude Rule 10b5-1 plan trades | Keep discretionary trades only. |
| Include amendments | Form 4/A. |
| Only new since last run | Default on. Also keeps the 30-day ledger for the signal rows. |
| Snapshot name | Which memory to use; a key-value store named `sec-form-4-insider-radar-<name>`. |
| Max transactions per run | Default 2,000. |

Examples:

```json
{ "transactionCodes": ["P"], "minValue": 100000, "roles": ["officer", "director"] }
```

Every open-market insider purchase over $100,000 by an officer or director, market-wide, with cluster signals.

```json
{ "tickers": ["NVDA", "AMD", "AVGO", "TSM"], "transactionCodes": [], "includeDerivatives": true, "filedWithinDays": 30 }
```

Everything four companies' insiders did in the last month, including option exercises.

### Pricing

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Insider transaction | $0.001 | $0.0009 | $0.00075 | $0.0006 |

EDGAR receives about 1,000 Form 4 filings on a business day, of which roughly 500 to 800 transactions are open-market purchases or sales. The default daily run therefore costs about $0.50 to $0.80 a day, around $12 to $18 a month, for every real insider trade in the market with cluster signals; a watchlist or a dollar floor costs cents. Signal rows, the summary row and empty runs are free. Set a maximum total charge on the run to cap spend; the Actor stops cleanly when it is reached and never delivers rows it could not bill.

### Use cases

- **Investors and newsletters**: cluster buys, large discretionary purchases, and CEO or CFO sales, the day after they are filed, without a $50-a-month screener.
- **Quant and research**: a clean daily transaction table with roles, codes and holdings after, ready for a database.
- **Compliance and journalists**: who at a company traded, when, and under what plan, with the filing one click away.
- **AI agents**: ask "which companies had three or more insiders buying this month" through the Apify MCP server and read the signal rows.

### Data source and limits

- Filings are listed from EDGAR's daily form index (complete for each past business day, published early the next morning) and from the latest-filings feed for today, then read from each filing's complete submission file, which embeds the XML ownership document. All are US government public-domain records.
- The SEC asks automated tools to declare themselves and stay under 10 requests a second; the Actor does both and retries with backoff. A filing that still cannot be read is counted in the summary row and picked up next run.
- Insiders have two business days to file, so a trade appears here two to three days after it happened. Filing dates follow EDGAR's US Eastern calendar.
- Insider names, roles and CIKs come from the filing itself; addresses are not included, and nothing is added from other sources.
- Nothing here is investment advice; the rows are the public record.
- At the end of each run the Actor reports run counts (rows delivered, events charged, duration, status) to its maintainer's dashboard. It never sends your input, your results, or anything about your account.

### Enjoying this Actor?

If it saved you time, please leave a review on the [Apify Store page](https://apify.com/upward_enterprises/sec-form-4-insider-radar) — it helps other people find it. Bug reports and feature requests are welcome on the Issues tab.

### About

Built and maintained by **Upward Enterprises · AI & API Services** (Iowa, USA). Public-data tools for people and AI agents, with pay-per-record pricing and no keys to manage.

### Changelog

- **0.1** (2026-09-10): first release.

# Actor input Schema

## `transactionCodes` (type: `array`):

Which Form 4 transaction codes count. P and S (the default) are the open-market or private purchases and sales that matter for signals. Empty means every code, including grants, tax withholding, option exercises and gifts.

## `filedWithinDays` (type: `integer`):

How far back to look by filing date, in calendar days before today (US Eastern), plus today. Default 1: yesterday's filings from EDGAR's complete daily index plus today's from the live feed. Insiders have two business days to file, so a daily run on this setting sees every trade.

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

Only filings by insiders of these companies, by stock ticker (e.g. AAPL, NVDA). Resolved to SEC CIK numbers through the SEC's public ticker file. Leave empty for the whole market.

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

Only filings for these issuer CIK numbers. Combined with any tickers above. Leave empty for the whole market.

## `roles` (type: `array`):

Only transactions by insiders with at least one of these relationships to the issuer. Empty means any.

## `minValue` (type: `integer`):

Only transactions worth at least this much (shares times price). Transactions with no price, such as grants, always pass when their code is selected. 0 keeps everything.

## `includeDerivatives` (type: `boolean`):

Off (default): only the non-derivative table (common stock and similar). On: also options, RSUs, warrants and convertibles from the derivative table, with exercise price, dates and underlying shares.

## `excludePlanTrades` (type: `boolean`):

Off (default): pre-arranged plan trades are delivered and flagged plan10b5_1. On: they are skipped, leaving discretionary trades only.

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

Off (default): original Form 4 filings only. On: also amended filings, marked isAmendment.

## `onlyNew` (type: `boolean`):

On (default): remember which transactions each snapshot name has delivered (90 days) and skip them next time, so a schedule never bills the same trade twice. Also keeps the 30-day trade history behind the cluster signals. Off: deliver everything in the window every run.

## `snapshotName` (type: `string`):

Which memory "only new" uses. Kept on your account as a key-value store named sec-form-4-insider-radar-<name>. Give each schedule its own name.

## `maxItems` (type: `integer`):

Upper limit on delivered transaction rows, newest filings first. The summary row says whether the limit cut the results.

## `proxyConfiguration` (type: `object`):

Normally not needed: EDGAR is a public API that asks only for a declared User-Agent and at most 10 requests a second. Turn a proxy on if the summary row reports SEC rate limiting from the platform's shared address.

## Actor input object example

```json
{
  "transactionCodes": [
    "P",
    "S"
  ],
  "filedWithinDays": 1,
  "tickers": [],
  "ciks": [],
  "roles": [],
  "minValue": 0,
  "includeDerivatives": false,
  "excludePlanTrades": false,
  "includeAmendments": false,
  "onlyNew": true,
  "snapshotName": "default",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `all` (type: `string`):

No description

## `transactionColumns` (type: `string`):

No description

## `issuerColumns` (type: `string`):

No description

## `csv` (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 = {
    "transactionCodes": [
        "P",
        "S"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("upward_enterprises/sec-form-4-insider-radar").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 = { "transactionCodes": [
        "P",
        "S",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("upward_enterprises/sec-form-4-insider-radar").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 '{
  "transactionCodes": [
    "P",
    "S"
  ]
}' |
apify call upward_enterprises/sec-form-4-insider-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,upward_enterprises/sec-form-4-insider-radar"
        }
    }
}
```

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/evbvGGxwIPQwYCvya/builds/aCnpyJVg1BACh20EV/openapi.json