# Insider Transactions Monitor — SEC Form 4 Trades (`apivault_labs/insider-transactions-monitor`) Actor

Track reported insider purchases, sales and other Form 4 transactions by company. Includes insider roles, exact share/price values, amendments, footnotes and original report links. Snapshot or watch for newly observed transactions. No source API key.

- **URL**: https://apify.com/apivault_labs/insider-transactions-monitor.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** 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 transaction row delivereds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Insider Transactions Monitor — SEC Form 4 Trades

**See what company insiders reported buying, selling or transferring.** Enter company tickers or CIKs to collect recent SEC Form 4 transaction lines with the reporting person's name and role, transaction date, share quantity, reported price, footnotes and original report link.

Choose a snapshot of recent transactions or a watchlist for newly observed records across runs. Purchases and sales stay separate from awards, gifts, withholding and option exercises. No source API key is required.

| At a glance | What you get |
| --- | --- |
| Companies | Up to 5 ticker or CIK entries |
| Reports | Recent Form 4 and optional Form 4/A amendments |
| Default selection | Reported purchase/sale codes P and S, non-derivative securities |
| Other operations | Choose `all`; optionally include derivative securities |
| Results | One row per reported transaction line, with all reporting owners together |
| Export | JSON, CSV or Excel |
| Price | $1 per 1,000 delivered transaction rows + Apify resources; no startup fee |

### First run: purchases and sales

1. Open **Input** and paste this example or edit the form.
2. Replace `AAPL` and `MSFT` with your company tickers. CIKs are numeric strings, such as `"0000320193"`.
3. Start the run and open **Dataset → Transactions**. Use **Export** for JSON, CSV or Excel.

```json
{
  "mode": "snapshot",
  "companies": ["AAPL", "MSFT"],
  "transactionScope": "purchases_sales",
  "includeDerivatives": false,
  "includeAmendments": true,
  "lookbackDays": 90,
  "maxFilingsPerCompany": 3,
  "maxResults": 10,
  "maxCostUsd": 0.01
}
```

This inspects up to the three newest matching reports per company and returns up to ten transaction lines across both companies. One report may contain several lines or no transactions matching your filters. The result fee is at most $0.01 at the displayed tariff, plus resources.

Snapshots are ordered by report acceptance time, newest first. Read `SUMMARY` for reports inspected, omitted reports, matching/delivered rows and coverage. `ERRORS` explains missing companies or unavailable reports. A successful run can return no matching rows.

### What a transaction means

| Code | Reported operation | Treatment |
| --- | --- | --- |
| P | Open-market or private purchase | Included in `purchases_sales` |
| S | Open-market or private sale | Included in `purchases_sales` |
| A | Grant, award or other acquisition from the issuer | Separate award category in `all` |
| F | Securities used or withheld for tax or exercise obligations | Separate withholding category in `all` |
| M / C | Exercise or conversion | Separate exercise/conversion categories in `all` |
| G / W | Gift / inheritance | Separate transfer categories in `all` |
| Other codes | Other operations described in the filing | Original code and available footnotes preserved in `all` |

P does not distinguish a public-market purchase from a private purchase, and S does not guarantee a public-market sale. `securityType` distinguishes non-derivative from derivative transaction lines. For derivatives, the category is labelled separately, for example `derivative_purchase`. An equity-swap flag, reporting-plan flag and filing footnotes are retained when supplied.

These are disclosures about reported activity, not trading recommendations or evidence of an insider's intentions. See the SEC's [guide to insider transaction reports](https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins/investor-bulletins-69).

### Include awards, gifts, options and other operations

```json
{
  "mode": "snapshot",
  "companies": ["TSLA"],
  "transactionScope": "all",
  "includeDerivatives": true,
  "lookbackDays": 365,
  "maxFilingsPerCompany": 2,
  "maxResults": 20,
  "maxCostUsd": 0.02
}
```

Review `transactionCode`, `transactionCategory`, `securityType` and the footnotes together. An option exercise, the resulting common-stock acquisition and a later sale can be separate source lines; the Actor does not combine them into one cash trade. Holdings-only lines are not returned as transactions.

### Exact values, missing prices and calculated amounts

Quantities and prices are decimal **strings** in `sharesDecimal` and `pricePerShareDecimal`, preserving fractional values. Missing or footnote-only values are `null`; an explicitly reported zero remains zero. Do not replace missing prices with zero.

When both numbers are present, `calculatedNominalValueDecimal` equals reported quantity multiplied by reported price. It is a **calculated nominal value**, not an SEC-reported cash total, net proceeds or a valuation of an option's underlying exposure. No option contract multiplier or currency conversion is applied. `valueCurrency` is `null`: the Actor does not assume a currency that the transaction fields do not identify.

Prices can be weighted averages or need further explanation. Check `priceFootnoteIds`, `footnoteIds`, `footnotes`, `valueHasFootnotes` and `filingRemarks`. Joint reports return all reporting owners in one array on the same transaction row; amounts are not duplicated into a separate paid row for each owner.

### Watch only newly observed transactions

1. Set `mode` to `watch` and choose companies, filters and report limits.
2. Choose your own `stateStoreName` beginning with `insider-watch-`. Replace the example name below.
3. Run once to establish a baseline. Existing matching transactions create **no Dataset rows or result fees** on that first successful scan.
4. Repeat with the same history name and selection settings. Unseen matching transaction IDs are returned, oldest report first. An unchanged repeat returns `NO_NEW_TRANSACTIONS` and zero rows.

```json
{
  "mode": "watch",
  "companies": ["AAPL", "MSFT"],
  "transactionScope": "purchases_sales",
  "includeDerivatives": false,
  "includeAmendments": true,
  "lookbackDays": 90,
  "maxFilingsPerCompany": 5,
  "stateStoreName": "insider-watch-my-companies",
  "maxResults": 20,
  "maxCostUsd": 0.02
}
```

Use one run at a time per history name. Changing companies, filters, date settings or `maxFilingsPerCompany` requires a new history and baseline. You can change the row/fee limits without resetting your watch. A company whose selected reports cannot all be processed does not receive an incomplete baseline.

If delivery is limited, remaining matching transactions can be delivered later while their reports remain in the selected scan and date window. A later amendment is a separate report and may repeat a transaction with corrected information. The Actor does not replace or cancel the original transaction automatically.

Each transaction has a stable `eventId` based on company, accession, security table and source row. Deduplicate by this ID in downstream workflows. Interrupted or overlapping runs can produce repeats. An amendment has its own ID; the same economic transaction in an original and amended report can therefore appear twice. Changes within an already observed source row are not treated as a new event.

The history belongs to the running account and supports up to 50,000 observed transaction IDs. At that limit, establish a new baseline under a new name. The Actor does not create schedules or send notifications; configure your own Apify schedule or integration if needed.

### Input reference

| Field | Default | Meaning |
| --- | --- | --- |
| `mode` | `snapshot` | `snapshot` or `watch` |
| `companies` | `["AAPL", "MSFT"]` | 1–5 company tickers or numeric CIK strings; aliases resolving to one company are counted once |
| `transactionScope` | `purchases_sales` | P/S codes only, or `all` reported codes |
| `includeDerivatives` | `false` | Include derivative-security transactions, labelled separately |
| `includeAmendments` | `true` | Include Form 4/A as separate reports |
| `lookbackDays` | `90` | 1–365 calendar days, filtered by report filing date |
| `sinceDate`, `untilDate` | Derived start; today UTC | Optional inclusive ISO filing dates. Start overrides the derived lookback; end cannot be future; maximum span 365 days |
| `maxFilingsPerCompany` | `5` | Inspect 1–10 newest matching reports per company. Older omitted reports are counted in `SUMMARY` |
| `maxResults` | `100` | Global delivered transaction-row cap, 0–1000; zero skips processing |
| `maxCostUsd` | No input fee cap | Optional result-fee cap in USD, 0–1000; platform resources are separate |
| `stateStoreName` | None | Required only for watch. `insider-watch-` followed by 3–49 lowercase letters/digits/hyphens, beginning with a letter/digit |

Date filters apply to **`filingDate`**, not the date of the transaction. A transaction reported late can be older than the chosen filing window. Only available recent company reports are searched; a 365-day request does not promise a complete year or historical archive.

### Output reference

One row represents one source transaction line. The Transactions view shows the main columns; Full report details contains every field.

| Fields | Meaning |
| --- | --- |
| `eventId`, `cik`, `accessionNumber`, `sourceRow` | Stable transaction identity, company identifier, filing identifier and row number within its security table |
| `companyName`, `ticker` | Issuer's reported name and symbol |
| `reportingOwners` | Array of reporting persons/entities, names, CIKs, director/officer/10% owner flags and officer titles when present |
| `form`, `isAmendment`, `dateOfOriginalSubmission` | Form 4/4-A and the original submission date if supplied; no inferred original accession |
| `periodOfReport`, `transactionDate`, `filingDate`, `acceptedAt`, `fetchedAt` | Report period, actual transaction date when stated, filing date, SEC acceptance time and retrieval time |
| `securityType`, `securityTitle` | `non_derivative` or `derivative`, with the reported security name |
| `transactionCode`, `transactionCategory`, `transactionFormType` | Original operation code, descriptive category and row-level form indicator when supplied |
| `acquiredDisposedCode`, `equitySwapInvolved` | A/D acquisition/disposition and optional swap flag |
| `sharesDecimal`, `pricePerShareDecimal` | Exact reported decimal strings, nullable |
| `calculatedNominalValueDecimal`, `valueCurrency`, `valueCalculation` | Optional quantity-times-price calculation, unknown currency and calculation note |
| `footnotes`, `footnoteIds`, `priceFootnoteIds`, `missingFootnoteIds`, `valueHasFootnotes` | Filing explanations, transaction references and unresolved references if any |
| `sharesOwnedAfterDecimal`, `directOrIndirectOwnership`, `natureOfOwnership` | Reported post-transaction balance and ownership information |
| `underlyingSecurityTitle`, `underlyingSharesDecimal`, `conversionOrExercisePriceDecimal`, `exerciseDate`, `expirationDate` | Available derivative details; null for non-derivative rows or missing source values |
| `reported10b5One`, `filingRemarks` | Reporting-plan flag and filing remarks when supplied; no inference when absent |
| `source`, `documentUrl`, `filingIndexUrl`, `sourceDocumentSha256` | SEC EDGAR attribution, original document/index links and a source-document checksum |

`SUMMARY` contains matching/delivered transaction counts, row truncation, reports selected/parsed and coverage per company. `scanTruncated` means some matching reports were omitted by the scan limit or could not be inspected. An empty result means no matching transactions in the successful selected scan, not no insider activity anywhere.

### Pricing

**$0.001 per delivered transaction row ($1 per 1,000), plus Apify resources. No startup event.** One filing can generate several rows. A joint filing is not charged once per owner; each reported transaction line is one result.

Five delivered rows cost $0.005 in result fees; 100 cost $0.10. Baseline, unchanged watch repeats, empty results and error-only outcomes have no transaction result fee, but still consume platform resources. Snapshot repeats can return and charge the same transaction lines again.

`maxCostUsd` caps result fees only. At this tariff, `0.01` permits up to ten rows; a value below `0.001` permits none, and `0` skips processing. A lower platform event-charge cap can reduce delivery further. Compute/storage and other platform costs are separate. Current rates appear on the Actor's Pricing tab. The underlying SEC filings are free; the Actor charge covers collection, filtering and watch processing.

### API and integrations

Store your Apify token in an environment variable. This starts an asynchronous run; after it completes, read the returned Dataset ID.

```bash
curl --request POST \
  'https://api.apify.com/v2/acts/apivault_labs~insider-transactions-monitor/runs?maxTotalChargeUsd=0.01' \
  --header "Authorization: Bearer ${APIFY_TOKEN}" \
  --header 'Content-Type: application/json' \
  --data '{"companies":["AAPL"],"transactionScope":"purchases_sales","maxFilingsPerCompany":3,"maxResults":10,"maxCostUsd":0.01}'
```

The response includes `data.id`, `data.defaultDatasetId` and `data.defaultKeyValueStoreId`. Check `https://api.apify.com/v2/actor-runs/RUN_ID` until the run finishes. Then export `https://api.apify.com/v2/datasets/DATASET_ID/items?format=json` with the same authorization header; use `csv` or `xlsx` for other formats. The run's Output links `SUMMARY` and `ERRORS`.

Use `eventId` when sending results into a database, spreadsheet or your own alert workflow. A successful start request does not mean a completed scan. Check the final run status and coverage before treating results as complete.

### Troubleshooting and coverage

| Status or code | Meaning and next step |
| --- | --- |
| `BASELINE_CREATED` | Expected first successful watch scan. Keep the same history/settings and run again later |
| `NO_NEW_TRANSACTIONS` | No unseen matches among the successfully selected reports; inspect coverage if reports were omitted |
| `NO_MATCHES` | No transactions matched the snapshot filters. Try `all` or include derivatives if appropriate |
| `LIMIT_REACHED` | Row or result-fee cap limited delivery; inspect `truncated` |
| `PARTIAL` | Some companies/reports failed. Inspect `ERRORS` and company coverage |
| `UNKNOWN_TICKER` | Company ticker was not resolved. Check the symbol or use its CIK |
| `CHECKPOINT_SCOPE_MISMATCH` | Settings differ from the saved watch. Restore them or start a new history |
| `NO_COMPANY_DATA` | No company could be processed. Read the underlying report/source error |
| `CHECKPOINT_CAPACITY_EXCEEDED` | Saved history reached its supported capacity; establish a new baseline |
| `SEC_HTTP_403` / `SEC_HTTP_429` | Source access was rejected or limited; processing stops and the error is reported |

Recent-report availability, per-company report limits and your date window determine coverage. Older reports and the full historical archive are not collected. Report corrections/removals can affect later availability; documents containing only holdings yield no transaction rows. Some values or dates exist only in footnotes and remain null rather than being guessed. Only the actual transaction codes and source disclosures establish an operation's reported meaning.

Avoid overlapping runs, use one writer for a watch history and inspect partial results. No guaranteed detection delay, investment performance, automated trade execution or SEC endorsement is implied. See SEC's [Form 4 instructions](https://www.sec.gov/files/form4data.pdf), [public-content reuse guidance](https://www.sec.gov/about/webmaster-frequently-asked-questions) and [access guidance](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data).

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/insider-transactions-monitor/changelog.md

# Actor input Schema

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

Snapshot returns matching transaction lines. Watch first creates a baseline, then returns newly observed transactions.

## `companies` (type: `array`):

One to five company tickers or numeric CIK strings. Multiple symbols for one company count once.

## `transactionScope` (type: `string`):

Purchases and sales selects reported P/S codes. All also includes awards, gifts, withholding, exercises and other reported codes. Derivative securities have a separate switch.

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

Include reported option and other derivative transaction lines, labelled separately from ordinary shares.

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

Include amendments as separate reports. They may repeat or correct earlier transactions; no automatic replacement of the original.

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

Filter by report filing date, not transaction date. Available recent reports only, not a complete historical archive.

## `sinceDate` (type: `string`):

Inclusive YYYY-MM-DD. Overrides the lookback-derived start; maximum selected span365 days.

## `untilDate` (type: `string`):

Inclusive YYYY-MM-DD, default today UTC; no future end dates.

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

Inspect the newest matching reports per company up to this limit. One report can contain several transactions; older omitted reports are counted in SUMMARY.

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

Global transaction-row limit for the whole run. Zero skips processing.

## `maxCostUsd` (type: `number`):

Caps result fees only. Platform resources are separate. Zero skips processing.

## `stateStoreName` (type: `string`):

Required for watch. Use your own name and one run at a time. Changed companies, filters or report-scan limit require a new history.

## Actor input object example

```json
{
  "mode": "snapshot",
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "transactionScope": "purchases_sales",
  "includeDerivatives": false,
  "includeAmendments": true,
  "lookbackDays": 90,
  "maxFilingsPerCompany": 5,
  "maxResults": 100
}
```

# Actor output Schema

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

No description

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/insider-transactions-monitor").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("apivault_labs/insider-transactions-monitor").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 apivault_labs/insider-transactions-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/insider-transactions-monitor"
        }
    }
}
```

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/54ldbRUtZs35g4ObR/builds/7ac1z9QDpBmMGhfTe/openapi.json