# Lobbying & FEC Filing Monitor — New Registrations, No Login (`flamboyant_liner/lobbying-activity-monitor`) Actor

Watch clients, registrants, issue codes or FEC committees and get only NEW Senate lobbying registrations, quarterly activity reports and FEC filings since the last run, with income, issues, lobbyists and receipts. Daily schedule. No login. MCP-ready. $20 per 1,000 alerts.

- **URL**: https://apify.com/flamboyant\_liner/lobbying-activity-monitor.md
- **Developed by:** [Khrystyna Skotte](https://apify.com/flamboyant_liner) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 alerts

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

## Lobbying Activity Monitor — new registrations, quarterly reports and FEC filings

Schedule this actor and get only the **new** federal lobbying filings for the organisations, lobbying firms or issues you watch, plus new FEC filings for watched political committees. It remembers what it has already reported, so a scheduled run emits only what changed. No login, no API key required.

Sources:

- **Senate Lobbying Disclosure Act (LDA) database** — every LD-1 registration (a new lobbyist/client relationship) and LD-2 quarterly activity report (income or expenses, issues lobbied, lobbyist names, agencies contacted), plus amendments and terminations.
- **FEC (Federal Election Commission) filings** — new reports (F3, F3X, F1, F24, ...) received for the committee IDs you watch, with total receipts, disbursements and cash on hand.

### Use cases

- **Competitive intelligence** — know the day a competitor hires a new lobbying firm, or how much they spent last quarter on which issues.
- **Policy and government-affairs teams** — track who is lobbying on your issue codes (e.g. TEC, HCR, TAX) and what they describe.
- **Journalists and researchers** — watch a list of companies, trade groups or firms and get a feed of their filings with links to the source document.
- **Campaign finance** — get an alert when a watched PAC or campaign committee files a new report.

### Input

| Field | Default | Meaning |
|---|---|---|
| `clientNames` | `["Amazon","OpenAI"]` | Organisations that hire lobbyists. Case-insensitive whole-word match on the client name as filed (`Amazon` matches `Amazon Web Services`, not `Amazonas Holdings`). |
| `registrantNames` | `[]` | Lobbying firms or in-house registrants, e.g. `Akin Gump`. |
| `issueCodes` | `[]` | Senate general issue codes, e.g. `TEC`, `HCR`, `TAX`, `DEF`, `ENG`, `FIN`, `TRD`, `CPI`, `ENV`, `IMM`. Full list: https://lda.gov/api/v1/constants/filing/lobbyingactivityissues/. Up to 200 of the newest filings are scanned per code per run. |
| `fecCommittees` | `[]` | FEC committee IDs, e.g. `C00401224`. Look them up at https://www.fec.gov/data/committees/. |
| `lookbackDays` | `120` | Only filings posted within this window are considered. |
| `maxNewPerWatch` | `5` | Cap per watched name, code or committee per run. Filings beyond the cap stay unseen and come out on the next run. |
| `maxItems` | `10` | Overall cap per run. |
| `firstRunMode` | `emitAll` | `emitAll` emits every current match on the first run; `baseline` records them silently so only later changes are reported. |
| `webhookUrl` | – | POST a JSON summary with the new filings (first 50) after each run. |
| `monitorId` | `default` | Name of the watchlist; each ID keeps its own seen-state. |
| `lobbyingApiKey` | – | Optional Senate LDA key (free at https://lda.gov/api/register/). Anonymous access is limited to about 15 requests per minute. |
| `fecApiKey` | – | Optional api.data.gov key. Without it the FEC branch uses `DEMO_KEY` (30 requests per hour), which is enough for a few committees per run. |

### Output

One record per new filing:

```json
{
  "source": "senate-lda",
  "filingId": "2be0a434-2b24-4ab6-a9cd-a2eee9315eb8",
  "filingType": "Q2",
  "filingTypeName": "2nd Quarter - Report",
  "filingYear": 2026,
  "period": "2nd Quarter (Apr 1 - Jun 30)",
  "postedDate": "2026-07-20T17:24:41-04:00",
  "registrant": "DLA PIPER LLP (US)",
  "client": "OPENAI OPCO, LLC",
  "clientDescription": "AI research and deployment company",
  "incomeUsd": 50000,
  "expensesUsd": null,
  "issues": [{ "code": "CPI", "name": "Computer Industry" }],
  "activityDescriptions": "Issues related to artificial intelligence policy ...",
  "lobbyists": ["JANE DOE", "JOHN ROE"],
  "filingUrl": "https://lda.gov/filings/public/filing/2be0a434-.../print/",
  "matchedWatch": "client:OpenAI",
  "changeType": "new_activity_report",
  "firstSeenAt": "2026-09-29T00:09:14.333Z",
  "monitorId": "default"
}
```

`changeType` is `new_registration` (LD-1 registration or registration amendment), `new_activity_report` (quarterly report, amendment or termination) or `new_fec_filing`. FEC rows carry `committeeId`, `committeeName`, `formType`, `reportType`, `coverageStart`, `coverageEnd`, `totalReceiptsUsd`, `totalDisbursementsUsd` and `cashOnHandUsd` instead of the lobbying fields. `incomeUsd` is what a firm was paid by the client; `expensesUsd` is what an in-house registrant spent.

### Quarterly cadence

Lobbying reports are filed quarterly and posted in the three weeks after each quarter ends (around January, April, July and October 20). Registrations, amendments and terminations arrive year-round. A weekly or daily schedule catches everything; expect most activity-report alerts in those four windows, and use a `lookbackDays` of at least 120 on the first run so the sample is not empty in a quiet month.

### Scheduling and baseline

1. Run once with `firstRunMode: "baseline"` to record the current filings without emitting them, or leave `emitAll` to receive the current set as a first batch.
2. Schedule the actor (daily or weekly). Each run emits only filings it has not reported before under the same `monitorId`.
3. Use several `monitorId` values for separate watchlists.

State lives in a key-value store named `lobby-monitor-<hash>` under key `STATE`; delete it to reset. The store keeps up to 50,000 seen filing IDs.

### Webhook

With `webhookUrl` set, each run POSTs:

```json
{ "monitorId": "default", "runAt": "...", "since": "2026-06-01", "new_registration": 1, "new_activity_report": 9, "new_fec_filing": 0, "emitted": 10, "filings": [ ...first 50 records... ] }
```

Point it at Slack, Zapier, Make or your own endpoint.

### Pricing

$0.005 per run plus $0.02 per alert emitted. A weekly schedule watching ten clients typically costs well under a dollar a month.

# Actor input Schema

## `clientNames` (type: `array`):

Organisations that hire lobbyists, e.g. "Amazon", "OpenAI", "Pfizer". Case-insensitive substring match on the client name as filed with the Senate ("Amazon" also matches "Amazon Web Services"). Any new registration or activity report naming one of them is emitted.

## `registrantNames` (type: `array`):

Lobbying firms or in-house registrants, e.g. "Akin Gump", "Brownstein". Substring match on the registrant name. Empty = none.

## `issueCodes` (type: `array`):

Senate general issue codes, e.g. TEC (Telecommunications), HCR (Health Issues), TAX (Taxation), DEF (Defense), ENG (Energy/Nuclear), FIN (Financial Institutions), TRD (Trade), CPI (Computer Industry), ENV (Environment), IMM (Immigration). Full list: https://lda.gov/api/v1/constants/filing/lobbyingactivityissues/. The newest filings are scanned and those tagged with the code are emitted (up to 200 filings scanned per code per run). Empty = none.

## `fecCommittees` (type: `array`):

FEC committee IDs, e.g. C00401224 (ActBlue), C00694323. New FEC filings (F3, F3X, F1, F24 ...) received for these committees are emitted. Find IDs at https://www.fec.gov/data/committees/. Empty = none.

## `lookbackDays` (type: `integer`):

Only consider filings posted within this many days. Lobbying reports are quarterly (posted around Jan 20, Apr 20, Jul 20, Oct 20), so keep at least 120 days for the first run to get a sample; the seen-state prevents duplicates on later runs.

## `maxNewPerWatch` (type: `integer`):

Stop after emitting this many new filings for each watched client, registrant, issue code or committee. Filings beyond the cap stay unseen and are emitted on the next run.

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

Overall cap on filings emitted in one run, across all watches.

## `firstRunMode` (type: `string`):

What to do when the monitor has no saved state yet. emitAll: treat every current match as new and emit it (good for a one-off pull or a first test). baseline: silently record every current match as seen and emit nothing, so the next scheduled run reports only what is new since.

## `webhookUrl` (type: `string`):

Optional. After each run a JSON summary {monitorId, runAt, new\_registration, new\_activity\_report, new\_fec\_filing, filings\[first 50]} is POSTed here (Slack/Zapier/Make/your API).

## `monitorId` (type: `string`):

Name of this watchlist. Each monitor ID keeps its own seen-state in a key-value store named lobby-monitor-<hash>, so you can run several profiles (e.g. "big-tech", "pharma-clients") side by side.

## `lobbyingApiKey` (type: `string`):

Optional. Anonymous access is limited to ~15 requests/minute; a free key from https://lda.gov/api/register/ lifts that. Sent as an Authorization: Token header.

## `fecApiKey` (type: `string`):

Optional. Only used when fecCommittees is set. Falls back to DEMO\_KEY (30 requests/hour). Get a free key at https://api.data.gov/signup/.

## Actor input object example

```json
{
  "clientNames": [
    "Amazon",
    "OpenAI"
  ],
  "registrantNames": [],
  "issueCodes": [],
  "fecCommittees": [],
  "lookbackDays": 120,
  "maxNewPerWatch": 5,
  "maxItems": 10,
  "firstRunMode": "emitAll",
  "webhookUrl": "",
  "monitorId": "default"
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of new lobbying registrations, activity reports and FEC filings found in this run (JSON).

# 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 = {
    "clientNames": [
        "Amazon",
        "OpenAI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flamboyant_liner/lobbying-activity-monitor").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 = { "clientNames": [
        "Amazon",
        "OpenAI",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("flamboyant_liner/lobbying-activity-monitor").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 '{
  "clientNames": [
    "Amazon",
    "OpenAI"
  ]
}' |
apify call flamboyant_liner/lobbying-activity-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flamboyant_liner/lobbying-activity-monitor"
        }
    }
}
```

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/4e7UQXMX5iWCPQ2d3/builds/pFsMJFR0ejainr7C2/openapi.json