DEV Community: SmartMoneyData

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.