# 📈 SEC Insider Trading Scraper (`skootle/sec-form4-insider-trades`) Actor

Turn raw SEC Form 4 filings into alert-ready insider trades. Search by ticker, company, insider, CIK, or date. Get one row per trade with shares, price, value, role, decoded action, and precomputed cluster signals. Export, run via API, schedule, or integrate with other tools.

- **URL**: https://apify.com/skootle/sec-form4-insider-trades.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 transaction records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

<!-- skootle:growth-loop-hook -->
### Stop decoding Form 4 XML by hand

Stop opening EDGAR filings, decoding one-letter transaction codes, and flattening nested XML by hand. This Actor turns Form 4 filings into alert-ready trade rows and can emit dedicated multi-insider cluster signals when the configured criteria are met.

- Search by ticker, company, insider, CIK, or date range.
- Get one clean row per saved transaction with shares, price, dollar value, role, decoded action, and direct filing URL.
- Schedule saved searches or send results to alerts, spreadsheets, databases, Slack, and APIs.

![SEC Form 4 Insider Trades hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/sec-form4-insider-trades-v2.png)

### TL;DR

Turn SEC Form 4 filings into transaction-level data without writing or maintaining an EDGAR XML parser. Track insider purchases, sales, grants, exercises, and ownership changes. When enough distinct insiders at one issuer meet your configured window and direction criteria, the Actor emits dedicated `cluster_signal` records alongside transaction rows.

**Verified cloud proof:** the current-build market-wide trial processed 5 filings, saved 19 transaction rows, and reported 0 parser errors. [Inspect the public sample dataset.](https://api.apify.com/v2/datasets/fdQQXDXyNbDf2hPV7/items?clean=true) Review every signal against the linked Form 4. Cluster signals are analytical flags, not investment advice.

<!-- skootle:review-cta -->
> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/sec-form4-insider-trades/reviews).

---

### What does SEC Form 4 Insider Trades do?

When a corporate insider (director, officer, or 10%+ shareholder) buys or sells equity in their own company, federal securities law requires them to file a Form 4 with the SEC within two business days. The filings publish on EDGAR as machine-readable XML. Each Form 4 can contain multiple transactions - a CEO selling shares, exercising options, and surrendering shares for tax withholding can all be in one filing.

This actor:

1. Calls EDGAR's full-text search API (`efts.sec.gov`) to find Form 4 filings matching your filter (ticker, issuer name, insider name, CIK, date range).
2. Fetches the XML for each matching filing directly from `sec.gov/Archives`.
3. Parses every non-derivative and derivative transaction into a flat row with typed numerics.
4. Decodes the transaction code (`P`, `S`, `A`, `D`, `M`, etc.) into a plain-English description.
5. Extracts the reporting owner's role flags (Director / Officer / 10% Owner / Other) and officer title text into typed booleans + enum.
6. Optionally runs cluster detection across all parsed transactions and emits a separate `cluster_signal` record when 3+ unique insiders at the same issuer trade in the same direction within a rolling N-day window.

The output is two record types in one dataset, discriminated by `recordType` (`transaction` or `cluster_signal`).

### Why scrape SEC Form 4?

Form 4 is a federally mandated disclosure of transactions by directors, officers, and 10% owners. Researchers and monitoring teams use it to study insider activity, but any signal requires context and should be checked against the underlying filing. The source data is public and free.

What's painful is the consumption shape. EDGAR publishes Form 4 as schema-X0609 XML with `nonDerivativeTransaction` and `derivativeTransaction` arrays nested under `ownershipDocument` root, with each transaction wrapped in a tree of `transactionAmounts`, `postTransactionAmounts`, `ownershipNature`, `securityTitle.value` blocks. Every field is a string. Every comparison code is a single uppercase letter. Every footnote is a separate element. To get a usable row out, you write 200+ lines of XML extraction per filing.

This actor does that extraction once. Buyers consume the rows.

### Who needs this?

- **Retail-investor SaaS products** building insider-trade alerts and research workflows.
- **Quant research desks** testing signals on normalized insider-transaction data.
- **Equity research analysts** building one-off industry insider-flow studies.
- **Financial journalists** running stories on specific insider moves.
- **Compliance teams** auditing their own executives' Section 16 reporting.
- **AI agents and automation pipelines** that need clean, parsed Form 4 data piped into a daily LLM context or a structured DB.

### How to use SEC Form 4 Insider Trades

1. Open the actor in the Apify Console.
2. Set `contactEmail` to your real work email. SEC.gov Fair Access policy requires this on every request. The email is stored encrypted; it is never displayed publicly.
3. Choose at least one filter: `tickers`, `issuerNames`, `ciks`, or `insiderNames`. If you leave all four empty, the actor pulls recent Form 4s market-wide.
4. (Optional) Restrict to a date range with `startDate` and `endDate`. Defaults to the last 30 days.
5. (Optional) Leave `emitClusterSignals` on (the default) to also get pre-computed cluster-buy/cluster-sell rows.
6. Set `maxFilings` (default 10 trial; production typically 100-1000).
7. Click **Start**.

### How much will scraping Form 4 cost?

Pricing is per-result (per transaction row written to the dataset). Cluster-signal records do not incur a separate event charge - they're free byproducts of the run.

| Plan tier | Per-result price |
|---|---|
| FREE | $0.006 |
| BRONZE | $0.005 |
| SILVER | $0.004 |
| GOLD | $0.003 |
| PLATINUM | $0.003 |
| DIAMOND | $0.003 |

You pay only for saved transaction rows. A 10-row trial costs $0.06 on the FREE tier or $0.03 on GOLD. The final cost of a date range depends on how many matching transactions EDGAR returns; use `maxTransactions` to set a predictable ceiling.

### Is it legal to scrape SEC EDGAR?

Yes. SEC EDGAR is the official U.S. Securities and Exchange Commission public-disclosure system. The data is explicitly released for public reuse. The only operational requirement is the [SEC Fair Access policy](https://www.sec.gov/os/accessing-edgar-data) requiring requests to include a real contact email in the User-Agent header - this actor enforces that. The free EDGAR full-text-search API (`efts.sec.gov`) is the official endpoint for programmatic search.

### Examples

**Track Apple insiders across a fixed research window.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "tickers": ["AAPL"],
  "startDate": "2026-07-01",
  "maxFilings": 100
}
````

**One-day market-wide insider sweep.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "startDate": "2026-07-16",
  "endDate": "2026-07-16",
  "maxFilings": 500,
  "emitClusterSignals": true,
  "clusterWindowDays": 5,
  "clusterMinInsiders": 3
}
```

**Watch a basket of tech tickers.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "tickers": ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "NVDA"],
  "startDate": "2026-07-01",
  "maxFilings": 1000
}
```

**Track one specific insider across all companies they file at.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "ciks": ["0001214128"],
  "maxFilings": 50
}
```

**Cluster signals only - tune the window tighter.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "startDate": "2026-07-01",
  "maxFilings": 2000,
  "emitClusterSignals": true,
  "clusterWindowDays": 3,
  "clusterMinInsiders": 4
}
```

**Audit one biotech's IPO-era insider activity.**

```json
{
  "contactEmail": "you@yourcompany.com",
  "issuerNames": ["MoonRoc Therapeutics"],
  "startDate": "2026-07-01",
  "maxFilings": 200
}
```

### Input parameters

| Field | Type | Description |
|---|---|---|
| `contactEmail` | string | **Required.** SEC Fair Access policy. |
| `tickers` | string\[] | Issuer tickers. |
| `issuerNames` | string\[] | Full or partial issuer names. |
| `ciks` | string\[] | 10-digit CIKs (issuer or insider). |
| `insiderNames` | string\[] | Reporting-owner names. |
| `startDate` | string | ISO date inclusive. Default: 30 days ago. |
| `endDate` | string | ISO date inclusive. Default: today. |
| `emitClusterSignals` | boolean | Compute and emit cluster rows. Default true. |
| `clusterWindowDays` | integer | Rolling window for cluster detection. Default 5. |
| `clusterMinInsiders` | integer | Minimum distinct insiders for a cluster. Default 3. |
| `maxFilings` | integer | Upper bound on filings fetched. Default 10. |
| `maxTransactions` | integer | Safety cap on transaction rows. Default 5000. |

### Output format

#### `transaction` record

| Field | Type | Notes |
|---|---|---|
| `recordType` | string | Always `"transaction"`. |
| `accessionNumber` | string | E.g. `"0001225208-26-005023"`. |
| `filingDate` | string | ISO date. |
| `periodOfReport` | string | ISO date of transaction period. |
| `filingUrl` | string | Direct URL to the Form 4 XML. |
| `issuerCik`, `issuerName`, `issuerTicker` | string | Subject company. |
| `insiderCik`, `insiderName` | string | Reporting owner. |
| `insiderRoles` | string\[] | Array of `Director`, `Officer`, `TenPercentOwner`, `Other`. |
| `insiderOfficerTitle` | string | Free-text officer title from filing. |
| `insiderIsDirector`, `insiderIsOfficer`, `insiderIsTenPercentOwner` | boolean | Typed booleans. |
| `securityTitle` | string | E.g. `"Common Stock"`, `"Restricted Stock Units"`. |
| `isDerivative` | boolean | True for options, RSUs, warrants, etc. |
| `transactionCode` | enum | SEC code: `P`, `S`, `A`, `D`, `F`, `M`, `G`, `C`, etc. |
| `transactionCodeDescription` | string | Plain-English description of the code. |
| `acquiredOrDisposed` | enum | `A` / `D` / `OTHER`. |
| `transactionDate` | string | ISO date. |
| `sharesTraded` | number | Typed numeric. |
| `pricePerShare` | number | Typed numeric in USD. |
| `transactionValueUsd` | number | shares × price; null when price is 0. |
| `postTransactionShares` | number | Shares the insider owns after this transaction. |
| `directOrIndirectOwnership` | enum | `D` (direct) / `I` (indirect) / `OTHER`. |
| `fieldCompletenessScore` | integer | 0-100. |
| `agentMarkdown` | string | LLM-ready card. |

The record below came from the verified current-build market-wide trial:

```json
{
  "recordType": "transaction",
  "outputSchemaVersion": "2026-05-12",
  "filingDate": "2026-07-17",
  "issuerName": "Nerdy Inc.",
  "issuerTicker": "NRDY",
  "insiderName": "Callaway Kyle",
  "insiderOfficerTitle": "Chief Accounting Officer",
  "transactionCode": "A",
  "transactionCodeDescription": "Grant, award, or other acquisition under benefit plan",
  "transactionDate": "2026-07-15",
  "sharesTraded": 100000,
  "pricePerShare": 0,
  "transactionValueUsd": null,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/2145476/000214547626000004/wk-form4_1784319778.xml"
}
```

#### `cluster_signal` record

Emitted when `emitClusterSignals: true` and 3+ unique insiders at the same issuer transact in the same direction within the rolling window.

| Field | Type | Notes |
|---|---|---|
| `recordType` | string | Always `"cluster_signal"`. |
| `clusterType` | enum | `cluster_buy` or `cluster_sell`. |
| `rollingWindowDays` | integer | The window setting. |
| `insiderCount` | integer | Distinct insiders. |
| `transactionCount` | integer | Underlying transactions. |
| `totalSharesTraded` | number | Sum of shares. |
| `totalValueUsd` | number | Sum of dollar value. |
| `insiderNames` | string\[] | Names of the participating insiders. |
| `firstTransactionDate`, `lastTransactionDate` | string | ISO dates spanning the cluster. |

### During the Actor run

The actor first hits EDGAR full-text search to enumerate Form 4 filings matching your filter. For each match, it fetches the filing XML at `sec.gov/Archives/edgar/data/...`, parses both transaction tables, and pushes one row per transaction. If cluster signals are enabled, the actor runs a rolling-window detection over the parsed transactions at the end of the run and pushes one record per detected cluster.

Run artifacts:

- `OUTPUT`: counts, total buys/sells in USD, unique issuers + insiders, API call counts.
- `AGENT_BRIEFING`: markdown digest with cluster signals + top 10 transactions by dollar value.

### FAQ

#### How does Form 4 reporting work?

Section 16 of the Securities Exchange Act of 1934 requires officers, directors, and 10%-plus shareholders to disclose covered transactions. The Actor uses EDGAR's full-text search index, whose indexing time is controlled by the SEC. Use overlapping date windows and deduplicate on accession and transaction identity for robust monitoring.

#### What's a "cluster buy" and why does it matter?

A cluster buy is when multiple distinct insiders at the same issuer make qualifying purchases within a short rolling window. The Actor's defaults use a 5-day window and 3 or more insiders. This is a screening flag, not a prediction or investment recommendation; inspect the underlying transaction codes, ownership changes, footnotes, and filing links.

#### Can I get only purchases (code P)?

Yes - filter client-side after the run. Apify's dataset query API supports filtering on any field. Or in your downstream pipeline, drop rows where `transactionCode !== "P"`. We considered an input filter but kept the output unfiltered so cluster detection can run across the whole set.

#### Why are some transactions missing dollar values?

Form 4 transactions filed with `pricePerShare: 0` are typically grants (code A), exercises of zero-cost RSUs, or tax-withholding share surrenders (code F) where there's no market price. The actor preserves the underlying numbers but sets `transactionValueUsd` to null. Filter on `transactionCode` in `["P", "S"]` to get only open-market transactions with real prices.

#### Can I use this with Python / Make / Zapier / n8n / Slack?

Yes. The Apify Python client is the easiest path. The `agentMarkdown` field on every transaction and cluster signal is designed for direct posting into a Slack channel.

#### How does this differ from existing free EDGAR scrapers?

Free actors pull the raw filing XML or return one row per filing. This actor returns one row per transaction (a single filing typically has 1-5), with the SEC code decoded into a description, the insider's role flags as typed booleans, and the cluster-signal layer pre-computed. The data shape is what every consumer of Form 4 needs but few existing actors deliver.

#### Does this overlap with sec-edgar-filings?

The sister actor `skootle/sec-edgar-filings` is a generalist EDGAR full-text scraper. This actor is the Form 4 specialist - every line of code is dedicated to the Form 4 schema. Use the generalist for 10-K/10-Q/8-K/13F/etc. Use this one for Form 4 specifically.

#### Why do I need to supply my own contact email?

SEC.gov Fair Access policy requires a real contact email in the User-Agent of every request. If multiple actors share one email at high volume, the SEC may rate-limit or block that email. Per-actor / per-buyer emails keep volume distributed and your access reliable.

#### How fresh is the data?

EDGAR ingests Form 4 filings continuously during business hours, but full-text-search indexing can lag and is controlled by the SEC. Schedule recurring runs with an overlapping date window and deduplicate on accession number plus transaction identity for robust monitoring.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/sec-form4-insider-trades/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose SEC Form 4 Insider Trades

- **One row per transaction, not per filing.** Multi-transaction filings get fanned out so downstream analytics is one filter expression, not a flatmap.
- **Cluster-buy / cluster-sell signals pre-computed.** The configurable rolling-window detector runs after parsing and emits dedicated signal records alongside transaction rows when the threshold is met.
- **Decoded transaction codes.** Plain-English description on every row. No more "what does code 'F' mean again?".
- **Role enum + officer title parsed.** `insiderRoles` is a typed array (`Director`, `Officer`, `TenPercentOwner`); `insiderOfficerTitle` carries the free-text title verbatim ("Chief Financial Officer").
- **Typed numerics throughout.** Shares, price, dollar value, post-transaction shares - all numbers, not strings.
- **Versioned schema** (`outputSchemaVersion: "2026-05-12"`).
- **`fieldCompletenessScore`** per record.
- **`agentMarkdown`** per record + **`AGENT_BRIEFING.md`** per run for LLM / Slack consumption.

### Other Skootle actors you might want to check

- [SEC EDGAR Filings](https://apify.com/skootle/sec-edgar-filings) - generalist EDGAR full-text search.
- [SAM.gov + USAspending Federal Contracts](https://apify.com/skootle/sam-gov-federal-contracts) - federal contract opportunities.
- [Federal Rulemaking Monitor](https://apify.com/skootle/federal-rulemaking-monitor) - FR + Regulations.gov.
- [CMS Open Payments](https://apify.com/skootle/cms-open-payments) - pharma payments to physicians, NPI-joined.

### Support and contact

Open an issue at the [Issues tab](https://apify.com/skootle/sec-form4-insider-trades/issues/open) for bugs or feature requests. Typical response time 48 hours.

# Actor input Schema

## `contactEmail` (type: `string`):

Required. SEC.gov Fair Access policy requires every request to include a real contact email in the User-Agent header. Use your work email; SEC may contact you about unusual usage. Stored encrypted; never displayed publicly.

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

Stock tickers to pull Form 4 filings for (e.g. \['AAPL', 'TSLA', 'NVDA']).

## `issuerNames` (type: `array`):

Full or partial issuer company names (e.g. \['Apple Inc', 'Tesla']).

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

Specific 10-digit Central Index Keys to look up. Use issuer CIKs to track a company; use insider CIKs to track a specific person's filings across companies.

## `insiderNames` (type: `array`):

Reporting-owner names to search for (e.g. \['Jeff Bezos', 'Elon Musk']).

## `startDate` (type: `string`):

ISO date (YYYY-MM-DD) for earliest filing date. Defaults to 30 days ago.

## `endDate` (type: `string`):

ISO date (YYYY-MM-DD) for latest filing date. Defaults to today.

## `emitClusterSignals` (type: `boolean`):

Run a rolling-window detection across all parsed transactions and emit one signal record per detected cluster (3+ unique insiders buying/selling the same issuer within N days).

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

How many days insiders' transactions must occur within for a cluster signal. Default 5.

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

Minimum number of distinct insiders required to fire a cluster signal. Default 3.

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

Upper bound on filings fetched. Each filing typically contains 1-5 transactions. Default 10 (trial); production 100-1000.

## `maxTransactions` (type: `integer`):

Upper bound on transaction rows pushed. Used as a safety cap independent of filings.

## Actor input object example

```json
{
  "tickers": [],
  "issuerNames": [],
  "ciks": [],
  "insiderNames": [],
  "emitClusterSignals": true,
  "clusterWindowDays": 5,
  "clusterMinInsiders": 3,
  "maxFilings": 10,
  "maxTransactions": 5000
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `agentBriefing` (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 = {
    "tickers": [],
    "issuerNames": [],
    "ciks": [],
    "insiderNames": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/sec-form4-insider-trades").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": [],
    "issuerNames": [],
    "ciks": [],
    "insiderNames": [],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/sec-form4-insider-trades").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [],
  "issuerNames": [],
  "ciks": [],
  "insiderNames": []
}' |
apify call skootle/sec-form4-insider-trades --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=skootle/sec-form4-insider-trades",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📈 SEC Insider Trading Scraper",
        "description": "Turn raw SEC Form 4 filings into alert-ready insider trades. Search by ticker, company, insider, CIK, or date. Get one row per trade with shares, price, value, role, decoded action, and precomputed cluster signals. Export, run via API, schedule, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "f4U7Ze52w7MTkPN3I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~sec-form4-insider-trades/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-sec-form4-insider-trades",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/skootle~sec-form4-insider-trades/runs": {
            "post": {
                "operationId": "runs-sync-skootle-sec-form4-insider-trades",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/skootle~sec-form4-insider-trades/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-sec-form4-insider-trades",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "contactEmail": {
                        "title": "Contact email (required by SEC)",
                        "type": "string",
                        "description": "Required. SEC.gov Fair Access policy requires every request to include a real contact email in the User-Agent header. Use your work email; SEC may contact you about unusual usage. Stored encrypted; never displayed publicly."
                    },
                    "tickers": {
                        "title": "Issuer tickers",
                        "type": "array",
                        "description": "Stock tickers to pull Form 4 filings for (e.g. ['AAPL', 'TSLA', 'NVDA']).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "issuerNames": {
                        "title": "Issuer company names",
                        "type": "array",
                        "description": "Full or partial issuer company names (e.g. ['Apple Inc', 'Tesla']).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "Issuer or insider CIKs",
                        "type": "array",
                        "description": "Specific 10-digit Central Index Keys to look up. Use issuer CIKs to track a company; use insider CIKs to track a specific person's filings across companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "insiderNames": {
                        "title": "Insider names",
                        "type": "array",
                        "description": "Reporting-owner names to search for (e.g. ['Jeff Bezos', 'Elon Musk']).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD) for earliest filing date. Defaults to 30 days ago."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD) for latest filing date. Defaults to today."
                    },
                    "emitClusterSignals": {
                        "title": "Emit cluster-buy / cluster-sell signals",
                        "type": "boolean",
                        "description": "Run a rolling-window detection across all parsed transactions and emit one signal record per detected cluster (3+ unique insiders buying/selling the same issuer within N days).",
                        "default": true
                    },
                    "clusterWindowDays": {
                        "title": "Cluster rolling-window days",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many days insiders' transactions must occur within for a cluster signal. Default 5.",
                        "default": 5
                    },
                    "clusterMinInsiders": {
                        "title": "Cluster minimum insiders",
                        "minimum": 2,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum number of distinct insiders required to fire a cluster signal. Default 3.",
                        "default": 3
                    },
                    "maxFilings": {
                        "title": "Max Form 4 filings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on filings fetched. Each filing typically contains 1-5 transactions. Default 10 (trial); production 100-1000.",
                        "default": 10
                    },
                    "maxTransactions": {
                        "title": "Max transaction rows",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Upper bound on transaction rows pushed. Used as a safety cap independent of filings.",
                        "default": 5000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```