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

Extract broker and financial-advisor records from FINRA BrokerCheck by name, firm, or location. Get CRD numbers, registration status, disclosure flags, and firm details as clean structured data — for lead generation, compliance, recruiting, and market research. No API key needed.

- **URL**: https://apify.com/rdx1s/finra-brokercheck-scraper.md
- **Developed by:** [RDX 1S](https://apify.com/rdx1s) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## FINRA BrokerCheck Scraper — Brokers, Advisors & Firms

Turn the public **FINRA BrokerCheck** database into clean, structured data —
every US broker, financial advisor, broker-dealer and RIA. Search by name, firm,
state, exam/license, or CRD number and export **30+ fields** per record to CSV,
JSON, or Excel.

✅ **No API key. No rate limits. No login.** BrokerCheck is public record
published by FINRA — this Actor just makes it usable, with built-in retry/backoff
so large pulls finish cleanly.

### What you can do with it

- **Build a targeted list** — e.g. *every advisor at LPL Financial in Texas*,
  with firm, office address, tenure, and disclosures.
- **Verify a roster of CRDs** — paste a list of CRD numbers and get back current
  status, firm, registered states and disclosure history (compliance & KYC).
- **Recruit by license** — find everyone holding a **Series 65 / Series 7** (or
  any exam) at a given firm or state.
- **Pull firm / RIA data** — search broker-dealers and RIAs (Form ADV): status,
  SEC #, branch count, office address, disclosures.
- **Feed an AI agent** — call it as a tool over **MCP**, or wire it into
  **n8n, Make and Zapier** to monitor advisors automatically.

### Example input

```json
{
  "searchType": "individual",
  "firm": "LPL FINANCIAL",
  "state": "TX",
  "examNames": ["Series 65"],
  "fetchDetails": true,
  "maxResults": 200
}
````

### Sample output (one record, trimmed)

```json
{
  "crd": "1113790",
  "firstName": "JOHN",
  "lastName": "SMITH",
  "statusText": "Active",
  "currentFirm": "LPL FINANCIAL LLC",
  "currentFirmSince": "5/7/2020",
  "branchStreet": "14 MAIN STREET, SUITE 305B",
  "branchCity": "MADISON",
  "branchState": "NJ",
  "latitude": "40.758346",
  "longitude": "-74.420134",
  "registeredStateCodes": ["CA", "CO", "DE", "FL", "NJ", "NY"],
  "disclosureCount": 0,
  "brokerCheckUrl": "https://brokercheck.finra.org/individual/summary/1113790"
}
```

### What you get (30+ fields)

- **Identity:** CRD, name, broker & advisor status (human-readable), industry
  start date, registration count.
- **Firm & office:** current firm + CRD, tenure, and the exact **branch street
  address with latitude/longitude** (with `fetchDetails`).
- **Licensing:** exams held (Series 7/65/…), and **registered states** with
  scope, status and date.
- **Risk:** disclosure count and full disclosure history; previous employment
  history.
- **Trust:** a one-click link to the official BrokerCheck profile.
- **Firms:** name, BD/RIA status, SEC #, branch count, office address, disclosures.

### Works with AI agents & automation

Every Apify Actor is exposed as a tool over the **Model Context Protocol
(MCP)**, so AI agents can call this scraper directly. It also runs from
**n8n, Make, Zapier**, the Apify API, or on a schedule.

### Good to know

- Source: public FINRA BrokerCheck — no PII beyond what FINRA publishes.
- `fetchDetails` enriches each person with disclosures, exams, registered states,
  tenure, branch address and geo (one extra request per record).
- CRD look-ups always resolve a known person regardless of other filters.

### Input reference

| Field               | Type    | Description                                                                 |
|---------------------|---------|-----------------------------------------------------------------------------|
| `query`             | string  | Name, firm, location, or CRD number to search.                              |
| `searchType`        | string  | `individual` (brokers & advisors) or `firm` (broker-dealers & RIAs).        |
| `queries`           | array   | Run several searches in one go; merged and de-duplicated by CRD.            |
| `crdNumbers`        | array   | Look up specific people directly by CRD number (verify a known list).       |
| `state`             | string  | Two-letter state code (e.g. `NY`). Keeps records registered in that state.  |
| `firm`              | string  | Individuals only: keep only people at this firm, e.g. `LPL FINANCIAL`.      |
| `examNames`         | array   | Individuals only: keep only holders of these exams, e.g. `Series 65`.       |
| `maxResults`        | integer | Max number of records to collect (default 100).                            |
| `fetchDetails`      | boolean | Enrich each person with disclosures, exams, states, tenure, branch & geo.   |
| `activeOnly`        | boolean | Keep only currently active records.                                        |
| `hasDisclosureOnly` | boolean | Keep only records with disclosure events.                                  |
| `includeRaw`        | boolean | Include the full raw FINRA source object (default off).                     |

### Run locally

```bash
pip install -r requirements.txt
apify run
```

# Actor input Schema

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

Name, firm, location, or a CRD number to search on FINRA BrokerCheck.

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

Search individuals (brokers & advisors) or firms (broker-dealers & RIAs).

## `queries` (type: `array`):

Run several searches in one go. Results are merged and de-duplicated by CRD.

## `crdNumbers` (type: `array`):

Individuals only: look up specific people directly by CRD number (ideal for verifying a known list).

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

Two-letter state code (e.g. NY, CA, TX). Keeps people/firms registered in that state (filtered on FINRA's side). Note: a person's current office may be in a neighbouring state.

## `firm` (type: `string`):

Individuals only: keep only people at this firm, e.g. 'LPL FINANCIAL'. Filtered on FINRA's side.

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

Individuals only: keep only people who hold one of these exams, e.g. 'Series 65', 'Series 7'. Turns on full details automatically.

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

Maximum number of records to collect.

## `fetchDetails` (type: `boolean`):

Individuals only: enrich each record with disclosures, exams, registered states, tenure, and full employment history.

## `activeOnly` (type: `boolean`):

Keep only currently active brokers/advisors (or active firms). Filtered on FINRA's side for individuals.

## `hasDisclosureOnly` (type: `boolean`):

Keep only records that have disclosure events.

## `includeRaw` (type: `boolean`):

Individuals only: add the full raw FINRA source object to each record.

## Actor input object example

```json
{
  "query": "smith",
  "searchType": "individual",
  "queries": [],
  "crdNumbers": [],
  "examNames": [],
  "maxResults": 100,
  "fetchDetails": false,
  "activeOnly": false,
  "hasDisclosureOnly": false,
  "includeRaw": false
}
```

# Actor output Schema

## `results` (type: `string`):

Collected FINRA BrokerCheck records.

# 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"
};

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

# Run the Actor and wait for it to finish
run = client.actor("rdx1s/finra-brokercheck-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 '{
  "query": "smith"
}' |
apify call rdx1s/finra-brokercheck-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINRA BrokerCheck Scraper",
        "description": "Extract broker and financial-advisor records from FINRA BrokerCheck by name, firm, or location. Get CRD numbers, registration status, disclosure flags, and firm details as clean structured data — for lead generation, compliance, recruiting, and market research. No API key needed.",
        "version": "1.0",
        "x-build-id": "I7zl4GB7gUs206klQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rdx1s~finra-brokercheck-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rdx1s-finra-brokercheck-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/rdx1s~finra-brokercheck-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rdx1s-finra-brokercheck-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/rdx1s~finra-brokercheck-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rdx1s-finra-brokercheck-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Name, firm, location, or a CRD number to search on FINRA BrokerCheck."
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "individual",
                            "firm"
                        ],
                        "type": "string",
                        "description": "Search individuals (brokers & advisors) or firms (broker-dealers & RIAs).",
                        "default": "individual"
                    },
                    "queries": {
                        "title": "Batch queries",
                        "type": "array",
                        "description": "Run several searches in one go. Results are merged and de-duplicated by CRD.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "crdNumbers": {
                        "title": "CRD numbers",
                        "type": "array",
                        "description": "Individuals only: look up specific people directly by CRD number (ideal for verifying a known list).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "State filter",
                        "type": "string",
                        "description": "Two-letter state code (e.g. NY, CA, TX). Keeps people/firms registered in that state (filtered on FINRA's side). Note: a person's current office may be in a neighbouring state."
                    },
                    "firm": {
                        "title": "Firm filter (individual search)",
                        "type": "string",
                        "description": "Individuals only: keep only people at this firm, e.g. 'LPL FINANCIAL'. Filtered on FINRA's side."
                    },
                    "examNames": {
                        "title": "Exam / license filter",
                        "type": "array",
                        "description": "Individuals only: keep only people who hold one of these exams, e.g. 'Series 65', 'Series 7'. Turns on full details automatically.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to collect.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Fetch full profile details",
                        "type": "boolean",
                        "description": "Individuals only: enrich each record with disclosures, exams, registered states, tenure, and full employment history.",
                        "default": false
                    },
                    "activeOnly": {
                        "title": "Active only",
                        "type": "boolean",
                        "description": "Keep only currently active brokers/advisors (or active firms). Filtered on FINRA's side for individuals.",
                        "default": false
                    },
                    "hasDisclosureOnly": {
                        "title": "With disclosures only",
                        "type": "boolean",
                        "description": "Keep only records that have disclosure events.",
                        "default": false
                    },
                    "includeRaw": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Individuals only: add the full raw FINRA source object to each record.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```