# FARA Foreign Agents Registry Scraper — DOJ Lobbying Data (`compute-edge/fara-foreign-agents-scraper`) Actor

Extract active foreign agent registrants from the Department of Justice FARA database. Filter by state, registration date, and agent name. Output includes registration details, addresses, and contact information for B2B lead generation, regulatory research, and lobbying intelligence.

- **URL**: https://apify.com/compute-edge/fara-foreign-agents-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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

## FARA Foreign Agents Registry Scraper

**Extract active foreign agent registrants from the U.S. Department of Justice FARA database** — the official registry of individuals and entities representing foreign principals in the United States.

### About FARA

The **Foreign Agents Registration Act (FARA)** requires individuals and organizations representing foreign governments, political parties, or other foreign principals to register with the U.S. Department of Justice. The FARA registry is a critical public resource for:

- **Regulatory compliance research** — Verify whether a firm is registered as a foreign agent
- **Lobbying intelligence** — Identify which firms represent which foreign interests
- **Risk assessment** — Monitor foreign representation in your sector
- **B2B lead generation** — Identify consulting firms specializing in government relations
- **Investigative journalism** — Track foreign influence activities
- **Academic research** — Analyze lobbying trends and international influence patterns

### Features

This scraper extracts **all active FARA registrants** from the DOJ's official JSON API. Each record includes:

| Field | Description |
|-------|-------------|
| **Registration Number** | Unique DOJ registration ID |
| **Agent Name** | Company, individual, or entity name |
| **Address** | Street address (primary office) |
| **City** | City of registration |
| **State** | US state (2-letter code) |
| **ZIP Code** | Postal code |
| **Registration Date** | Date registered (ISO YYYY-MM-DD format) |
| **Country** | Foreign country represented (if available) |
| **FARA Profile URL** | Direct link to DOJ FARA registry profile |

#### Filtering Options

- **State Filter** — Narrow results to registrants in a specific state (e.g., "CA", "NY", "DC")
- **Name Filter** — Search for agents by name (case-insensitive partial match)
- **Registered After** — Return only registrants registered on or after a specific date (YYYY-MM-DD)
- **Max Results** — Limit the number of records returned (default: 5,000; 0 = unlimited)

### How to scrape FARA foreign agent data

#### Step 1: Choose your filters

Open the actor configuration screen and decide which registrants you want:

- Leave all fields blank for **all active registrants** (default behavior)
- Set **State Filter** to "DC" to get Washington D.C.-based agents
- Set **Name Filter** to "Consulting" to find consulting firms
- Set **Registered After** to "2026-01-01" to get recent registrations

#### Step 2: Run the actor

Click **"Start"** or **"Run"**. The actor will:
1. Fetch the DOJ FARA active registrants API
2. Apply your filters
3. Extract structured data into the dataset

Typical runtime: **30-60 seconds** for the full registry (~5,000+ registrants).

#### Step 3: Download your data

Results are available in multiple formats:
- **Table view** — Browse in the Apify UI
- **JSON download** — Programmatic access
- **CSV export** — Open in Excel/Google Sheets
- **API endpoint** — Integrate into your workflow

### Example: Scraping DC-based foreign agents

**Input configuration:**

```json
{
  "stateFilter": "DC",
  "nameFilter": "",
  "registeredAfter": "",
  "maxResults": 0
}
````

**Output (sample record):**

```json
{
  "registrationNumber": 7739,
  "name": "RP&B Consulting",
  "address": "1000 Vermont Avenue NW, Suite 400",
  "city": "Washington",
  "state": "DC",
  "zip": "20005",
  "registrationDate": "2026-06-16",
  "country": "Various",
  "faraProfileUrl": "https://efile.fara.gov/ords/fara/f?p=212:200"
}
```

### Pricing

**$0.003 per record** — Cost-effective access to FARA data. A typical full-registry scrape (5,000+ registrants) costs ~$15. This is a fraction of manual research time and significantly cheaper than purchasing compiled FARA datasets from third-party vendors.

**Example pricing scenarios:**

- Scrape all active registrants (~5,000 records): **~$15**
- Filter DC-based agents (~1,500 records): **~$4.50**
- Filter recent registrations (last 30 days, ~50 records): **~$0.15**

### Data Format & Integration

#### JSON Output

Each record is valid JSON and includes all fields above. Perfect for:

- Database imports
- API integrations
- Data analysis in Python/R
- Building compliance dashboards

#### CSV Export

Results can be exported as CSV for spreadsheet analysis:

```
registrationNumber,name,address,city,state,zip,registrationDate,country,faraProfileUrl
7739,RP&B Consulting,1000 Vermont Avenue NW Suite 400,Washington,DC,20005,2026-06-16,Various,https://efile.fara.gov/...
```

#### Webhook Integration

Set up webhooks to automatically send results to your pipeline when the actor completes.

### Other scrapers

Explore related Apify actors from seatsignal for comprehensive U.S. government data:

- **[Senate Lobbying Disclosure Scraper](https://console.apify.com)** — LDA filings, lobbyist details, client associations
- **[SEC EDGAR Scraper](https://console.apify.com)** — Corporate filings, executive compensation, acquisition history
- **[House Clerk Visitor Logs Scraper](https://console.apify.com)** — Congress visitor records, meeting history
- **[GSA Contract Database Scraper](https://console.apify.com)** — Federal contract awards and spending

### FAQ

**Q: How often is the FARA registry updated?**\
A: FARA is updated in real time as registrants file. This actor scrapes the live API, so you'll always get current data.

**Q: Can I scrape historical FARA data (registrations from years past)?**\
A: This actor returns only *active* registrants. For historical data, you may need to contact the DOJ's FARA office directly or use their advanced search tools at [efile.fara.gov](https://efile.fara.gov).

**Q: What's the difference between FARA and the Senate Lobbying Disclosure Act (LDA)?**\
A: FARA tracks foreign agents (representing foreign governments/entities). LDA tracks domestic lobbying (representing clients inside the US). A firm may file both if they represent both foreign and domestic clients.

**Q: Can I use this data for commercial purposes?**\
A: Yes. FARA data is public information released by the DOJ. This scraper accesses only publicly available data. Check FARA's terms and consult legal counsel for your specific use case.

**Q: What happens if registration details change mid-year?**\
A: This scraper returns the current registration snapshot from the live API. Historical changes are maintained by the DOJ — contact them for amendment history.

**Q: Can I filter by foreign country represented?**\
A: The current version returns country info when available, but doesn't filter by it. Contact support if you need country-based filtering.

### Legal Notice

This actor scrapes publicly available data from the U.S. Department of Justice FARA registry. The data is in the public domain and available for research, journalism, and compliance purposes. By using this actor, you agree to respect the terms of use of the DOJ website and use the data responsibly.

**Do not** use this data for:

- Harassment or targeting of individuals
- Unauthorized commercial resale without attribution
- Violation of any applicable laws or regulations

For questions or issues, contact <support@seatsignal.com>.

***

**Built by seatsignal** — Bringing transparency to government data.

# Actor input Schema

## `stateFilter` (type: `string`):

Filter by US state (2-letter code, case-insensitive). Examples: 'CA', 'NY', 'DC'. Leave blank for all states.

## `nameFilter` (type: `string`):

Filter by agent name (case-insensitive partial match). Examples: 'Consulting', 'Group'. Leave blank for all names.

## `registeredAfter` (type: `string`):

Only include agents registered after this date (YYYY-MM-DD format). Example: '2026-01-01'. Leave blank for all dates.

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

Maximum number of registrant records to return. Set to 0 for unlimited.

## Actor input object example

```json
{
  "stateFilter": "",
  "nameFilter": "",
  "registeredAfter": "",
  "maxResults": 5000
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/fara-foreign-agents-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/fara-foreign-agents-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 '{}' |
apify call compute-edge/fara-foreign-agents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FARA Foreign Agents Registry Scraper — DOJ Lobbying Data",
        "description": "Extract active foreign agent registrants from the Department of Justice FARA database. Filter by state, registration date, and agent name. Output includes registration details, addresses, and contact information for B2B lead generation, regulatory research, and lobbying intelligence.",
        "version": "0.1",
        "x-build-id": "b8YRwHpX0cteH9IQG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fara-foreign-agents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fara-foreign-agents-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/compute-edge~fara-foreign-agents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fara-foreign-agents-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/compute-edge~fara-foreign-agents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fara-foreign-agents-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": {
                    "stateFilter": {
                        "title": "State Filter",
                        "type": "string",
                        "description": "Filter by US state (2-letter code, case-insensitive). Examples: 'CA', 'NY', 'DC'. Leave blank for all states.",
                        "default": ""
                    },
                    "nameFilter": {
                        "title": "Agent Name Filter",
                        "type": "string",
                        "description": "Filter by agent name (case-insensitive partial match). Examples: 'Consulting', 'Group'. Leave blank for all names.",
                        "default": ""
                    },
                    "registeredAfter": {
                        "title": "Registered After",
                        "type": "string",
                        "description": "Only include agents registered after this date (YYYY-MM-DD format). Example: '2026-01-01'. Leave blank for all dates.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of registrant records to return. Set to 0 for unlimited.",
                        "default": 5000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
