# SEC Form 4 Insider Transactions Scraper (`automation-lab/sec-form-4-insider-transactions-scraper`) Actor

Extract insider stock transactions from SEC Form 4 filings by ticker, CIK, or accession number using EDGAR feeds and XML documents.

- **URL**: https://apify.com/automation-lab/sec-form-4-insider-transactions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## SEC Form 4 Insider Transactions Scraper

Track insider trading disclosures from SEC EDGAR Form 4 filings and export clean transaction-level rows for analysis, alerts, dashboards, and compliance review.

### What does SEC Form 4 Insider Transactions Scraper do?

SEC Form 4 Insider Transactions Scraper fetches recent SEC ownership filings for public companies and parses the raw XML filing documents into structured dataset rows.

It accepts stock tickers, SEC CIKs, or direct accession numbers, resolves company identifiers through official SEC feeds, downloads recent Form 4 / 4-A filings, and extracts each reported insider transaction.

Each row represents one transaction, not just one filing. That makes the output ready for spreadsheets, databases, alerting tools, and downstream financial research workflows.

### Who is it for?

- 📈 Investors monitoring insider buying and selling across a watchlist
- 📰 Finance journalists looking for newly reported executive transactions
- 🧾 Compliance teams reviewing insider activity and ownership disclosures
- 🔎 Market researchers building signals from SEC Form 4 data
- 🏦 Analysts enriching company profiles with recent officer and director trades
- 🤖 Automation teams that need a repeatable EDGAR Form 4 extractor

### Why use this scraper?

SEC filings are public, but the raw EDGAR pages are filing-centric and can be awkward to use in automated workflows.

This actor converts Form 4 XML into normalized rows with issuer, reporting owner, relationship flags, transaction code, shares, price, ownership type, accession number, and source URLs.

You get a repeatable Apify actor instead of one-off scripts, manual EDGAR searches, or expensive market-data APIs.

### Data you can extract

| Field | Description |
| --- | --- |
| `issuerCik` | SEC CIK for the issuer |
| `issuerName` | Company name from the Form 4 issuer block |
| `issuerTicker` | Ticker from SEC XML or the SEC ticker map |
| `reportingOwnerCik` | CIK for the insider/reporting owner |
| `reportingOwnerName` | Insider or reporting owner name |
| `isDirector` | Whether the owner is marked as a director |
| `isOfficer` | Whether the owner is marked as an officer |
| `isTenPercentOwner` | Whether the owner is a 10% owner |
| `officerTitle` | Officer title when supplied |
| `transactionType` | Non-derivative or derivative transaction |
| `securityTitle` | Security name, such as common stock or option |
| `transactionDate` | Date of the transaction |
| `transactionCode` | SEC transaction code such as P, S, A, M, F |
| `shares` | Number of shares or derivative securities |
| `pricePerShare` | Transaction price per share when reported |
| `acquiredDisposedCode` | A for acquired, D for disposed |
| `sharesOwnedFollowingTransaction` | Ownership after the transaction |
| `directOrIndirectOwnership` | Direct or indirect ownership flag |
| `ownershipNature` | Nature of indirect ownership when reported |
| `filingDate` | SEC filing date |
| `periodOfReport` | Period of report from the filing |
| `accessionNumber` | SEC accession number |
| `filingUrl` | SEC archive filing folder |
| `xmlUrl` | Raw XML document URL |

### How much does it cost to scrape SEC Form 4 insider transactions?

This actor uses pay-per-event pricing.

- A small one-time run-start event is charged when the actor begins.
- A per-transaction event is charged for each dataset row saved.
- You control cost with `maxTransactions`, `maxFilingsPerEntity`, tickers, CIKs, and date filters.

For a cheap first run, keep the default input or reduce `maxTransactions` to 25.

### How to use the actor

1. Open the actor on Apify.
2. Enter stock tickers such as `NVDA`, `TSLA`, `MSFT`, or `AAPL`.
3. Optionally add SEC CIKs if you already know them.
4. Set `maxTransactions` to cap the number of rows.
5. Optionally set `sinceDate` or `beforeDate` for a filing-date window.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or through the Apify API.

### Input options

#### Stock tickers

Use `tickers` for the most common workflow. The actor resolves tickers through the official SEC `company_tickers.json` file.

#### SEC CIKs

Use `ciks` when you already know the issuer CIK. Leading zeroes are optional.

#### Direct accession numbers

Use `accessionNumbers` when you need to reprocess an exact Form 4 filing. Include at least one ticker or CIK so the actor can build the SEC archive path.

#### Maximum transaction rows

`maxTransactions` caps the total dataset rows saved during a run.

#### Maximum filings per company

`maxFilingsPerEntity` controls how many recent Form 4 / 4-A filings are inspected for each company.

#### Filing date filters

Use `sinceDate` and `beforeDate` in `YYYY-MM-DD` format to filter by SEC filing date.

#### SEC User-Agent

SEC requests require a descriptive User-Agent. The default is suitable for testing, but production users should set their own application/company and contact email.

### Output example

```json
{
  "issuerTicker": "MSFT",
  "issuerName": "MICROSOFT CORP",
  "reportingOwnerName": "Jolla Alice L.",
  "isOfficer": true,
  "officerTitle": "Chief Accounting Officer",
  "transactionDate": "2026-06-15",
  "transactionCode": "A",
  "securityTitle": "Common Stock",
  "shares": 5004,
  "pricePerShare": 0,
  "acquiredDisposedCode": "A",
  "sharesOwnedFollowingTransaction": 76152.6646,
  "accessionNumber": "0000789019-26-000135",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/789019/000078901926000135/"
}
````

### Tips for better results

- Use a focused ticker watchlist for daily monitoring.
- Increase `maxFilingsPerEntity` when companies have many recent ownership filings.
- Use date filters for weekly, monthly, or quarterly review workflows.
- Keep `requestDelayMs` at 100 ms or higher to be friendly to SEC systems.
- Include derivative transactions when monitoring options, RSUs, and warrants.
- Disable derivative transactions if you only need common-stock Form 4 rows.

### Common transaction codes

- `P` — open market or private purchase
- `S` — open market or private sale
- `A` — grant, award, or other acquisition
- `M` — exercise or conversion of derivative security
- `F` — payment of exercise price or tax liability by delivering securities
- `G` — gift
- `D` — sale or transfer back to issuer

Always review the original filing and SEC code definitions for legal or investment decisions.

### Integrations

Use this actor with:

- Google Sheets exports for watchlist monitoring
- BigQuery or Snowflake for historical insider-transaction models
- Slack alerts when executives report large purchases or sales
- CRM enrichment for public-company executive activity
- Newsroom dashboards for filings published during market-moving periods
- Compliance queues for officer and director transaction review

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-form-4-insider-transactions-scraper').call({
  tickers: ['NVDA', 'MSFT'],
  maxTransactions: 100,
  maxFilingsPerEntity: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/sec-form-4-insider-transactions-scraper').call(run_input={
    'tickers': ['TSLA', 'AAPL'],
    'maxTransactions': 100,
    'maxFilingsPerEntity': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sec-form-4-insider-transactions-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"tickers":["NVDA","MSFT"],"maxTransactions":100,"maxFilingsPerEntity":20}'
```

### MCP usage

You can use this actor from Claude Code, Claude Desktop, or another MCP client through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/sec-form-4-insider-transactions-scraper
```

Claude Code setup:

```bash
claude mcp add apify-sec-form-4 "https://mcp.apify.com/?tools=automation-lab/sec-form-4-insider-transactions-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-sec-form-4": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-form-4-insider-transactions-scraper"
    }
  }
}
```

Example prompts:

- "Run the SEC Form 4 Insider Transactions Scraper for NVDA and summarize officer sales this month."
- "Extract Form 4 transactions for MSFT and return purchases above 1,000 shares."
- "Monitor my ticker list for new insider transaction rows and prepare a compliance summary."

### SEC fair-access notes

The actor uses public SEC EDGAR JSON and XML endpoints. SEC requires automated tools to identify themselves with a descriptive User-Agent and to avoid abusive request rates.

The input includes `secUserAgent` and `requestDelayMs` so users can keep runs compliant and transparent.

### Legality

SEC Form 4 filings are public regulatory disclosures. This actor only accesses public SEC endpoints and preserves source filing URLs.

### Is scraping SEC Form 4 data legal?

SEC Form 4 filings are public regulatory disclosures. This actor only accesses public SEC endpoints and preserves source filing URLs.

You are responsible for using the data in compliance with applicable laws, SEC terms and guidance, internal policies, and professional obligations. This actor does not provide legal, tax, or investment advice.

### FAQ

#### Can I monitor several companies in one run?

Yes. Add multiple tickers or CIKs and use `maxTransactions` to cap total output rows.

#### Does this actor scrape Form 3 or Form 5?

Version 0.1 focuses on Form 4 and 4-A transaction disclosures. Form 3 and Form 5 support can be added later if user demand warrants it.

### Troubleshooting

#### Why did my run return zero rows?

The ticker may have no recent Form 4 filings within your date window, the ticker may be invalid, or `maxFilingsPerEntity` may be too low. Try removing date filters and increasing the filing limit.

#### Why do some prices show as zero?

Form 4 filings can report grants, awards, or non-cash transactions with a zero price. Review `transactionCode`, `acquiredDisposedCode`, and the original filing.

#### Why is the reporting owner relationship blank?

The SEC filing controls which relationship fields are present. Some owners include director/officer flags and title; others may not.

### Related scrapers

Explore related Automation Lab actors for financial and market research workflows:

- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/rss-feed-scraper
- https://apify.com/automation-lab/company-information-scraper

### Reliability

The scraper avoids browser automation and uses official SEC endpoints. This keeps runs lightweight, fast, and low cost compared with scraping rendered web pages.

### Limitations

- It extracts recent filings available in SEC submissions feeds for each issuer.
- Direct accession parsing requires a CIK or ticker to build the archive path.
- Historical backfills beyond recent SEC submissions may require a future archive-index mode.
- Transaction interpretation still requires domain knowledge and review of original filings.

### Changelog

- `0.1.0` — Initial actor for ticker/CIK Form 4 discovery and XML transaction extraction.

### Support

If you need help with a Form 4 workflow, include the tickers, CIKs, date range, and run ID when contacting support.

# Actor input Schema

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

Public company tickers to resolve through SEC company\_tickers.json. Leave the prefill to collect a diversified market sample.

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

Optional SEC CIK identifiers, with or without leading zeroes. These are combined with tickers.

## `accessionNumbers` (type: `array`):

Optional Form 4 accession numbers to parse directly. Provide at least one ticker or CIK so the SEC archive path can be built.

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

Maximum insider transaction rows to save across all filings.

## `maxFilingsPerEntity` (type: `integer`):

How many recent Form 4 / 4-A filings to inspect for each ticker or CIK.

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

Optional lower bound for SEC filingDate in YYYY-MM-DD format.

## `beforeDate` (type: `string`):

Optional upper bound for SEC filingDate in YYYY-MM-DD format.

## `includeNonDerivativeTransactions` (type: `boolean`):

Extract common stock and other non-derivative Form 4 transaction rows.

## `includeDerivativeTransactions` (type: `boolean`):

Extract option, warrant, RSU, and other derivative Form 4 transaction rows.

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

SEC requires a descriptive User-Agent. Replace with your company/app and contact email for production monitoring.

## `requestDelayMs` (type: `integer`):

Friendly delay between SEC requests. Keep at 100ms or higher to respect SEC fair-access guidance.

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "TSLA",
    "MSFT",
    "AAPL",
    "AMZN",
    "META",
    "GOOGL",
    "JPM"
  ],
  "ciks": [],
  "accessionNumbers": [],
  "maxTransactions": 20,
  "maxFilingsPerEntity": 20,
  "includeNonDerivativeTransactions": true,
  "includeDerivativeTransactions": true,
  "secUserAgent": "automation-lab SEC Form 4 Insider Transactions Scraper contact@automation-lab.com",
  "requestDelayMs": 150
}
```

# Actor output Schema

## `overview` (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": [
        "NVDA",
        "TSLA",
        "MSFT",
        "AAPL",
        "AMZN",
        "META",
        "GOOGL",
        "JPM"
    ],
    "ciks": [],
    "accessionNumbers": [],
    "maxTransactions": 20,
    "maxFilingsPerEntity": 20,
    "sinceDate": "",
    "beforeDate": "",
    "includeNonDerivativeTransactions": true,
    "includeDerivativeTransactions": true,
    "secUserAgent": "automation-lab SEC Form 4 Insider Transactions Scraper contact@automation-lab.com",
    "requestDelayMs": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-form-4-insider-transactions-scraper").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": [
        "NVDA",
        "TSLA",
        "MSFT",
        "AAPL",
        "AMZN",
        "META",
        "GOOGL",
        "JPM",
    ],
    "ciks": [],
    "accessionNumbers": [],
    "maxTransactions": 20,
    "maxFilingsPerEntity": 20,
    "sinceDate": "",
    "beforeDate": "",
    "includeNonDerivativeTransactions": True,
    "includeDerivativeTransactions": True,
    "secUserAgent": "automation-lab SEC Form 4 Insider Transactions Scraper contact@automation-lab.com",
    "requestDelayMs": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-form-4-insider-transactions-scraper").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": [
    "NVDA",
    "TSLA",
    "MSFT",
    "AAPL",
    "AMZN",
    "META",
    "GOOGL",
    "JPM"
  ],
  "ciks": [],
  "accessionNumbers": [],
  "maxTransactions": 20,
  "maxFilingsPerEntity": 20,
  "sinceDate": "",
  "beforeDate": "",
  "includeNonDerivativeTransactions": true,
  "includeDerivativeTransactions": true,
  "secUserAgent": "automation-lab SEC Form 4 Insider Transactions Scraper contact@automation-lab.com",
  "requestDelayMs": 150
}' |
apify call automation-lab/sec-form-4-insider-transactions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/sec-form-4-insider-transactions-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form 4 Insider Transactions Scraper",
        "description": "Extract insider stock transactions from SEC Form 4 filings by ticker, CIK, or accession number using EDGAR feeds and XML documents.",
        "version": "0.1",
        "x-build-id": "NAk3o0JfvjeKakLoi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-form-4-insider-transactions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-form-4-insider-transactions-scraper",
                "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/automation-lab~sec-form-4-insider-transactions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-form-4-insider-transactions-scraper",
                "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/automation-lab~sec-form-4-insider-transactions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-form-4-insider-transactions-scraper",
                "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": {
                    "tickers": {
                        "title": "Stock tickers",
                        "type": "array",
                        "description": "Public company tickers to resolve through SEC company_tickers.json. Leave the prefill to collect a diversified market sample.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "SEC CIKs",
                        "type": "array",
                        "description": "Optional SEC CIK identifiers, with or without leading zeroes. These are combined with tickers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accessionNumbers": {
                        "title": "Direct accession numbers",
                        "type": "array",
                        "description": "Optional Form 4 accession numbers to parse directly. Provide at least one ticker or CIK so the SEC archive path can be built.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTransactions": {
                        "title": "Maximum transaction rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum insider transaction rows to save across all filings.",
                        "default": 20
                    },
                    "maxFilingsPerEntity": {
                        "title": "Maximum filings per company",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many recent Form 4 / 4-A filings to inspect for each ticker or CIK.",
                        "default": 20
                    },
                    "sinceDate": {
                        "title": "Filed on or after",
                        "type": "string",
                        "description": "Optional lower bound for SEC filingDate in YYYY-MM-DD format."
                    },
                    "beforeDate": {
                        "title": "Filed on or before",
                        "type": "string",
                        "description": "Optional upper bound for SEC filingDate in YYYY-MM-DD format."
                    },
                    "includeNonDerivativeTransactions": {
                        "title": "Include non-derivative transactions",
                        "type": "boolean",
                        "description": "Extract common stock and other non-derivative Form 4 transaction rows.",
                        "default": true
                    },
                    "includeDerivativeTransactions": {
                        "title": "Include derivative transactions",
                        "type": "boolean",
                        "description": "Extract option, warrant, RSU, and other derivative Form 4 transaction rows.",
                        "default": true
                    },
                    "secUserAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "SEC requires a descriptive User-Agent. Replace with your company/app and contact email for production monitoring.",
                        "default": "automation-lab SEC Form 4 Insider Transactions Scraper contact@automation-lab.com"
                    },
                    "requestDelayMs": {
                        "title": "Delay between SEC requests (ms)",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Friendly delay between SEC requests. Keep at 100ms or higher to respect SEC fair-access guidance.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
