Insider Buy Signals
Verify any U.S. SEC filing claim, field-by-field, against the filing it came from. Every
figure here — shares, price, dollar value, percent, stake size — traces to a parsed field in a
real EDGAR filing and ships with a link to that filing on sec.gov. Records that can't be linked
to a filing are dropped, never guessed: no scores, no unsourced numbers. We call this filing-verified.
We also ran the obvious question — does insider buying predict returns? — as four sealed,
pre-registered tests. I tried four times to prove otherwise, and four times the data said no;
the full record is at https://www.tradestarinsider.com/what-we-tested. This repo is the
MIT-licensed MCP server, client library, and worked examples for the
TradeStar Insider API.
Free vs paid
The data is the same on every plan. Every row is filing-verified and links to its source on
sec.gov. Plans differ in history, volume and export:
The free tier serves the last 30 days of filings. Older filings are not hidden: a request for
an older date tells you the filing exists and is on the paid plan — it never claims that no
filing exists. The verify_* tools check any filing across the full history for free. The paid
plan is $29 a month on RapidAPI: 100,000 calls a month and full history since 2024, plus the key
for the paid MCP endpoint from /v1/mcp-key.
(On RapidAPI the free Basic plan is 100 calls a day, or 3,000 calls a month where the console
allows only a monthly quota.)
There are two free ways in, each with its own limit: the open, no-key endpoint
(mcp.tradestarinsider.com/mcp and /public/v1) enforces a hard 100 data calls per day per
IP, resetting at 00:00 UTC — over the cap it returns a plain message (a tool result on MCP,
HTTP 429 on REST), never a transport error. MCP handshakes and verify_* checks both behave as
expected (handshakes are free; a verify counts as one call). RapidAPI Basic meters per key
at the same 100 calls/day. Both serve the same 30-day free window.
Full pricing and a key: https://www.tradestarinsider.com/pricing
Run the MCP server locally
The server is published as insider-signals-mcp — a tiny stdio proxy to the remote endpoint.
Run it with no install using uvx:
To wire it into Claude Desktop, add this to claude_desktop_config.json:
Or point any MCP client straight at the remote endpoint (no proxy needed):
https://mcp.tradestarinsider.com/mcp (Streamable HTTP, no auth). The verify tools are the
core: check an insider purchase, an activist 13D stake, an 8-K event, or a 13F holding against
its source filing.
What the data is
Five filing-verified families from SEC EDGAR (plus federal contract awards from USAspending):
- Insider Form 4 purchases (SEC transaction code P) — cluster buys (two or more insiders
buying the same company inside a window of seven calendar days or fewer) and buys large
relative to the insider's existing holdings.
- Activist Schedule 13D stakes, 13F fund position changes, and recent federal
contract awards.
Code P does not by itself prove an open-market buy. A purchase filed under P can be an
IPO / offering / private-placement allocation, so every purchase record carries an
offering_context flag (true = allocation, not open-market) and clusters carry a
uniform_price_cluster flag marking a single administered price. Option exercises, 10b5-1
planned sales, and sub-threshold noise (below $50,000) are dropped. Every field we return is
parsed from a real filing and ships with its sec.gov link. Records that can't be linked to a
filing are dropped, never guessed. No scores, no unsourced numbers. We call this filing-verified.
What the data is not
It is not a prediction. We ran four pre-registered, sealed tests for whether insider buying
precedes price moves over our own history, and all four returned NULL — no return edge
distinguishable from base rate — so we do not claim one. The full record (question, method,
sample, number, verdict per test) is public at
What we tested. This is a clean,
filing-verified lookup and verification layer over public purchases — you decide what they mean. It is also not real-time: ingestion is a once-daily weekday cron, so
new filings surface next business day, not live.
Coverage
- Insider Form 4 buys: full history 2024-01-02 → 2026-10-09 (686 U.S. trading days),
no non-holiday gaps (market holidays such as Presidents' Day carry no filings and are not
gaps). Read the live number any time at
/v1/health — it is the source of truth and
advances every business day. Every served purchase is a filing-verified code-P purchase,
never an open-market guess: records that can't be traced to a parsed SEC filing field are
dropped, never inferred.
- Completeness: we capture 93.70% of in-window code P purchases (lower bound
87.28%); of the filings we skip, only 0.75% (95% CI 0.34–1.63%) turn out to be
purchases we genuinely missed — the rest are sales, option exercises, amendments, and
sub-$50k buys we exclude by design. (This recall figure is from a sealed, pre-registered
20-trading-day study, 2026-08-17 → 2026-09-14; see
What we tested.)
Install
Zero runtime dependencies — the client uses only the Python standard library.
Quickstart (free, no key)
The free tier answers on the open discovery surface with no key and per-IP rate limiting:
See examples/rest_api.py for a runnable version.
Free tier vs. keyed tier
For the keyed tier, subscribe on RapidAPI and construct the client with your key:
Calling a keyed method without a key raises InsiderSignalsError with status == 403.
Worked examples — one real request and response per tool
Every response below is a real capture from the live public API, on the free tier (no key).
The two free list tools (today, clusters) were re-captured on 2026-10-21 and show the free
30-day window in their coverage_* fields — a free caller sees exactly this. The verify_*
examples are from an earlier capture (2026-09-23); verification is full-history on every plan, so
their coverage_* fields reflect that capture date and are not clamped to the 30-day window. The
live coverage window moves daily — read /v1/health for the current bounds.
today — today's insider buys
(An empty set is normal pre-market / on a non-trading day; it repopulates the moment new
filings materialize.)
clusters — cluster buys (2+ insiders, one issuer, ≤7 days)
verify — confirm an insider code P purchase claim
A claim with no matching filing returns "status": "not_found" (in-window) or
"out_of_coverage" (outside the collected days) — never a guess.
Purchase record fields. Every confirmed purchase filing — on both verify
(by claim) and the by-accession fetch — carries the same four extra fields, so a
consumer reads one shape regardless of how the row was pulled:
Any field that could not be resolved is null and explained under a
partial_fields object (field → reason) on that record — a missing value is never
silent. A record with everything resolved omits partial_fields entirely. Example:
Form 4/A amendments. When an insider files a Form 4/A that corrects an earlier
Form 4, verify returns the amended filing as the current record — the superseded
original is not returned as a co-equal filing. If your claim cited the figure the
amendment changed, the verdict carries a superseded object naming the
original_accession, the amendment_accession, and the corrected figure, and the
message says the figure was corrected by 4/A. The keyed amendments_recent
(GET /v1/amendments/recent) lists these amendments newest-first, each with its
original_accession and a changed_fields map of what the 4/A changed (before → after);
an amendment whose original is outside our collected window is still listed, flagged
original_in_corpus: false, with the before/after left null — never guessed.
verify_13d — confirm a Schedule 13D activist-stake claim
verify_8k — confirm an 8-K material-event claim
verify_13f — confirm a 13F institutional-holding claim
Response shape
Every data route returns the same envelope; the rows live under signals, and the client's
list-returning methods hand you that list directly. The verify* methods return the full
envelope (you want the status and matched/filings fields).
List controls
Every list route (today, clusters, ticker, range, amendments/recent) accepts the same
optional query parameters. The response echoes the ones you set under params and always reports
total_matched, so you page rather than hit a silent cap.
Every listing row carries first_served_at — the UTC ISO-8601 instant that row first crossed our
publish boundary (the atomic write that made it public). It is stamped once, per ingest batch, and
never rewritten, so it is a stable anchor for as_of replay and for measuring publish latency. On
rows materialized before this field existed it is null, explained under partial_fields (and such
rows are kept by an as_of query, since they were already public before the field). as_of is
the companion to days: days bounds the filing date, as_of bounds when we served it.
MCP server (for AI assistants)
Ask an AI client (Claude and other MCP clients) for these signals directly. Open, free, per-IP
rate limited — no API key, no OAuth:
Then ask: "Show today's insider buy signals" or "Any insider cluster buys this week? Link the
filings." See examples/mcp_client.md for the tool list and a
programmatic SDK example.
Pricing
RapidAPI is the checkout. Two plans: Basic (free) and one $29-a-month plan with 100,000 calls a
month and full history since 2024. After subscribing, call /v1/mcp-key to get your key and both
keyed URLs — the key also unlocks the paid MCP endpoint.
Hard limits, no overage — requests over the cap return 429 until the window resets. The free
discovery surface and the MCP server are open and per-IP rate limited; metered API billing runs
through RapidAPI.
Disclaimer
Information, not investment advice. Every figure is parsed from a public SEC filing and links to
its source on sec.gov. Insider buying guarantees nothing — insiders are wrong plenty — but
code P purchases are real money on the line.
License
MIT. Changelog: CHANGELOG.md.