# DOJ FARA Filings Scraper (`automation-lab/doj-fara-filings-scraper`) Actor

Extract public DOJ FARA registrants, foreign principals, short-form registrants, political activity rows, and DOJ eFile source links.

- **URL**: https://apify.com/automation-lab/doj-fara-filings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## DOJ FARA Filings Scraper

Extract public Foreign Agents Registration Act (FARA) records from the DOJ eFile Browse Filings pages.

Use this actor to monitor active registrants, foreign principals, short-form registrants, political activity rows, political contribution tables, and DOJ source links in a clean Apify dataset.

### What does DOJ FARA Filings Scraper do?

DOJ FARA Filings Scraper collects rows from public DOJ FARA eFile Browse Filings reports.

It turns government HTML tables into structured JSON records.

It is designed for monitoring workflows where teams need repeatable exports instead of manual copy and paste.

The actor currently extracts first-page rows from multiple report categories and combines them into one normalized dataset.

Each row keeps a `rawColumns` object so you can audit the exact DOJ table values.

### Who is it for?

Compliance teams use it to watch foreign-agent registrations.

Policy intelligence teams use it to track registrants, principals, and political activities.

Investigative researchers use it to build repeatable FARA watchlists.

Risk teams use it to enrich entity due-diligence workflows.

Journalists and civic researchers use it to collect source-linked public records.

### Why use this FARA scraper?

✅ Public DOJ source pages

✅ Structured dataset output

✅ Multiple FARA report categories

✅ Detail links back to eFile

✅ Normalized top-level fields plus raw columns

✅ No login required

✅ No browser automation required for the MVP

### What data can you extract?

| Field | Description |
| --- | --- |
| `reportType` | Selected FARA report category |
| `reportTitle` | DOJ page title |
| `registrantName` | Registrant or registration name |
| `registrationNumber` | FARA registration number |
| `registrationDate` | Registration date when available |
| `foreignPrincipalName` | Foreign principal name |
| `countryOrLocation` | Country or location represented |
| `shortFormName` | Short form registrant name |
| `activityDate` | Political activity date |
| `method` | Activity method |
| `purpose` | Activity purpose |
| `address` | Address from DOJ table |
| `detailUrl` | DOJ eFile detail URL |
| `sourceUrl` | Report URL scraped |
| `rawColumns` | Original parsed table columns |
| `scrapedAt` | Extraction timestamp |

### Supported FARA report categories

The actor supports these DOJ Browse Filings report categories:

- Active registrants
- Active foreign principals
- Active short form registrants
- Terminated short form registrants
- Historical short form registrants
- Foreign principal political activities
- Active registrants political contributions
- Terminated foreign principals
- Historical foreign principals

### How much does it cost to scrape DOJ FARA filings?

This actor uses Apify pay-per-event pricing.

You pay a small run-start event and a per-row event for each saved FARA record.

Use a small `maxItems` value for quick tests.

Use 100+ rows for recurring compliance monitoring.

Current per-row pricing is approximately: Free $0.000049663, Starter/BRONZE $0.000043186, Scale/SILVER $0.000033685, Business/GOLD $0.000025911, Platinum $0.000017274, Diamond $0.000012092.

### How to scrape DOJ FARA filings

1. Open the actor on Apify.
2. Keep the prefilled report categories or choose your own.
3. Set `maxItems` to the number of rows you need.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Input configuration

#### `reportTypes`

Choose one or more FARA report categories.

Leaving the prefill selected is a good monitoring default.

#### `maxItems`

Set the maximum rows saved across all selected reports.

The default is 15 rows.

The maximum is 10,000 rows.

### Output example

```json
{
  "reportType": "active-registrants",
  "reportTitle": "Active Registrants",
  "registrantName": "Example Registrant LLC",
  "registrationNumber": "1234",
  "registrationDate": "01/01/2026",
  "detailUrl": "https://efile.fara.gov/ords/fara/f?p=...",
  "sourceUrl": "https://efile.fara.gov/ords/fara/f?p=1381:17:0",
  "rawColumns": {
    "Registrant": "Example Registrant LLC",
    "Registration #": "1234"
  },
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
````

### Tips for monitoring workflows

Run the actor daily or weekly for watchlist collection.

Store exported datasets in your compliance data lake.

Compare new runs against previous exports by registration number and report type.

Use `detailUrl` to open the DOJ record for source review.

Keep `rawColumns` in your warehouse for audit trails.

### Integrations

Connect this actor with Google Sheets for analyst review.

Send output to Slack when a scheduled run finds rows.

Load dataset items into BigQuery, Snowflake, or Postgres.

Use Apify webhooks to trigger downstream compliance checks.

Combine FARA records with entity-resolution tools in your due-diligence pipeline.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/doj-fara-filings-scraper').call({
  reportTypes: ['active-registrants', 'active-foreign-principals'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/doj-fara-filings-scraper').call(run_input={
    'reportTypes': ['active-registrants', 'political-activities'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~doj-fara-filings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"reportTypes":["active-registrants"],"maxItems":100}'
```

### Use with AI agents via MCP

DOJ FARA Filings Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client with this actor-specific tools URL. This exposes the DOJ FARA Filings Scraper tool directly.

Setup for Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/doj-fara-filings-scraper"
```

Setup for Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/doj-fara-filings-scraper"
    }
  }
}
```

Example prompts:

- "Use automation-lab/doj-fara-filings-scraper to run active FARA registrants and summarize new registration numbers."
- "Export active foreign principals from FARA and group them by country or location."
- "Monitor FARA political activity rows and flag methods mentioning meetings."

### Data quality notes

The actor reads public DOJ HTML tables.

Some DOJ report categories use different column names.

Top-level fields are normalized when possible.

The original values remain available in `rawColumns`.

### Limitations

This MVP does not download every linked filing document.

It does not require credentials.

It does not bypass access controls.

Oracle APEX pagination may change, so high-volume pagination can be added later if users need full historical dumps.

### Legality

This actor collects publicly accessible DOJ FARA pages.

Users are responsible for using the data lawfully.

Respect applicable laws, Apify terms, and DOJ website terms.

Do not use extracted data for prohibited profiling or harassment.

### FAQ and troubleshooting

**How fast is this FARA scraper?**

Most monitoring runs finish in under a minute because the actor uses HTTP requests instead of a browser.

**Does this replace the official DOJ FARA website?**

No. It structures public DOJ eFile tables for exports and automation while preserving source URLs for review.

**How much does a typical run cost?**

Small monitoring runs are usually a fraction of a cent plus the run-start event because no proxy or browser is required.

**Why did I get fewer rows than `maxItems`?**

Selected reports may expose only a limited first page of server-rendered rows.

Choose more report categories to collect more rows in one run.

#### Why is a field missing on some rows?

Different FARA report categories have different table columns.

Check `rawColumns` for the exact original DOJ fields.

#### Can I get the source page?

Yes. Each item includes `sourceUrl`, and many rows include `detailUrl`.

### Related scrapers

Explore related automation-lab actors:

- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/rss-feed-scraper

### Changelog

#### 0.1

Initial version for DOJ FARA public Browse Filings report extraction.

### Support

Open an Apify issue if a DOJ page changes or you need additional FARA report categories.

### Maintenance notes

The actor is intentionally HTTP-first for cost control.

It uses no residential proxy by default.

It keeps memory at 256 MB.

It preserves source URLs for every output item.

### Summary

DOJ FARA Filings Scraper gives compliance and research teams a repeatable way to extract structured public FARA rows from DOJ eFile pages.

# Actor input Schema

## `reportTypes` (type: `array`):

Public DOJ FARA Browse Filings reports to scrape. Leave the prefill as-is to monitor active registrants, principals, short forms, and political activity tables.

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

Maximum FARA rows to save across all selected reports. Use 100+ for monitoring exports; use 10-25 for quick smoke tests.

## Actor input object example

```json
{
  "reportTypes": [
    "active-registrants",
    "active-foreign-principals",
    "political-activities"
  ],
  "maxItems": 15
}
```

# Actor output Schema

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

No description

# 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 = {
    "reportTypes": [
        "active-registrants",
        "active-foreign-principals",
        "political-activities"
    ],
    "maxItems": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/doj-fara-filings-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 = {
    "reportTypes": [
        "active-registrants",
        "active-foreign-principals",
        "political-activities",
    ],
    "maxItems": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/doj-fara-filings-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 '{
  "reportTypes": [
    "active-registrants",
    "active-foreign-principals",
    "political-activities"
  ],
  "maxItems": 15
}' |
apify call automation-lab/doj-fara-filings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DOJ FARA Filings Scraper",
        "description": "Extract public DOJ FARA registrants, foreign principals, short-form registrants, political activity rows, and DOJ eFile source links.",
        "version": "0.1",
        "x-build-id": "CIPsZl8n3xhrA66w5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~doj-fara-filings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-doj-fara-filings-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/automation-lab~doj-fara-filings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-doj-fara-filings-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/automation-lab~doj-fara-filings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-doj-fara-filings-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",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "reportTypes": {
                        "title": "Report categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Public DOJ FARA Browse Filings reports to scrape. Leave the prefill as-is to monitor active registrants, principals, short forms, and political activity tables.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "active-registrants",
                                "active-foreign-principals",
                                "active-short-form-registrants",
                                "terminated-short-form-registrants",
                                "historical-short-form-registrants",
                                "political-activities",
                                "political-contributions",
                                "terminated-foreign-principals",
                                "historical-foreign-principals"
                            ],
                            "enumTitles": [
                                "Active registrants",
                                "Active foreign principals",
                                "Active short form registrants",
                                "Terminated short form registrants",
                                "Historical short form registrants",
                                "Foreign principal political activities",
                                "Registrant political contributions",
                                "Terminated foreign principals",
                                "Historical foreign principals"
                            ]
                        },
                        "default": [
                            "active-registrants",
                            "active-foreign-principals",
                            "political-activities"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum FARA rows to save across all selected reports. Use 100+ for monitoring exports; use 10-25 for quick smoke tests.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```