# Capitol Trades Scraper (`solidcode/capitoltrades-scraper`) Actor

\[💰 $0.90 / 1K] Track US congressional stock trades from Capitol Trades. Every politician disclosure: buy/sell, ticker, company, trade-size range, transaction & filing dates, reporting gap, owner. Filter by politician, party, chamber, state, or company.

- **URL**: https://apify.com/solidcode/capitoltrades-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Agents, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Capitol Trades Scraper

Pull every US congressional stock-trade disclosure from Capitol Trades at scale — one clean row per trade, complete with politician, company, ticker, transaction type, dollar-size band, price, and every disclosure date. Built for financial researchers, investigative journalists, and compliance teams who need to track how members of Congress trade without opening PDF filings or checking disclosure pages one at a time.

### Why This Scraper?

- **20+ structured fields per trade** — politician, party, chamber, home state, company, ticker, sector, transaction type, owner, size band, price, and every disclosure date, already parsed into one flat row. No filings to read by hand.
- **Reporting-gap days on every trade** — see exactly how many days passed between a trade and its public disclosure, so you can surface the slowest, latest filers in a single sort.
- **Trade-size ranges with numeric $ min/max bounds** — every disclosed band (e.g. "$15K–$50K") also ships as `sizeRangeMin` and `sizeRangeMax` numbers, so you can sort, sum, and rank by dollar exposure.
- **Filter by politician name or stock ticker directly** — type "Nancy Pelosi" or "NVDA" and get matches; no bioguide IDs and no hand-built query strings required.
- **House & Senate, all 50 states + DC** — full congressional coverage with two-chamber and per-state filters.
- **4 transaction types × 4 owner categories** — split Buy / Sell / Exchange / Receive and Self / Spouse / Child / Joint to isolate exactly the disclosures you care about.
- **Company sector and clean ticker on every row** — group trades by sector (information technology, energy, financials, health care, and more) or by ticker for portfolio-level analysis.
- **Flexible date targeting** — quick windows of 7, 30, 90, 180, or 365 days, or an exact custom transaction-date range, plus sort by published date, trade date, or reporting delay.
- **Paste-a-URL power mode** — already have a filtered Capitol Trades URL? Drop it in and get every matching trade with full parity to the site's own filters.

### Use Cases

**Investment Research & Signal Generation**
- Track what congressional committee members buy and sell ahead of major votes or hearings
- Build a "congressional buys" watchlist from Buy transactions in a sector you follow
- Rank trades by dollar exposure using the numeric size bounds to focus on the largest positions

**Journalism & Watchdog Reporting**
- Surface the slowest disclosures by sorting on reporting-gap days to spot filings that stretched past the STOCK Act's 45-day window
- Follow a single member's full trading record by name across House and Senate terms
- Cross-reference a member's trades in a company against their committee assignments

**Compliance & Ethics Monitoring**
- Monitor spouse, child, and joint-account trades that members are still required to disclose
- Flag transactions in sensitive sectors (defense, health care, energy) for conflict-of-interest review
- Keep an audit trail of every disclosure with its filing date and Capitol Trades source link

**Quant & Backtesting**
- Assemble a time series of congressional trades by transaction date for factor research
- Backtest a "follow the politician" strategy using per-trade price and size bands
- Segment trade flow by party, chamber, or state to test cross-sectional hypotheses

**Newsletters & Content**
- Auto-generate a weekly "who traded what" digest from the last 7 days
- Feed a public dashboard tracking the most active congressional traders

### Getting Started

#### The Latest Trades

The simplest possible run — the 100 most recently published disclosures:

```json
{
    "maxItems": 100
}
````

#### Track One Politician's Recent Buys

```json
{
    "politicians": ["Nancy Pelosi"],
    "transactionTypes": ["buy"],
    "dateRange": "90d",
    "maxItems": 200
}
```

#### Trades in a Company, Slowest Filers First

Pull every disclosed trade in NVIDIA or Microsoft and sort so the latest disclosures rise to the top:

```json
{
    "issuers": ["NVDA", "Microsoft"],
    "sortBy": "reportingGap",
    "maxItems": 500
}
```

#### Full-Featured Example

Senate trades from three states, in a custom date window, ordered by trade date:

```json
{
    "chamber": ["senate"],
    "states": ["CA", "TX", "NY"],
    "transactionTypes": ["buy", "sell"],
    "owners": ["self", "spouse"],
    "tradedAfter": "2025-01-01",
    "tradedBefore": "2025-12-31",
    "sortBy": "traded",
    "maxItems": 1000
}
```

#### Paste a Capitol Trades URL

Already built a filtered view on the site? Paste the URL and the filters above are ignored:

```json
{
    "startUrls": ["https://www.capitoltrades.com/trades?party=democrat&txType=buy"],
    "maxItems": 200
}
```

### Input Reference

Every field is optional. Leave everything blank to pull the entire trades feed. Filters combine — a trade must match all of them.

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `politicians` | array | `[]` | Filter to specific members. Enter names (e.g. "Nancy Pelosi") or Capitol Trades profile URLs. Blank = all politicians. |
| `issuers` | array | `[]` | Filter to specific traded companies. Enter company names (e.g. "Apple") or ticker symbols (e.g. "NVDA", "MSFT"). Blank = all companies. |
| `party` | array (select) | `[]` | Democrat, Republican, Other / Independent. |
| `chamber` | array (select) | `[]` | House of Representatives, Senate. |
| `states` | array (select) | `[]` | Any of the 50 US states plus District of Columbia. |
| `transactionTypes` | array (select) | `[]` | Buy, Sell, Exchange, Receive. |
| `owners` | array (select) | `[]` | Self, Spouse, Child, Joint — the account behind the trade. Applied to the collected results. |

#### Date Range

Limit results by when the trade happened. Use the quick window OR the custom dates — a custom date takes priority over the quick window.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dateRange` | string (select) | `All time` | Quick transaction-date window: All time, Last 7 days, Last 30 days, Last 90 days, Last 6 months, Last year. |
| `tradedAfter` | string | — | Only trades on or after this date. Format `YYYY-MM-DD` (e.g. `2025-01-01`). |
| `tradedBefore` | string | — | Only trades on or before this date. Format `YYYY-MM-DD` (e.g. `2025-06-30`). |

#### Ordering & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | string (select) | `Published date (newest first)` | Order results by: Published date (newest first), Trade date (newest first), or Reporting delay (longest first). |
| `maxItems` | integer | `100` | Maximum trades to collect. Set to `0` to collect every available trade. Lower it to keep runs fast and costs predictable. |
| `startUrls` | array | `[]` | Advanced: paste one or more Capitol Trades filtered URLs (starting with `https://www.capitoltrades.com/trades`). When provided, the filters above are ignored. |

### Output

Every row is one individual trade disclosure. Here is a representative result:

```json
{
    "tradeId": "20003801566",
    "politicianName": "Debbie Dingell",
    "politicianId": "D000624",
    "party": "democrat",
    "chamber": "house",
    "state": "MI",
    "politicianUrl": "https://www.capitoltrades.com/politicians/D000624",
    "issuerName": "NVIDIA Corp",
    "ticker": "NVDA",
    "issuerId": "431632",
    "issuerUrl": "https://www.capitoltrades.com/issuers/431632",
    "sector": "information-technology",
    "owner": "spouse",
    "txType": "buy",
    "sizeRange": "$15K–$50K",
    "sizeRangeMin": 15001,
    "sizeRangeMax": 50000,
    "price": 178.24,
    "txDate": "2026-07-14",
    "pubDate": "2026-07-23T13:05:01Z",
    "filedDate": "2026-07-22",
    "reportingGapDays": 8,
    "url": "https://www.capitoltrades.com/trades/20003801566"
}
```

#### Politician

| Field | Type | Description |
|-------|------|-------------|
| `politicianName` | string | Full name of the member of Congress |
| `politicianId` | string | Capitol Trades / bioguide identifier |
| `party` | string | `democrat`, `republican`, or `other` |
| `chamber` | string | `house` or `senate` |
| `state` | string | Two-letter code of the state the member represents |
| `politicianUrl` | string | Member's Capitol Trades profile URL |

#### Company

| Field | Type | Description |
|-------|------|-------------|
| `issuerName` | string | Traded company / issuer name |
| `ticker` | string | Stock ticker (`N/A` for non-listed assets) |
| `issuerId` | string | Capitol Trades issuer identifier |
| `issuerUrl` | string | Issuer's Capitol Trades page URL |
| `sector` | string | Issuer sector (e.g. `information-technology`, `energy`, `financials`) |

#### Transaction

| Field | Type | Description |
|-------|------|-------------|
| `tradeId` | string | Unique trade / disclosure identifier |
| `txType` | string | `buy`, `sell`, `exchange`, or `receive` |
| `owner` | string | `self`, `spouse`, `child`, `joint`, or `not-disclosed` |
| `sizeRange` | string | Disclosed value band, e.g. `$15K–$50K` |
| `sizeRangeMin` | number | Lower dollar bound of the band |
| `sizeRangeMax` | number | Upper dollar bound of the band (`null` for the open `> $50M` band) |
| `price` | number | Security price at the transaction, when disclosed (`null` otherwise) |
| `url` | string | The trade's Capitol Trades detail URL |

#### Dates & Disclosure

| Field | Type | Description |
|-------|------|-------------|
| `txDate` | string | Transaction (trade) date, `YYYY-MM-DD` |
| `pubDate` | string | When Capitol Trades published the disclosure (ISO 8601) |
| `filedDate` | string | Filing date, `YYYY-MM-DD` |
| `reportingGapDays` | number | Days between the trade and its disclosure — the "filed after" gap |

### Tips for Best Results

- **Start small to preview.** Set `maxItems` to 100–200 on your first run to confirm the fields and filters match what you need, then scale up.
- **Filter companies by name or ticker.** Enter "NVDA" or "Apple" in `issuers` — the scraper resolves both to the right company, so you never have to look up an internal ID.
- **Sort by reporting delay to catch slow filers.** Set `sortBy` to "Reporting delay (longest first)" to bubble up the trades that took the longest to disclose — the fastest way to find filings that stretched past the STOCK Act's 45-day window.
- **Custom dates beat the quick window.** For an exact span, set `tradedAfter` and `tradedBefore`; they override the Date Range preset. Use the quick window only for rolling "last N days" pulls.
- **Owner filtering runs on the collected results.** When you filter to Spouse, Child, or Joint only, raise `maxItems` so enough trades are scanned to return a full set — these owners are a small slice of total volume.
- **Use the size bounds for dollar analysis.** Sort or aggregate on `sizeRangeMin` / `sizeRangeMax` to rank trades by exposure; the text `sizeRange` is for display, the numbers are for math.
- **Combine filters to zero in.** Filters AND together — pair a chamber, a party, and a date window to build a tight, repeatable feed for a recurring report.

### Pricing

**From $0.90 per 1,000 results** — undercuts the going market rate for congressional-trade data while returning richer, fully parsed rows. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.10 | $0.10 | $0.09 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one trade row in your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects US congressional stock-trade disclosures that are public records. Under the STOCK Act, members of Congress must publicly file their periodic transaction reports, and Capitol Trades aggregates those public filings. Use the data for research, journalism, compliance, and analysis. Users are responsible for complying with applicable laws and Capitol Trades' terms of service. Do not use extracted data for harassment or any illegal purpose.

# Actor input Schema

## `politicians` (type: `array`):

Filter to specific members of Congress. Enter names (e.g. 'Nancy Pelosi') or Capitol Trades profile URLs. Leave empty to include all politicians.

## `issuers` (type: `array`):

Filter to specific traded companies. Enter company names (e.g. 'Apple') or ticker symbols (e.g. 'NVDA', 'MSFT'). Leave empty to include all companies.

## `party` (type: `array`):

Only include trades by members of these parties.

## `chamber` (type: `array`):

Only include trades by members of these chambers of Congress.

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

Only include trades by members representing these states.

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

Only include these kinds of transactions.

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

Only include trades made by these owners (the member, their spouse, a child, or a joint account). This filter is applied to the results after they are collected, so scanning stops once a long run of pages contains no matching owner. A very rare owner type (for example 'Child') on a broad, unfiltered query can therefore be capped before every match is found — to get exhaustive results for a rare owner, narrow the query with a politician, company, or date filter.

## `dateRange` (type: `string`):

Quick window based on the transaction date. Choose 'All time' for no date limit. For an exact custom range, use the two date fields below instead.

## `tradedAfter` (type: `string`):

Only include trades on or after this date. Use the format YYYY-MM-DD (e.g. 2025-01-01). Leave empty to ignore.

## `tradedBefore` (type: `string`):

Only include trades on or before this date. Use the format YYYY-MM-DD (e.g. 2025-06-30). Leave empty to ignore.

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

Order in which trades are collected.

## `maxItems` (type: `integer`):

Maximum number of trades to collect. Set to 0 (or leave blank) to collect ALL matching trades — with no filters applied the full feed is 37,000+ rows, so a blank or 0 value can be a very large, slow, and costly run. Set a limit to keep run size and cost predictable.

## `startUrls` (type: `array`):

Optional. Paste one or more Capitol Trades filtered URLs (starting with https://www.capitoltrades.com/trades). When provided, the filters above are ignored and these URLs are scraped exactly as configured on the site.

## Actor input object example

```json
{
  "politicians": [],
  "issuers": [],
  "party": [],
  "chamber": [],
  "states": [],
  "transactionTypes": [],
  "owners": [],
  "sortBy": "published",
  "maxItems": 100,
  "startUrls": []
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of trades with key fields like politician, company, transaction type, size, and dates.

# 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 = {
    "politicians": [],
    "issuers": [],
    "party": [],
    "chamber": [],
    "states": [],
    "transactionTypes": [],
    "owners": [],
    "dateRange": "",
    "sortBy": "published",
    "maxItems": 100,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/capitoltrades-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 = {
    "politicians": [],
    "issuers": [],
    "party": [],
    "chamber": [],
    "states": [],
    "transactionTypes": [],
    "owners": [],
    "dateRange": "",
    "sortBy": "published",
    "maxItems": 100,
    "startUrls": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "politicians": [],
  "issuers": [],
  "party": [],
  "chamber": [],
  "states": [],
  "transactionTypes": [],
  "owners": [],
  "dateRange": "",
  "sortBy": "published",
  "maxItems": 100,
  "startUrls": []
}' |
apify call solidcode/capitoltrades-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/capitoltrades-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Capitol Trades Scraper",
        "description": "[💰 $0.90 / 1K] Track US congressional stock trades from Capitol Trades. Every politician disclosure: buy/sell, ticker, company, trade-size range, transaction & filing dates, reporting gap, owner. Filter by politician, party, chamber, state, or company.",
        "version": "1.0",
        "x-build-id": "tPdvlvKnfmScEoU4a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~capitoltrades-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-capitoltrades-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~capitoltrades-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-capitoltrades-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~capitoltrades-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-capitoltrades-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "politicians": {
                        "title": "Politicians",
                        "type": "array",
                        "description": "Filter to specific members of Congress. Enter names (e.g. 'Nancy Pelosi') or Capitol Trades profile URLs. Leave empty to include all politicians.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "issuers": {
                        "title": "Companies / Tickers",
                        "type": "array",
                        "description": "Filter to specific traded companies. Enter company names (e.g. 'Apple') or ticker symbols (e.g. 'NVDA', 'MSFT'). Leave empty to include all companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "party": {
                        "title": "Party",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include trades by members of these parties.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "democrat",
                                "republican",
                                "other"
                            ],
                            "enumTitles": [
                                "Democrat",
                                "Republican",
                                "Other / Independent"
                            ]
                        }
                    },
                    "chamber": {
                        "title": "Chamber",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include trades by members of these chambers of Congress.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "house",
                                "senate"
                            ],
                            "enumTitles": [
                                "House of Representatives",
                                "Senate"
                            ]
                        }
                    },
                    "states": {
                        "title": "States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include trades by members representing these states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY",
                                "DC"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming",
                                "District of Columbia"
                            ]
                        }
                    },
                    "transactionTypes": {
                        "title": "Transaction Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these kinds of transactions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "buy",
                                "sell",
                                "exchange",
                                "receive"
                            ],
                            "enumTitles": [
                                "Buy",
                                "Sell",
                                "Exchange",
                                "Receive"
                            ]
                        }
                    },
                    "owners": {
                        "title": "Owner",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include trades made by these owners (the member, their spouse, a child, or a joint account). This filter is applied to the results after they are collected, so scanning stops once a long run of pages contains no matching owner. A very rare owner type (for example 'Child') on a broad, unfiltered query can therefore be capped before every match is found — to get exhaustive results for a rare owner, narrow the query with a politician, company, or date filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "self",
                                "spouse",
                                "child",
                                "joint"
                            ],
                            "enumTitles": [
                                "Self",
                                "Spouse",
                                "Child",
                                "Joint"
                            ]
                        }
                    },
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "",
                            "7d",
                            "30d",
                            "90d",
                            "180d",
                            "365d"
                        ],
                        "type": "string",
                        "description": "Quick window based on the transaction date. Choose 'All time' for no date limit. For an exact custom range, use the two date fields below instead."
                    },
                    "tradedAfter": {
                        "title": "Traded On or After",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include trades on or after this date. Use the format YYYY-MM-DD (e.g. 2025-01-01). Leave empty to ignore."
                    },
                    "tradedBefore": {
                        "title": "Traded On or Before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include trades on or before this date. Use the format YYYY-MM-DD (e.g. 2025-06-30). Leave empty to ignore."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "published",
                            "traded",
                            "reportingGap"
                        ],
                        "type": "string",
                        "description": "Order in which trades are collected."
                    },
                    "maxItems": {
                        "title": "Maximum Trades",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of trades to collect. Set to 0 (or leave blank) to collect ALL matching trades — with no filters applied the full feed is 37,000+ rows, so a blank or 0 value can be a very large, slow, and costly run. Set a limit to keep run size and cost predictable."
                    },
                    "startUrls": {
                        "title": "Capitol Trades URLs (advanced)",
                        "type": "array",
                        "description": "Optional. Paste one or more Capitol Trades filtered URLs (starting with https://www.capitoltrades.com/trades). When provided, the filters above are ignored and these URLs are scraped exactly as configured on the site.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
