FINRA BrokerCheck Scraper — Full Database Export & Broker Lookup

Scrape registered broker and investment adviser records from FINRA BrokerCheck via FINRA's public JSON API — or download the entire BrokerCheck database (650,000+ professionals) in one run. Returns CRD numbers, employment history, license exams, state registrations, regulatory disclosures, and firm affiliations for every registered financial professional and 3,500+ firms.

FINRA publishes this data record-by-record but offers no bulk export and no official API contract. Commercial advisor-database vendors resell it at $5,000–50,000/year. This actor gives you the same registry, straight from the source, priced per record.

---

Download the Entire BrokerCheck Database

The most popular way to use this actor: one crawl_all run exports the complete individual registry as CSV, JSON, or Excel.

{
    "mode": "crawl_all",
    "fetchDetails": true,
    "includeDisclosures": true,
    "maxItems": 1000000
}

FINRA's search API caps any single query at 9,000 results, so a blank "get everything" search can't work. crawl_all shards the registry by state and name-prefix automatically and de-duplicates by CRD — each broker is fetched and billed exactly once, even when registered in many states.

What a full export costs ($0.10 per run start + $0.0015 per listing record / $0.003 per full-detail record):

Pull	Records	Approx. cost	Approx. runtime
One state (e.g. "states": ["WY"]), listing tier	~2–5K	$3–8	minutes
One large state (CA/NY/TX), full detail	~50–90K	$150–270	hours
Entire registry, listing tier (fetchDetails: false)	~650K	~$975	hours
Entire registry, full detail + disclosures	~650K	~$1,950	hours

Listing records carry identity, current employer + location, and scope; full-detail records add exams, complete employment history, state registrations, and disclosure texts at the premium per-record rate. Either way this is a 3–25× cheaper way to own the dataset than commercial advisor-data subscriptions.

Tips for full-registry runs:

• The default 36-hour run timeout comfortably covers a full-registry crawl.
• Memory: 1024 MB recommended (512 MB minimum) — the crawler tracks every CRD seen for de-duplication.
• If a run stops early (timeout, abort), don't restart it — resume it. The crawl state lives in a persisted request queue: either Resurrect the run in the Apify console, or start a new run passing the resumeCursor value from the stopped run's Output. Both continue exactly where it stopped — already-fetched records are not re-fetched and not re-billed.
• Container migrations resume automatically for the same reason.

Keep it fresh with delta runs (crawl_delta)

A full export decays: brokers change firms, register, deregister, and pick up disclosures continuously — roughly 300–500 registry changes per day. crawl_delta keeps your copy current without re-buying the registry, and it's fully self-managing:

Schedule this input daily (or weekly/monthly) and you're done:

{
    "mode": "crawl_delta",
    "includeInactive": true,
    "maxItems": 1000000
}

• The actor keeps a compact coverage snapshot in a key-value store on your Apify account. Every run compares what it sweeps against that snapshot, outputs only new/changed records, and folds everything it saw back in. No dataset IDs to track, no inputs to change — day-over-day diffs, automatically.
• Start however you like. With no snapshot yet, whatever the run sweeps is billed as new once and becomes covered ground. One big first run (cheapest bootstrap — resume it if interrupted), a single state, or a capped test run all work; coverage just accumulates across runs, whatever the inputs.

Every output record carries a delta_status field:

delta_status	Meaning	Typical signal
new	CRD entered the registry since your last run	newly registered rep
changed	firm, branch location, registration scope, registration count, or disclosure flag changed	firm move, breakaway, deregistration, new disclosure

Apply the delta to your copy (upsert by crd_number) and your dataset matches the live registry every morning. A broker who deregisters shows up as changed — their registration scope flips to InActive — which is why the preset keeps includeInactive: true.

What a delta run costs. Two line items, both shown in the run log:

• Sweep fee — one record-event per 50 already-covered records scanned (checking covered ground for changes is the work you're paying for): ≈ $20 for a full-registry sweep at steady state, ~$0.10–0.30 for a single state. Records billed as new/changed never accrue the fee — building coverage is never double-billed.
• Delivered records — the per-record price for each new / changed record.

Cadence (full registry)	Sweep fee	Churn records	Total per run
Bootstrap (uncovered ground, however split)	—	~650K total	~$975 listing / ~$1,950 full detail
Daily	~$19.50	~300–500	~$20
Weekly	~$19.50	~2–3K	~$24
Monthly	~$19.50	~10–12K	~$37
(compare: full re-download)	—	—	~$975

Good to know:

• Keep includeInactive: true — departures are the signal most delta users want, and a deregistering broker's record flips to inactive rather than vanishing (FINRA keeps past registrants searchable for years). Without it, that changed record is filtered out of your output.
• One snapshot covers everything: state-scoped and full-registry schedules share it, so a "states": ["NY", "NJ", "CT"] tri-state schedule and a nationwide run build on each other instead of interfering.
• Building coverage in many tiny runs re-scans covered ground each time (and pays the fee on it) — one big run, resumed if interrupted, is the cheapest bootstrap.
• Already have a crawl_all dataset? Pass its ID once as baselineDatasetId to seed coverage from it instead of re-buying those records; drop the parameter on later runs.

Related registries: pair this export with our SEC Form ADV / IAPD Scraper (RIA firms and investment advisers) and CFP Directory Scraper (certified financial planners) for a complete advisor-universe dataset.

---

FINRA BrokerCheck Scraper Features

• Full-database export — crawl_all enumerates the entire individual registry; crawl_delta keeps it current for a fraction of the cost
• Searches both individual brokers/advisers and firms in a single actor
• Six operating modes: individual search, firm search, CRD lookups, full-registry crawl, delta refresh
• Extracts 30+ fields per record — name, CRD, scope, employment history, exams, state registrations, disclosures
• Returns full employment history with dates, firm CRDs, and branch locations
• Includes regulatory disclosures: event date, type, resolution, initiator, allegations, and sanctions
• Filters by US state — one or several at once (states: ["NY", "NJ", "CT"]) — and by current-employer firm name (works with or without a name query)
• Pure JSON API — no browser rendering, no CAPTCHA solving
• Resumable: interrupted runs continue via resumeCursor or console Resurrect — no re-billing of fetched records

---

Who Uses FINRA BrokerCheck Data?

• Financial services sales teams — Build targeted lists of advisers by firm, state, or license type and feed them into your CRM
• Advisor recruiters & succession planners — Own the full registry, then track crawl_delta firm-move and deregistration signals to spot breakaways and retiring advisers first
• Compliance and due diligence — Pull a broker's full employment history and disclosure record for KYC, hiring, or regulatory screening
• Fintech and RIA tech builders — Seed your product's adviser database with authoritative, government-sourced data and keep it synced with monthly deltas
• Journalists and researchers — Track sanctions, customer complaints, and regulatory actions across the industry

---

How FINRA BrokerCheck Scraper Works

1. Pick a mode — search by name, search a firm, look up specific CRD numbers, or crawl the whole registry
2. The scraper hits FINRA's BrokerCheck API, paginates through listing results, and fetches the full detail record for each hit
3. Each record is normalized into a flat, structured JSON object with consistent field names and formatted dates
4. Results stream into the Apify dataset — you export CSV, JSON, or Excel from the console

---

Input

{
    "mode": "individual_search",
    "queries": ["Smith"],
    "states": ["WY"],
    "includeInactive": false,
    "includeDisclosures": true,
    "maxItems": 100
}

Field	Type	Default	Description
mode	string	individual_search	One of individual_search, firm_search, by_crd_individual, by_crd_firm, crawl_all, crawl_delta
queries	array	["Smith"]	One or more names — ["Smith"] or ["Smith", "Jones", "Garcia"]. Each runs as its own search, results combined without duplicates. Required for the two search modes unless firmName is set (ignored by the crawl modes)
states	array	[]	One or more two-letter state codes — ["CA"] or ["NY", "NJ", "CT"]. Leave empty for all states. Brokers registered in several listed states are returned and billed once
firmName	string	""	Filter individuals by current-employer firm name (case-insensitive). Works with or without query
fetchDetails	boolean	true	true = full detail records (exams, disclosures, history) at the premium record rate. false = fast listing-level records (identity, current employer + location) at the base rate
crdNumbers	array	[]	List of CRD numbers. Required for by_crd_individual and by_crd_firm
baselineDatasetId	string	""	crawl_delta only (required): dataset ID of your previous crawl_all/crawl_delta run to diff against
includeInactive	boolean	false	Include records with InActive or NotInScope status
includeDisclosures	boolean	true	Include full disclosure events in the output
maxItems	integer	100	Maximum records to return. Set high (e.g. 1000000) for the crawl modes

Search multiple names and states at once

{
    "mode": "individual_search",
    "queries": ["Smith", "Jones", "Garcia"],
    "states": ["TX", "OK", "NM"]
}

Firm search example

{
    "mode": "firm_search",
    "queries": ["Fidelity"],
    "maxItems": 50
}

Direct CRD lookup

{
    "mode": "by_crd_individual",
    "crdNumbers": ["1113790", "1056376"],
    "includeInactive": true
}

---

FINRA BrokerCheck Scraper Output Fields

One schema covers both individuals and firms — the record_type field tells you which is which, and firm-only or individual-only fields are empty when not applicable.

Individual record

{
    "record_type": "individual",
    "crd_number": "1113790",
    "full_name": "JOSEPH THOMAS SMITH",
    "first_name": "JOSEPH",
    "last_name": "SMITH",
    "middle_name": "THOMAS",
    "other_names": ["JOE SMITH", "SMITTY SMITH"],
    "bc_scope": "Active",
    "ia_scope": "Active",
    "has_disclosures": false,
    "disclosure_count": 0,
    "industry_start_date": "1984-01-14",
    "registration_count": 1,
    "state_registration_count": 10,
    "current_employer_name": "LPL FINANCIAL LLC",
    "current_employer_crd": "6413",
    "current_employer_city": "MADISON",
    "current_employer_state": "NJ",
    "employment_history": [
        "LPL FINANCIAL LLC (CRD 6413) — MADISON, NJ [2020-05-07 — present]",
        "SAGEPOINT FINANCIAL, INC. (CRD 133763) — MADISON, NJ [2007-11-20 — 2020-05-11]"
    ],
    "license_exams": [
        "Series 65 — Uniform Investment Adviser Law Examination (2002-08-02) [IA]",
        "Series 7 — General Securities Representative Examination (1983-04-16) [BC]"
    ],
    "state_registrations": [
        "California — BC APPROVED 2020-05-07",
        "New Jersey — IA APPROVED 2020-05-08"
    ],
    "registered_sros": [
        "FINRA APPROVED (Categories: Full Registration/General Securities Representative, Securities Trader)"
    ],
    "disclosures": [],
    "brokercheck_url": "https://brokercheck.finra.org/individual/summary/1113790"
}

Field	Type	Description
record_type	string	Always individual or firm
delta_status	string	crawl_delta only: new or changed vs your coverage snapshot (deregistration = scope flip = changed). Empty in all other modes
crd_number	string	Central Registration Depository number
full_name	string	Full name (individuals only)
first_name / last_name / middle_name	string	Name parts
other_names	string[]	Alternate names, maiden names, nicknames
bc_scope	string	Broker-dealer registration scope: Active, InActive, NotInScope, Expanded
ia_scope	string	Investment adviser registration scope
has_disclosures	boolean	True if the record has disclosure events
disclosure_count	number	Number of disclosure events
industry_start_date	string	Date entered the securities industry (YYYY-MM-DD)
registration_count	number	Number of active FINRA registrations
state_registration_count	number	Number of active state registrations
current_employer_name	string	Current firm name
current_employer_crd	string	Current firm CRD
current_employer_city / current_employer_state	string	Current branch office location
employment_history	string[]	Formatted: "Firm Name (CRD) — City, ST [start — end]"
license_exams	string[]	Formatted: "Series 7 — Exam Name (YYYY-MM-DD) [scope]"
state_registrations	string[]	Formatted: "State — SCOPE STATUS YYYY-MM-DD"
registered_sros	string[]	Formatted SRO entries with status and registration categories
disclosures	string[]	Formatted disclosure events with date, type, initiator, allegations, sanctions
brokercheck_url	string	Direct URL to the BrokerCheck profile page

Firm record

{
    "record_type": "firm",
    "crd_number": "166782",
    "firm_name": "FIDELITY SELECTCO, LLC",
    "firm_other_names": ["FIDELITY SELECTCO, LLC"],
    "firm_sec_number": "801-77635",
    "firm_ia_scope": "INACTIVE",
    "firm_bc_scope": "",
    "firm_has_disclosures": true,
    "firm_branch_count": 0,
    "firm_main_office_street": "6501 S FIDDLER'S GREEN CIRCLE, STE 300 - 600, SUITE 600",
    "firm_main_office_city": "GREENWOOD VILLAGE",
    "firm_main_office_state": "CO",
    "firm_main_office_zip": "80111",
    "firm_main_office_country": "United States",
    "disclosures": [],
    "brokercheck_url": "https://brokercheck.finra.org/firm/summary/166782"
}

Field	Type	Description
firm_name	string	Firm legal name
firm_other_names	string[]	Alternate firm names
firm_sec_number	string	SEC file number (e.g. 801-12345 IA, 8-12345 BD)
firm_ia_scope / firm_bc_scope	string	Firm's IA and BD registration scopes
firm_has_disclosures	boolean	True if the firm has disclosure events
firm_branch_count	number	Number of firm branches
firm_main_office_*	string	Main office street, city, state, zip, country

---

FAQ

Can I download the entire FINRA BrokerCheck database?

Yes — that's what crawl_all mode is for. FINRA offers no bulk download or export endpoint of its own; the registry is only reachable through a search API capped at 9,000 results per query. crawl_all shards the registry by state and name-prefix, walks past that cap, and de-duplicates by CRD. A complete pull is ~650,000 records — roughly $975 at the listing tier or $1,950 with full details and disclosures — exportable as CSV, JSON, or Excel. Coverage is near-complete (a guaranteed 100% dump is impossible without a bulk endpoint, which FINRA doesn't provide).

How do I keep a full BrokerCheck export up to date?

Schedule crawl_delta — daily, weekly, or monthly, whatever freshness you need. No configuration required: the first run exports everything and saves a snapshot to your account; every later run outputs only records that changed since the previous run and updates the snapshot. Deregistrations show up as changed (registration scope flips to inactive). You're billed a sweep fee of one record-event per 50 registry entries scanned (≈$20 full-registry, cents per state) plus the delivered records — a refresh runs ~$20–40 instead of a ~$975+ re-pull. See "Keep it fresh with delta runs" above.

How do I scrape FINRA BrokerCheck?

FINRA BrokerCheck Scraper pulls data from FINRA's public Elasticsearch-backed JSON API at api.brokercheck.finra.org. Pick a mode, set a query, and run it. No authentication, no CAPTCHA, no proxy setup — FINRA publishes this data on purpose.

How much does FINRA BrokerCheck Scraper cost to run?

Pay-per-event pricing: $0.10 per run start, $0.0015 per listing-level record, and $0.003 per full-detail record (exams, employment history, disclosures — fetchDetails: true, the default). A 1,000-record listing run costs about $1.60; the entire 650K-record registry runs about $975 at the listing tier or $1,950 in full detail. crawl_delta runs additionally bill a sweep fee of one record-event per 50 registry entries scanned (≈$20 for a full-registry delta), so keeping the dataset fresh stays far cheaper than re-downloading it.

What happens if a big run times out or I abort it?

Nothing is lost. The crawl state lives in a persisted request queue. Either Resurrect the run in the Apify console, or copy the resumeCursor value from the stopped run's Output and pass it as input to a new run — both continue exactly where the crawl stopped, and already-fetched records are not re-fetched and not re-billed.

What data can I get from FINRA BrokerCheck?

The full public record for each individual or firm — identity, CRD, scope, employment history, licenses and exams, state registrations, SRO memberships, and any regulatory disclosures (complaints, sanctions, bankruptcies). Roughly 30+ fields per record.

Can I filter by state or firm?

FINRA BrokerCheck Scraper filters individual searches by US state — states: ["CA"], or several at once with states: ["NY", "NJ", "CT"] — and by current-employer firm name (firmName: "Goldman") — use firmName alone (no query) to pull everyone registered under one firm. Full detail records include each person's license exams, so you can filter by exam (e.g. Series 79) in your own post-processing. For firm-level filtering, use firm_search mode with the firm name as the query.

Does FINRA BrokerCheck Scraper need proxies?

No proxy setup is needed on your side — rotation is built in purely to keep bulk crawls fast under FINRA's per-IP rate cap.

How do I look up specific brokers by CRD number?

Use mode: "by_crd_individual" with a crdNumbers array. Each CRD is fetched directly without going through search pagination, which is both faster and cheaper when you already know who you want.

---

Need More Features?

Need custom fields, bulk state sweeps, or a different regulatory data source? File an issue or get in touch.

Why Use FINRA BrokerCheck Scraper?

• The only practical bulk export — FINRA has no download endpoint; commercial advisor databases charge thousands per year for the same registry
• Authoritative source — Data comes straight from FINRA's public API, not a screen-scraped copy
• Own the dataset, keep it fresh — one crawl_all plus cheap monthly crawl_delta refreshes beats renting access
• Clean structured output — All array fields return primitive strings with consistent formatting, so you can load it into a database or spreadsheet without a cleanup pass
• Six modes, one actor — Search individuals, search firms, look up CRDs, export everything, or diff against last month

---

Further reading: How to Get Company Registry Data in Bulk (Without an Enterprise API Contract)