# Insider Trading Tracker - SEC Form 4 Insider Buys & Sells (`groupoject/sec-insider-trading-tracker`) Actor

Insider trading tracker for SEC Form 4 filings: every insider buy and sell from EDGAR across the market, by ticker or by insider. Price, value, holdings change, 10b5-1 plan flag, derivatives, footnotes and cluster-buy signals. Schedule it for new-trade alerts.

- **URL**: https://apify.com/groupoject/sec-insider-trading-tracker.md
- **Developed by:** [Group Oject](https://apify.com/groupoject) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 trades

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

## Insider Trading Tracker - SEC Form 4 Insider Buys & Sells

This insider trading tracker reads SEC Form 4 filings straight from EDGAR and turns every insider buy and sell into a clean row: who traded, which company, the transaction code in plain English, shares, price, dollar value, holdings before and after, and whether the trade was part of a 10b5-1 plan. Watch the whole market (like OpenInsider's latest-trades screen), a list of tickers, or specific insiders, and flag cluster buys automatically.

![Insider Trading Tracker output in Apify: ticker, company, insider, role, trade date, Form 4 transaction code, buy or sell, shares, price and dollar value](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/sec-insider-trading-tracker-output.png)

*Real output from a default run of Insider Trading Tracker in Apify Console.*

### What can this insider trading tracker do?

- **Three ways to track.** `latest` reads every Form 4 filed across the US market in your date range. `tickers` follows the companies you name (AAPL, NVDA, BRK.B ...). `insiders` follows people or funds by SEC CIK or by name ("Elon Musk", "Warren Buffett").
- **One row per transaction**, from Table I (common stock) and Table II (options, RSUs, warrants, convertibles, with exercise price, expiration and underlying shares). Every footnote attached to a row is included as text.
- **Filter like a screener.** Transaction codes with labels (P purchase, S sale, A grant, M exercise, F tax withholding, G gift ...), an "only open-market buys and sells" switch, minimum trade value, minimum shares, minimum % change in holdings, insider role (director, officer, 10% owner, other) and officer title words (CEO, CFO, President).
- **Separate planned trades.** Each row has `is10b5_1Plan`, read from the row's footnotes and the filing's Rule 10b5-1 checkbox. Turn on `excludePlannedTrades` to keep only discretionary trades.
- **Signals.** `clusterBuy` / `clusterSell` (N or more distinct insiders trading the same company within X days), `isLargestBuyForIssuer`, `isLargeTrade`, and tags such as `c-suite-buy`, `director-buy`, `new-position`, `holdings-up-10pct-plus` and `sold-entire-position`.
- **Amendments and other forms.** Form 4/A is included by default with `isAmendment` and the original filing date. Form 5 (annual) and Form 3 (initial holdings) are optional.
- **Monitoring.** `onlyNew` + `stateKey` remembers what earlier runs returned, so a scheduled run saves (and bills) only new trades. Cluster detection keeps a memory of recent buys across runs.
- **A summary for every run.** The `SUMMARY` record lists the top open-market buys and sells by value, cluster buys by company, the most-bought companies and counts by transaction code. It is not billed.
- **Plays by SEC's rules.** Only official, public SEC EDGAR data. Requests carry a declared User-Agent and stay under 8 per second (SEC allows 10).

### What data do you get?

| Field | Description |
|---|---|
| `issuerName`, `issuerTicker`, `issuerCik` | Company whose shares were traded |
| `insiderName`, `insiderCik` | The insider (reporting person) and their SEC CIK |
| `insiderRole`, `insiderRoles`, `officerTitle` | "Chief Executive Officer, Director", role flags, title as filed |
| `isDirector`, `isOfficer`, `isTenPercentOwner`, `isOtherRole` | Relationship to the company |
| `reportingOwners` | All reporting persons on joint filings |
| `transactionDate`, `deemedExecutionDate` | Trade date |
| `transactionCode`, `transactionLabel`, `transactionCategory` | `P` / "Open market or private purchase" / `open-market-buy` |
| `acquiredDisposed` | Acquired or Disposed |
| `shares`, `pricePerShare`, `valueUsd` | Shares, price, shares × price |
| `sharesOwnedBefore`, `sharesOwnedAfter`, `ownershipChangePct`, `isNewPosition` | Holdings before and after, % change |
| `directOrIndirect`, `natureOfOwnership` | Direct, or Indirect "By trust", "By spouse" ... |
| `isDerivative`, `securityTitle`, `conversionOrExercisePrice`, `exerciseDate`, `expirationDate`, `underlyingSecurityTitle`, `underlyingShares` | Table II details |
| `is10b5_1Plan`, `plan10b5_1Source`, `filing10b5_1Checkbox` | Rule 10b5-1 plan flag and where it came from |
| `footnotes`, `remarks` | Footnote text for the row and filing remarks |
| `formType`, `isAmendment`, `originalFilingDate` | 4, 4/A, 5, 3 ... |
| `accessionNumber`, `filingDate`, `acceptedAt`, `periodOfReport` | Filing identifiers and EDGAR acceptance time (US Eastern) |
| `filingUrl`, `xmlUrl` | SEC filing index page and the raw Form 4 XML |
| `clusterBuy`, `clusterSell`, `clusterInsiderCount`, `isLargestBuyForIssuer`, `isLargeTrade`, `signals` | Computed signals |

The dataset has two views: **Insider trades** (the overview table) and **Signals**.

### How much does it cost?

Pay per result: **$2.50 per 1,000 trades** (one dataset row = one trade). There is no subscription, and you are never charged for errors, for filings that don't match your filters, or for the `SUMMARY` and `ERRORS` records. The run stops at the maximum charge you set.

On paid Apify plans the per-result price drops automatically (Bronze and above get volume discounts); the Pricing tab shows your exact rate.

- **Daily market scan of open-market buys and sells.** A typical trading day has a few hundred Form 4 filings and roughly 100–400 open-market P/S rows. One run with `mode: "latest"`, `lastNDays: 1`, `openMarketOnly: true` returns those rows.
- **Watchlist monitor.** 20 tickers checked every hour with `onlyNew: true` returns only the trades filed since the last run, often 0–30 rows a day. A run that finds nothing new saves no rows, so it has no per-result charge.

### How to use it

1. Open the actor and pick **What to track**: latest filings, tickers or insiders.
2. Set the date range (**Last N days**, or Date from / Date to).
3. Add filters: open-market only, transaction codes, minimum value, roles, 10b5-1 exclusion.
4. Click **Start**. Rows appear in the dataset as **Insider trades**; open **Signals** for cluster buys, and the `SUMMARY` record for top trades.
5. To get alerts, turn on **Only new trades**, give the monitor a **State key** and schedule the actor.

#### Input example

```json
{
  "mode": "latest",
  "lastNDays": 1,
  "openMarketOnly": true,
  "minTransactionValueUsd": 100000,
  "excludePlannedTrades": true,
  "maxResults": 500
}
```

Track companies or people instead:

```json
{ "mode": "tickers", "tickers": ["AAPL", "NVDA", "TSLA"], "lastNDays": 90 }
```

```json
{ "mode": "insiders", "insiderCiks": ["Elon Musk", "1197649"], "lastNDays": 365 }
```

### Output example

Synthetic example row (values invented for illustration):

```json
{
  "id": "0001234567-26-000123:N1",
  "issuerName": "Example Widgets Corp",
  "issuerTicker": "EXWD",
  "issuerCik": "0009999999",
  "insiderName": "Doe Jane",
  "insiderCik": "0009000001",
  "insiderRole": "Chief Executive Officer, Director",
  "insiderRoles": ["director", "officer"],
  "officerTitle": "Chief Executive Officer",
  "isDirector": true,
  "isOfficer": true,
  "isTenPercentOwner": false,
  "rowType": "transaction",
  "isDerivative": false,
  "securityTitle": "Common Stock",
  "transactionDate": "2026-10-26",
  "transactionCode": "P",
  "transactionLabel": "Open market or private purchase",
  "transactionCategory": "open-market-buy",
  "acquiredDisposed": "Acquired",
  "shares": 10000,
  "pricePerShare": 25.5,
  "valueUsd": 255000,
  "sharesOwnedBefore": 40000,
  "sharesOwnedAfter": 50000,
  "ownershipChangePct": 25,
  "isNewPosition": false,
  "directOrIndirect": "Direct",
  "is10b5_1Plan": false,
  "plan10b5_1Source": null,
  "filing10b5_1Checkbox": false,
  "footnotes": "F1: The price reported is a weighted average of purchases from $25.40 to $25.60.",
  "formType": "4",
  "isAmendment": false,
  "accessionNumber": "0001234567-26-000123",
  "filingDate": "2026-10-27",
  "acceptedAt": "2026-10-27T17:30:05-04:00",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/9999999/000123456726000123/0001234567-26-000123-index.htm",
  "xmlUrl": "https://www.sec.gov/Archives/edgar/data/9999999/000123456726000123/form4.xml",
  "clusterBuy": true,
  "clusterSell": false,
  "clusterInsiderCount": 3,
  "isLargestBuyForIssuer": true,
  "isLargeTrade": false,
  "signals": ["open-market-buy", "cluster-buy", "largest-buy-for-issuer", "c-suite-buy", "director-buy", "holdings-up-10pct-plus"]
}
```

### Monitor new insider trades on a schedule

1. Set **Only new trades** (`onlyNew: true`) and a **State key** such as `my-watchlist`. Each state key keeps its own memory in a named key-value store, so different watchlists don't interfere.
2. In Apify Console, open **Schedules** and run the actor every hour, or once a day after the market closes (most Form 4s are filed in the evening, US Eastern).
3. Each run saves only trades it hasn't returned before. Filings it already read are skipped before download, so repeat runs are fast and you pay only for new rows.
4. Send the new rows where you need them with Apify integrations: a webhook, Slack, e-mail, Google Sheets, Zapier, Make or n8n.

Example: alert on insider buying worth $250k+ by officers at your watchlist companies.

```json
{
  "mode": "tickers",
  "tickers": ["AAPL", "MSFT", "AMZN", "JPM", "XOM"],
  "lastNDays": 7,
  "transactionCodes": ["P"],
  "minTransactionValueUsd": 250000,
  "roles": ["officer"],
  "onlyNew": true,
  "stateKey": "watchlist-buys"
}
```

### Use with the API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/groupoject~sec-insider-trading-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"latest","lastNDays":1,"openMarketOnly":true,"maxResults":200}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("groupoject/sec-insider-trading-tracker").call(run_input={
    "mode": "tickers",
    "tickers": ["NVDA", "TSLA"],
    "lastNDays": 30,
    "openMarketOnly": True,
})
for trade in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(trade["transactionDate"], trade["issuerTicker"], trade["insiderName"], trade["transactionCode"], trade["valueUsd"])
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('groupoject/sec-insider-trading-tracker').call({
    mode: 'latest',
    lastNDays: 1,
    transactionCodes: ['P'],
    minTransactionValueUsd: 100000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((t) => t.clusterBuy));
```

### Use with AI agents / MCP

Connect the Apify MCP server at `https://mcp.apify.com?tools=groupoject/sec-insider-trading-tracker` in Claude Desktop, Cursor, VS Code or any MCP client. Example prompt: *"Which companies had cluster insider buying in the last 7 days, and who bought the most in dollars?"* The flat JSON rows, plain-English transaction labels and the `signals` tags make the data easy for an agent to filter and summarize.

### Use cases

- **Insider buying alerts.** Schedule `onlyNew` runs for open-market purchases above a dollar threshold and send them to Slack or e-mail.
- **Investment research.** Pull a year of trades for a ticker, compare discretionary buying with planned 10b5-1 sales, and spot cluster buys. Combine with price data in your own model.
- **AI agents and newsletters.** Feed the daily largest buys and cluster buys into an LLM summary or a market newsletter.
- **Compliance and governance.** Follow trades by named officers, directors and 10% owners, including amendments, gifts and indirect holdings.

### Integrations

Use Apify integrations to send results to **Make**, **Zapier**, **n8n**, **Google Sheets**, **Slack**, e-mail or any **webhook** when a run finishes. Export the dataset as JSON, CSV, Excel or XML.

### FAQ

#### Where does the data come from, and is it legal to use?

From SEC EDGAR, the US Securities and Exchange Commission's public filing system. Corporate insiders must report their trades on Form 4 within two business days, and the SEC publishes the filings for anyone to read. This actor downloads only those public filings, sends a declared User-Agent and keeps under SEC's fair-access limit of 10 requests per second. No login, no paid data feed.

#### How fresh is the data?

`latest` mode uses EDGAR's full-text search index, which lists filings minutes after EDGAR accepts them. Insiders have two business days after the trade to file, so `transactionDate` can be a day or two before `filingDate`. Most Form 4s are filed in the late afternoon and evening (US Eastern).

#### How are amendments handled?

A Form 4/A is returned as its own rows with `isAmendment: true` and `originalFilingDate`. It does not delete the original filing's rows; compare the two by insider, issuer and trade date. Drop amendments by removing "4/A" from Form types.

#### Why do my numbers differ from OpenInsider?

OpenInsider merges all transactions of one filing into a single line with an average price and shows only some transaction types by default. This actor returns every transaction line (several sales at different prices are several rows), includes derivative rows, amendments and all codes unless you filter them. It also uses EDGAR's own filing date. Use `openMarketOnly` and `includeDerivative: false` for the closest match.

#### How does the 10b5-1 flag work?

Since April 2023, Form 4 has a checkbox for trades made under a Rule 10b5-1 plan, and filers usually add a footnote such as "effected pursuant to a Rule 10b5-1 trading plan adopted on ...". A row is flagged when its own footnotes say so. When no footnote in the filing mentions a plan but the checkbox (or remarks) does, open-market P and S rows are flagged and `plan10b5_1Source` says `checkbox` or `remarks`.

#### Why did I get no rows?

Check the date range first: weekends and holidays have no filings (in `latest` mode with Last N days, the actor then uses the most recent filing day). Strict filters, such as P only above $1M with officers only, can match nothing on a quiet day. Unknown tickers and names are listed in the `ERRORS` record. Ticker mode only covers companies in SEC's ticker list; use the company's CIK otherwise.

#### Do I need a proxy or an SEC account?

No account is needed. SEC data is public. The actor uses Apify's datacenter proxy by default only to spread heavy scans over several IPs, and falls back to a direct connection if the proxy fails. If you run very large scans, add your e-mail in `contactEmail` so SEC can identify your traffic.

#### Is this investment advice?

No. This tool reports what insiders filed with the SEC. Insider purchases and sales have many reasons (taxes, diversification, planned sales, option expirations) and are not a recommendation to buy or sell anything.

### Related actors

- [Google News Scraper & Monitor](https://apify.com/groupoject/google-news-scraper) - pull news about the companies where insiders are buying or selling.
- [Google Trends Scraper - Interest, Rising Queries & Breakouts](https://apify.com/groupoject/trendpulse-keyword-monitor) - check search interest for a company or ticker next to its insider activity.

# Actor input Schema

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

"latest" = every Form 4 filed across the US market in the date range (the OpenInsider-style feed). "tickers" = insider trades at the companies in Tickers. "insiders" = trades by the people or entities in Insider CIKs or names.

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

Company stock tickers for mode "tickers" (for example AAPL, NVDA, BRK.B). A 10-digit SEC CIK also works. Ignored in other modes.

## `insiderCiks` (type: `array`):

For mode "insiders": the insider's SEC CIK (for example 1494730) or name (for example "Elon Musk"). Names are matched against EDGAR's filer list; a CIK is exact. Ignored in other modes.

## `lastNDays` (type: `integer`):

Filings filed in the last N calendar days (US Eastern time), today included. In "latest" mode, if that window has no filings yet (weekend, holiday, early morning) the most recent filing day is used. Ignored when Date from / Date to are set.

## `dateFrom` (type: `string`):

Optional start of the filing-date range, YYYY-MM-DD. Overrides Last N days.

## `dateTo` (type: `string`):

Optional end of the filing-date range, YYYY-MM-DD. Defaults to today.

## `openMarketOnly` (type: `boolean`):

Shortcut for transaction codes P and S: the trades where insiders put their own money in or take it out. Skips grants, option exercises, tax withholding and gifts.

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

Keep only these SEC transaction codes. Leave empty for all codes.

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

Keep only trades where shares × price is at least this amount. Trades without a price (most grants and exercises) are dropped when this is above 0.

## `roles` (type: `array`):

Keep only insiders with at least one of these relationships to the company. Leave empty for all.

## `officerTitleKeywords` (type: `array`):

Keep only insiders whose title contains one of these words, for example CEO, CFO, President, Chief. Case-insensitive.

## `excludePlannedTrades` (type: `boolean`):

Drop trades made under a pre-arranged Rule 10b5-1 trading plan (detected from the filing's 10b5-1 checkbox and footnotes). Planned sales say less about the insider's view than discretionary ones.

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

Also return Table II rows: options, RSUs, warrants and convertible securities (with exercise price, expiration and underlying shares).

## `minShares` (type: `integer`):

Keep only trades of at least this many shares.

## `minOwnershipChangePct` (type: `integer`):

Keep only trades that changed the insider's holding of that security by at least this percent (up or down). New positions always pass.

## `formTypes` (type: `array`):

Ownership forms to read. Form 4 = changes in ownership (the main insider trading form), 4/A = amendments, Form 5 = annual statement of changes, Form 3 = initial ownership (returned as holding rows).

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

Stop after this many trade rows (each row is one billed result). Newest filings are read first.

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

Optional cap on how many filings are downloaded per run (0 = no cap). Useful for broad market scans with strict filters.

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

Remember what earlier runs returned (per State key) and save only trades not seen before. Schedule the actor to get a stream of new insider trades; you are billed only for new rows.

## `stateKey` (type: `string`):

Name of the monitor. Use a different key for each watchlist or schedule so they keep separate memories.

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

A trade is flagged clusterBuy (or clusterSell) when at least this many different insiders made open-market purchases (sales) of the same company within the cluster window.

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

Length of the window, in transaction-date days, used for cluster detection.

## `largeTradeUsd` (type: `integer`):

Trades worth at least this much get isLargeTrade = true and a large-buy / large-sale signal.

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

SEC asks automated tools to declare a contact in the User-Agent. Leave empty to use this actor's own descriptive User-Agent; add your e-mail if you run large scans and want SEC to be able to reach you. It is sent only to sec.gov.

## `proxyConfiguration` (type: `object`):

SEC data is public; a proxy only spreads requests over IPs so heavy runs stay under SEC's per-IP rate limit. Apify datacenter proxy is used by default with a direct-connection fallback.

## Actor input object example

```json
{
  "mode": "latest",
  "tickers": [
    "AAPL",
    "NVDA",
    "TSLA"
  ],
  "insiderCiks": [
    "Elon Musk"
  ],
  "lastNDays": 1,
  "openMarketOnly": true,
  "transactionCodes": [],
  "minTransactionValueUsd": 0,
  "roles": [],
  "officerTitleKeywords": [],
  "excludePlannedTrades": false,
  "includeDerivative": true,
  "minShares": 0,
  "formTypes": [
    "4",
    "4/A"
  ],
  "maxResults": 25,
  "maxFilings": 0,
  "onlyNew": false,
  "stateKey": "default",
  "clusterMinInsiders": 3,
  "clusterWindowDays": 10,
  "largeTradeUsd": 1000000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `trades` (type: `string`):

One row per Form 4 transaction (non-derivative and derivative).

## `signals` (type: `string`):

Cluster buys/sells, largest buys and signal tags.

## `summary` (type: `string`):

Counts by transaction code, top open-market buys and sells by value, cluster buys, most-bought companies and run statistics.

## `errors` (type: `string`):

Tickers, insiders or filings that could not be read. Only present when something failed; never billed.

# 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 = {
    "mode": "latest",
    "tickers": [
        "AAPL",
        "NVDA",
        "TSLA"
    ],
    "insiderCiks": [
        "Elon Musk"
    ],
    "lastNDays": 1,
    "openMarketOnly": true,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("groupoject/sec-insider-trading-tracker").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 = {
    "mode": "latest",
    "tickers": [
        "AAPL",
        "NVDA",
        "TSLA",
    ],
    "insiderCiks": ["Elon Musk"],
    "lastNDays": 1,
    "openMarketOnly": True,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("groupoject/sec-insider-trading-tracker").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 '{
  "mode": "latest",
  "tickers": [
    "AAPL",
    "NVDA",
    "TSLA"
  ],
  "insiderCiks": [
    "Elon Musk"
  ],
  "lastNDays": 1,
  "openMarketOnly": true,
  "maxResults": 25
}' |
apify call groupoject/sec-insider-trading-tracker --silent --output-dataset

```

## MCP server setup

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

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/IDPzKytyK40TdB9Qo/builds/1wr4ZXpeYP33PwZS5/openapi.json