# SEC Insider Trading Tracker – Form 4 (`sfoln/sec-insider-trading`) Actor Insider trades from SEC Form 4 and Form 5 filings: one row per transaction with the insider's name and role, date, transaction code, shares, price, value, holdings after and 10b5-1 flag. By company ticker, CIK or name, or for all companies. $2 per 1,000 transactions. - **URL**: https://apify.com/sfoln/sec-insider-trading.md - **Developed by:** [SFOLN LLC](https://apify.com/sfoln) (community) - **Categories:** News, AI, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.80 / 1,000 insider transactions This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README Track **insider trading from SEC Form 4 and Form 5 filings**: one clean row per transaction with the insider's name and role as filed (director, officer and title, 10% owner), transaction date, SEC transaction code and its meaning (open-market purchase, sale, award, option exercise, tax withholding, gift), shares, price, dollar value, shares owned afterwards, direct or indirect ownership, the Rule 10b5-1 flag and the filing's footnotes. Look up companies by ticker, CIK or name, or read the latest filings of **all companies** to spot insider buying across the market. Built for investors, quant and research teams, journalists and AI agents. - **What you get:** issuer, insider and role, date, code, acquired/disposed, shares, price, value, holdings after, option and RSU details, footnotes, links to the filing. - **Price:** $0.002 per transaction ($2 per 1,000); unknown companies, unreadable filings and summaries are free. - **Works everywhere:** API, MCP for AI agents, Make, Zapier, n8n, schedules and webhooks. ### Input | Field | Type | Default | Description | | --- | --- | --- | --- | | `companies` | string\[] | – | Issuers by ticker (`AAPL`), CIK (`320193`) or name, one per line. Empty: the latest Form 4/5 transactions of all companies. | | `transactionCodes` | string\[] | all | Only these codes, e.g. `P` (open-market purchase), `S` (sale), `A` (award), `M` (option exercise), `F` (tax withholding), `G` (gift). | | `dateFrom` / `dateTo` | string | – | Filing-date window: `YYYY-MM-DD` or a span back from today such as `30 days`. For all companies the default window is the last 3 days. | | `minTransactionValue` | integer | – | Only transactions worth at least this many US dollars (shares × price). | | `includeDerivative` | boolean | true | Also return option, RSU and warrant transactions (Form 4 Table II). | | `includeAmendments` | boolean | true | Also read amended filings (4/A, 5/A). | | `maxTransactionsPerCompany` | integer | 50 | Transactions per company, newest filings first (1–5,000). For all companies: transactions in total. | | `maxCompanies` | integer | 100 | Safety cap on companies per run; extra inputs are reported as `inputItemsDropped`. | | `concurrency` | integer | 2 | Companies processed in parallel (1–5). All requests share SEC's rate limit. | | `includeRaw` | boolean | false | Attach the transaction as parsed from the filing XML. | ```json { "companies": ["AAPL", "NVDA", "TSLA"], "dateFrom": "90 days", "maxTransactionsPerCompany": 100 } ``` Market-wide open-market purchases of at least $100,000 filed in the last week: ```json { "transactionCodes": ["P"], "minTransactionValue": 100000, "dateFrom": "7 days", "maxTransactionsPerCompany": 200 } ``` ### Output Each transaction is one row (`recordType: "transaction"`, charged); each company (or the market-wide run) also gets one summary record (`recordType: "summary"`, never charged). Example (insider name replaced with a placeholder): ```json [ { "input": "AAPL", "recordType": "transaction", "position": 3, "accessionNumber": "0001140361-26-038674", "form": "4", "filingDate": "2026-10-05", "periodOfReport": "2026-10-01", "issuerCik": 320193, "issuerName": "Apple Inc.", "issuerTicker": "AAPL", "ownerName": "DOE JANE Q", "ownerCik": 9990001, "ownerRelationship": "Director, Officer (Executive Chair)", "isDirector": true, "isOfficer": true, "officerTitle": "Executive Chair", "isTenPercentOwner": false, "reportingOwners": [{ "name": "DOE JANE Q", "cik": 9990001, "relationship": "Director, Officer (Executive Chair)" }], "table": "non-derivative", "securityTitle": "Common Stock", "transactionDate": "2026-10-02", "transactionCode": "S", "transactionCodeDescription": "Open market or private sale", "acquiredDisposed": "D", "shares": 23143, "pricePerShare": 331.44, "transactionValue": 7670515.92, "sharesOwnedAfter": 3432778, "directOrIndirect": "D", "ownershipNature": null, "conversionOrExercisePrice": null, "exerciseDate": null, "expirationDate": null, "underlyingSecurityTitle": null, "underlyingShares": null, "deemedExecutionDate": null, "equitySwapInvolved": false, "isRule10b5_1": true, "footnotes": [ "This transaction was made pursuant to a Rule 10b5-1 trading plan adopted by the reporting person on May 28, 2026.", "This transaction was executed in multiple trades at prices ranging from $330.66 to $331.655; the price reported above reflects the weighted average sale price." ], "xmlUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126038674/form4.xml", "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126038674/0001140361-26-038674-index.htm", "status": "ok", "charged": true, "chargedEvent": "insider-transaction", "source": "sec-edgar", "fetchedAt": "2026-10-14T10:00:00.000Z" }, { "input": "AAPL", "query": "AAPL", "issuerCik": 320193, "issuerName": "Apple Inc.", "issuerTicker": "AAPL", "matchedBy": "ticker", "filingsScanned": 5, "recordType": "summary", "resultsDelivered": 50, "stopReason": "limit", "status": "ok", "charged": false, "source": "sec-edgar", "fetchedAt": "2026-10-14T10:00:00.000Z" } ] ``` | Field | Description | | --- | --- | | `ownerName`, `ownerCik`, `ownerRelationship`, `isDirector`, `isOfficer`, `officerTitle`, `isTenPercentOwner` | The reporting owner and relationship to the issuer exactly as filed (the first owner of a joint filing; all owners are in `reportingOwners`). | | `table` | `non-derivative` (shares, Table I) or `derivative` (options, RSUs, warrants, Table II). | | `transactionCode`, `transactionCodeDescription`, `acquiredDisposed` | SEC transaction code with its meaning; `A` acquired or `D` disposed. | | `shares`, `pricePerShare`, `transactionValue`, `sharesOwnedAfter` | Amounts as filed; value = shares × price (null when the price is only in a footnote, e.g. RSU vesting). | | `directOrIndirect`, `ownershipNature` | `D` direct or `I` indirect ownership and how it is held (trust, family member, fund). | | `conversionOrExercisePrice`, `exerciseDate`, `expirationDate`, `underlyingSecurityTitle`, `underlyingShares` | Derivative transactions only. | | `isRule10b5_1`, `footnotes` | The 10b5-1 trading-plan checkbox and the footnotes the transaction references (weighted-average price ranges, plan adoption dates). | | `filingsScanned`, `filingsInWindow`, `resultsDelivered`, `stopReason` | Summary records only: filings read, filings EDGAR lists for the window (all-companies mode), transactions delivered and why delivery stopped. | `status`: transaction rows are always `ok`. A summary is `ok` (also when no transaction matched the filters), `not_found` when no SEC registrant matches the input (not charged), `error` when EDGAR failed (not charged), and `skipped_budget` / `skipped_free_plan` when a cap was reached. ### Pricing Store discounts: the FREE and BRONZE tiers use the list prices below. SILVER receives 5% off; GOLD, PLATINUM and DIAMOND receive 10% off billable result events. The platform start fee is unchanged. Check the Actor's Store pricing table for the prices currently in effect. Pay-per-event, charged only for delivered results: | Event | Price | When | | --- | --- | --- | | `insider-transaction` | $0.002 ($2 / 1,000) | once per transaction row delivered | Set **Maximum cost per run** to cap spend: the Actor stops reading filings when the remaining budget cannot pay for another transaction and never charges for filtered-out transactions. Accounts on the Apify free plan can process up to 10 companies per run and 20 transactions per company; further companies are returned with `status: "skipped_free_plan"` and are not charged. Upgrade to any paid Apify plan for full batches. ### Use with AI agents (MCP) Use this Actor from Claude, ChatGPT, Cursor, VS Code or any other MCP client through the [Apify MCP server](https://mcp.apify.com). Add this server URL to your client and sign in with your Apify account when asked: ```text https://mcp.apify.com?tools=sfoln/sec-insider-trading ``` To run the MCP server locally instead, start `npx -y @apify/actors-mcp-server --tools sfoln/sec-insider-trading` with your `APIFY_TOKEN` in the environment. Example prompt: > Show the five most recent insider transactions at Apple from SEC Form 4 filings, with who traded, the price and the value. Runs started by an agent are billed like any other run (see Pricing). Agents can cap what a run may spend with `maxTotalChargeUsd`. ### API usage Run the Actor and get its dataset items in one call (the call waits up to 5 minutes for the run to finish): ```bash curl -X POST "https://api.apify.com/v2/acts/sfoln~sec-insider-trading/run-sync-get-dataset-items" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{"companies": ["AAPL"], "maxTransactionsPerCompany": 5}' ``` For large inputs, start the run asynchronously and download the dataset when it has finished: ```bash ## 1. Start a run: the response holds the run ID (data.id) and its dataset ID (data.defaultDatasetId) curl -X POST "https://api.apify.com/v2/acts/sfoln~sec-insider-trading/runs" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{"companies": ["AAPL"], "maxTransactionsPerCompany": 5}' ## 2. Repeat until data.status is SUCCEEDED (each call waits up to 60 s) curl "https://api.apify.com/v2/actor-runs/?waitForFinish=60" -H "Authorization: Bearer " ## 3. Download the results (format=json, csv or xlsx) curl "https://api.apify.com/v2/datasets//items?format=json" -H "Authorization: Bearer " ``` Python ([apify-client](https://pypi.org/project/apify-client/)): ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("sfoln/sec-insider-trading").call(run_input={"companies": ["AAPL"], "maxTransactionsPerCompany": 5}) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` Instead of polling, you can attach a webhook to the run (see Integrations). The API tab of this page shows the same calls for JavaScript and the Apify CLI. ### Integrations - **Make, Zapier and n8n:** run `sfoln/sec-insider-trading` with the Apify app (in n8n, the Apify node) and pass the dataset items to the next step of your workflow. - **Google Sheets:** add the items to a sheet with the Google Sheets step of Make, Zapier or n8n, or download them as CSV or Excel from the run's Storage tab or the API (`format=csv` or `format=xlsx`). - **Webhooks:** get a POST request when a run succeeds or fails: add a webhook in the Actor's Integrations tab, or pass `webhooks` when you start a run through the API. - **Schedules:** run it hourly, daily or weekly with the same input from Apify Schedules; every run keeps its results in its own dataset. - **More:** Slack, Google Drive, GitHub, LangChain, LlamaIndex and other [Apify integrations](https://docs.apify.com/platform/integrations). ### Related Actors - [SEC EDGAR Filings Scraper – 10-K, 10-Q, 8-K](https://apify.com/sfoln/sec-edgar-filings) - [SEC Form D Startup Funding Leads](https://apify.com/sfoln/sec-form-d-leads) - [Website Contact Details Scraper](https://apify.com/sfoln/company-contacts-finder) See [all our Actors](https://apify.com/sfoln) on Apify Store. ### FAQ #### How much does it cost, and am I charged for failed items? You pay per event at the prices under Pricing above, plus a run start fee of $0.00005 per GB of memory, with no subscription; platform usage is included. Errors and skipped items (`skipped_…` statuses) are never charged; a lookup that finds nothing is charged only where Pricing says so, and every record's `charged` field shows whether it was billed. Set **Maximum cost per run** to cap what a single run can spend. #### How fresh is the data? Each run queries its source while it runs, so you get what the source returns at that moment. Source-specific details, such as how often a provider refreshes its own database, are under Limits & notes. #### What are the limits? Per-run caps (for example the maximum number of items) are listed under Input, source limits under Limits & notes, and the free-plan limit under Pricing. For big batches, start the run asynchronously (see API usage) and read the dataset when it has finished. #### Can I schedule runs or get results by webhook? Yes. Create a schedule in Apify Console to run it hourly, daily or weekly with the same input, and add a webhook to get a POST request when a run finishes (see Integrations). #### What does this Actor record about my runs? This Actor records operational metrics about each run (item counts, duration, charges, error codes and a pseudonymous hash of your Apify user ID) to monitor reliability and costs. It never stores your input or results. #### Which transactions are included? Every transaction in Table I (shares) and, unless switched off, Table II (options, RSUs, warrants) of Forms 4 and 5, including amendments. Holdings reported without a transaction are not rows. Filter by transaction code, for example P for open-market purchases. #### Can I see trades across all companies? Yes: leave companies empty to read the latest Form 4 and 5 filings of all companies in the date window (default: the last 3 days), newest filing date first, combined with code and value filters to find, for example, large open-market purchases. #### How do I get help? Open an issue in the Actor's Issues tab and include the link to the run, so we can reproduce the problem. Feature requests are welcome there too. ### Limits & notes - Data comes live from SEC EDGAR (company filing histories, the Form 3/4/5 XML documents and EDGAR full-text search): filings appear minutes after acceptance. - Companies are looked up as issuers: Form 4s a company files as the owner of another issuer's shares are skipped. - Each filing is one request at SEC's limit of about 10 per second (the Actor uses 8 for the whole run), so a company with hundreds of filings takes a minute or two; strict filters (code, value) read more filings per delivered row, at most 2,000 filings per company. - The all-companies mode reads Form 4 and Form 5 filings newest filing date first and at most 10,000 filings per date window. - Values are exactly as reported: prices can be weighted averages of several trades (see the footnotes) and amended filings (4/A) repeat or correct earlier ones. - A company named twice in one run (for example `AAPL` and `320193`) is charged once per transaction: the second input delivers only transactions the first did not. - If SEC refuses the run for exceeding its request rate (HTTP 403 "Request Rate Threshold Exceeded", a pause of about 10 minutes), the Actor stops reading after a few refused filings instead of skipping them one by one: the summary's `error` has code `rate_limit` (with `status: "error"` when nothing was delivered) and refused filings are not charged, and later companies of the run fail the same way at once, without contacting SEC, until the pause has passed. Run again later. # Actor input Schema ## `companies` (type: `array`): Issuers by ticker (AAPL), CIK (320193) or name, one per line. Leave empty to get the latest Form 4/5 transactions of all companies in the date window (default: the last 3 days). Accounts on the Apify free plan can process up to 10 companies per run and 20 transactions per company. ## `transactionCodes` (type: `array`): Only these Form 4 codes, e.g. P (open-market purchase), S (sale), A (award), M (option exercise), F (tax withholding), G (gift). Empty: all. ## `dateFrom` (type: `string`): Earliest filing date: YYYY-MM-DD or a span such as "30 days". Default: none for companies, the last 3 days for all companies. ## `dateTo` (type: `string`): Latest filing date (YYYY-MM-DD or a span such as "7 days"). Empty: today. ## `minTransactionValue` (type: `integer`): Only transactions with shares × price of at least this many dollars (transactions without a price are then left out). ## `includeDerivative` (type: `boolean`): Also return option, RSU and warrant transactions (Table II of Form 4). ## `includeAmendments` (type: `boolean`): Also read amended filings (4/A, 5/A). ## `maxTransactionsPerCompany` (type: `integer`): Transactions returned per company, newest filings first (for all companies: transactions in total). ## `maxCompanies` (type: `integer`): Safety cap on companies processed in this run; the rest are ignored and counted as inputItemsDropped in the OUTPUT record. ## `concurrency` (type: `integer`): Companies processed in parallel. All requests share SEC's rate limit (8 requests per second). ## `includeRaw` (type: `boolean`): Attach the transaction as parsed from the filing's XML to each row. ## Actor input object example ```json { "companies": [ "AAPL" ], "includeDerivative": true, "includeAmendments": true, "maxTransactionsPerCompany": 5, "maxCompanies": 100, "concurrency": 2, "includeRaw": false } ``` # Actor output Schema ## `results` (type: `string`): No description ## `summary` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "companies": [ "AAPL" ], "maxTransactionsPerCompany": 5 }; // Run the Actor and wait for it to finish const run = await client.actor("sfoln/sec-insider-trading").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "companies": ["AAPL"], "maxTransactionsPerCompany": 5, } # Run the Actor and wait for it to finish run = client.actor("sfoln/sec-insider-trading").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 '{ "companies": [ "AAPL" ], "maxTransactionsPerCompany": 5 }' | apify call sfoln/sec-insider-trading --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,sfoln/sec-insider-trading" } } } ``` 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 ` 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/IcMQDa79BHigpEmp5/builds/xa3BIHQ0onFp8OmSV/openapi.json