DEV Community: SmartMoneyData

Track Polymarket Whales and Top Traders with Python (No API Key)

SmartMoneyData — Wed, 14 Oct 2026 00:40:29 +0000

Polymarket is a prediction market: people bet real money on elections, sports, crypto prices and world events, and every trade settles on-chain. That makes it unusually transparent. You can see every wallet, every bet and every position.

That transparency is also why people watch the "smart money" there. When a wallet with a long record of profits puts $50,000 on one outcome, it is worth knowing about. This tutorial shows how to follow those wallets without running a blockchain indexer.

What you will build

A feed of large ("whale") trades as they happen
The top traders by profit, with their current open positions
The biggest holders on each side of any market
A watchlist of specific wallets and their portfolios

The data source

We will use the Polymarket Whale Tracker, which reads Polymarket's public data. It needs no Polymarket account and no API key. It has four modes:

Mode	Returns
`whales`	large trades: wallet, trader name, side, outcome, price, `usdValue`, market, and the trader's portfolio value
`top-traders`	the leaderboard by profit or volume, with each trader's top open positions
`market`	a market's prices, volume, liquidity, top holders of each outcome and recent large trades
`wallets`	portfolio value and open positions for wallets you choose

It costs $3 per 1,000 records.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"   # Apify Console → Settings → API & Integrations

Step 2: Whale trades

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/polymarket-smart-money").call(
    run_input={"mode": "whales", "minUsd": 10000, "lookbackHours": 24, "maxResults": 100}
)
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(t["timestamp"], t["trader"], t["side"], t["outcome"], f'${t["usdValue"]:,.0f}', "on", t["market"])

In a test run on October 13, 2026 with a lower $1,000 minimum, the 20 most recent large trades were all from the previous few minutes and added up to about $40,000. The largest was a $5,000 bet on "No" at 63 cents in a combined Brazil, Israel and US Senate election market. Each row also carries traderPortfolioValue, so you can tell a $5,000 bet from a wallet worth $35,000 (a big conviction bet) from the same bet by a wallet worth $5 million (pocket change).

Filter by topic or side:

run_input = {"mode": "whales", "minUsd": 25000, "marketKeyword": "election", "side": "BUY"}

Step 3: What are the best traders holding?

run = client.actor("smartmoney-data/polymarket-smart-money").call(
    run_input={"mode": "top-traders", "timePeriod": "MONTH", "orderBy": "PNL",
               "maxResults": 25, "positionsPerTrader": 5}
)
for tr in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f'#{tr["rank"]} {tr["trader"]}  profit ${tr["pnlUsd"]:,}  volume ${tr["volumeUsd"]:,}')
    for p in tr["topPositions"]:
        print(f'    {p["outcome"]:>4} @ {p["avgPrice"]}  now {p["currentPrice"]}  ${p["currentValue"]:,.0f}  {p["market"]}')

If several of the month's top traders hold the same outcome, that is a crowded smart-money position:

import pandas as pd
from collections import Counter

traders = list(client.dataset(run["defaultDatasetId"]).iterate_items())
crowded = Counter((p["market"], p["outcome"]) for tr in traders for p in tr["topPositions"])
for (market, outcome), n in crowded.most_common(10):
    print(n, "top traders hold", outcome, "on", market)

Step 4: Who holds a market?

Pass a Polymarket URL (or slug). An event URL covers all of its open markets:

run = client.actor("smartmoney-data/polymarket-smart-money").call(
    run_input={"mode": "market", "markets": ["https://polymarket.com/event/ballon-dor-winner-2026"],
               "holdersPerOutcome": 10, "minUsd": 5000}
)
for m in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(m["market"], f'volume ${m["volumeUsd"]:,.0f}')
    for o in m["outcomes"]:
        top = o["topHolders"][0] if o["topHolders"] else None
        print("  ", o["outcome"], o["price"], "biggest holder:", top and top["trader"], top and top["shares"])

Step 5: Watch specific wallets

run = client.actor("smartmoney-data/polymarket-smart-money").call(
    run_input={"mode": "wallets", "wallets": ["0x...", "0x..."], "positionsPerTrader": 20}
)

Schedule this in Apify Console (every hour, say) and connect Slack, email or Google Sheets to get a running log.

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/polymarket-smart-money

Then ask: "What are this month's 10 most profitable Polymarket traders betting on right now?"

FAQ

Do I need a Polymarket account or API key? No. Everything comes from Polymarket's public data endpoints.

How live is it? Trades show up seconds after they happen. Each run is a snapshot, so schedule it for an ongoing feed.

Why do some traders show a wallet address instead of a name? Polymarket only shows a username if the trader set one. Otherwise the actor uses Polymarket's generated pseudonym.

Is this legal to use? Yes. It reads public on-chain and public API data. Check whether Polymarket is available where you live before trading on it.

Data is for informational purposes only and is not investment or betting advice.

Free Company Financials API: Quarterly Revenue, EPS and Cash Flow from SEC XBRL (Python)

SmartMoneyData — Wed, 14 Oct 2026 00:40:25 +0000

If you need revenue, EPS or free cash flow for a few hundred companies, your options are usually a paid data vendor or scraping a finance website until it blocks you.

There is a third option. Every US-listed company files its financial statements with the SEC in XBRL, a machine-readable format, and the SEC serves all of it as JSON. In practice that JSON is hard to use directly:

The same line item has different names at different companies (Revenues, RevenueFromContractWithCustomerExcludingAssessedTax, SalesRevenueNet...).
10-Qs often report cash flow year to date, so Q2 is really "six months".
Q4 never appears on its own. It only exists inside the annual 10-K figure.
Restated numbers sit next to the originals.

This tutorial uses an actor that does all of that cleanup and returns one row per quarter.

What you will build

Quarterly or annual financials for any list of tickers
Margins and year-over-year growth, already calculated
A comparison table across companies
A screen for companies with growing revenue and rising margins

The data source

We will use US Company Financials. Each row is one quarter (or fiscal year) for one company:

Group	Fields
Income statement	`revenue`, `costOfRevenue`, `grossProfit`, `researchAndDevelopment`, `operatingIncome`, `netIncome`, `epsBasic`, `epsDiluted`, `dilutedShares`
Cash flow	`operatingCashFlow`, `capitalExpenditure`, `freeCashFlow`, `shareBuybacks`, `dividendsPaid`
Balance sheet	`cash`, `totalAssets`, `totalLiabilities`, `stockholdersEquity`, `longTermDebt`, `sharesOutstanding`
Ratios	`grossMargin`, `operatingMargin`, `netMargin`, `revenueGrowthYoY`, `netIncomeGrowthYoY`, `epsGrowthYoY`
Labels	`fiscalYear`, `fiscalPeriod`, `periodStart`, `periodEnd`, `derivedFromYearToDate`

derivedFromYearToDate lists the fields that were calculated rather than reported directly (for example Q4 = full year minus Q1 to Q3), so you always know what you are looking at. It costs $2 per 1,000 periods.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"   # Apify Console → Settings → API & Integrations

Step 2: Quarterly financials

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/us-company-financials").call(
    run_input={"tickers": ["AAPL", "MSFT", "NVDA", "JPM"], "periodType": "quarterly", "periods": 8}
)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for r in rows[:4]:
    print(r["ticker"], r["fiscalYear"], r["fiscalPeriod"], r["periodEnd"],
          f'revenue ${r["revenue"]/1e9:.1f}B', f'EPS {r["epsDiluted"]}', f'net margin {r["netMargin"]}%')

In a test run on October 13, 2026, Apple's latest quarter (fiscal Q3 2026, ended June 27) came back as:

revenue $109.4B (+16.4% year over year)
net income $29.8B, diluted EPS $2.02 (+28.7%)
gross margin 50.1%, operating margin 32.6%
free cash flow $31.9B, of which $25.1B went to buybacks

The cash flow figures there were derived from Apple's year-to-date numbers, and the row says so.

Step 3: Compare companies

import pandas as pd

df = pd.DataFrame(rows)
latest = df.sort_values("periodEnd").groupby("ticker").tail(1)
print(latest[["ticker", "periodEnd", "revenue", "grossMargin", "operatingMargin",
              "revenueGrowthYoY", "freeCashFlow"]].to_string(index=False))

Banks are handled too. They tag revenue differently (net of interest expense) and have no cost of goods sold, so gross margin is left empty instead of being made up.

Step 4: A simple growth screen

q = df.sort_values(["ticker", "periodEnd"])
q["marginChange"] = q.groupby("ticker").operatingMargin.diff(4)   # vs same quarter last year

screen = q.groupby("ticker").tail(1).query("revenueGrowthYoY > 10 and marginChange > 0")
print(screen[["ticker", "revenueGrowthYoY", "operatingMargin", "marginChange"]])

Step 5: Annual data and long history

run = client.actor("smartmoney-data/us-company-financials").call(
    run_input={"tickers": ["AAPL"], "periodType": "annual", "periods": 15}
)

Data goes back to around 2009, when XBRL filing began.

Going further

Add who owns the company with Institutional Ownership by Ticker, and what insiders are doing with Insider Trades.
Watch for warning signs (late filings, restatements, auditor changes) with Red Flag Radar.

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/us-company-financials

Then ask: "Compare the last four quarters of revenue growth and operating margin for MSFT, GOOGL and META."

FAQ

How fresh is the data? A quarter shows up as soon as the company files its 10-Q or 10-K, usually 4 to 6 weeks after the quarter ends.

Does it cover foreign companies? Companies that file 10-K and 10-Q forms, plus foreign filers using 20-F or 40-F where they tag their statements in XBRL. Some smaller foreign filers do not.

Why is Q4 EPS sometimes empty? Per-share figures cannot be derived by subtraction (share counts change during the year), so Q4 EPS is only filled when the company reports it.

Is this legal to use? Yes. SEC filings are public records.

Data is for informational purposes only and is not investment advice.

Track Dark Pool Volume for Any Stock with Free FINRA Data (Python)

SmartMoneyData — Wed, 14 Oct 2026 00:34:37 +0000

A large share of US stock trading never touches an exchange. Institutions route big orders to dark pools, private venues where nobody sees the order until it has traded, and retail orders are mostly filled off-exchange by wholesalers.

You do not need a paid data feed to see how much of a stock trades in the dark. FINRA requires every alternative trading system (ATS) and off-exchange dealer to report weekly volume per stock, and publishes it for free through OTC Transparency. The data is just awkward to use: a separate API, paging, tier-specific delays and venue-level rows you have to add up yourself.

What you will build

Weekly dark pool volume, trades and dollar value for a watchlist
The dark pool venues where each stock trades the most
A flag for weeks when dark pool volume jumps well above normal
A market-wide list of the most traded dark pool stocks

The data source

We will use the Dark Pool Volume Tracker, which reads FINRA's OTC Transparency weekly data and returns one report per stock:

Field	Meaning
`weekStartDate`	the latest week FINRA has published
`atsShares`, `atsTrades`, `atsNotionalUsd`	dark pool (ATS) volume that week
`avgAtsTradeSize`	shares per dark pool trade
`otcNonAtsShares`	other off-exchange volume, mostly wholesalers
`atsChangeWoWPct`, `atsVsAverage`	change vs last week and vs recent average
`unusualAtsVolume`	true when the week is well above normal
`topVenues`	the biggest dark pools for the stock, with market share
`history`	the previous weeks, for charting

It costs $5 per 1,000 stock reports.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"   # Apify Console → Settings → API & Integrations

Step 2: Dark pool volume for a watchlist

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/dark-pool-volume-tracker").call(
    run_input={"tickers": ["AAPL", "TSLA", "NVDA", "GME"], "weeks": 8}
)
reports = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for r in reports:
    print(r["ticker"], r["weekStartDate"], f'{r["atsShares"]:,}', "dark pool shares,",
          f'{r["atsVsAverage"]}x average')

In a test run on October 13, 2026, the latest week FINRA had published for Tier 1 stocks was September 21. AAPL traded 23.2 million shares on 32 dark pools that week, worth about $7.9 billion, 15% fewer shares than the week before (0.79x its recent average). Dark pools made up 33% of AAPL's off-exchange volume; the other 67% was other off-exchange trading, mostly wholesalers filling retail orders.

Step 3: Where does a stock trade in the dark?

aapl = next(r for r in reports if r["ticker"] == "AAPL")
for v in aapl["topVenues"]:
    print(f'{v["name"]:<30} {v["shares"]:>12,} shares  {v["sharePct"]}%')

For AAPL in that week, UBS ATS was the largest venue with 14.3% of dark pool volume, followed by Intelligent Cross, Level ATS, BIDS and OneChronos. BIDS is worth watching: it handled only 3,630 trades but 1.6 million shares, which works out to about 435 shares per trade. That is block trading, the kind institutions do.

Step 4: Flag unusual weeks

A stock whose dark pool volume suddenly doubles is worth a closer look: somebody large may be building or unwinding a position quietly.

run = client.actor("smartmoney-data/dark-pool-volume-tracker").call(
    run_input={"tickers": ["AMC", "GME", "PLTR", "SOFI", "RIVN"],
               "unusualRatio": 2, "onlyUnusual": True}
)
for r in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(r["ticker"], r["atsVsAverage"], "x normal,", r["atsChangeWoWPct"], "% week over week")

Step 5: The whole market

Leave tickers empty to get the stocks with the most dark pool volume in the latest week:

run = client.actor("smartmoney-data/dark-pool-volume-tracker").call(run_input={"topCount": 50})

Step 6: Chart the history

import pandas as pd

hist = pd.DataFrame(aapl["history"]).set_index("weekStartDate").sort_index()
hist[["atsShares", "otcShares"]].plot(kind="bar", stacked=True, title="AAPL off-exchange volume")

Going further

Pair dark pool volume with short interest, fails-to-deliver and the Reg SHO list in Short Squeeze Radar.
See who owns the stock with Institutional Ownership by Ticker.

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/dark-pool-volume-tracker

Then ask: "Which of my stocks had unusually high dark pool volume in the latest FINRA week?"

FAQ

Is this real-time dark pool data? No. Real-time dark pool prints come from paid feeds. This is FINRA's official weekly data, published two weeks after the week ends for Tier 1 (S&P 500 and Russell 1000) stocks and four weeks for everything else.

What is the difference between ATS and OTC volume? ATS volume is trading on registered alternative trading systems, which is what people usually mean by dark pools. OTC non-ATS volume is other off-exchange trading, mostly wholesalers filling retail orders.

Is this legal to use? Yes. FINRA publishes OTC Transparency data for public use.

Data is for informational purposes only and is not investment advice.

Who Owns a Stock? Get Every Hedge Fund and Institutional Holder with Python (SEC 13F)

SmartMoneyData — Wed, 14 Oct 2026 00:34:33 +0000

"Who owns this stock?" sounds like a simple question. Most finance sites answer it with the top 10 holders, a quarter late, and put the rest behind a paywall.

The full answer is public. Every investment manager with $100M or more in US stocks files a Form 13F with the SEC each quarter, listing every position. The SEC even publishes all of them as one bulk data set. The problem is size: one quarter is a 100 MB zip holding a 400 MB table of about 3 million positions, keyed by CUSIP rather than ticker.

This tutorial gets you from a ticker to the full holder list, with quarter-over-quarter changes, without downloading any of that yourself.

What you will build

The full list of institutions holding a stock, largest first
Who added, reduced, opened (NEW) or EXITED a position versus the previous quarter
The top buyers and sellers of a stock in one call
A cross-check of several stocks to see which funds hold all of them

The data source

We will use the Institutional Ownership by Ticker actor. It reads the SEC's quarterly Form 13F data sets, maps your ticker to its CUSIP, and compares the latest quarter with the one before. For each ticker it returns one summary row, then one row per holder:

Field	Meaning
`filer`, `filerCik`	the fund or institution
`action`	NEW, ADDED, REDUCED, UNCHANGED or EXITED vs last quarter
`shares`, `valueUsd`	position at quarter end
`changeShares`, `changePct`	how much they bought or sold
`pctOfInstitutionalShares`	their slice of all 13F-reported shares
`putShares`, `callShares`	options, kept apart from the share count
`filingUrl`	the original filing on EDGAR

It costs $2 per 1,000 rows.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"   # Apify Console → Settings → API & Integrations

Step 2: Get the holders of a stock

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/institutional-ownership-by-ticker").call(
    run_input={"tickers": ["AAPL", "PLTR"], "maxHoldersPerTicker": 200}
)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

summaries = [r for r in rows if r["type"] == "ticker-summary"]
holders = [r for r in rows if r["type"] == "holder"]

for s in summaries:
    print(s["ticker"], s["reportPeriod"], s["holders"], "holders,",
          s["newPositions"], "new,", s["exited"], "exited")

In a test run on October 13, 2026 (quarter ending June 30, 2026), this found 6,139 institutions holding AAPL and 2,880 holding PLTR. For AAPL, 295 opened new positions, 2,547 added, 2,892 trimmed and 185 sold out.

Step 3: See who is buying and who is selling

import pandas as pd

df = pd.DataFrame(holders)
aapl = df[df.ticker == "AAPL"]

print(aapl[["filer", "action", "shares", "changeShares", "pctOfInstitutionalShares"]].head(10))

The largest holders come first. In the same run BlackRock held 1.16 billion AAPL shares (11.9% of all 13F-reported shares, up 1.6% on the quarter), followed by Vanguard and State Street.

The summary row already ranks the biggest movers, so you do not have to sort 6,000 rows yourself:

s = next(s for s in summaries if s["ticker"] == "AAPL")
for b in s["topBuyers"][:5]:
    print("BUY ", b["filer"], f'{b["changeShares"]:+,}', b["action"])
for b in s["topSellers"][:5]:
    print("SELL", b["filer"], f'{b["changeShares"]:+,}', b["action"])

Step 4: Find new money

New positions are often the most interesting rows: a fund that did not own the stock at all last quarter now does.

new = df[df.action == "NEW"].sort_values("valueUsd", ascending=False)
print(new[["ticker", "filer", "shares", "valueUsd", "filedOn"]].head(20))

Step 5: Which funds hold all of my stocks?

Run several tickers at once and intersect the holder lists:

held = df[df.action != "EXITED"]
counts = held.groupby("filer").ticker.nunique()
print(counts[counts == held.ticker.nunique()].index.tolist()[:20])

Going further

One fund's whole portfolio instead of one stock's holders: Hedge Fund 13F Tracker.
What the best-known funds agree on: Hedge Fund 13F Consensus.
Faster signals than 13F: insiders file within two days (Insider Trades), and 5%+ activist stakes within ten (13D/13G).

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/institutional-ownership-by-ticker

Add it as a remote MCP server in Claude, ChatGPT or Cursor, then ask: "Which funds opened new positions in NVDA last quarter?"

FAQ

Why is the data a quarter behind? Managers have 45 days after each quarter to file, and the SEC then publishes the bulk data set. Every 13F site has the same delay, because it is the same data.

Are short positions included? No. 13F covers long positions, plus puts and calls, which are reported separately here.

What about amended filings? They are applied: a restatement replaces the original report, and a "new holdings" amendment adds to it.

Is this legal to use? Yes. Form 13F filings are public SEC records.

Data is for informational purposes only and is not investment advice.

Congress Trading Data APIs Compared: Subscriptions, Free Tiers and Pay-per-Result (2026)

SmartMoneyData — Sun, 11 Oct 2026 18:45:06 +0000

If you want congressional stock trades in your own code, a spreadsheet or an AI agent, you have three kinds of options. This post compares them by price model, coverage and the fields you get back, so you can pick one without signing up for five trials.

Prices checked October 2026. They change, so confirm on each provider's page before you buy.

Option 1: The official sources (free, but a project)

All the data starts in two places:

Senate: the eFD search site (efdsearch.senate.gov). You have to accept terms in a session before searching, and periodic transaction reports are HTML tables (some older ones are scanned images).
House: the Clerk's financial disclosure site (disclosures-clerk.house.gov). It has an index file per year and one PDF per report.

Good: free, primary source, nothing filtered.
Bad: two formats, PDF parsing, session handling, no tickers on many rows, and no structured amount fields. Budget a few days to build it and ongoing time to keep it working when either site changes.

Option 2: Subscription data providers

Several companies sell congressional trading data as part of a broader alternative-data API. For example, Quiver Quantitative's API page lists plans starting at $30/month. Other providers such as Financial Modeling Prep, Disclosed Capitol and Eulerpool offer congressional trading endpoints with free tiers and paid upgrades.

Good: maintained for you, often with history going back years and extras like charts or email alerts.
Bad: a monthly fee whether you pull ten rows or ten thousand, and commercial use can need a separate plan. Check what "free tier" covers (delay, rate limits, Senate only, and so on).

Option 3: Pay per result

The Congress Stock Trades API on Apify (disclosure: I built it) reads both official sources directly on every run and charges per trade returned: $5 per 1,000 trades, no subscription. Apify's free plan credit covers a first test, and filters run before billing, so you only pay for the rows you keep.

What makes it different from a plain feed:

Field	Why it matters
`chamber`, `politician`, `state`, `party`	Senate and House in one schema
`ticker`, `assetName`, `assetType`	stocks, options, bonds and funds told apart
`amountMin`, `amountMax`	numeric bounds of the reported range, so you can sort and filter
`owner`	Self, Spouse, Joint or Dependent Child
`reportingLagDays`	days from trade to disclosure; the STOCK Act allows 45
`committeeOversight`, `oversightCommittees`	does one of the member's committees oversee the company's sector? (Armed Services and defense, Banking and financials, and so on)
`filingUrl`	link to the original filing on every row

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("smartmoney-data/congress-stock-trades-tracker").call(run_input={
    "lookbackDays": 90,
    "transactionTypes": ["purchase"],
    "minAmountUsd": 50000,
    "onlyCommitteeOversight": True,
})
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(t["politician"], t["ticker"], t["amountRange"], t["oversightCommittees"])

It also works with no code (Apify schedules with email, Slack or Google Sheets output) and from Claude or ChatGPT as an MCP tool: mcp.apify.com/?tools=smartmoney-data/congress-stock-trades-tracker.

Good: no monthly fee, primary source on every run, committee and lag fields built in, and the same pricing model as the Form 4 insider, 13F and Form 144 Actors in the same suite.
Bad: it fetches live, so a run over many months of reports takes minutes, not milliseconds. For instant lookups, save results to your own database on a daily schedule.

Which one should you use?

You want	Pick
To learn how the filings work, or zero cost at any effort	Official sources
Years of history, charts and a dashboard	A subscription provider
Data in your own code or agent, paying only for what you pull	Pay per result
A daily alert on a few tickers or members	Pay per result on a schedule (costs cents a month)

Whichever you choose, remember that the amounts are ranges, trades are disclosed up to 45 days late (sometimes later), and a trade in a sector a member's committee oversees is legal and public, not proof of anything. It's a lead to look into, not a trading signal on its own.

Build a Biotech Catalyst Calendar: PDUFA Dates, Trial Readouts and FDA Approvals in Python

SmartMoneyData — Sun, 11 Oct 2026 18:45:03 +0000

Biotech stocks move on a handful of dates: the day a pivotal trial reads out, the day the FDA decides on an application (the PDUFA date), and the day an advisory committee votes. Paid catalyst calendars charge hundreds of dollars a month for this. The underlying data is public; it is just spread across three government sources that do not talk to each other.

This tutorial builds that calendar for any list of tickers.

The three sources

Source	What it gives you
ClinicalTrials.gov	Every trial a company sponsors, with its phase and primary completion date, the point after which topline data usually follows
SEC 8-K filings	PDUFA target action dates and advisory committee dates the company announced in its press releases
openFDA (Drugs@FDA)	FDA approvals of the company's applications, including label expansions

Joining them by hand means matching sponsor names ("Vertex Pharmaceuticals Incorporated" on ClinicalTrials.gov, "VERTEX PHARMS INC" at the FDA, "VERTEX PHARMACEUTICALS INC / MA" at the SEC) and reading press releases for dates written like "PDUFA date November 30th". The Biotech Catalyst Calendar does that matching for you, without needing an API key, and returns one row per dated event.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"

Step 2: Build the calendar

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/biotech-catalyst-calendar").call(
    run_input={
        "tickers": ["VRTX", "SRPT", "MRNA"],
        "daysAhead": 365,
        "daysBack": 0,          # upcoming events only
    }
)
events = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for e in events:
    print(f'{e["date"]}  {e["ticker"]:<5} {e["eventType"]:<26} {e["title"][:70]}')

Each row has date, daysUntil, eventType (pdufa-date, fda-advisory-committee, trial-primary-completion, fda-approval, fda-supplement-approval), a title, a detail (for PDUFA dates, the exact sentence from the press release), and a link to the source.

A real example

Running it for Vertex (VRTX) in October 2026 found 247 trials where Vertex is the lead sponsor and picked up this line from its second-quarter 2026 results release:

povetacicept PDUFA date November 30th

The release didn't state a year, so the actor dated the PDUFA event from the filing date (August 3, 2026), giving 2026-11-30. The row is marked yearInferred: true, and the original sentence is in detail, so you can check the inference yourself.

Step 3: Only the binary events

Trial completions are useful for planning, but PDUFA dates and advisory committees are the classic binary events:

import pandas as pd

df = pd.DataFrame(events)
binary = df[df.eventType.isin(["pdufa-date", "fda-advisory-committee"])]
print(binary[["date", "ticker", "eventType", "detail"]].to_string(index=False))

Or skip trials entirely with "sources": ["filings"], which is faster and cheaper.

Step 4: Next 90 days, sorted

upcoming = df[df.daysUntil.between(0, 90)].sort_values("date")
print(upcoming[["date", "daysUntil", "ticker", "eventType", "title"]].to_string(index=False))

Caveats worth knowing

Trial dates are estimates. Sponsors register planned completion dates and update them. isEstimated tells you which are planned and which already happened, and precision: "month" means the sponsor gave only a month.
Not every PDUFA date is public. Companies are not required to disclose them, and some only mention them on earnings calls. The actor finds the ones written in 8-K filings and their press-release exhibits.
Big pharma runs hundreds of trials. Use "phases": ["PHASE3"] and maxTrialsPerTicker to focus.

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/biotech-catalyst-calendar

Add it as a remote MCP server in Claude, ChatGPT or Cursor and ask: "What binary events do VRTX, SRPT and MRNA have in the next 90 days?"

Related tools

FDA Recall Checker: FDA recalls, drug labels and adverse-event counts
Insider Trading API: are insiders buying ahead of the readout?
Trading Halts: biotech stocks are often halted for news pending on decision day

Data is for informational purposes only and is not investment advice.

Track Insider Buying and Selling with SEC Form 4 Data in Python

SmartMoneyData — Sun, 11 Oct 2026 18:45:00 +0000

When a CEO buys their own company's stock on the open market, they are putting personal money behind a view only they can really hold. Insider buying is one of the most studied signals in finance, and the raw data is free: every officer, director and 10% owner has to file a Form 4 with the SEC within two business days of a trade.

The catch is the format. Form 4s are XML documents scattered across EDGAR, mixed with option grants, tax withholdings and gifts that are not real buying or selling. This tutorial turns them into a clean table of trades you can actually use.

What you will build

A script that pulls recent insider purchases and sales for any tickers
A filter that keeps only real open-market trades and drops pre-planned 10b5-1 sales
A "cluster buying" check: several insiders buying the same stock at once
A Google Sheets or Slack feed of new trades

The data source

We will use the Insider Trading API, which reads Form 4 filings straight from SEC EDGAR, typically minutes after they are published. Each row is one transaction:

Field	Meaning
`ticker`, `issuerName`	the company
`insiderName`, `insiderRole`	who traded, e.g. "Chief Financial Officer"
`transactionCode`, `transactionType`	P = open-market purchase, S = open-market sale, and others
`shares`, `pricePerShare`, `valueUsd`	size of the trade
`holdingChangePct`	how much of their stake they bought or sold
`is10b5_1Plan`	true if the trade was pre-scheduled under a 10b5-1 plan
`filingUrl`	link to the original filing

It costs $3 per 1,000 transactions, and transactions filtered out are free.

Step 1: Setup

pip install apify-client pandas
export APIFY_TOKEN="your-token-here"   # from Apify Console → Settings → API & Integrations

Step 2: Pull insider trades for a watchlist

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/sec-insider-trades-tracker").call(
    run_input={
        "tickers": ["AAPL", "NVDA", "TSLA", "JPM"],
        "lookbackDays": 90,
        "transactionCodes": ["P", "S"],   # open-market buys and sells only
    }
)
trades = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for t in trades[:10]:
    print(t["ticker"], t["insiderName"], t["insiderRole"], t["transactionType"], t["valueUsd"])

Leave tickers empty to get the most recent Form 4s across the whole market instead.

Step 3: Separate signal from noise

Most insider selling is routine: executives sell on a pre-set schedule (10b5-1 plans) to diversify or pay taxes. Purchases are rarer and more informative. Two filters do most of the work:

import pandas as pd

df = pd.DataFrame(trades)
buys = df[(df.transactionCode == "P") & (df.valueUsd >= 100_000)]
discretionary_sales = df[(df.transactionCode == "S") & (~df.is10b5_1Plan)]

print(buys[["ticker", "insiderName", "insiderRole", "valueUsd", "transactionDate"]])

Step 4: Find cluster buying

One insider buying can be noise. Three insiders buying the same stock in the same few weeks is much harder to dismiss:

clusters = (buys.groupby("ticker")
                .agg(insiders=("insiderName", "nunique"),
                     total_usd=("valueUsd", "sum"),
                     last_buy=("transactionDate", "max"))
                .query("insiders >= 2")
                .sort_values(["insiders", "total_usd"], ascending=False))
print(clusters)

Step 5: Send it somewhere useful

Google Sheets / Slack / email: schedule the actor in Apify Console and add an integration.
Only new trades: Smart Money Alerts remembers what it already sent.
A combined score: Smart Money Confluence blends insider trades with activist 13D stakes, Form 144 planned sales and Congress trades into one score per ticker.

Bonus: see sales before they happen

Insiders who own restricted stock must file a Form 144 when they plan to sell, often before the Form 4 shows up. The Form 144 API returns those notices the day they are filed.

Use it from an AI assistant

https://mcp.apify.com/?tools=smartmoney-data/sec-insider-trades-tracker

Add it as a remote MCP server in Claude, ChatGPT or Cursor, then ask: "Which insiders bought more than $500k of their own company's stock this week?"

FAQ

How fast does a trade appear? Insiders have two business days to file; the actor reads EDGAR directly, so a filing is available minutes after the SEC publishes it.

What do the transaction codes mean? P is an open-market purchase and S an open-market sale. A (grants), F (tax withholding) and M (option exercises) are usually compensation, not conviction, which is why the default keeps only P and S.

Is this legal to use? Yes. Form 4 filings are public SEC records.

Data is for informational purposes only and is not investment advice.

How to Track Congress Stock Trades with a Free API (Python, 2026)

SmartMoneyData — Sun, 11 Oct 2026 18:44:56 +0000

Members of Congress have to report their stock trades under the STOCK Act. The data is public, but it is spread across two government websites with different formats: the Senate's eFD system and the House Clerk's PDF filings. If you have ever tried to answer "which politicians bought NVDA this quarter?", you know it takes an afternoon.

This tutorial shows how to get every trade from both chambers as one clean table in about ten lines of Python, then go a step further: flag the trades where a member sits on a committee that oversees the company's industry.

What you will build

A script that pulls every disclosed trade from the last 90 days
A filter for one ticker, one politician, or large trades only
A "conflict" view: Armed Services members trading defense stocks, Energy committee members trading oil companies, and so on
An optional daily alert for new trades

The data source

We will use the Congress Stock Trades API on Apify. It reads the official Senate and House disclosures directly, so there is no third-party scraper in between, and returns one row per trade:

Field	Example
`politician`, `chamber`, `state`	Jane Q. Public, House, CA
`ticker`, `assetName`	GOOGL, Alphabet Inc. - Class A
`transactionType`	Purchase / Sale / Exchange
`transactionDate`, `disclosureDate`	2026-09-01, 2026-09-16
`reportingLagDays`	15
`amountRange`, `amountMin`, `amountMax`	$250,001 - $500,000
`committees`, `sector`, `committeeOversight`	the member's committees, the company's sector, and whether they overlap
`filingUrl`	link to the original disclosure

Pricing is pay per result ($5 per 1,000 trades), and Apify's free plan credit is enough to follow along.

Step 1: Install the client and get a token

pip install apify-client

Create a free Apify account, then copy your API token from Settings → API & Integrations. Store it in an environment variable rather than in your code:

export APIFY_TOKEN="your-token-here"

Step 2: Pull the last 90 days of trades

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("smartmoney-data/congress-stock-trades-tracker").call(
    run_input={"lookbackDays": 90}
)
trades = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(trades), "trades")

for t in trades[:5]:
    print(t["politician"], t["transactionType"], t["ticker"], t["amountRange"])

Step 3: Filter by ticker, politician or size

Every filter runs before you are charged, so narrow inputs are also cheaper:

run = client.actor("smartmoney-data/congress-stock-trades-tracker").call(
    run_input={
        "tickers": ["NVDA", "MSFT"],          # only these stocks
        "politicians": [],                    # e.g. ["Pelosi"] for one member
        "transactionTypes": ["purchase"],     # purchase, sale, exchange
        "minAmountUsd": 50000,                # skip the $1,001 - $15,000 bucket
        "lookbackDays": 180,
    }
)

Step 4: Find committee conflicts

This is the part most trackers skip. Each trade is enriched with the member's committee assignments and the company's sector (from its SEC industry code). committeeOversight is true when they overlap, for example an Armed Services member trading a defense contractor.

run = client.actor("smartmoney-data/congress-stock-trades-tracker").call(
    run_input={"lookbackDays": 180, "onlyCommitteeOversight": True}
)
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f'{t["politician"]:<25} {t["ticker"]:<6} {t["transactionType"]:<9} '
          f'{t["amountRange"]:<22} via {", ".join(t["oversightCommittees"])}')

A note on interpretation: an overlap is not evidence of wrongdoing. Many members hold diversified portfolios and trades are often made by spouses or advisers. The flag tells you where to look, and the filingUrl takes you to the original disclosure.

Step 5: Load into pandas

import pandas as pd

df = pd.DataFrame(trades)
summary = (df[df.transactionType == "Purchase"]
           .groupby("ticker")
           .agg(buyers=("politician", "nunique"), max_amount=("amountMax", "sum"))
           .sort_values("buyers", ascending=False)
           .head(10))
print(summary)

reportingLagDays is worth a look too: the law allows 45 days, and late filers show up immediately.

Step 6: Get alerts on new trades

Two options:

Schedule it in Apify Console (daily is plenty, since disclosures arrive in batches) and connect the Slack, email or webhook integration.
Use Smart Money Alerts, which remembers what it already sent and only notifies you about new trades, insider buys or activist stakes on your watchlist.

Use it from an AI assistant

The same data is available to Claude, ChatGPT or Cursor through the Apify MCP server. Add this URL as a remote MCP server or custom connector:

https://mcp.apify.com/?tools=smartmoney-data/congress-stock-trades-tracker

Then ask: "Which members of Congress traded defense stocks in the last 90 days, and do any of them sit on Armed Services?"

FAQ

How current is the data? Members must report within 45 days of a trade, so the data is as fresh as the filings. The actor reads new disclosures every run.

Does it include spouses and dependents? Yes. The owner field says whether the trade was the member's, a spouse's, or a dependent child's.

Is this legal to use? Yes. STOCK Act disclosures are public records published by Congress.

Data is for informational purposes only and is not investment advice.