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

\[💰 $2 / 1K] Search FINRA BrokerCheck for US securities brokers and firms. Get CRD numbers, registrations, license exams, employment history, and regulatory disclosures by name, CRD, or state.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## FINRA BrokerCheck Scraper

Pull public regulatory records for US securities brokers and brokerage firms straight from FINRA BrokerCheck — CRD numbers, license exams, full employment timelines with dates, state-by-state registrations, and every disclosure event (customer disputes, regulatory actions, criminal, financial, and judgment records). Search by name, look up a known CRD number, or filter by state, and pull both individual brokers and firms in one run. Built for compliance teams, financial recruiters, and due-diligence analysts who need verified broker histories without manually opening one BrokerCheck profile at a time.

### Why This Scraper?

- **CRD-anchored records** — every broker and firm is keyed to its Central Registration Depository number, the same unique ID regulators use, so results join cleanly to your own systems and never collide on similar names.
- **Full license-exam history** — Series 7, Series 63, Series 66, the SIE, and every principal and product exam a broker has passed, each with the date taken and its scope.
- **Complete employment timeline with dates** — current and previous registering firms, each with firm CRD, city, state, and registration start/end dates — not just the latest employer.
- **State-by-state registration coverage** — registration status across all 50 states plus DC and Puerto Rico, alongside self-regulatory-organization (SRO) registrations like FINRA and the exchanges.
- **Every regulatory disclosure event** — customer disputes, regulatory actions, criminal, financial, and judgment/lien records, each with event date, type, and resolution — the data that matters most for vetting.
- **Brokers and firms in one actor** — flip a single setting to pull individual financial professionals or brokerage and investment-advisory companies, with a `recordType` field on every row to split them downstream.
- **Active and formerly-registered records** — include barred, suspended, and no-longer-registered individuals by toggling one switch, so you catch the people who left the industry under a cloud.
- **Broker-dealer and investment-adviser scopes** — separate registration-scope fields for the BD and IA sides of every record, so you can tell a dual-registrant from a pure broker or pure adviser.

### Use Cases

**Compliance & Due Diligence**
- Vet a candidate or counterparty's full regulatory history before onboarding
- Confirm a broker holds the exams and state registrations required for a role
- Flag undisclosed customer disputes or regulatory actions during KYC reviews
- Build an audit trail of CRD-verified employment history for a hire

**Recruiting & Talent**
- Source licensed brokers by name, firm, or state for a specific desk
- Verify a recruit's claimed Series 7 / Series 66 licenses against the official record
- Track which firms a target candidate has registered with and for how long
- Filter to brokers currently at a named competitor to build a poaching list

**Investor Protection & Research**
- Screen an advisor before handing over assets — disclosures, sanctions, and bars
- Identify clusters of disclosure events tied to a single firm or branch
- Monitor formerly-registered brokers who left after regulatory trouble
- Compare registration scopes to spot advisers operating outside their license

**Journalism & Regulatory Research**
- Investigate a firm's roster of brokers and their collective disclosure record
- Build datasets of barred or suspended individuals for accountability reporting
- Map employment movement of high-disclosure brokers across firms over time
- Quantify disclosure rates by state, firm, or registration scope

**Data Enrichment & Lead Generation**
- Enrich a CRM of financial professionals with current employer and CRD numbers
- Append verified license and registration data to an existing contact list
- Power advisor-comparison and broker-lookup tools with structured records
- Feed BrokerCheck data into risk-scoring and onboarding dashboards

### Getting Started

#### Search Brokers by Name

The simplest run — one name, up to 100 brokers, full profiles:

```json
{
    "searchType": "individual",
    "searchQueries": ["Smith"],
    "maxResults": 100
}
````

#### Filter Brokers by State and Employer

Keep only brokers registered in California whose current firm is Edward Jones:

```json
{
    "searchType": "individual",
    "searchQueries": ["Smith"],
    "state": "CA",
    "employerName": "Edward Jones",
    "maxResults": 200
}
```

#### Look Up Records by CRD Number

Pull exact records when you already know the CRD — works for brokers and firms (set `searchType` to match):

```json
{
    "searchType": "firm",
    "crdNumbers": ["7556", "8174"],
    "includeDetails": true
}
```

#### Advanced — Include Inactive Brokers, Full Profiles

Search a firm name, include formerly-registered individuals, and fetch every profile in full:

```json
{
    "searchType": "individual",
    "searchQueries": ["Morgan Stanley"],
    "includeInactive": true,
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchType` | select | `Brokers (individuals)` | Whether to look up brokers (individual financial professionals) or firms (brokerage and advisory companies). Applies to both name searches and CRD lookups. |
| `searchQueries` | string\[] | `["Smith"]` | One or more names or keywords (a broker name like "John Smith" or a firm name like "Morgan Stanley"). Each query is searched separately; results are merged and de-duplicated by CRD number. |
| `crdNumbers` | string\[] | `[]` | Look up specific records directly by their CRD number. Uses the same `searchType` to decide whether these are broker or firm CRDs. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `state` | select | `All states` | Limit broker searches to professionals registered in one US state (all 50 states plus DC and Puerto Rico). Applies to broker name searches only. |
| `employerName` | string | `""` | Keep only brokers whose current employer name contains this text (case-insensitive). Leave blank to keep everyone. |
| `includeInactive` | boolean | `false` | Include records no longer active in the industry (barred, suspended, or out of scope). Off by default — only currently or recently active records are returned. |

#### Output Detail & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | Fetch each record's full profile: license exams, registrations, complete employment history, and disclosure events. Turn off for faster, lighter runs that return listing-level summary data only. |
| `maxResults` | integer | `100` | How many records to return across all queries and CRD lookups. Set to 0 to collect as many as possible. Results are capped to exactly this number. This actor returns up to 250,000 results per run; larger requests are collected up to that ceiling. |

### Output

Every row carries a `recordType` field — `individual` or `firm` — so you can split the two cleanly downstream. Detail arrays (exams, employment history, registrations, disclosures) appear only when `includeDetails` is on.

#### Broker (`recordType: "individual"`)

```json
{
    "recordType": "individual",
    "crdNumber": "1056376",
    "name": "JAMES MICHAEL SMITH",
    "firstName": "JAMES",
    "middleName": "MICHAEL",
    "lastName": "SMITH",
    "otherNames": [],
    "bcScope": "Active",
    "iaScope": "NotInScope",
    "hasDisclosures": true,
    "disclosureCount": 2,
    "registrationCount": 3,
    "stateRegistrationCount": 5,
    "industryStartDate": "1985-03-12",
    "currentEmployerName": "EDWARD JONES",
    "currentEmployerCrd": "250",
    "city": "ST LOUIS",
    "state": "MO",
    "employmentHistory": [
        {
            "firmName": "EDWARD JONES",
            "firmCrd": "250",
            "city": "ST LOUIS",
            "state": "MO",
            "startDate": "2009-06-01",
            "endDate": null,
            "current": true
        }
    ],
    "licenseExams": [
        { "examCategory": "Series 7", "examName": "General Securities Representative Examination", "examTakenDate": "1985-04-20", "scope": "product" },
        { "examCategory": "SIE", "examName": "Securities Industry Essentials Examination", "examTakenDate": "2018-10-01", "scope": "state" }
    ],
    "stateRegistrations": [
        { "state": "MO", "regScope": "BD", "status": "APPROVED", "regDate": "2009-06-15" }
    ],
    "registeredSros": [
        { "sro": "FINRA", "status": "APPROVED" }
    ],
    "disclosures": [
        { "eventDate": "2014-08-11", "disclosureType": "Customer Dispute", "disclosureResolution": "Settled", "brokerCategory": "Customer Dispute - Settled", "adviserCategory": null, "detail": {} }
    ],
    "brokercheckUrl": "https://brokercheck.finra.org/individual/summary/1056376"
}
```

##### Core Identity

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"individual"` |
| `crdNumber` | string | CRD number — FINRA's unique broker ID |
| `name` | string | Full legal name |
| `firstName` / `middleName` / `lastName` | string | Name components |
| `otherNames` | string\[] | Alternate or former names |
| `bcScope` | string | Broker-dealer registration scope (Active, InActive, NotInScope) |
| `iaScope` | string | Investment-adviser registration scope |
| `currentEmployerName` | string | Current registering firm's legal name |
| `currentEmployerCrd` | string | Current firm's CRD number |
| `city` / `state` | string | Current branch office location |
| `brokercheckUrl` | string | Direct BrokerCheck profile link |

##### Employment & Tenure

| Field | Type | Description |
|-------|------|-------------|
| `industryStartDate` | string | Date the broker entered the industry |
| `registrationCount` | number | Count of approved FINRA registrations |
| `employmentHistory` | object\[] | Current and previous firms, each with `firmName`, `firmCrd`, `city`, `state`, `startDate`, `endDate`, and a `current` flag |

##### Exams & Registrations

| Field | Type | Description |
|-------|------|-------------|
| `licenseExams` | object\[] | Exams passed: `examCategory` (e.g. Series 7), `examName`, `examTakenDate`, `scope` |
| `stateRegistrations` | object\[] | Per-state registration: `state`, `regScope`, `status`, `regDate` |
| `stateRegistrationCount` | number | Number of state registrations |
| `registeredSros` | object\[] | Self-regulatory-organization registrations: `sro`, `status` |

##### Disclosures

| Field | Type | Description |
|-------|------|-------------|
| `hasDisclosures` | boolean | Whether any disclosure events exist |
| `disclosureCount` | number | Number of disclosure events |
| `disclosures` | object\[] | Each event: `eventDate`, `disclosureType` (Customer Dispute, Regulatory, Criminal, Financial, Judgment/Lien), `disclosureResolution`, `brokerCategory`, `adviserCategory`, `detail` |

#### Firm (`recordType: "firm"`)

```json
{
    "recordType": "firm",
    "crdNumber": "7556",
    "name": "MORGAN STANLEY",
    "otherNames": ["MORGAN STANLEY DW INC."],
    "bcScope": "Active",
    "iaScope": "Active",
    "hasDisclosures": true,
    "disclosureCount": 2,
    "firmSecNumber": "8-15869",
    "branchCount": 1421,
    "mainOfficeStreet": "1585 BROADWAY",
    "city": "NEW YORK",
    "state": "NY",
    "zip": "10036",
    "country": "United States",
    "disclosures": [
        { "eventDate": "2016-12-09", "disclosureType": "Regulatory", "disclosureResolution": "Final", "brokerCategory": "Regulatory - Final", "adviserCategory": null, "detail": {} }
    ],
    "brokercheckUrl": "https://brokercheck.finra.org/firm/summary/7556"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"firm"` |
| `crdNumber` | string | Firm CRD number |
| `name` | string | Firm legal name |
| `otherNames` | string\[] | Alternate or former firm names |
| `bcScope` | string | Broker-dealer registration scope |
| `iaScope` | string | Investment-adviser registration scope |
| `firmSecNumber` | string | SEC file number (BD or IA). Appears only when **Include full profiles** is on. |
| `branchCount` | number | Number of branch offices |
| `mainOfficeStreet` | string | Headquarters street address |
| `city` / `state` / `zip` / `country` | string | Headquarters location |
| `hasDisclosures` | boolean | Whether any firm disclosure events exist |
| `disclosureCount` | number | Number of firm disclosure events |
| `disclosures` | object\[] | Each event: `eventDate`, `disclosureType`, `disclosureResolution`, `brokerCategory`, `adviserCategory`, `detail` |
| `brokercheckUrl` | string | Direct BrokerCheck profile link |

### Tips for Best Results

- **Use exact names to narrow large result sets.** A surname like "Smith" returns thousands of brokers; searching "John Q Smith" or pairing the name with a `state` filter gets you a focused, usable set faster.
- **Turn off `includeDetails` for bulk lists.** When you only need names, CRD numbers, and current employers, switching details off returns lighter, cheaper rows. Turn it back on for exams, full employment history, registrations, and disclosures.
- **The `state` filter matches the current registered branch only.** It keeps brokers whose current employment is in that state — not their full historical state-registration list. To see every state a broker is registered in, leave the filter off and read the `stateRegistrations` array instead.
- **Toggle `includeInactive` to catch brokers who left under a cloud.** By default only active records return; flip it on to surface barred, suspended, and formerly-registered individuals — exactly the people a due-diligence review needs to find.
- **Look up by CRD when you know it.** A CRD lookup returns the exact record with no name-matching ambiguity, and works even for inactive individuals and firms that a name search would skip.
- **Set `searchType` to match your CRD list.** Broker and firm CRDs live in separate namespaces — a firm CRD searched as an individual will not resolve, so set `searchType` to `firm` for firm CRDs.
- **Batch many names in one run.** Pass several names or keywords at once; results are merged and de-duplicated by CRD, so overlapping searches never produce the same broker twice.

### Pricing

**From $2.00 per 1,000 results** — flat pay-per-result pricing that undercuts manual profile-by-profile lookups and bundles full exam, employment, registration, and disclosure data at no extra charge. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.24 | $0.225 | $0.215 | $0.20 |
| 1,000 | $2.40 | $2.25 | $2.15 | $2.00 |
| 10,000 | $24.00 | $22.50 | $21.50 | $20.00 |
| 100,000 | $240.00 | $225.00 | $215.00 | $200.00 |

A "result" is any broker or firm row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

FINRA BrokerCheck data is public regulatory information that FINRA publishes for investor protection. This actor is designed for legitimate compliance, due diligence, recruiting, research, and investor-protection use. Users are responsible for complying with applicable laws and FINRA's terms of use, including fair-use and anti-spam rules. Do not use extracted data for harassment, discrimination, or any unlawful purpose, and handle records about individuals responsibly. </content> </invoke>

# Actor input Schema

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

Whether to look up brokers (individual financial professionals) or firms (brokerage and investment-advisory companies). This applies to both name searches and CRD-number lookups below.

## `searchQueries` (type: `array`):

One or more names or keywords to search (e.g. a broker's name like "John Smith", or a firm name like "Morgan Stanley"). Each query is searched separately and results are merged and de-duplicated by CRD number. FINRA returns up to about 9,000 records per individual search term — split very broad searches (like a common surname) into more specific terms to collect more. Very broad single-term searches beyond ~9,000 results may not be fully exhaustive.

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

Look up specific records directly by their CRD number (the unique ID FINRA assigns to every broker and firm). Use the same 'Search for' setting above to tell us whether these are broker or firm CRDs.

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

Limit broker searches to professionals registered in a specific US state. Only applies to broker (individual) name searches. Searches stop scanning after a long stretch of pages with no match — use a more specific name if you expect rare results.

## `employerName` (type: `string`):

Keep only brokers whose current employer name contains this text (case-insensitive). For example, enter "Edward Jones" to keep only professionals currently at Edward Jones. Leave blank to keep everyone. Searches stop scanning after a long stretch of pages with no match — use a more specific name if you expect rare results.

## `includeInactive` (type: `boolean`):

Include records that are no longer active in the industry (marked InActive or out of scope). By default only currently registered or recently active records are returned.

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

Fetch each record's full profile: license exams, registrations, complete employment history, and regulatory disclosure events (complaints, regulatory actions, judgments). Turn this off for faster, cheaper runs that return only listing-level summary data.

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

How many records to collect across all queries and CRD lookups. Default 100 — increase for bigger runs, or set to 0 to collect as many as possible. This actor returns up to 250,000 results per run; if you request more, it collects up to that ceiling. Results are capped to exactly the number you ask for. Note that FINRA returns up to about 9,000 records per individual search term — split very broad searches into more specific terms to collect more, and very broad single-term searches beyond ~9,000 may not be fully exhaustive.

## Actor input object example

```json
{
  "searchType": "individual",
  "searchQueries": [
    "Smith"
  ],
  "crdNumbers": [],
  "state": "",
  "includeInactive": false,
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped brokers and firms with the most useful columns at a glance.

## `registrations` (type: `string`):

Table focused on registration scopes and regulatory disclosure counts.

# 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 = {
    "searchType": "individual",
    "searchQueries": [
        "Smith"
    ],
    "crdNumbers": [],
    "state": "",
    "employerName": "",
    "includeInactive": false,
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchType": "individual",
    "searchQueries": ["Smith"],
    "crdNumbers": [],
    "state": "",
    "employerName": "",
    "includeInactive": False,
    "includeDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchType": "individual",
  "searchQueries": [
    "Smith"
  ],
  "crdNumbers": [],
  "state": "",
  "employerName": "",
  "includeInactive": false,
  "includeDetails": true,
  "maxResults": 100
}' |
apify call solidcode/finra-brokercheck-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINRA BrokerCheck Scraper",
        "description": "[💰 $2 / 1K] Search FINRA BrokerCheck for US securities brokers and firms. Get CRD numbers, registrations, license exams, employment history, and regulatory disclosures by name, CRD, or state.",
        "version": "1.0",
        "x-build-id": "7UlbHzAdUhVlZLAGs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~finra-brokercheck-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~finra-brokercheck-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~finra-brokercheck-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchType": {
                        "title": "Search for",
                        "enum": [
                            "individual",
                            "firm"
                        ],
                        "type": "string",
                        "description": "Whether to look up brokers (individual financial professionals) or firms (brokerage and investment-advisory companies). This applies to both name searches and CRD-number lookups below.",
                        "default": "individual"
                    },
                    "searchQueries": {
                        "title": "Names or keywords",
                        "type": "array",
                        "description": "One or more names or keywords to search (e.g. a broker's name like \"John Smith\", or a firm name like \"Morgan Stanley\"). Each query is searched separately and results are merged and de-duplicated by CRD number. FINRA returns up to about 9,000 records per individual search term — split very broad searches (like a common surname) into more specific terms to collect more. Very broad single-term searches beyond ~9,000 results may not be fully exhaustive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "crdNumbers": {
                        "title": "CRD numbers (optional)",
                        "type": "array",
                        "description": "Look up specific records directly by their CRD number (the unique ID FINRA assigns to every broker and firm). Use the same 'Search for' setting above to tell us whether these are broker or firm CRDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "PR"
                        ],
                        "type": "string",
                        "description": "Limit broker searches to professionals registered in a specific US state. Only applies to broker (individual) name searches. Searches stop scanning after a long stretch of pages with no match — use a more specific name if you expect rare results.",
                        "default": ""
                    },
                    "employerName": {
                        "title": "Current employer contains",
                        "type": "string",
                        "description": "Keep only brokers whose current employer name contains this text (case-insensitive). For example, enter \"Edward Jones\" to keep only professionals currently at Edward Jones. Leave blank to keep everyone. Searches stop scanning after a long stretch of pages with no match — use a more specific name if you expect rare results."
                    },
                    "includeInactive": {
                        "title": "Include inactive records",
                        "type": "boolean",
                        "description": "Include records that are no longer active in the industry (marked InActive or out of scope). By default only currently registered or recently active records are returned.",
                        "default": false
                    },
                    "includeDetails": {
                        "title": "Include full profiles",
                        "type": "boolean",
                        "description": "Fetch each record's full profile: license exams, registrations, complete employment history, and regulatory disclosure events (complaints, regulatory actions, judgments). Turn this off for faster, cheaper runs that return only listing-level summary data.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many records to collect across all queries and CRD lookups. Default 100 — increase for bigger runs, or set to 0 to collect as many as possible. This actor returns up to 250,000 results per run; if you request more, it collects up to that ceiling. Results are capped to exactly the number you ask for. Note that FINRA returns up to about 9,000 records per individual search term — split very broad searches into more specific terms to collect more, and very broad single-term searches beyond ~9,000 may not be fully exhaustive.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
