# BrokerCheck Scraper - Financial Advisors, Brokers & Firms (`scrapesage/brokercheck-scraper`) Actor

Scrape FINRA BrokerCheck & SEC IAPD: brokers, investment advisers and firms by name, CRD or firm roster. Full reports — employment history, Series exams/licenses, registered states, disclosures, firm AUM/address/phone. Monitoring + leads. No login, no API key, no browser.

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

## Pricing

from $10.00 / 1,000 adviser / broker scrapeds

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/docs.md):

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

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

## BrokerCheck Scraper — Financial Advisors, Brokers & Firms (CRDs, Licenses, Disclosures & Leads)

Extract **complete broker, investment adviser and firm data** straight from the authoritative public registries — **FINRA BrokerCheck** and the **SEC's Investment Adviser Public Disclosure (IAPD)**. Search by name, by CRD number, or pull **every adviser and broker registered at a firm** in one run. Each record ships the full report: **current and previous firms, Series exams & licenses, registered states, SRO categories, disclosures (regulatory actions & customer disputes), years of experience** — and for firms, **type, size, office address, phone, owners and Form ADV brochures**.

No login, no cookies, no browser, no API key — fast, reliable JSON extraction from the official source the whole industry trusts.

### Why this BrokerCheck scraper?

Other "financial advisor" scrapers pull a **subset** from Google Maps or a single membership directory (CFP, NAPFA, FPA). This actor reads the **complete, authoritative U.S. universe** — ~630,000 brokers and ~440,000 investment-adviser reps across ~15,000+ firms — directly from FINRA and the SEC, and ships the **richest dataset in the category**.

| Data | Typical scrapers | This actor |
|---|---|---|
| Authoritative source (FINRA + SEC) | ❌ Maps / one directory | ✅ official registries |
| CRD number (the industry key) | ❌ | ✅ |
| Broker **and** investment-adviser status | partial | ✅ both |
| Series exams & licenses (7, 63, 65, 66…) | ❌ | ✅ |
| Registered states + SRO categories | ❌ | ✅ |
| Current **and** previous firms (work history) | ❌ | ✅ |
| **Disclosures** (regulatory actions, disputes) | ❌ | ✅ |
| Firm type, size, owners, Form ADV brochures | ❌ | ✅ |
| Firm office address + phone | partial | ✅ |
| Full adviser/broker **roster of any firm** | ❌ | ✅ by firm CRD |
| Disclosure-change **monitoring** | ❌ | ✅ |
| Firm contact leads (emails, socials from its site) | ❌ | ✅ opt-in |
| Lead score (0–100) | ❌ | ✅ |

### Use cases

- **Recruiting & competitive intelligence** — pull a competitor's entire adviser/broker roster by firm CRD, complete with licenses, experience and location. The fastest way to build a recruiting list of in-market reps.
- **Fintech & wealthtech sales / lead generation** — target RIA firms and broker-dealers by location, type and size; score them and enrich firm websites for contact emails and socials.
- **Compliance, RegTech & due diligence** — screen brokers, advisers and firms for disclosures (regulatory actions, customer disputes), and monitor for **new** disclosure events over time.
- **Market & M&A research** — map firm size, ownership, registrations and adviser movement (employment history) across the industry.
- **Verification & onboarding** — confirm a CRD's registrations, licenses and clean/flagged status before doing business.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **BrokerCheck Scraper**, choose **Individuals** or **Firms**, and enter search terms, CRD numbers, or a firm CRD to pull its full roster.
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchType": "individuals",
    "firmCrdNumbers": ["6413"],
    "maxResultsPerTerm": 100,
    "includeDetails": true,
    "stateFilter": "NJ",
    "roleFilter": "advisers",
    "activeOnly": true
}
````

- **searchType** — `individuals` (brokers & advisers) or `firms` (broker-dealers & RIAs).
- **searchTerms** — person names (`John Smith`) or firm names (`Edward Jones`). Each is paginated up to the limit.
- **firmCrdNumbers** — firm CRD numbers (e.g. `6413` = LPL Financial) → list **every** broker & adviser registered there. The recruiting wedge (Individuals mode).
- **crdNumbers** — fetch full reports for specific CRD numbers directly (individuals or firms per the mode).
- **source** *(default `auto`)* — `auto` (BrokerCheck for individuals; BrokerCheck + SEC IAPD merged for firms), `brokercheck` (brokers), or `sec_iapd` (investment advisers).
- **includeDetails** *(default true)* — fetch each record's full report (history, exams, registrations, disclosures; firms add address/phone/owners/brochures). Off = fast lightweight records.
- **roleFilter** *(default any)* — `brokers`, `advisers`, or `any` (Individuals).
- **stateFilter** — keep one US state (`NY` or `New York`); individuals match branch or registered states, firms match office state.
- **activeOnly / withDisclosuresOnly** — registration-status and disclosure filters.
- **enrichFirmContacts** *(default false)* — crawl a firm's own website (home + contact/about) for emails, phones and socials.
- **monitorMode** *(default false)* — emit only records that are new, or whose disclosure count changed since the last run.
- **maxResultsPerTerm** — cap per search term / per firm roster (paginates automatically).

### Output

One record per individual (`type: "individual"`) or firm (`type: "firm"`). An individual record:

```json
{
    "type": "individual",
    "crd": "1113790",
    "fullName": "Joseph Thomas Smith",
    "isBroker": true,
    "isInvestmentAdviser": true,
    "role": "Broker & Investment Adviser",
    "brokerStatus": "Active",
    "adviserStatus": "Active",
    "industryStartDate": "1984-01-14",
    "yearsExperience": 42,
    "currentFirmName": "LPL Financial Llc",
    "currentFirmCrd": "6413",
    "branchCity": "Madison",
    "branchState": "NJ",
    "branchZip": "07940",
    "latitude": 40.76,
    "longitude": -74.42,
    "currentFirms": [{ "firmCrd": "6413", "firmName": "LPL Financial Llc", "registrationBeginDate": "2020-05-07", "branchCity": "Madison", "branchState": "NJ" }],
    "previousFirms": [{ "firmCrd": "7556", "firmName": "Prudential", "branchState": "NJ" }],
    "licenses": ["Series 65", "Series 63", "Series 7"],
    "exams": [{ "category": "Series 65", "name": "Uniform Investment Adviser Law Examination", "scope": "IA", "takenDate": "2002-08-02" }],
    "registeredStateNames": ["California", "Colorado", "Florida", "Maryland", "New Jersey"],
    "registeredStatesCount": 10,
    "registeredSROs": [{ "sro": "FINRA", "status": "APPROVED", "categories": ["General Securities Representative", "Securities Trader"] }],
    "hasDisclosures": false,
    "disclosureCount": 0,
    "disclosures": [],
    "reportUrl": "https://brokercheck.finra.org/individual/summary/1113790",
    "source": "brokercheck",
    "leadScore": 86,
    "scrapedAt": "2026-06-15T12:00:00.000Z"
}
```

A firm record (`type: "firm"`) carries `crd`, `firmName`, `firmType`, `firmSize`, `isBrokerDealer`, `isInvestmentAdviser`, `regulator`, `district`, `formedState`, `street`/`city`/`state`/`postalCode`, `phone`, `secNumber`, `hasDisclosures`/`disclosureCount`/`disclosures`, `directOwners`, `brochures` (Form ADV), `reportUrl`, plus `website`/`contactEmails`/`contactPhones`/`socialLinks` when contact enrichment is on.

#### What to expect (field coverage)

This is official registry data, so the core fields are essentially always present; some are populated only when they exist for that record.

| Entity | Always present | Usually present | Present when it exists |
|---|---|---|---|
| **Individual** | CRD, name, broker/adviser status, role, report URL | current firm + branch location, licenses, registered states, years of experience | previous firms, disclosures (only flagged reps), SRO categories |
| **Firm** | CRD, name, type, broker-dealer/adviser status, report URL | office address, phone, regulator, formed state | direct owners, Form ADV brochures, disclosures, website/emails (with enrichment) |

A blank field means the registry doesn't hold that value for the record — never that scraping failed. Nothing is dropped, so you always get the richest dataset available.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly with `monitorMode` to catch new advisers at a firm, newly registered firms, or **new disclosures** as they post.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, compliance review) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/brokercheck-scraper').call({
    searchType: 'individuals',
    firmCrdNumbers: ['6413'],
    maxResultsPerTerm: 200,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} brokers & advisers`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new adviser/firm leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get alerted when a monitored firm adds a rep or posts a new disclosure.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list every active investment adviser at LPL Financial in New Jersey with their licenses" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **financial & B2B intelligence stack** — pair adviser/broker data with company, contract and filing intel:

- **[SEC EDGAR Scraper](https://apify.com/scrapesage/sec-edgar-scraper)** — filings, XBRL financials, and company profiles.
- **[USAspending Scraper](https://apify.com/scrapesage/usaspending-scraper)** — federal awards, contractors and leads.
- **[SAM.gov Scraper](https://apify.com/scrapesage/sam-gov-scraper)** — federal contract opportunities and contacts.
- **[Companies House Scraper](https://apify.com/scrapesage/companies-house-scraper)** — UK companies, directors and PSCs.
- **[Healthgrades Scraper](https://apify.com/scrapesage/healthgrades-scraper)** — doctors, reviews and provider leads.
- **[Y Combinator Scraper](https://apify.com/scrapesage/ycombinator-scraper)** — startups, founders and jobs.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers and leads.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.

### Tips

- **Pull a firm's whole roster**: put the firm's CRD in `firmCrdNumbers` (find it by searching the firm name first, or from the firm's BrokerCheck URL). Then filter by `stateFilter` and `roleFilter` to slice the list.
- **Fastest runs**: turn `includeDetails` off for lightweight records (name, CRD, current firm, location, status) when you don't need the full report — then re-run with details on for the CRDs you keep.
- **Compliance monitoring**: schedule with `monitorMode` on; you'll only get records that are new or whose disclosure count changed — perfect for watchlists.
- **Investment advisers vs brokers**: `roleFilter: "advisers"` (or `source: "sec_iapd"`) for RIAs; `roleFilter: "brokers"` for registered reps. Many professionals are both.
- **Firm emails**: turn on `enrichFirmContacts` — FINRA/SEC never publish emails, so the actor crawls the firm's own website for them.

### FAQ

**Where does the data come from?** FINRA BrokerCheck (`brokercheck.finra.org`) and the SEC's Investment Adviser Public Disclosure (`adviserinfo.sec.gov`) — the official, public U.S. registries for brokers and investment advisers. No API key or login is needed.

**What is a CRD number?** The Central Registration Depository number — FINRA's unique ID for each individual and firm. It's the reliable key for direct lookups and firm rosters.

**Can I get every adviser at a specific firm?** Yes — put the firm's CRD in `firmCrdNumbers` (Individuals mode) and the actor pages through the firm's entire roster, up to your limit.

**Do records include emails or phone numbers?** Firms include their official business phone and address. FINRA/SEC don't publish emails — turn on `enrichFirmContacts` to crawl the firm's own website for contact emails, phones and socials.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor for new disclosures?** Create a [Schedule](https://docs.apify.com/platform/schedules) and turn on `monitorMode`. The actor remembers each CRD's disclosure count and emits a record only when something is new or has changed.

**Is scraping this data legal?** This actor collects publicly available regulatory data only. You are responsible for using the data in compliance with applicable laws (e.g. FCRA, GDPR/CCPA for personal data) and FINRA/SEC terms. It is not a consumer report and must not be used for FCRA-regulated decisions.

**A field is empty — why?** The registry simply doesn't hold that value for that record (e.g. a rep with no previous firms or no disclosures). Fields are blank only when the data doesn't exist — never because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Scrape individuals (brokers & investment advisers) or firms (broker-dealers & RIA firms). Search terms, CRD numbers and the role/state filters apply to whichever you pick.

## `searchTerms` (type: `array`):

Keywords to search FINRA/SEC for. For individuals use person names (`John Smith`); for firms use firm names (`Morgan Stanley`, `Edward Jones`). One per row. Each is paginated up to the limit below.

## `firmCrdNumbers` (type: `array`):

List every broker & adviser registered at these firms (use the firm's CRD number, e.g. `6413` for LPL Financial). The recruiting/competitive-intel wedge. Used when scraping Individuals.

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

Fetch full reports for specific CRD numbers directly. Treated as individuals or firms depending on the mode above. One CRD per row.

## `source` (type: `string`):

Auto uses FINRA BrokerCheck for individuals and both BrokerCheck + SEC IAPD for firms (merged). Force one registry if you only want brokers (BrokerCheck) or investment advisers (SEC IAPD).

## `maxResultsPerTerm` (type: `integer`):

Cap the number of records returned per search term or per firm roster. Results paginate automatically until this limit or the result set is exhausted.

## `includeDetails` (type: `boolean`):

Open each record's full report: employment history, Series exams & licenses, registered states, SRO categories, disclosures, and (firms) address, phone, type, size, owners and Form ADV brochures. Off = fast lightweight records from search only.

## `roleFilter` (type: `string`):

Keep only brokers, only investment advisers, or any. Applies to the Individuals mode.

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

Keep only records in this US state — `NY` or `New York`. Individuals match by branch office or any registered state; firms match by office state. Leave blank for all states.

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

Keep only currently-active brokers/advisers (or active firms). Off includes former/inactive registrations too.

## `withDisclosuresOnly` (type: `boolean`):

Keep only records that have reportable disclosures (regulatory actions, customer disputes, etc.) — for compliance, due-diligence and screening.

## `enrichFirmContacts` (type: `boolean`):

Opt-in lead enrichment for firms that publish a website: crawl the firm's own site (home + a contact/about page) for contact emails, phone numbers and social links. FINRA/SEC do not expose emails — this is the only public source.

## `monitorMode` (type: `boolean`):

Remember CRDs seen in previous runs and emit ONLY records that are new — or whose disclosure count changed (a new regulatory event). Ideal for compliance monitoring. Pairs with Apify Schedules to track changes over time.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' CRDs (and their disclosure counts) for monitoring mode. Use a different name per tracked target to keep histories separate.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Lower it if you hit rate limits on very large runs.

## `proxyConfiguration` (type: `object`):

Proxy settings. FINRA BrokerCheck and SEC IAPD work fine through the default Apify datacenter proxy.

## Actor input object example

```json
{
  "searchType": "individuals",
  "firmCrdNumbers": [
    "6413"
  ],
  "source": "auto",
  "maxResultsPerTerm": 50,
  "includeDetails": true,
  "roleFilter": "any",
  "stateFilter": "",
  "activeOnly": false,
  "withDisclosuresOnly": false,
  "enrichFirmContacts": false,
  "monitorMode": false,
  "monitorStoreName": "brokercheck-monitor",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Individual rows carry full registration, license, employment and disclosure data; firm rows carry profile, address, phone, disclosures and lead fields.

# 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 = {
    "firmCrdNumbers": [
        "6413"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = { "firmCrdNumbers": ["6413"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BrokerCheck Scraper - Financial Advisors, Brokers & Firms",
        "description": "Scrape FINRA BrokerCheck & SEC IAPD: brokers, investment advisers and firms by name, CRD or firm roster. Full reports — employment history, Series exams/licenses, registered states, disclosures, firm AUM/address/phone. Monitoring + leads. No login, no API key, no browser.",
        "version": "0.1",
        "x-build-id": "sXXh8ATRkReGlM7ez"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~brokercheck-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~brokercheck-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-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/scrapesage~brokercheck-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-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",
                "required": [
                    "searchType"
                ],
                "properties": {
                    "searchType": {
                        "title": "What to scrape",
                        "enum": [
                            "individuals",
                            "firms"
                        ],
                        "type": "string",
                        "description": "Scrape individuals (brokers & investment advisers) or firms (broker-dealers & RIA firms). Search terms, CRD numbers and the role/state filters apply to whichever you pick.",
                        "default": "individuals"
                    },
                    "searchTerms": {
                        "title": "Search terms (names or firm names)",
                        "type": "array",
                        "description": "Keywords to search FINRA/SEC for. For individuals use person names (`John Smith`); for firms use firm names (`Morgan Stanley`, `Edward Jones`). One per row. Each is paginated up to the limit below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "firmCrdNumbers": {
                        "title": "Firm CRD numbers — pull the full adviser/broker roster",
                        "type": "array",
                        "description": "List every broker & adviser registered at these firms (use the firm's CRD number, e.g. `6413` for LPL Financial). The recruiting/competitive-intel wedge. Used when scraping Individuals.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "crdNumbers": {
                        "title": "CRD numbers — direct lookups",
                        "type": "array",
                        "description": "Fetch full reports for specific CRD numbers directly. Treated as individuals or firms depending on the mode above. One CRD per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "source": {
                        "title": "Data source",
                        "enum": [
                            "auto",
                            "brokercheck",
                            "sec_iapd"
                        ],
                        "type": "string",
                        "description": "Auto uses FINRA BrokerCheck for individuals and both BrokerCheck + SEC IAPD for firms (merged). Force one registry if you only want brokers (BrokerCheck) or investment advisers (SEC IAPD).",
                        "default": "auto"
                    },
                    "maxResultsPerTerm": {
                        "title": "Max results per term / roster",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap the number of records returned per search term or per firm roster. Results paginate automatically until this limit or the result set is exhausted.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Fetch full reports (recommended)",
                        "type": "boolean",
                        "description": "Open each record's full report: employment history, Series exams & licenses, registered states, SRO categories, disclosures, and (firms) address, phone, type, size, owners and Form ADV brochures. Off = fast lightweight records from search only.",
                        "default": true
                    },
                    "roleFilter": {
                        "title": "Role filter (individuals)",
                        "enum": [
                            "any",
                            "brokers",
                            "advisers"
                        ],
                        "type": "string",
                        "description": "Keep only brokers, only investment advisers, or any. Applies to the Individuals mode.",
                        "default": "any"
                    },
                    "stateFilter": {
                        "title": "State filter",
                        "type": "string",
                        "description": "Keep only records in this US state — `NY` or `New York`. Individuals match by branch office or any registered state; firms match by office state. Leave blank for all states.",
                        "default": ""
                    },
                    "activeOnly": {
                        "title": "Active registrations only",
                        "type": "boolean",
                        "description": "Keep only currently-active brokers/advisers (or active firms). Off includes former/inactive registrations too.",
                        "default": false
                    },
                    "withDisclosuresOnly": {
                        "title": "With disclosures only",
                        "type": "boolean",
                        "description": "Keep only records that have reportable disclosures (regulatory actions, customer disputes, etc.) — for compliance, due-diligence and screening.",
                        "default": false
                    },
                    "enrichFirmContacts": {
                        "title": "Enrich firm contacts (crawl website for emails, phone, socials)",
                        "type": "boolean",
                        "description": "Opt-in lead enrichment for firms that publish a website: crawl the firm's own site (home + a contact/about page) for contact emails, phone numbers and social links. FINRA/SEC do not expose emails — this is the only public source.",
                        "default": false
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new or changed records",
                        "type": "boolean",
                        "description": "Remember CRDs seen in previous runs and emit ONLY records that are new — or whose disclosure count changed (a new regulatory event). Ideal for compliance monitoring. Pairs with Apify Schedules to track changes over time.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the 'already seen' CRDs (and their disclosure counts) for monitoring mode. Use a different name per tracked target to keep histories separate.",
                        "default": "brokercheck-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower it if you hit rate limits on very large runs.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. FINRA BrokerCheck and SEC IAPD work fine through the default Apify datacenter proxy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```