# FINRA BrokerCheck Scraper (`parseforge/finra-brokercheck-scraper`) Actor

Scrape FINRA BrokerCheck for individual brokers and firms. Search by name, CRD, firm, city, state, or exam. Get registration history, disclosures, and exam records. Export to CSV, JSON, Excel, or XML.

- **URL**: https://apify.com/parseforge/finra-brokercheck-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 81 total users, 3 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.45 / 1,000 result-items

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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### FINRA BrokerCheck Scraper

**Scrape FINRA BrokerCheck for individual brokers and firms, with exam filters and location data.** Every result includes registration history, disclosures, and exam records. No API key needed. Export to CSV, JSON, Excel, or XML.

FINRA BrokerCheck is the official public database of registered brokers and investment advisors in the US. Its web interface limits you to manual lookups and paginated results. This actor reads the public API directly, letting you search by name, firm, city, state, or exam, and returns each match as a flat row with all available fields.

| Who uses it | What they scrape FINRA BrokerCheck for |
|---|---|
| Compliance officers | Verify the registration status and disciplinary history of brokers they are considering hiring. |
| Financial advisors | Check their own BrokerCheck profile for accuracy and completeness. |
| Background check services | Aggregate broker data for due diligence reports on financial professionals. |
| Researchers | Analyze industry trends by collecting broker demographics, exam pass rates, and firm affiliations. |

### Full Demo

[![FINRA BrokerCheck Scraper Demo](https://img.youtube.com/vi/ljtvJp9TWbA/maxresdefault.jpg)](https://www.youtube.com/watch?v=ljtvJp9TWbA)

### What it does

This actor collects broker and firm records from FINRA BrokerCheck by name, CRD number, firm, location, or exam, and returns each one as a flat row with registration status, employment history, disclosures, and exam details.

- 🔍 **Search by name or CRD:** Enter a broker's name or CRD number to get their full record.
- 🏢 **Filter by firm:** Narrow results to brokers at a specific firm (e.g. Morgan Stanley) using firm name or CRD.
- 📍 **Location filters:** Restrict by city and state to find brokers in a specific area.
- 📋 **Exam filters:** Return only brokers who have passed specific exams (e.g. Series 7, Series 79) using single or multiple exam names.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with FINRA BrokerCheck data

**🔍 Verify broker credentials.**

A compliance officer searches a candidate's name and firm to confirm their FINRA registration and check for any disclosures before hiring.

**📊 Analyze industry exam trends.**

A researcher collects brokers who passed Series 79 in New York to study the distribution of investment banking professionals.

**🏢 Map firm affiliations.**

A background check service queries all brokers at a given firm CRD to build a directory of its registered representatives.

**📍 Find local advisors.**

An investor searches for brokers in their city and state to identify nearby financial professionals with clean records.

### Why choose this scraper

|  | What you get |
|---|---|
| **Full registration history** | Current and past employers, registration dates, and termination details. |
| **Disclosures** | Customer disputes, regulatory actions, criminal charges, and financial disclosures. |
| **Exam records** | All passed exams with dates and scores where available. |
| **Location data** | City, state, and ZIP of the broker's registered office. |

### How it compares

No other Store actor targets FINRA BrokerCheck the same way, so the honest comparison is with the alternatives teams actually weigh.

| | FINRA BrokerCheck Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When FINRA BrokerCheck changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the actor from a search query (name or CRD), optionally combined with firm, location, and exam filters. Filters run as each record is read so only matching brokers reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "query": "Smith",
  "maxItems": 10
}
```

A larger pull:

```json
{
  "query": "Smith",
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.05 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $5.00 |
| 1,000 results | $50.00 |
| 10,000 results | $500.00 |

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to FINRA BrokerCheck through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/finra-brokercheck-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your search query is spelled correctly. For individuals, try a partial name or CRD number. For firms, ensure the firm name is accurate. Also verify that your filters (city, state, exam) are not too restrictive.

**The exam filter returns no results even though I know the broker passed that exam.**

The exam filter matches against the exact exam name or series code. Try using the series code (e.g. '7' instead of 'Series 7') or check FINRA's official exam list for the correct name.

**My firm name filter is not working.**

The actor looks up the firm's CRD number automatically. If the firm name is ambiguous, provide the firm CRD directly in the firmCrd field. Enable 'Prefer Largest Firm' to pick the main operational entity.

**The run is taking too long.**

Narrow your search with more specific filters (city, state, exam) or reduce maxItems. The actor fetches all matching records from FINRA before applying filters, so a broad query with many results can be slow.

### FAQ

| Question | Answer |
|---|---|
| Do I need a FINRA API key? | No. This actor uses the public BrokerCheck API that FINRA makes available without authentication. |
| Can I search by CRD number? | Yes. Enter the CRD number in the query field for individual or firm search. |
| How do I filter by exam? | Use the examName or examNames fields. You can enter the full exam name or the series code (e.g. 'Series 7' or '7'). |
| Does the actor support ZIP code filtering? | No. FINRA's public API does not support ZIP code filtering. Use city and state instead. |
| What does 'Include Previous Registrations' do? | When enabled, the actor returns brokers who are no longer registered. Disable it to get only currently registered individuals. |
| Can I search for firms? | Yes. Set searchType to 'firm' and enter the firm name or CRD/SEC number. |
| How many results can I get per run? | You can set maxItems up to 1,000,000. The actor will paginate through results until it reaches that limit. |
| What data is included in the output? | Each record includes registration status, employment history, disclosures, exam records, and location details as available from FINRA. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by FINRA (Financial Industry Regulatory Authority). It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `searchType` (type: `string`):

Type of search to perform - Individual brokers/advisors or Firms

## `query` (type: `string`):

Search term for broker/advisor name or firm name. For individuals, you can search by name or CRD number. For firms, you can search by firm name or CRD/SEC number.

## `includePrevious` (type: `boolean`):

Include brokers/advisors who are no longer registered

## `firmName` (type: `string`):

Filter individuals by firm name (e.g. 'Morgan Stanley', 'Goldman Sachs'). The actor automatically looks up the firm's FINRA CRD number and applies the filter, because the public BrokerCheck API only accepts firm CRDs, not firm-name strings.

## `firmCrd` (type: `string`):

Advanced: filter individuals by the firm's exact FINRA CRD number (e.g. '149777' for Morgan Stanley). Skips the firm-name lookup. Leave blank to use Firm Name instead.

## `preferLargestFirm` (type: `boolean`):

When the firm name matches multiple FINRA registrations, pick the broker-dealer with the most registered branch offices (usually the main operational firm) instead of FINRA's default text-relevance top result. Ignored when firmCrd is provided.

## `city` (type: `string`):

Filter individuals by city of their registered office (e.g. 'New York', 'Chicago'). Automatically uppercased before querying. Works best when combined with state.

## `state` (type: `string`):

Filter individuals by US state code (2-letter, e.g. 'NY', 'CA'). Automatically uppercased.

## `zipCode` (type: `string`):

The public FINRA BrokerCheck API does not support ZIP-code filtering. This field is accepted for backwards compatibility but is ignored. Use city+state instead.

## `examName` (type: `string`):

Return ONLY individuals who have passed this exam. Enter the full exam name (e.g. 'Investment Banking Registered Representative Examination') OR the FINRA series code (e.g. 'Series 79' or just '79'). Matching is case-insensitive and ignores spacing/punctuation, and it matches both the exam name and its series code. FINRA's API has no server-side exam filter, so the actor fetches candidates from your search (query/firm/state) and keeps only the matching ones — always combine this with a search scope so the run stays fast. Leave blank to disable.

## `examNames` (type: `array`):

Return individuals who have passed ANY of these exams (OR logic). Each entry can be a full exam name or a series code (e.g. \['Series 79', 'Series 7']). Same matching rules as the single Exam Filter. Combined with the single Exam Filter (union) when both are set. Leave empty to disable.

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

How many brokers to collect per run.

## Actor input object example

```json
{
  "searchType": "individual",
  "query": "Smith",
  "includePrevious": true,
  "preferLargestFirm": true,
  "maxItems": 10
}
```

# 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 = {
    "query": "Smith",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/finra-brokercheck-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 = {
    "query": "Smith",
    "maxItems": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "query": "Smith",
  "maxItems": 10
}' |
apify call parseforge/finra-brokercheck-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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