Insider Trading API: Pull SEC Form 4 Data for Any Company

Pull a company's insider transactions from SEC Form 4 filings, in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to pull the latest insider transactions for NVIDIA (CIK 1045810) and give me a table with the date traded, the date filed, the insider, shares sold, average price and shares still owned.

One prompt reads a company's Form 4 history. 1 min setup · 8-20 hrs saved.

You want insider transactions as data: who at a company bought or sold shares, how many, at what price, and when it was filed. This guide shows the quick route, one call per company from your agent, what came back when we ran it on 2026-10-16, and the traps in the output. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call. It describes the data and how to pull it. Nothing here is investment advice.

What is the easiest way to get insider trading data through an API?

Monid. Install it once, add a key, and your agent calls a Form 4 endpoint with a company identifier and gets the transactions back as JSON, with no data contract and no vendor account to set up.

• Pay per call. Each request is billed on its own, at $0.01 a call (Verified 2026-10-16 on the insider trading tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every API. The same key and balance call the insider endpoints and every other tool on Monid. When you also want company news or fundamentals for the same name, it is another call on the same balance.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tool is there whenever your agent needs it, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

Pulling the history for ten companies costs about $0.10 (Verified 2026-10-16).

How do you pull Form 4 insider transactions for a company or the whole market?

Call the company endpoint with a CIK for one company, or the search endpoint with a ticker or name, and loop it over your list. The company endpoint is /get_company_insider_trading from the provider secform4. It requires cik, the Central Index Key that identifies a filer in the SEC's system, passed as a string such as "1045810" for NVIDIA.

Monid fits a list because the work is the same call repeated, and you pay for the companies you check and nothing between runs. The fork between a seat on a platform and a call for what you use is laid out in dataset versus API for B2B data.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Step 1. Find the company

What it does. Gets you to a record without knowing the CIK.

The endpoint. secform4/search, billed per call, takes query. The live schema says the query can be a ticker symbol, a CIK or a company name.

The call.

monid run -p secform4 -e /search --query '{"query": "NVIDIA"}'

We ran it on 2026-10-16 with NVDA as the query and got the same ten rows as the CIK call below.

Step 2. Pull a company's history by CIK

What it does. The transaction list for one filer's company.

The endpoint. secform4/get_company_insider_trading, per call, requires cik.

The call.

monid run -p secform4 -e /get_company_insider_trading --query '{"cik": "1045810"}'

What comes back. data.items, newest first. On 2026-10-16 it held ten rows for NVIDIA, from a sale traded on 2026-09-21 back to one traded on 2026-05-27.

Step 3. Scan the market rather than one name

What it does. Lists transactions across companies instead of one.

The endpoints. secform4/get_insider_buys and secform4/get_insider_sales, per call, no arguments.

monid run -p secform4 -e /get_insider_buys --query '{}'

The market-wide lists have a catch about age, covered in the problems section below.

Or hand the whole job to an agent

Can you get Form 4 data yourself with Python?

Yes, and for one company it is an afternoon. You find the company's identifier, fetch the filings, parse each one into rows, and store them. The filings are public documents, and the work is turning many documents into one clean table.

The cost is everything around the parser. You need the company lookup from a ticker to a CIK, a fetch layer that respects the rate limits of whoever serves the filings, parsing for the different shapes a filing can take, and a repair whenever a source changes its page. Rules on how you may access and reuse filings differ by source and by country, so check the terms of whatever you fetch from. The first working version takes hours and the upkeep does not stop.

The Monid route is the choice for anything you will run more than once. The fetching and parsing are maintained for you, the output is JSON with the same thirteen fields on every row, and a call is $0.01 (Verified 2026-10-16). Free screener sites are quicker for a single name, but they are made for a person reading a page, not for a list or an agent.

What does Form 4 data look like, and what can you build with it?

Form 4 data is a list of changes in an insider's holdings, and each call returns it as short typed rows. On 2026-10-16 we ran /get_company_insider_trading for NVIDIA (CIK 1045810) and /search for NVDA, so the fields below are what came back.

The response

Thirteen fields per row, all strings:

{
  "transaction_date": "2026-08-31 Sale",
  "reported_datetime": "2026-09-02 6:10 pm",
  "company": "NVIDIA CORP",
  "symbol": "NVDA",
  "symbol_url": "https://www.secform4.com/#S2",
  "insider_relationship": "STEVENS MARK A Director",
  "insider_relationship_url": "https://www.secform4.com/insider-trading/1199039.htm",
  "shares_traded": "1,848,501",
  "average_price": "$222.26",
  "total_amount": "$410,843,671",
  "shares_owned": "29,921,132 (Indirect Direct)",
  "filing": "View",
  "filing_url": "https://www.secform4.com/filings/1045810/0001199039-26-000012.htm"
}

transaction_date holds the date and the action together ("2026-08-31 Sale"). reported_datetime is when the filing was posted. insider_relationship joins the person's name and role into one string. filing_url points to the filing itself.

shares_owned is the balance after the trade. In the NVIDIA rows, the 2026-09-03 row shows 28,898,893 shares owned. The 2026-09-18 row sold 1,366,000 and shows 27,532,893, which is exactly the difference. That makes the field usable for a check: each row's balance should equal the previous balance minus the shares sold.

What you can build with it

• A transaction table per company. Loop the CIK call over a list and store the rows.
• A fraction-of-holding column. Divide shares traded by the balance before the trade. For the 2026-08-31 row, 1,848,501 shares against 29,921,132 + 1,848,501 before the sale is about 5.8%. The dollar amount alone says little about the size of the move relative to the holding.
• A filing-lag column. Subtract transaction_date from reported_datetime. In the ten NVIDIA rows the gap was one to five calendar days.
• A watch on named insiders. The same person appears across rows and across companies through insider_relationship_url, so you can follow one filer.

What goes wrong when you pull insider trading data?

Five things show up when you read the output. All five are from the 2026-10-16 runs.

Why are the market-wide lists not recent?

Because the lists we ran were about six months old. /get_insider_buys and /get_insider_sales took no input and returned rows with transaction dates from 2026-04-08 to 2026-04-17, on a day when the NVIDIA company call reached 2026-09-21. The inspect text for the buys endpoint says the data is delayed by six months for public users. The sales list showed the same age: its first row was traded on 2026-04-16 and its last on 2026-04-17, across 100 rows.

So the market-wide lists suit looking at the shape of the data, not tracking what happened this week. For current activity, call the company endpoint for the names you care about, which was current to September 2026 in our run. Always check the newest transaction_date in a result before you build a schedule on it.

Why is the "full history" ten rows?

Because the endpoint returned a recent page, not everything. The description promises the full insider trading history, including buy, sell and option transactions. The NVIDIA call returned ten rows, all sales, spanning 2026-05-27 to 2026-09-21. Treat the result as the latest page for a company. If you need purchases or older rows, expect to find them through other calls, and count the rows you get before you assume completeness.

Why does the date field need parsing?

Because the action is inside the date string. transaction_date is "2026-09-21 Sale", not a date. Split it on the first space, parse the date, and keep the action as its own column. On the market-wide buys list we also saw "Purchase (A)" for one row, so match on the start of the string rather than on an exact value.

Why are all the numbers strings?

Because they arrive formatted for display: share counts with thousands separators, prices and totals with a leading dollar sign, and a holding such as "29,921,132 (Indirect Direct)". Strip the commas and the dollar sign, and split the suffix off shares_owned before you do arithmetic. The suffix describes how the shares are held, and a row can show a direct and an indirect holding in one figure.

Why does a ticker not always get you where you need to go?

Because the company endpoint wants a CIK. The search endpoint accepts a ticker, a CIK or a name and returns the same rows under data.results, where the company endpoint uses data.items. In a pipeline, read both keys or pick one endpoint and stay with it. Identifier hops like this are a recurring tax on chained endpoints, as in business entity search.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. Use the first two for anything current. The last two are for exploring the shape of market-wide data or for work where six-month-old rows are fine.

When is another route a better fit?

You need real-time alerts. A call returns what is published when you make it, and a filing is published after the trade. A data platform with push alerts, or a direct feed of the filings, is the better route when minutes matter to you.

You need every historical row. The company endpoint returned ten rows for NVIDIA. A research project that needs years of filings is better served by a bulk download of the filings or a database built for it.

You need institutional holdings or other filing types. This endpoint family is about one form, filed by insiders about their own holdings. Fund positions and ownership stakes come from other forms and other datasets.

You need companies outside the US. The data is built on US filings. Other countries have their own disclosure regimes with their own formats, and none of them appears here. Rules differ by country, so check the ones that apply to you.

And the disclosure: we resell this endpoint. The most useful thing in this post is the checklist of traps: check the newest date before you rely on a list, count the rows, split the date and the action, and strip the formatting from the numbers. That is the right habit whoever you buy the data from.

Conclusion

The quickest way to get insider trading data through an API is one call per company through Monid: $0.01 a call (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. Parsing filings yourself works for one company and costs hours of parser work and upkeep; Monid keeps the fetching and the parsing maintained.

Two things matter more than which endpoint you pick. Read the newest date in every result, because the market-wide lists were six months old on the day we ran them. And divide before you compare, because shares_owned is the balance after the trade and turns a raw dollar amount into a share of a holding.

How we estimated the time saved: a parser plus a ticker-to-CIK lookup and the first handling of date and number formats is roughly 6 to 12 hours, plus 2 to 8 hours for the first month of upkeep as sources change. That is 8 to 20 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p secform4 -e /get_company_insider_trading, then make one call with a CIK you know and compare the newest transaction_date with today. Start at monid.ai.

FAQ

Published September 2026.