# Congress Stock Trades & Financial Disclosures Scraper (House) (`topapi/congress-disclosures-scraper`) Actor

Scrape US House members' stock trades from the Clerk's own periodic transaction reports: one row per trade with ticker, asset, buy/sell, amount range, owner, dates, late-filing flag, party and committees, plus the full disclosure filings index with PDF links. Monitor mode. $1.30 per 1,000 rows.

- **URL**: https://apify.com/topapi/congress-disclosures-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** News, Automation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.30 / 1,000 trade or filing rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Congress Stock Trades & Financial Disclosures Scraper do?

**Congress Stock Trades & Financial Disclosures Scraper** reads the U.S. House of Representatives' financial disclosure system (disclosures-clerk.house.gov) and turns every periodic transaction report (PTR) a member files under the STOCK Act into rows: **one row per trade** with the member, party, committees, ticker, asset, buy or sell, disclosed amount range, owner, trade date, notification date and filing date. It also returns the full **disclosure filings index** (annual reports, amendments, candidate reports, extensions and notices) with each form's PDF link. Built for traders, quant researchers, journalists, compliance teams and transparency sites that want congressional trades as data instead of PDFs.

Congress stock trades API - House STOCK Act trades - Pelosi trade tracker - periodic transaction report scraper

- **Every trade line of every e-filed PTR:** the newest 1,000 trades come back in about 3 seconds; every PTR of report year 2025 (515 reports, 7,667 trades) in 15-19 seconds.
- **Member context on every row:** party, bioguide ID, committee and subcommittee seats from the House Clerk's own member list, plus birthday, gender and OpenSecrets / GovTrack ids.
- **Signals you can filter on:** days to disclose, late-filing flag against the 45-day STOCK Act limit, the "capital gains over $200" box, sector and industry of the listed company, signal tags, a 0-100 importance score and an alert priority.
- **Annual reports too:** add filing type O (annual) and the trades listed on Schedule B of annual, amendment, terminated-filer and new-filer reports come back in the same row shape.
- **No login, cookies or API key:** the actor reads the Clerk's public yearly index and the filed PDFs directly.
- **Pay only for delivered rows:** no start fee; scanned-filing rows and summary records are free.
- **Export anywhere:** JSON, CSV, Excel, XML; schedules, webhooks, Make, Zapier, n8n, Google Sheets; callable from the Apify API and the MCP server.

### What data can you get from House financial disclosures?

<table>
<tr>
<td>🏛️ Member name, first / last name</td>
<td>🗳️ Party (`party`, `partyCode`)</td>
<td>📍 State and district (`stateDistrict`)</td>
</tr>
<tr>
<td>🧾 Committees and subcommittees</td>
<td>🆔 Bioguide ID, OpenSecrets ID, GovTrack ID</td>
<td>🎂 Birthday and gender</td>
</tr>
<tr>
<td>📈 Ticker (`ticker`)</td>
<td>🏢 Asset name and asset type code</td>
<td>🏭 Sector and industry</td>
</tr>
<tr>
<td>🔁 Purchase / sale / partial sale / exchange</td>
<td>💲 Amount range, min, max, midpoint</td>
<td>👥 Owner: self, spouse, joint, dependent child</td>
</tr>
<tr>
<td>📅 Trade, notification and filing dates</td>
<td>⏱️ Days to disclose, late-filing flag</td>
<td>☑️ Capital gains over $200 box</td>
</tr>
<tr>
<td>🗂️ Account the asset is held in (`subholdingOf`)</td>
<td>📝 Description (option strike and expiry, notes)</td>
<td>🔗 PDF link of the filing</td>
</tr>
</table>

Measured on a 1,000-trade run of the newest filings (2026-08-03 to 2026-11-05, 110 reports, 51 members): ticker on 87% of trades (bonds, funds and private holdings are filed without one), sector on 85%, party, committees and bioguide ID on 99-100%, account (`subholdingOf`) on 81%, a description on 8%, an owner code on 53% (the rest are the member's own trades), the capital-gains box read on 100% (ticked on 19%). 18% of those trades were disclosed more than 45 days after they happened.

### How to scrape congressional stock trades

1. [Create a free Apify account](https://console.apify.com/sign-up) - $5 of monthly credit, no card needed.
2. Open [Congress Stock Trades & Financial Disclosures Scraper](https://apify.com/topapi/congress-disclosures-scraper) and click **Try for free**.
3. Leave the form empty for the newest trades, or type **Members** (e.g. `Pelosi`), **Tickers** (e.g. `NVDA`), a party, a committee or a date window.
4. Set **Max rows** and click **Start**. Rows stream into the dataset as each report is read.
5. Open the **Storage** tab and **Export** as JSON, CSV or Excel - or put the actor on a schedule with **Only new filings** on.

### ⬇️ Input

Every field is optional. An empty form returns the newest trades filed with the House Clerk this year and last year, newest first, up to 200 rows.

| Field | What it does | Default |
|---|---|---|
| `recordTypes` | `transactions` (one row per trade), `filings` (one row per form in the index) or both | `["transactions"]` |
| `members` | Filer names, one per line; a line matches when every word is in the name (`Pelosi`, `Ro Khanna`) | all |
| `tickers` | Tickers as filed (`NVDA`, `AAPL`) | all |
| `filingTypes` | House codes: P PTR, O annual, A amendment, T terminated filer, H new filer, C candidate, X extension, D campaign notice, W withdrawal, E exemption | P for trades, all for filings |
| `firstName`, `lastName` | Part of the filer's first / last name | - |
| `docIds` | House DocIDs (`20035662`) or form links (`https://disclosures-clerk.house.gov/public_disc/ptr-pdfs/2026/20035662.pdf`) | - |
| `states`, `districts` | `CA`, `TX` / `CA11`, `AK00` | all |
| `party` | Democrat, Republican or Independent (sitting members) | any |
| `committees` | Part of a committee or subcommittee name (`Armed Services`, `Financial Services`) | all |
| `transactionTypes` | purchase, sale_full, sale_partial, exchange | all |
| `owners` | self, spouse, joint, dependent | all |
| `assetTypes` | ST stocks, OP options, EF ETFs, MF mutual funds, GS government securities, CS corporate bonds, CT crypto, and more | all |
| `minAmount`, `maxAmount` | Keep ranges reaching at least / starting at most this many USD | - |
| `lateFilingsOnly` | Only PTR trades disclosed more than 45 days after the trade | false |
| `minImportanceScore` | Only trades scoring at least this (0-100) | 0 |
| `keywords`, `excludeKeywords` | Words in the asset name or description (`Treasury`, `call options`) | - |
| `daysBack` | Only filings filed in the last N days | - |
| `filedFrom`, `filedTo`, `reportedOn` | Filing date window / one filing day | - |
| `transactionDateFrom`, `transactionDateTo` | Trade date window | - |
| `years` | Report years to read, e.g. `[2026, 2025]` (index from 2008, e-filed PTRs from 2014) | this year and last year |
| `includeMemberDetails` | Party, bioguide ID, committees, birthday, gender, ids | true |
| `includeSector` | Sector and industry for listed tickers | true |
| `includeScannedFilings` | Free rows for scanned paper PTRs (no text layer) when no trade filter is set | true |
| `includeAggregates`, `includeEvents`, `includeTrends`, `includeStories` | Free summary records (see Output) | false |
| `trendBucket` | week or month | week |
| `committeeData` | Your own member -> committees map for the committee filter | - |
| `saveSourcePdfs`, `saveRawText` | Keep each parsed PDF / its decoded text in the run's key-value store | false |
| `monitorMode`, `monitorStoreName`, `resetMonitor` | Return only filings not read by earlier runs of the same input | off |
| `maxResults` | Most charged rows per run (0 = no limit) | 200 |
| `maxFilings` | Most forms opened per run | no limit |
| `sortBy` | newest or oldest filings first | newest |
| `outputProfile` | full, minimal, dashboard or monitoring columns | full |
| `maxConcurrency`, `proxyConfiguration` | Forms fetched at once; your own proxy | 8; direct |

Field names used by other congress-trade actors work as well, so a saved task can switch without edits: `First_Name`, `Last_Name`, `Stock_Symbol`, `Start_Date`, `End_Date` (trade dates), `Date_Reported`, `Max_Results`, `maxItems`, `ticker`, `member`, `politicians`, `lookbackDays`, `incremental`, `newOnly`, `watchlistName`, `includeCommittees` and others.

#### Input JSON

Every trade by one member in the last two years:

```json
{ "members": ["Pelosi"] }
```

Three tickers across the whole House, newest first:

```json
{ "tickers": ["NVDA", "AAPL", "MSFT"], "maxResults": 150 }
```

Large purchases by members of one committee, filed this year:

```json
{ "committees": ["Armed Services"], "transactionTypes": ["purchase"], "minAmount": 50001, "filedFrom": "2026-01-01" }
```

Late disclosures of $250,001 and up, with summary and event records:

```json
{ "lateFilingsOnly": true, "minAmount": 250001, "includeAggregates": true, "includeEvents": true }
```

Every filing in the index for 2026 (no PDFs opened):

```json
{ "recordTypes": ["filings"], "years": [2026], "maxResults": 0 }
```

#### How the House data is read

The Clerk publishes one index file per report year (every filing: name, filing type, seat, filing date, DocID; about 2,000-3,500 a year) and each form as a PDF. The actor reads the index for the years it needs, applies every name, seat, party, committee, filing type and date filter there, then opens only the forms that can match. Trade tables are read from the PDF text: the PTR table, or Schedule B of an annual / amendment / terminated / new-filer report. A ticker, keyword, asset type, amount or date filter first checks each form's raw text and skips forms that cannot match before the full read.

### ⬆️ Output

One item per trade (`recordType: "transaction"`). A real row from the 1,000-trade test run (report 20035455):

```json
{
  "recordType": "transaction",
  "transactionId": "H-20035455-1",
  "chamber": "House",
  "memberName": "Hon. Josh Gottheimer",
  "firstName": "Josh",
  "lastName": "Gottheimer",
  "filerStatus": "Member",
  "state": "NJ",
  "district": "05",
  "stateDistrict": "NJ05",
  "party": "Democrat",
  "bioguideId": "G000583",
  "isCurrentMember": true,
  "committees": ["Committee on Financial Services", "Permanent Select Committee on Intelligence"],
  "ownerCode": "JT",
  "owner": "Joint",
  "ticker": "MSFT",
  "assetName": "Microsoft Corporation - Common Stock",
  "asset": "Microsoft Corporation - Common Stock (MSFT) [OP]",
  "assetType": "OP",
  "assetTypeLabel": "Options",
  "sector": "Technology",
  "industry": "Computer Software: Prepackaged Software",
  "transactionType": "P",
  "transactionTypeLabel": "Purchase",
  "transactionSide": "buy",
  "transactionDate": "2026-08-14",
  "notificationDate": "2026-09-14",
  "filingDate": "2026-09-14",
  "amountRange": "$250,001 - $500,000",
  "amountMin": 250001,
  "amountMax": 500000,
  "amountMidpoint": 375001,
  "capitalGainsOver200": false,
  "filingStatus": "New",
  "subholdingOf": "Morgan Stanley - Portfolio Management Active Assets Account",
  "description": "Call options; Strike price $340; Expires 10/16/2026",
  "daysToDisclose": 31,
  "isLateFiling": false,
  "complianceStatus": "on-time",
  "signalTags": ["large-trade", "joint-trade", "option", "buy"],
  "importanceScore": 47,
  "alertPriority": "medium",
  "source": "periodic-transaction-report",
  "filingType": "P",
  "filingTypeLabel": "Periodic Transaction Report",
  "filingYear": 2026,
  "docId": "20035455",
  "pdfUrl": "https://disclosures-clerk.house.gov/public_disc/ptr-pdfs/2026/20035455.pdf",
  "rowIndexInFiling": 1,
  "parseStatus": "parsed",
  "contentHash": "eed0a743998af2b8"
}
```

(abridged: the full row also carries `fullName`, `prefix`, `suffix`, `stateName`, `partyCode`, `subcommittees`, `memberSince`, `birthday`, `gender`, `nickname`, `opensecretsId`, `govtrackId`, `comment`, `daysFromNotification`, `filingComment` and `scrapedAt`.)

A filing row (`recordType: "filing"`) carries the member fields plus `filingType`, `filingTypeLabel`, `filingYear`, `filingDate`, `pdfUrl`, `filedElectronically`, `parseStatus`, `transactionCount` and, when the form was read, `pages`, `periodCovered` and `signedDate`.

#### Fields

| Field | Meaning |
|---|---|
| `transactionType` | As filed: `P` purchase, `S` sale, `S (partial)` partial sale, `E` exchange |
| `ownerCode` / `owner` | `SP` spouse, `JT` joint, `DC` dependent child; empty code = the member |
| `assetType` | House asset type code: `ST` stock, `OP` option, `GS` government security, `MF` mutual fund, `EF` ETF, `CS` corporate bond, `CT` crypto, `HN` private fund, ... (forms before mid-2018 print none) |
| `amountRange` | The disclosed bracket; members report ranges, not exact values |
| `capitalGainsOver200` | The form's "Cap. Gains > $200?" box: true ticked, false not ticked, null when the form has no box |
| `daysToDisclose` | Trade date to filing date |
| `isLateFiling` / `complianceStatus` | PTR trades over 45 days (late) / over 90 days (severely-late); null on Schedule B rows, where the 45-day rule does not apply |
| `signalTags` | late-filing, severely-late, large-trade (from $250,001), very-large-trade (from $1,000,001), owner tag, asset tag, buy / sell, partial-sale, capital-gains-over-200, amended, new-filing (last 7 days) |
| `importanceScore` | 0-100: size of the range + lateness + option / crypto / purchase / spouse flags + recency |
| `contentHash` | Changes when an amended filing changes the trade line |
| `parseStatus` | `parsed`, `parsed-no-transactions`, `scanned-no-text-layer`, `not-read` |

Free summary records when switched on: `tickerSummary` (per ticker: purchases, sales, buyers, sellers, buy/sell ratio, estimated volume from range midpoints, a 0-100 consensus score), `memberSummary` (per member: trades, volume, late-filing rate, favorite tickers and sectors, trading style), `event` (large_purchase, large_sale, late_filing, severely_late_filing, trade_cluster when 3+ members buy one ticker within 30 days, congressional_accumulation, committee_activity, behavior_change), `trend` (per ticker per week or month) and `story` (templated headlines). A 300-row run with every add-on returned 139 ticker summaries, 32 member summaries, 30 events, 190 trend records and 23 stories.

### How can I use congressional trading data?

- **Copy-trading and signals:** watch what members and their spouses buy, by ticker, sector or committee.
- **Journalism:** find late disclosures, large trades and committee members trading the companies their committee oversees.
- **Compliance and research:** build a history of STOCK Act filings by member, party and state.
- **Alerts:** schedule a monitor run every hour and send new trades to Slack, email or a webhook.
- **Dashboards:** use the `dashboard` row profile for BI tools.

### How much does it cost to scrape congressional stock trades?

**$1.30 per 1,000 rows** ($0.0013 per trade or filing row). No start fee. You are charged only for rows written to the dataset; scanned-filing rows and summary records are free.

| Run | Rows | Price |
|---|---|---|
| Newest trades (the form's sample input) | 50 | $0.065 |
| One member, last two years (Pelosi) | 40 | $0.052 |
| Newest trades | 1,000 | $1.30 |
| Every PTR trade of report year 2025 | 7,667 | $9.97 |
| Empty monitor poll | 0 | $0 |

Set **Maximum cost per run** in the run options to cap a run; it stops cleanly at the limit.

### Run it on a schedule (monitor mode)

Turn on **Only new filings** (`monitorMode`), give the watch a `monitorStoreName`, and add an Apify schedule (for example `0 * * * *`, hourly). The first run returns what matches now; every later run returns only trades from filings it has not read before. The House index is refreshed through the day, so an hourly or daily schedule catches new reports as they appear. An empty poll writes nothing and returned in about 1 second in our tests.

```json
{ "monitorMode": true, "monitorStoreName": "nvda-watch", "tickers": ["NVDA"] }
```

### Integrations, API, scheduling & MCP

- **API:** `POST https://api.apify.com/v2/acts/topapi~congress-disclosures-scraper/run-sync-get-dataset-items?token=<TOKEN>` with the input JSON returns the rows in one call.
- **Webhooks:** fire on `ACTOR.RUN.SUCCEEDED` to push each run's dataset to your service.
- **Make, Zapier, n8n, Google Sheets, Slack:** connect from the actor's Integrations tab.
- **MCP / AI agents:** add the actor through the Apify MCP server (`https://mcp.apify.com`) and ask for "House trades in NVDA this year".

### More TopApi scrapers

<table>
<tr>
<td>📊 <a href="https://apify.com/topapi/yahoo-finance-scraper">Yahoo Finance Scraper</a>: quotes, financials, options and price history for the tickers members trade</td>
<td>📈 <a href="https://apify.com/topapi/x-trends-scraper">X Trends Scraper</a>: trending topics by country and city</td>
<td>🗽 <a href="https://apify.com/topapi/truth-social-scraper">Truth Social Scraper</a>: posts, replies and profiles</td>
</tr>
<tr>
<td>🔎 <a href="https://apify.com/topapi/bing-search-scraper">Bing Search Scraper</a>: news and web results for a member or a company</td>
<td>🧭 <a href="https://apify.com/topapi">All TopApi actors</a></td>
<td></td>
</tr>
</table>

### Limits & empty runs

- **House only.** The Senate's eFD site opens its search and its reports only after a visitor accepts an on-screen agreement for a browser session; this actor does not do that, so Senate trades are not included.
- **Scanned paper filings:** about 12-13% of PTRs (56 of 456 in 2026, 66 of 515 in 2025) are paper forms scanned to images with no text. Their trades are not read (no guessing from images); each comes back as a free filing row with its PDF link when no trade filter is set.
- **Coverage:** the House index goes back to report year 2008; e-filed PTRs start in 2014. Forms filed before mid-2018 print no asset type code, and forms before 2019 have no capital-gains box (those fields are null, never guessed).
- **Speed:** 50 trades in about 2 seconds, 1,000 in about 3 seconds, a full report year (7,667 trades) in 15-19 seconds on the default 512 MB. A ticker or keyword search reads the whole window (two years by default, ~970 reports) and takes 4-10 seconds.
- **Party and committees** come from the Clerk's current member list; former members get party and ids from the congress-legislators files, candidates get none.
- **Empty dataset:** no filing matched (the status line says which filter removed how many), every match was a scanned filing, or in monitor mode nothing is new. Nothing is charged for an empty run.

### FAQ

#### How many trades can it collect in one run?

There is no cap beyond `maxResults`: a run read every PTR of report year 2025 (515 reports) and returned 7,667 trades in 15-19 seconds.

#### How fresh is the data?

The actor reads the Clerk's index and the filed PDFs live on every run; the 2026 index carried filings up to the previous day when tested.

#### Does it cover the Senate?

No. See Limits: the Senate site requires accepting an agreement for a session before any search.

#### Can I get one member's trades?

Yes: put the name in **Members** (`Pelosi`, `Gottheimer`) or use `firstName` + `lastName`. Add `years` to go further back than two years.

#### Why is the ticker empty on some trades?

Members disclose bonds, Treasury bills, funds, private companies and real estate too; those are filed without a ticker. `assetType` tells you what the asset is.

#### What does "capital gains over $200" mean?

It is the box on the form the member ticks when a sale produced more than $200 of capital gains. The actor reads the box itself: true, false, or null when the form has no box.

#### How is a late filing defined?

A PTR trade disclosed more than 45 days after it happened (the STOCK Act limit) is `late`; over 90 days is `severely-late`. Annual-report Schedule B trades are not flagged.

#### Can it return annual reports and other filings?

Yes: `recordTypes: ["filings"]` returns every form in the index (annual, amendment, candidate, extension, notices) with its PDF link. Add `O` to `filingTypes` to also get the trades listed on annual reports' Schedule B.

#### Can I run it with the Apify API or an MCP server?

Yes - see Integrations. Every input is plain JSON and the run returns a dataset.

#### Do I need an account, cookies or an API key for the House site?

No. Only an Apify account to run the actor.

#### Why did my run return no results?

The status line says why: no filing matched the name, seat or dates; your trade filters removed every row; every matching filing was a scanned paper form; or a monitor run found nothing new.

#### Is this affiliated with the U.S. House of Representatives?

No. It is an independent tool that reads the public records the Clerk publishes.

#### Your feedback

Found a form that parses wrong or a field you need? Open an issue on the actor's Issues tab with the DocID.

# Actor input Schema

## `recordTypes` (type: `array`):

Transactions = one row per trade line of each periodic transaction report (PTR), and of Schedule B of annual reports when you add that filing type. Filings = one row per form in the House Clerk's index (member, filing type, dates, PDF link). Both = the filing row, then its trades.

## `members` (type: `array`):

Member or filer names, one per line, e.g. "Pelosi", "Nancy Pelosi", "Ro Khanna". A line matches when every word of it is in the filer's name. Empty = every filer.

## `tickers` (type: `array`):

Stock tickers, one per line, e.g. NVDA, AAPL, MSFT. Keeps only trades of these tickers (as filed in the report). Empty = every asset.

## `filingTypes` (type: `array`):

Which House forms to read. Empty = periodic transaction reports for trades, every type for filings. Annual, amendment, terminated-filer and new-filer reports add the trades of their Schedule B.

## `firstName` (type: `string`):

Filer first name (part of it is enough), e.g. "Nancy". Combine with Last name.

## `lastName` (type: `string`):

Filer last name (part of it is enough), e.g. "Pelosi".

## `docIds` (type: `array`):

Specific filings, one per line: a House DocID (e.g. 20035662) or a form link (https://disclosures-clerk.house.gov/public_disc/ptr-pdfs/2026/20035662.pdf). The run returns those filings and their trades.

## `states` (type: `array`):

Two-letter state codes, one per line, e.g. CA, TX, NY.

## `districts` (type: `array`):

Seats as the Clerk writes them, one per line, e.g. CA11, TX31, AK00 (at large).

## `party` (type: `string`):

Keep only sitting members of this party (from the House Clerk's member list).

## `committees` (type: `array`):

Keep only sitting members who hold a seat on a committee or subcommittee whose name contains one of these, e.g. "Armed Services", "Financial Services", "Energy and Commerce".

## `transactionTypes` (type: `array`):

Keep only these trade types. Empty = all.

## `owners` (type: `array`):

Whose account the trade was reported under. Empty = all.

## `assetTypes` (type: `array`):

Keep only these House asset type codes. Empty = all.

## `minAmount` (type: `integer`):

Keep trades whose disclosed range reaches at least this value, e.g. 50001 keeps $50,001 - $100,000 and up.

## `maxAmount` (type: `integer`):

Keep trades whose disclosed range starts at or below this value.

## `lateFilingsOnly` (type: `boolean`):

Keep only trades disclosed more than 45 days after they happened (the STOCK Act limit).

## `minImportanceScore` (type: `integer`):

Keep trades whose importanceScore (0-100: size, lateness, asset and owner flags, recency) is at least this.

## `keywords` (type: `array`):

Keep trades whose asset name or description contains one of these, e.g. "Treasury", "call options", "Bitcoin".

## `excludeKeywords` (type: `array`):

Drop trades whose asset name or description contains one of these.

## `daysBack` (type: `integer`):

Only filings filed in the last N days, e.g. 7 or 30.

## `filedFrom` (type: `string`):

Earliest filing date (YYYY-MM-DD).

## `filedTo` (type: `string`):

Latest filing date (YYYY-MM-DD).

## `transactionDateFrom` (type: `string`):

Earliest trade date (YYYY-MM-DD).

## `transactionDateTo` (type: `string`):

Latest trade date (YYYY-MM-DD).

## `reportedOn` (type: `string`):

Only filings filed on this day, e.g. what was filed today.

## `years` (type: `array`):

Report years to read, e.g. \[2026, 2025] (the House index goes back to 2008; trade reports start in 2014). Overrides the default of this year and last year.

## `includeMemberDetails` (type: `boolean`):

Add party, bioguide ID, committee and subcommittee seats (House Clerk member list), birthday, gender and OpenSecrets / GovTrack ids (congress-legislators) to each row.

## `includeSector` (type: `boolean`):

Add the listed company's sector and industry to trades with a ticker (Nasdaq's listing file). Funds and unlisted assets stay empty.

## `includeScannedFilings` (type: `boolean`):

Paper filings scanned to images have no text, so their trades cannot be read. On: each one comes back as a free filing row with its PDF link.

## `includeAggregates` (type: `boolean`):

Add one tickerSummary record per ticker (buyers, sellers, buy/sell ratio, volume, consensus score) and one memberSummary per member (trades, volume, late-filing rate, favorite tickers and sectors).

## `includeEvents` (type: `boolean`):

Add event records: large purchase / sale, late and severely late filing, trade cluster (3+ members buying one ticker within 30 days), congressional accumulation, committee activity, behavior change.

## `includeTrends` (type: `boolean`):

Add per-ticker trend records: purchases, sales and volume per week or month.

## `trendBucket` (type: `string`):

Period of the trend records.

## `includeStories` (type: `boolean`):

Add templated headline records built from the strongest events.

## `committeeData` (type: `object`):

Optional member -> committees map that replaces the Clerk's list for the committee filter, e.g. {"Pelosi": \["Intelligence"]}.

## `saveSourcePdfs` (type: `boolean`):

Store each parsed form's PDF in the run's key-value store (key pdf-<DocID>).

## `saveRawText` (type: `boolean`):

Store each parsed form's decoded text in the run's key-value store (key text-<DocID>).

## `monitorMode` (type: `boolean`):

Remember every filing read for this input (in a named key-value store) and return only trades and filings filed since. An empty poll writes nothing.

## `monitorStoreName` (type: `string`):

Named key-value store for the monitor memory. Use one name per watch list.

## `resetMonitor` (type: `boolean`):

Forget what earlier runs read and start again.

## `maxResults` (type: `integer`):

Most charged rows (trades + filings) per run. 0 = no limit.

## `maxFilings` (type: `integer`):

Most filings opened per run (each PTR or report PDF counts once). Empty = no limit.

## `sortBy` (type: `string`):

Order in which filings are read and delivered (trades keep the order of their report).

## `outputProfile` (type: `string`):

Which fields each transaction row carries.

## `maxConcurrency` (type: `integer`):

Forms fetched at the same time.

## `proxyConfiguration` (type: `object`):

The House Clerk's files are read on direct egress first; if the host refuses, the run moves to the Apify datacenter proxy, then to residential. Set your own proxy to read through it instead.

## Actor input object example

```json
{
  "recordTypes": [
    "transactions"
  ],
  "party": "any",
  "lateFilingsOnly": false,
  "includeMemberDetails": true,
  "includeSector": true,
  "includeScannedFilings": true,
  "includeAggregates": false,
  "includeEvents": false,
  "includeTrends": false,
  "trendBucket": "week",
  "includeStories": false,
  "saveSourcePdfs": false,
  "saveRawText": false,
  "monitorMode": false,
  "monitorStoreName": "congress-disclosures-monitor",
  "resetMonitor": false,
  "maxResults": 50,
  "sortBy": "newest",
  "outputProfile": "full",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One item per House trade line (and per filing when asked): member, party, committees, ticker, asset, buy/sell, amount range, owner, dates, late-filing flag, PDF link.

## `summary` (type: `string`):

Index years read, filings matched and read, forms parsed / skipped / scanned, filters, egress and stop reason.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "recordTypes": [
        "transactions"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/congress-disclosures-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "recordTypes": ["transactions"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/congress-disclosures-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "recordTypes": [
    "transactions"
  ],
  "maxResults": 50
}' |
apify call topapi/congress-disclosures-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/congress-disclosures-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ndaEcdgbyDcp3he6c/builds/dAz0KXlgVg7eAPzbH/openapi.json
