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

Search BrokerCheck public broker, adviser, and firm records by name or CRD. Export disclosures, registrations, firms, locations, and URLs.

- **URL**: https://apify.com/automation-lab/finra-brokercheck-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Search FINRA BrokerCheck public broker, adviser, and firm records from Apify.

Use this actor to collect structured BrokerCheck search results for compliance review, recruiting, due diligence, firm monitoring, and financial-services lead research.

### What does FINRA BrokerCheck Scraper do?

FINRA BrokerCheck Scraper searches the public BrokerCheck API and saves normalized records to an Apify dataset.

It can search:

- Individual brokers and advisers
- Broker-dealer and adviser firms
- Names, company keywords, and CRD numbers
- Current branch and office locations
- Disclosure and registration signals

### Who is it for?

Compliance analysts use it to prepare review lists.

Wealth-management recruiters use it to screen broker candidates.

Legal and due-diligence teams use it to collect public regulatory context.

Financial-services researchers use it to build lists of firms or representatives.

Data teams use it to feed internal CRMs, monitoring dashboards, and enrichment workflows.

### Why use this actor?

BrokerCheck is useful, but manual searches do not scale.

This actor turns public search results into exportable JSON, CSV, Excel, RSS, or API records.

You get consistent columns for CRD, name, status, disclosure flags, locations, firm identifiers, and source URLs.

### What data can you extract?

| Field | Description |
| --- | --- |
| `recordType` | `individual` or `firm` |
| `searchQuery` | Query that produced the row |
| `sourceUrl` | Public BrokerCheck profile URL |
| `crd` | BrokerCheck source / CRD identifier |
| `name` | Person or firm name |
| `status` | Public scope/status label |
| `disclosureFlag` | Whether BrokerCheck flags disclosures |
| `finraRegistrationCount` | Public registration count |
| `currentEmployments` | Current firm/branch data for individuals |
| `city`, `state` | Location fields when available |
| `rawSearchResult` | Raw public search payload for auditability |

### How much does it cost to scrape FINRA BrokerCheck?

This actor uses pay-per-event pricing.

There is a small start fee and a per-record fee for each saved BrokerCheck result.

The default input is intentionally small enough for a quick, low-cost first run.

Final tiered prices are calculated from cloud run costs before QA handoff.

### Input options

`searchMode` chooses individuals, firms, or both.

`queries` accepts names or keywords such as `john smith`, `vanguard`, or `merrill lynch`.

`crds` accepts CRD numbers and combines them with query searches.

`states` and `cities` filter returned records by public branch or office locations.

`includePrevious` includes previous names and registrations in individual searches.

`includeDetails` attempts best-effort BrokerCheck summary enrichment when the detail endpoint is accessible.

`maxResults` limits the total dataset size.

`maxResultsPerQuery` limits each individual query.

### Example input

```json
{
  "searchMode": "individual",
  "queries": ["john smith"],
  "includePrevious": true,
  "includeDetails": false,
  "maxResults": 100,
  "maxResultsPerQuery": 100
}
````

### Example firm input

```json
{
  "searchMode": "firm",
  "queries": ["vanguard"],
  "maxResults": 50,
  "maxResultsPerQuery": 50
}
```

### Example output

```json
{
  "recordType": "individual",
  "source": "FINRA BrokerCheck",
  "searchQuery": "john smith",
  "sourceUrl": "https://brokercheck.finra.org/individual/summary/6808119",
  "crd": "6808119",
  "name": "John Morgan Smith",
  "status": "Active",
  "brokerCheckScope": "Active",
  "investmentAdviserScope": "NotInScope",
  "disclosureFlag": false,
  "finraRegistrationCount": 1,
  "state": "NC",
  "city": "CHARLOTTE"
}
```

### How to run

1. Open the actor on Apify.
2. Enter broker, adviser, or firm names.
3. Choose individual, firm, or all search mode.
4. Set a maximum result count.
5. Run the actor.
6. Export the dataset or consume it with the API.

### Tips for better results

Use full names when possible.

Use firm names for firm mode.

Use CRD numbers when you already know them.

Keep `includeDetails` off for high-volume runs unless you specifically need best-effort detail payloads.

Use state filters after broad searches to narrow locations.

### Integrations

Send records to Google Sheets for analyst review.

Sync CRDs and disclosure flags to a CRM.

Trigger Make or Zapier workflows when new records are found.

Join BrokerCheck output with SEC adviser, ADV, or disciplinary datasets.

Store raw payloads in a data warehouse for audit trails.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/finra-brokercheck-scraper').call({
  searchMode: 'individual',
  queries: ['john smith'],
  maxResults: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/finra-brokercheck-scraper').call(run_input={
    'searchMode': 'firm',
    'queries': ['vanguard'],
    'maxResults': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~finra-brokercheck-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchMode":"individual","queries":["john smith"],"maxResults":100}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/finra-brokercheck-scraper`

Claude Code setup:

```bash
claude mcp add apify-brokercheck "https://mcp.apify.com/?tools=automation-lab/finra-brokercheck-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-brokercheck": {
      "url": "https://mcp.apify.com/?tools=automation-lab/finra-brokercheck-scraper"
    }
  }
}
```

Example prompts:

- "Search BrokerCheck for John Smith and summarize active registrations."
- "Find public BrokerCheck firm records for Vanguard and list disclosure flags."
- "Export the first 100 BrokerCheck individual records for this name list."

### Data quality notes

The actor preserves raw public search payloads.

Fields may be absent when FINRA does not return them for a record.

Location filters are post-filters over returned branch or office data.

Profile detail enrichment is best-effort and disabled by default.

### Legality

BrokerCheck data is public regulatory information, but your use still needs to comply with FINRA terms, Apify terms, privacy rules, and the laws that apply to your workflow.

### Legal and permitted use

This actor accesses public BrokerCheck search data.

Use it only for lawful, authorized, and compliant workflows.

Respect FINRA terms, privacy expectations, and applicable financial-services rules.

Do not use the output to make automated adverse decisions without proper review.

### Troubleshooting

If no records are returned, broaden the query or remove city/state filters.

If detail enrichment is empty, keep using the search result fields; detail endpoints may be unavailable from some environments.

If a run is slow, lower `maxResults` or split a large name list into smaller runs.

### Related scrapers

- https://apify.com/automation-lab/sec-investment-adviser-scraper
- https://apify.com/automation-lab/sec-adv-scraper
- https://apify.com/automation-lab/finra-disciplinary-actions-scraper

### FAQ

#### Can I search by CRD?

Yes. Add CRD values to the `crds` field.

#### Can I scrape firms and brokers together?

Yes. Set `searchMode` to `all`.

#### Does this require login?

No. It uses public BrokerCheck search endpoints.

#### Does it fetch every profile detail page?

No. The reliable MVP is the public search API. Summary detail enrichment is optional and best-effort.

### Changelog

Initial private build supports BrokerCheck individual and firm search, location filters, CRD inputs, and typed dataset output.

# Actor input Schema

## `searchMode` (type: `string`):

Choose whether to search individual representatives, firms, or both BrokerCheck indexes.

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

Broker, adviser, firm, or keyword searches. Examples: John Smith, Vanguard, Merrill Lynch.

## `crds` (type: `array`):

Optional CRD numbers to search directly. These are combined with the names/keywords list.

## `states` (type: `array`):

Optional two-letter US state filters matched against branch or office location fields.

## `cities` (type: `array`):

Optional city filters matched against branch or office location fields.

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

When searching individuals, ask BrokerCheck to include previous names and registrations in the search scope.

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

Attempt BrokerCheck summary endpoints for each result. Search results are still saved if detail endpoints are blocked or unavailable.

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

Total maximum dataset records to save across all searches.

## `maxResultsPerQuery` (type: `integer`):

Limit per name/CRD query before moving to the next query.

## Actor input object example

```json
{
  "searchMode": "individual",
  "queries": [
    "john smith"
  ],
  "crds": [],
  "states": [],
  "cities": [],
  "includePrevious": true,
  "includeDetails": false,
  "maxResults": 20,
  "maxResultsPerQuery": 20
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchMode": "individual",
    "queries": [
        "john smith"
    ],
    "crds": [],
    "states": [],
    "cities": [],
    "includePrevious": true,
    "includeDetails": false,
    "maxResults": 20,
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchMode": "individual",
    "queries": ["john smith"],
    "crds": [],
    "states": [],
    "cities": [],
    "includePrevious": True,
    "includeDetails": False,
    "maxResults": 20,
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "searchMode": "individual",
  "queries": [
    "john smith"
  ],
  "crds": [],
  "states": [],
  "cities": [],
  "includePrevious": true,
  "includeDetails": false,
  "maxResults": 20,
  "maxResultsPerQuery": 20
}' |
apify call automation-lab/finra-brokercheck-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINRA BrokerCheck Scraper",
        "description": "Search BrokerCheck public broker, adviser, and firm records by name or CRD. Export disclosures, registrations, firms, locations, and URLs.",
        "version": "0.1",
        "x-build-id": "SVhgIup8pIhIiWjdm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~finra-brokercheck-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~finra-brokercheck-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~finra-brokercheck-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "individual",
                            "firm",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose whether to search individual representatives, firms, or both BrokerCheck indexes.",
                        "default": "individual"
                    },
                    "queries": {
                        "title": "Names or keywords",
                        "type": "array",
                        "description": "Broker, adviser, firm, or keyword searches. Examples: John Smith, Vanguard, Merrill Lynch.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "crds": {
                        "title": "CRD numbers",
                        "type": "array",
                        "description": "Optional CRD numbers to search directly. These are combined with the names/keywords list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Optional two-letter US state filters matched against branch or office location fields.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional city filters matched against branch or office location fields.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePrevious": {
                        "title": "Include previous names/registrations",
                        "type": "boolean",
                        "description": "When searching individuals, ask BrokerCheck to include previous names and registrations in the search scope.",
                        "default": true
                    },
                    "includeDetails": {
                        "title": "Best-effort detail enrichment",
                        "type": "boolean",
                        "description": "Attempt BrokerCheck summary endpoints for each result. Search results are still saved if detail endpoints are blocked or unavailable.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Total maximum dataset records to save across all searches.",
                        "default": 20
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum records per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Limit per name/CRD query before moving to the next query.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
