INSIDER TRADES · FORM 4

The Form 4 API, normalized.

Every time a corporate insider buys or sells their own company’s stock, the SEC requires a Form 4. Filingrail’s insider-trades endpoint turns those filings into one clean JSON row per transaction — insider name and title, the transaction code, shares, price, and USD value — with a link back to the source filing on every record.

Try free on RapidAPI See a sample response

Free tier: 50 requests/day, no credit card. Endpoint: GET /v1/companies/{ticker}/insider-trades

The fields

One row per insider transaction.

A Form 4 packs a lot into terse XML: who traded, what relationship they have to the issuer, what kind of transaction it was, and at what price. Filingrail parses each transaction into a flat, currency-tagged JSON object. These are the fields you get on every record:

Form 4 insider-trade fields returned by Filingrail
Field What it is
insider_name Reporting person — the officer, director, or 10% owner named on the Form 4.
insider_relationship Object describing their relationship to the issuer: is_director, is_officer, officer_title, is_10pct_owner, is_other.
transaction_code The SEC transaction code (P, S, A, M, F, G, D, X …) describing what happened.
transaction_date The date the transaction was executed, per the filing.
security_title The class of security transacted, as reported (e.g. Common Stock).
shares Number of shares in the transaction.
price_per_share Reported per-share price, in USD. Null for grants and gifts with no stated price.
total_value_usd Shares × price, computed for convenience. Null where no price was reported.
shares_owned_after Beneficial ownership after the transaction, as reported.
is_direct_ownership True for direct (D) ownership, false for indirect (I), per the filing.
accession_number The SEC accession number of the Form 4 this row was parsed from.
filing_url Direct link to that Form 4 on sec.gov — the traceability contract, on every record.

SAMPLE

A real-shaped response.

One GET against the insider-trades endpoint returns the transactions array plus a meta block. The values below are an illustrative example of the response shape.

The field that matters most for trust: filing_url, on every record. It points at the exact Form 4 on sec.gov, so any value you surface can be traced back to its filing.

GET /v1/companies/AAPL/insider-trades · 200 OK 
{
  "data": [
    {
      "insider_name": "Levinson Arthur D",
      "insider_relationship": {
        "is_director": true,
        "is_officer": false,
        "officer_title": null,
        "is_10pct_owner": false,
        "is_other": false
      },
      "transaction_date": "2026-05-19",
      "transaction_code": "S",
      "security_title": "Common Stock",
      "shares": 4000,
      "price_per_share": 196.42,
      "total_value_usd": 785680.00,
      "shares_owned_after": 113500,
      "is_direct_ownership": true,
      "accession_number": "0000320193-26-000061",
      "filing_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000061/0000320193-26-000061-index.htm"
    }
  ],
  "meta": {
    "ticker": "AAPL",
    "cik": "0000320193",
    "as_of": "2026-08-13T06:31:00Z"
  }
}

Illustrative example. Every record links to its source filing.

Transaction codes

Read the codes the SEC uses.

Every Form 4 transaction carries a one-letter SEC code. Filingrail passes the raw transaction_code through unchanged so your logic can filter on it. The two that matter most: P (an open-market purchase — an insider buying with their own money) and S (a sale).

P

Open-market or private purchase

Most-watched signal — an insider buying with their own money.

S

Open-market or private sale

Routine for compensated executives; context matters.

A

Grant, award, or other acquisition

Equity compensation; not a market transaction.

M

Exercise / conversion of derivative

Options exercised into common shares.

F

Payment of exercise price / tax by withholding shares

Shares surrendered to cover taxes.

G

Bona fide gift

Transfer with no purchase price.

D

Disposition to the issuer

Shares returned to the company.

X

Exercise of in-the-money / at-the-money derivative

Derivative exercise variant.

HOW-TO

Build an insider-trade watcher.

Four steps from a free key to a script that surfaces open-market insider buys across a watchlist. No scraper, no XML parser, no rate-limit governor to babysit.

  1. 1

    Subscribe on RapidAPI

    Subscribe to the free Basic tier on the Filingrail listing and copy your X-RapidAPI-Key from your dashboard.

  2. 2

    Call the endpoint

    Send a GET to /v1/companies/{ticker}/insider-trades with two headers.

  3. 3

    Filter for purchases

    Keep records where transaction_code === "P" to surface open-market buys, then read insider_name, shares, and price_per_share.

  4. 4

    Verify against the filing

    Open the record’s filing_url to check any transaction against the original Form 4 on sec.gov.

curl · insider-trades 
curl --request GET \
  --url 'https://filingrail.p.rapidapi.com/v1/companies/AAPL/insider-trades?limit=25' \
  --header 'X-RapidAPI-Key: YOUR_RAPIDAPI_KEY' \
  --header 'X-RapidAPI-Host: filingrail.p.rapidapi.com'
Python · watcher.py 
import os
import requests

API = "https://filingrail.p.rapidapi.com"
HEADERS = {
    "X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],
    "X-RapidAPI-Host": "filingrail.p.rapidapi.com",
}

def insider_trades(ticker, limit=50):
    resp = requests.get(
        f"{API}/v1/companies/{ticker}/insider-trades",
        params={"limit": limit},
        headers=HEADERS,
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

def open_market_buys(ticker):
    payload = insider_trades(ticker)
    buys = [
        t for t in payload["data"]
        if t["transaction_code"] == "P"          # P = open-market purchase
    ]
    for t in buys:
        print(
            f'{t["transaction_date"]}  {t["insider_name"]} '
            f'({t["insider_relationship"]["officer_title"]})  {t["shares"]:,} sh '
            f'@ ${t["price_per_share"]}  '
            f'src={t["filing_url"]}'          # the exact Form 4 this row came from
        )
    return buys

for symbol in ["AAPL", "MSFT", "NVDA"]:
    print(f"== {symbol} insider buys ==")
    open_market_buys(symbol)

The watcher loops a watchlist, filters for code P, and prints each buy with its source filing URL.

ALTERNATIVES

When to reach for Filingrail.

There are good free tools for insider data, and they’re worth knowing. Filingrail earns its place when you want a hosted JSON endpoint with billing and source-traceability handled for you.

openinsider

A free website for reading insider filings in a browser. Excellent for eyeballing recent activity. It isn’t built as a JSON API, so for programmatic access you’d be scraping HTML. Filingrail gives you the same underlying SEC data as a stable REST endpoint.

edgartools

A well-regarded open-source Python library that parses EDGAR yourself. If you want full control and don’t mind running and maintaining the parser, deduper, and SEC fair-access rate limiting, it’s a solid choice. Filingrail is the hosted alternative: no parser to maintain, billed through RapidAPI, with filing_url on every record.

FAQ

Form 4 API, answered.

Still wondering something? Email support@hudsonenterprisesllc.com — same business day response.

What is a Form 4 API?
A Form 4 API returns the contents of SEC Form 4 filings — the disclosure that corporate insiders (officers, directors, and 10% owners) must file when they buy or sell their company’s stock — as structured JSON instead of raw XML. Filingrail’s insider-trades endpoint serves one row per transaction with the insider’s name and relationship to the issuer, the SEC transaction code, share count, per-share price, computed USD value, and a link to the source filing.
What is the endpoint and what does it return?
GET /v1/companies/{ticker_or_cik}/insider-trades. It returns an array of insider transactions for the company you ask for, newest first, plus a meta block. Each record carries insider_name, insider_relationship, transaction_code, transaction_date, security_title, shares, price_per_share, total_value_usd, shares_owned_after, is_direct_ownership, plus accession_number and filing_url pointing at the source Form 4 on sec.gov.
How current is the insider-trades data?
Filingrail ingests SEC EDGAR daily, so the insider-trades corpus is kept current with the latest accepted Form 4 filings. The exact ingest timestamp for any response is exposed in meta.as_of, so you never have to guess how fresh a result is.
How is this different from openinsider or edgartools?
openinsider.com is a free website you read in a browser — great for eyeballing, not built as a JSON API. edgartools is an excellent open-source Python library that parses EDGAR yourself, which means you also run and maintain the parser, the deduper, and the SEC fair-access rate limiting. Filingrail is a hosted REST API: no parser to maintain, billed through RapidAPI, and every record links back to its source filing via a per-record filing_url.
What do the transaction codes mean?
They are the SEC’s standard Form 4 transaction codes. The two most-watched are P (an open-market purchase — an insider buying with their own money) and S (a sale). A is an equity-compensation grant, M is an option exercise into common shares, and F is shares withheld to pay taxes. Filingrail passes the raw SEC code through unchanged, so you map it however your application needs.
Can I get Form 3 and Form 5 too?
The insider-trades endpoint serves Form 4 transactions today. Form 3 (initial ownership) and Form 5 (annual) are on the roadmap. If you need them sooner, email support@hudsonenterprisesllc.com and tell us your use case.
Is there a free tier?
Yes. The Basic plan on RapidAPI is $0 with a hard cap of 50 requests/day — enough to evaluate the endpoint and build a prototype with no credit card. Pro is $9/mo for 5,000 requests, Ultra is $49/mo for 50,000, and Mega is $199/mo for 500,000. RapidAPI handles billing, keys, and rate limiting.
Why does every record include a source filing URL?
So any number you surface can be traced back to the exact SEC Form 4 it came from. Each record’s filing_url opens that exact filing on sec.gov. That audit-grade traceability is the differentiator — most financial-data APIs abstract the source away.

Start on the free tier.

50 requests/day, no credit card. Query insider trades for any ticker and read the source filing behind every record.

Try free on RapidAPI View the full API