# SEC insider data for AI agents (`spidey_silk_sense/sec-insider-conviction-signal`) Actor

Scores US insider trades on conviction. Separates genuine open-market buys from option exercises and 10b5-1 planned sales, weights by officer seniority and stake change, and flags multi-insider buy clusters.

- **URL**: https://apify.com/spidey\_silk\_sense/sec-insider-conviction-signal.md
- **Developed by:** [Investor's Toolkit](https://apify.com/spidey_silk_sense) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 Insider Conviction Signal

**Turn raw SEC Form 4 filings into a scored insider trading signal — with option exercises, tax withholding, and Rule 10b5-1 planned trades correctly stripped out.**

Most Form 4 tools hand you every filing an insider submits. That is the problem. The large majority of Form 4 activity is compensation mechanics — option exercises, restricted stock vesting, shares withheld for tax, gifts — and none of it tells you anything about what the insider believes. Feed that into a model and you get noise with a ticker attached.

This Actor returns only the transactions where an insider made a choice, and scores each one by how much conviction it actually represents.

***

### What it does

- **Filters to informative transactions only.** Transaction codes `P` (open-market purchase) and `S` (open-market sale), non-derivative. Codes `A`, `M`, `F`, `G`, `C`, `X` are parsed and discarded.
- **Resolves Rule 10b5-1 plan participation properly.** A trade scheduled months in advance carries very little information about present belief. The explicit schema flag only exists on post-2023 filings, so this Actor resolves plan status through three independent paths — the schema flag, footnotes linked to the specific transaction, and unlinked filing footnotes — and reports which path it used so you can discount weak evidence yourself.
- **Weights by seniority.** A CEO buying with personal cash is not the same event as a 10% holder rebalancing a mandate. Free-text officer titles are normalised into seniority buckets.
- **Measures conviction, not just size.** Scoring uses the trade's value *relative to the insider's resulting position*. Someone increasing their stake 40% is saying more than someone adding 0.4%, regardless of dollar amount.
- **Detects insider buy clusters.** Flags issuers where multiple *distinct* insiders bought on the open market inside a rolling window. Distinctness is enforced on owner CIK, so one insider filing several tranches never counts as a cluster.

### Output

Two record types in one dataset.

**`transaction`** — one per scored insider trade:

```json
{
  "record_type": "transaction",
  "transaction_date": "2026-03-11",
  "ticker": "EXIN",
  "issuer_name": "EXAMPLE INDUSTRIES INC.",
  "owner_name": "Doe Jane A",
  "officer_title": "President and Chief Executive Officer",
  "seniority": "ceo",
  "transaction_code": "P",
  "code_meaning": "Open-market or private purchase",
  "shares": 40000,
  "price_per_share": 25.5,
  "value_usd": 1020000.0,
  "shares_owned_after": 140000,
  "rule_10b5_1": false,
  "rule_10b5_1_evidence": null,
  "direction": "buy",
  "conviction_score": 60.83,
  "score_components": {
    "seniority_weight": 1.0,
    "size_factor": 1.577,
    "conviction_ratio": 0.4,
    "plan_multiplier": 1.0
  },
  "source_url": "https://www.sec.gov/Archives/edgar/data/..."
}
```

**`cluster`** — one per issuer with coordinated insider buying:

```json
{
  "record_type": "cluster",
  "ticker": "EXIN",
  "window_start": "2026-03-02",
  "window_end": "2026-04-01",
  "distinct_insiders": 3,
  "distinct_roles": ["ceo", "cfo", "director"],
  "total_value_usd": 2840000.0,
  "cluster_score": 71.4,
  "insiders": ["Doe Jane A", "Ng Peter", "Ruiz Marta"]
}
```

`conviction_score` is signed: positive is buying, negative is selling, magnitude is conviction on a 0–100 scale. Every component is exposed, so you can audit or re-derive any score rather than trusting a black box.

### Modes

**Daily scan** — sweeps the EDGAR daily index for every Form 4 filed in the last N days. Schedule it to run each evening for a market-wide insider monitor.

**Tickers** — pulls Form 4 history for named companies over a chosen window. Use for research, backtesting, and backfill.

### Input

| Field | Description |
|---|---|
| `userAgent` | **Required.** The SEC requires a descriptive User-Agent containing a contact email, e.g. `Acme Research contact@acme.com`. |
| `mode` | `daily` or `tickers`. |
| `lookbackDays` | Days to scan in daily mode. Form 4s are due within two business days, so `3` catches essentially everything. |
| `tickers` | Symbols to pull, in tickers mode. |
| `minAbsScore` | Drop transactions below this magnitude. `25` is a reasonable noise floor. |
| `excludePlanned` | Drop Rule 10b5-1 trades entirely rather than discounting them. |
| `includeClusters` | Emit cluster records. |
| `seniorityWeights` | Override the role weights used in scoring. |

### Tuning it for your own model

The scoring weights are not hard-coded opinions you have to accept. `seniorityWeights` is overridable from the input, and `clusterWindowDays` / `clusterMinInsiders` control cluster sensitivity. If you disagree with how a 10% owner is weighted, change it.

### Notes on data and compliance

Data comes from the SEC's EDGAR system, which publishes filings as public records and explicitly supports programmatic access. This Actor uses no headless browser, no proxies, and no anti-bot evasion; it sends a descriptive User-Agent and stays under the SEC's published request-rate ceiling.

Form 4 filings are self-reported by insiders and their agents. Amendments (`4/A`) are returned alongside originals and are not automatically reconciled against the filing they amend. Filings before mid-2003 pre-date the XML schema and are not parsed. Issuers without a listed ticker may return a null or placeholder symbol.

Nothing here is investment advice. Insider buying is a studied but noisy factor; this Actor gives you a clean input to your own research process, not a recommendation.

### Common questions

**Why are there so few records compared to other Form 4 scrapers?**
Because the others are returning option exercises and tax withholding. If you want the raw firehose, that is a different tool. This one is deliberately selective.

**Why is a large insider sale scoring near zero?**
It was almost certainly a Rule 10b5-1 planned sale. Check the `rule_10b5_1` and `rule_10b5_1_evidence` fields. If you want those dropped entirely rather than discounted, set `excludePlanned`.

**Can I get intraday or real-time alerts?**
Schedule the Actor with `lookbackDays: 1`. Resolution is bounded by EDGAR's own publication cadence.

# Actor input Schema

## `userAgent` (type: `string`):

The SEC requires a descriptive User-Agent containing a contact email. Example: 'Acme Research contact@acme.com'. Runs without a valid email will fail fast.

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

'daily' scans the EDGAR daily index for all recent Form 4 filings (use this for scheduled monitoring). 'tickers' pulls filing history for named companies (use this for research and backfill).

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

How many calendar days back to scan. Weekends are skipped automatically. Form 4s are due within two business days, so 3 catches essentially everything.

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

Ticker symbols to pull Form 4 history for.

## `tickerLookbackDays` (type: `integer`):

How far back to pull each company's Form 4 history, in days.

## `directions` (type: `array`):

Keep buys, sells, or both.

## `minAbsScore` (type: `integer`):

Drop transactions scoring below this magnitude (0-100). Raise it to cut noise; 25 is a reasonable starting threshold.

## `excludePlanned` (type: `boolean`):

Planned trades are scheduled in advance and carry far less information about current belief. Turn on to drop them entirely rather than merely discounting them.

## `includeClusters` (type: `boolean`):

Emit an additional record per issuer where multiple distinct insiders bought on the open market inside a rolling window.

## `clusterWindowDays` (type: `integer`):

The rolling window, in days, within which multiple insiders' open-market buys are grouped into one cluster. A shorter window demands tighter timing to count as coordinated.

## `clusterMinInsiders` (type: `integer`):

How many distinct insiders (by owner CIK) must buy on the open market inside the window for it to count as a cluster. Higher values return fewer, stronger clusters.

## `seniorityWeights` (type: `object`):

Override the role weights used in scoring. Keys: ceo, cfo, c\_suite\_other, svp\_evp, officer, director, ten\_percent\_owner, other.

## `maxFilings` (type: `integer`):

Hard ceiling on submissions fetched. Protects against a runaway bill on a wide date range.

## Actor input object example

```json
{
  "userAgent": "Your Company your.email@example.com",
  "mode": "daily",
  "lookbackDays": 3,
  "tickers": [
    "AAPL",
    "NVDA",
    "JPM"
  ],
  "tickerLookbackDays": 180,
  "directions": [
    "buy",
    "sell"
  ],
  "minAbsScore": 0,
  "excludePlanned": false,
  "includeClusters": true,
  "clusterWindowDays": 30,
  "clusterMinInsiders": 3,
  "maxFilings": 2000
}
```

# Actor output Schema

## `results` (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 = {
    "userAgent": "Your Company your.email@example.com",
    "tickers": [
        "AAPL",
        "NVDA",
        "JPM"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spidey_silk_sense/sec-insider-conviction-signal").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 = {
    "userAgent": "Your Company your.email@example.com",
    "tickers": [
        "AAPL",
        "NVDA",
        "JPM",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("spidey_silk_sense/sec-insider-conviction-signal").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 '{
  "userAgent": "Your Company your.email@example.com",
  "tickers": [
    "AAPL",
    "NVDA",
    "JPM"
  ]
}' |
apify call spidey_silk_sense/sec-insider-conviction-signal --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spidey_silk_sense/sec-insider-conviction-signal"
        }
    }
}
```

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/AZRqfokDncRe0XoVN/builds/A0OvoSA6Z9y5vJ4wm/openapi.json