# SEC Insider Trading API: Form 4, 13F Holdings, Funds (`actose/sec-edgar-insider-trades-13f`) Actor

Insider trades (SEC Form 4) and 13F fund holdings as clean rows: insider, role, code, shares, price, value, CUSIP, portfolio weight, QoQ changes. Only-new mode. No API key, no login. MCP-ready for AI agents. Pay per result, errors free. $2 per 1,000 results

- **URL**: https://apify.com/actose/sec-edgar-insider-trades-13f.md
- **Developed by:** [ABM](https://apify.com/actose) (community)
- **Categories:** Business, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

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

## SEC Insider Trading API: Form 4 & 13F Holdings Scraper

**$2 per 1,000 results ($0.002 per row). No API key, no login, no monthly rental. Errors and empty results are free.**

Get **insider trades (SEC Form 4)** and **institutional fund holdings (SEC 13F-HR)** as clean, flat rows, read straight from the official SEC EDGAR XML files:

- **Form 4**: one row per transaction, with company, ticker, insider name and role (CEO, CFO, director, 10% owner), transaction code in plain English (open market purchase, sale, grant, option exercise, gift...), shares, price, total value, shares owned after, direct/indirect ownership, Rule 10b5-1 plan flag, derivative details (options, RSUs) and footnotes.
- **13F-HR**: one row per position, with issuer, CUSIP, value in USD, shares, put/call, portfolio weight, voting authority and **quarter-over-quarter changes** (NEW, INCREASED, DECREASED, UNCHANGED, SOLD_OUT).
- **Only new filings** mode for scheduled runs: you get, and pay for, only the filings published since your last run.
- Every row has a one-sentence **`summary`** written for LLMs, RAG and alerts.

It focuses on these two forms and does not re-export generic filing lists (10-K, 8-K...). Use it next to a general EDGAR filings tool, not instead of one.

### How much does it cost?

Pay per event: **$0.002 per result** (one result = one Form 4 transaction row or one 13F position row).

| What you extract | Rows | Price |
|---|---|---|
| All NVDA insider trades in the last 30 days | ~20-60 | ~$0.04-$0.12 |
| 1,000 insider transactions | 1,000 | **$2.00** |
| Top 100 positions of one fund + QoQ changes | ~100-130 | ~$0.25 |
| Daily "only new" alert on 20 tickers | ~0-30 per day | a few cents per day |

You pay nothing for tickers that don't exist, filings that fail to parse, transactions removed by your filters, or runs with no results. Use **Max results** and the run budget to cap spending. When the budget is reached, the run stops cleanly. It never delivers unpaid "preview" rows.

### Input

```json
{
  "tickers": ["NVDA", "TSLA"],
  "formType": "4",
  "days": 30,
  "transactionCodes": ["P", "S"],
  "minTransactionValueUsd": 100000,
  "onlyNew": false,
  "maxResults": 1000
}
```

13F holdings of a fund, with changes vs the previous quarter:

```json
{
  "ciks": ["1067983"],
  "formType": "13F-HR",
  "quarters": 1,
  "compareWithPrevious": true,
  "maxHoldingsPerFiling": 100
}
```

| Field | Meaning |
|---|---|
| `tickers` / `ticker` | US tickers (`BRK.B` and `BRK-B` both work). For Form 4: the company's insider trades. |
| `ciks` | SEC CIK numbers: a **fund** for 13F (1067983 = Berkshire Hathaway), or an **insider** for all their Form 4 trades across companies. |
| `formType` | `4`, `13F-HR` or `both`. |
| `days` | Form 4 look-back window (filing date). |
| `transactionCodes` | Filter, e.g. `["P"]` = open market purchases only. |
| `insiderRoles` | `director`, `officer`, `tenPercentOwner`, `other`. |
| `minTransactionValueUsd` | Skip small trades. |
| `includeDerivative` | Include options/RSUs (Table II). |
| `quarters` | 13F: number of recent quarters per fund. |
| `compareWithPrevious` | 13F: add QoQ change fields and sold-out rows. |
| `aggregateByCusip` | 13F: merge split lines of the same security. |
| `maxHoldingsPerFiling` | 13F: keep the N largest positions (+ up to N sold-out). |
| `onlyNew` / `stateStoreName` | Only filings not delivered in previous runs. |
| `maxResults` | Hard cap on billed rows. |

### Output

Form 4 row:

```json
{
  "recordType": "insiderTransaction",
  "formType": "4",
  "accessionNumber": "0001197647-26-000011",
  "filingDate": "2026-10-09",
  "issuerCik": "1045810",
  "issuerName": "NVIDIA CORP",
  "ticker": "NVDA",
  "insiderCik": "1197647",
  "insiderName": "COXE TENCH",
  "insiderRelationship": "Director",
  "isDirector": true,
  "isOfficer": false,
  "isRule10b51Plan": true,
  "transactionId": "0001197647-26-000011-N1",
  "isDerivative": false,
  "securityTitle": "Common Stock",
  "transactionDate": "2026-10-07",
  "transactionCode": "G",
  "transactionType": "Gift",
  "acquiredDisposed": "D",
  "shares": 500000,
  "pricePerShare": 0,
  "totalValueUsd": 0,
  "sharesOwnedAfter": 23671360,
  "ownershipType": "Indirect",
  "ownershipNature": "By Trust",
  "footnotes": "[F1] ...",
  "summary": "COXE TENCH (Director) disposed of 500,000 Common Stock of NVIDIA CORP (NVDA) on 2026-10-07 [code G: Gift] under a Rule 10b5-1 plan, holding 23,671,360 afterwards (indirect).",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000119764726000011/0001197647-26-000011-index.htm",
  "xmlUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000119764726000011/wk-form4_1791579847.xml"
}
```

13F row (example values):

```json
{
  "recordType": "fundHolding",
  "formType": "13F-HR",
  "filingDate": "2026-08-14",
  "reportPeriod": "2026-06-30",
  "fundCik": "1067983",
  "fundName": "BERKSHIRE HATHAWAY INC",
  "nameOfIssuer": "APPLE INC",
  "titleOfClass": "COM",
  "cusip": "037833100",
  "valueUsd": 57000000000,
  "shares": 280000000,
  "sharesType": "SH",
  "putCall": null,
  "portfolioWeightPct": 22.4,
  "previousReportPeriod": "2026-03-31",
  "previousShares": 300000000,
  "sharesChange": -20000000,
  "sharesChangePct": -6.6667,
  "positionChange": "DECREASED",
  "summary": "BERKSHIRE HATHAWAY INC held 280,000,000 SH of APPLE INC (COM, CUSIP 037833100) worth $57.00B as of 2026-06-30 (22.40% of reported portfolio), down 6.7% in shares vs 2026-03-31."
}
```

Fields that don't apply to a row type are `null`. The **Overview** table view shows the key columns of both row types.

### Use cases

**1. Insider-buying alert for a stock-picking newsletter.** An equity analyst wants every open-market purchase of more than $250k by insiders of their 15-stock watchlist, each morning.
Input: `{"tickers": ["NVDA","AMD","PLTR","SOFI","INTC"], "formType": "4", "days": 3, "transactionCodes": ["P"], "minTransactionValueUsd": 250000, "onlyNew": true}`
Output: `[{"ticker": "INTC", "insiderName": "...", "insiderRelationship": "Officer (CEO)", "shares": 40000, "pricePerShare": 24.1, "totalValueUsd": 964000, "summary": "..."}]`
Next: a daily schedule sends the new rows to Google Sheets and Slack. Cluster buys (3+ insiders in a week) become newsletter picks. Cost: usually under $0.05 a day.

**2. Fund-replication / 13F tracker for a portfolio manager.** A PM follows 5 value funds and wants the new positions and exits every quarter.
Input: `{"ciks": ["1067983","1649339","1336528"], "formType": "13F-HR", "quarters": 1, "compareWithPrevious": true, "maxHoldingsPerFiling": 50, "onlyNew": true}`
Output: `[{"fundName": "BERKSHIRE HATHAWAY INC", "nameOfIssuer": "...", "positionChange": "NEW", "valueUsd": 1200000000, "portfolioWeightPct": 0.47}, {"positionChange": "SOLD_OUT", ...}]`
Next: filter `positionChange in (NEW, SOLD_OUT)` to get a "smart money moves" table. A weekly schedule with `onlyNew` only bills when a new 13F appears, about $0.10-0.30 per fund per quarter.

**3. Compliance and governance review.** A compliance officer or proxy advisor checks every trade by one director across all boards they sit on, over 2 years. The director's own CIK is used, not the company's.
Input: `{"ciks": ["1197647"], "formType": "4", "days": 730, "includeDerivative": true}`
Output: `[{"issuerName": "...", "transactionCode": "M", "transactionType": "Option exercise / conversion (exempt)", "isRule10b51Plan": true, "footnotes": "[F1] ..."}, ...]`
Next: export to CSV, check the trades against blackout windows and 10b5-1 plan adoption dates, and keep the `filingUrl` as the audit trail.

**4. Quant dataset / backtest.** A quant researcher builds a 5-year insider-sales dataset for 50 tickers (`"days": 1825`, `"transactionCodes": ["S","P"]`). They join on `ticker` + `transactionDate` with prices to measure post-trade drift. 10,000 rows cost $20.

### Use with AI agents (MCP)

This actor works as a tool for Claude, Cursor, ChatGPT and other agents via the Apify MCP server (`https://mcp.apify.com`). Add the actor `sec-edgar-insider-trades-13f` and ask, for example: *"Which NVDA insiders sold more than $1M of stock this month?"* or *"What did Berkshire buy and sell last quarter?"*. The `summary` field gives the agent a ready-made sentence per row, so it doesn't need to decode SEC codes.

### API examples

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<username>/sec-edgar-insider-trades-13f").call(run_input={
    "tickers": ["NVDA"], "formType": "4", "days": 30, "transactionCodes": ["S"],
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["summary"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('<username>/sec-edgar-insider-trades-13f').call({
    ciks: ['1067983'], formType: '13F-HR', compareWithPrevious: true, maxHoldingsPerFiling: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.positionChange === 'NEW'));
```

### Integrations (Make, Zapier, n8n, Google Sheets)

- **Make / Zapier**: "Run actor" with `{"tickers": [...], "formType": "4", "days": 2, "onlyNew": true}` on a daily schedule. Then "Get dataset items", a filter on `totalValueUsd > 500000`, then Gmail / Slack / Google Sheets "Add row".
- **n8n**: Schedule Trigger (every day 07:00) → Apify node (run actor, wait for finish) → IF `transactionCode == "P"` → Telegram message with `{{$json.summary}}`.
- **Google Sheets**: use Apify's Google Sheets integration on the dataset (Overview view) to get a live insider-trading sheet.
- Datasets export to **JSON, CSV, Excel, XML, RSS** from the console or the API.

### FAQ

**Where does the data come from?** Only from official public SEC EDGAR endpoints (submissions JSON and the raw XML filed by insiders and funds). No scraping of third-party sites, no login.

**How fresh is it?** Form 4 must be filed within 2 business days of the trade, and the actor reads EDGAR live. Funds file 13F up to 45 days after quarter end.

**What does each transaction code mean?** `transactionType` translates it: P purchase, S sale, A grant/award, M option exercise, F tax withholding, G gift, and so on. Real buying/selling signals are mostly **P** and **S**.

**Why are prices sometimes 0 or null?** Grants, gifts and some exercises have no price. Weighted-average prices are explained in `footnotes`.

**How do I find a fund's CIK?** Search the fund on sec.gov/edgar/search. The number in the URL (e.g. 1067983) is the CIK.

**Are 13F values in dollars?** Yes. Filings from before 2023, which reported in thousands, are converted to dollars.

**Does "only new" work for 13F?** Yes. A 13F quarter is delivered once, and later runs skip it until the next quarter is filed.

### Limits

- US SEC filers only. Form 4 covers Section 16 insiders (officers, directors, 10% owners). Form 3/5 and Form 144 are not included.
- 13F lists only long US-listed equity positions, options and convertibles over the reporting threshold. Shorts, cash and non-US holdings are not reported by funds.
- 13F amendments (13F-HR/A) are used only when no original filing exists for the quarter. Partial "new holdings" amendments are not merged.
- Very large funds (index managers) report 20,000+ positions. Keep `maxHoldingsPerFiling` set to control cost.
- Very old Form 4 filings (before mid-2003, not in XML) are skipped.
- SEC allows ~10 requests/second. The actor stays below that, so a very large historical pull takes a few minutes.

Not investment advice. Data is provided as filed with the SEC.

# Actor input Schema

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

US stock tickers, e.g. NVDA, AAPL, BRK.B. For Form 4 you get the insider trades of these companies. For 13F, use the ticker only if the company itself files 13F (e.g. BRK.B for Berkshire Hathaway); otherwise use the fund's CIK below.

## `ticker` (type: `string`):

Shortcut for one ticker. Added to the Tickers list.

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

SEC Central Index Keys, digits only. Use a fund's CIK for 13F holdings (e.g. 1067983 = Berkshire Hathaway, 1350694 = Bridgewater Associates) or an insider's CIK with Form 4 to get all their trades across companies. Find a CIK on sec.gov/edgar/search.

## `formType` (type: `string`):

4 = insider transactions (one row per transaction). 13F-HR = fund holdings (one row per position). both = both for every ticker/CIK.

## `days` (type: `integer`):

Only Form 4 filings filed in the last N days.

## `transactionCodes` (type: `array`):

Keep only these SEC transaction codes. Empty = all. Common: P (open market purchase), S (open market sale), A (grant/award), M (option exercise), F (tax withholding), G (gift).

## `insiderRoles` (type: `array`):

Keep only insiders with one of these roles. Empty = all. Values: director, officer, tenPercentOwner, other.

## `minTransactionValueUsd` (type: `integer`):

Skip transactions whose shares x price is below this value. 0 = keep all (including grants at $0).

## `includeDerivative` (type: `boolean`):

Include options, RSUs and warrants (Table II) as well as common stock (Table I).

## `quarters` (type: `integer`):

How many of the most recent 13F report periods to extract per fund (1 = latest quarter).

## `compareWithPrevious` (type: `boolean`):

Adds previousShares, sharesChange, sharesChangePct and positionChange (NEW, INCREASED, DECREASED, UNCHANGED, SOLD_OUT). Sold-out positions are added as extra rows.

## `aggregateByCusip` (type: `boolean`):

Merge lines of the same CUSIP (split by manager or discretion in the filing) into one row. Untick to get the raw filing lines.

## `maxHoldingsPerFiling` (type: `integer`):

Keep the N largest positions (by value) of each 13F, plus up to N sold-out positions. 0 = all. Large index funds report 20,000+ positions, so set a limit to control cost.

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

Include amended Form 4 filings. For 13F, an amendment is used only when no original filing exists for that quarter.

## `onlyNew` (type: `boolean`):

For scheduled runs: skip filings already delivered in a previous run (remembered per ticker/CIK in a named key-value store). You only pay for new results.

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

Name of the key-value store that remembers delivered filings. Use different names for independent schedules.

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

Safety cap on Form 4 filings read per ticker or CIK (newest first). 0 = no cap.

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

Stop after this many rows in total (each row is one billed result). 0 = no limit (your run budget still applies).

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "TSLA"
  ],
  "ciks": [
    "1067983"
  ],
  "formType": "4",
  "days": 30,
  "transactionCodes": [
    "P",
    "S"
  ],
  "minTransactionValueUsd": 0,
  "includeDerivative": true,
  "quarters": 1,
  "compareWithPrevious": true,
  "aggregateByCusip": true,
  "maxHoldingsPerFiling": 500,
  "includeAmendments": true,
  "onlyNew": false,
  "stateStoreName": "sec-insider-13f-state",
  "maxFilingsPerEntity": 200,
  "maxResults": 1000
}
```

# Actor output Schema

## `overview` (type: `string`):

Insider transactions and fund holdings in a table.

## `results` (type: `string`):

Every field of every row, as JSON.

# 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"
    ],
    "ciks": [
        "1067983"
    ],
    "days": 30,
    "transactionCodes": [
        "P",
        "S"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/sec-edgar-insider-trades-13f").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",
    ],
    "ciks": ["1067983"],
    "days": 30,
    "transactionCodes": [
        "P",
        "S",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("actose/sec-edgar-insider-trades-13f").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 '{
  "tickers": [
    "NVDA",
    "TSLA"
  ],
  "ciks": [
    "1067983"
  ],
  "days": 30,
  "transactionCodes": [
    "P",
    "S"
  ]
}' |
apify call actose/sec-edgar-insider-trades-13f --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,actose/sec-edgar-insider-trades-13f"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cwuKTHRMgld7JoOnM/builds/sy5Yyj1VG67vdbSXL/openapi.json