# Nevada Contractor License Scraper — NSCB (`haketa/nevada-contractor-scraper`) Actor

Extract licensed contractors from the Nevada State Contractors Board (NSCB) by county & classification. Get license number, business name, phone, address, trade classification, bond/monetary limit, expiry date & status — for B2B leads, compliance & market research.

- **URL**: https://apify.com/haketa/nevada-contractor-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## Nevada Contractor License Scraper — NSCB

Extract **licensed contractors from the Nevada State Contractors Board (NSCB)** — the official registry of licensed contractors in Nevada. Choose counties and (optionally) a trade classification, and get clean records for every contractor: **license number, business name, phone, address, trade classification, bond/monetary limit, expiry date and license status**.

No code, no login. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, HubSpot, Make, Zapier and n8n.

> **🏗️ Built for B2B lead generation, compliance & market research.** Every record carries the **license number, business name, phone and bond limit** — perfect for building targeted lists of licensed contractors, verifying licenses, or analysing the Nevada construction market.

---

### 📋 What this scraper does

The Nevada State Contractors Board licenses every contractor operating in the state. This actor turns that public registry into a clean, structured dataset you can filter, analyse or feed into a CRM.

Pick your counties (and optionally a trade), and it will:

- ✅ Collect every matching licensed contractor
- ✅ Return the **license number** and **license status** (Active, Inactive, ...)
- ✅ Capture the **business name, phone and full address**
- ✅ Include the **trade classification(s)** (electrical, plumbing, HVAC, general building, ...)
- ✅ Report the **monetary / bond limit** and **license expiry date**
- ✅ Filter to **active licenses only** and by **trade classification**
- ✅ De-duplicate every contractor by license number

---

### ⭐ Why choose this scraper

- **Official license data.** Straight from the Nevada State Contractors Board — the authoritative source.
- **Ready-to-use leads.** Business name, phone and address for every licensed contractor.
- **Compliance-ready.** License number, status, expiry and bond limit for verification and due diligence.
- **Trade targeting.** Filter by classification — electrical, plumbing, HVAC, roofing, general building and more.
- **Fast and complete.** Every contractor in a county in a single pass.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **B2B lead generation** | Build targeted lists of licensed contractors for insurance, suppliers, SaaS and services. |
| **License verification & compliance** | Check license number, status, expiry and bond limit for due diligence. |
| **Insurance & bonding** | Reach contractors by trade and limit for liability, workers' comp and surety products. |
| **Construction market research** | Measure how many contractors, and which trades, operate in each county. |
| **Supplier & distributor sales** | Find contractors by classification and location to sell materials and equipment. |
| **Data products & dashboards** | Feed a clean licensed-contractor feed into BI tools or a database. |

---

### 🚀 Quick start

1. Pick one or more **Counties** (e.g. `Clark (Las Vegas)`, `Washoe (Reno)`).
2. (Optional) Enter a **Classification / trade** (e.g. `Electrical`, `Plumbing`, `HVAC`).
3. Keep **Active licenses only** on for outreach.
4. Set **Max contractors** and click **Start**.
5. Download your data from the **Storage → Dataset** tab.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Counties** | multi-select | Nevada counties to scrape. Empty = all counties. Clark (Las Vegas) and Washoe (Reno) are the largest. |
| **Classification / trade** | string | Optional. Filter by trade — e.g. `C-2` or `Electrical`, `Plumbing`, `General Building`, `Roofing`, `Painting`. Empty = all trades. |
| **Active licenses only** | boolean | Keep only active licenses (recommended). |
| **Max contractors** | integer | Cap on total contractors. `0` = no limit. |
| **Proxy** | object | Apify Proxy (US recommended, on by default). |

#### Example 1 — Active contractors in Clark County (Las Vegas)

```json
{
  "counties": ["clark"],
  "activeOnly": true,
  "maxItems": 500
}
````

#### Example 2 — Electrical contractors in Washoe (Reno)

```json
{
  "counties": ["washoe"],
  "classification": "electrical",
  "activeOnly": true,
  "maxItems": 300
}
```

#### Example 3 — HVAC contractors statewide

```json
{
  "counties": [],
  "classification": "air conditioning",
  "activeOnly": true,
  "maxItems": 1000
}
```

***

### 📦 Output

Each contractor becomes one dataset record:

```json
{
  "licenseNumber": "0095648",
  "businessName": "AGILE CONSTRUCTION SERVICES LLC",
  "status": "Active",
  "phone": "(916) 895-8991",
  "street": "3170 E SUNSET RD STE B",
  "city": "LAS VEGAS",
  "state": "NV",
  "zip": "89120",
  "county": "Clark",
  "classifications": "B-2 Residential and Small Commercial",
  "monetaryLimit": "$200,000.00",
  "expiresDate": "06-30-2028",
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `licenseNumber` | NSCB license number (used for de-duplication). |
| `businessName` | Contractor business name. |
| `status` | License status (Active, Inactive, ...). |
| `phone` | Phone number. |
| `street` / `city` / `state` / `zip` | Business address. |
| `county` | Nevada county searched. |
| `classifications` | Trade classification(s). |
| `monetaryLimit` | Bond / monetary limit. |
| `expiresDate` | License expiry date. |
| `scrapedAt` | Extraction timestamp. |

***

### 🏗️ Trade classifications you can filter

General Engineering (A) · General Building (B) · Plumbing & Heating (C-1) · Electrical (C-2) · Carpentry (C-3) · Painting & Decorating (C-4) · Concrete (C-5) · Roofing & Siding · Refrigeration & Air Conditioning (C-21 / HVAC) · Landscaping · Masonry · Excavating & Grading · Solar · and many more.

Enter a class code (e.g. `C-2`) or a keyword (e.g. `electrical`, `plumbing`, `roofing`).

***

### 🗺️ Counties

All 17 Nevada counties are supported: Carson City, Churchill, **Clark (Las Vegas)**, Douglas, Elko, Esmeralda, Eureka, Humboldt, Lander, Lincoln, Lyon, Mineral, Nye, Pershing, Storey, **Washoe (Reno)** and White Pine.

***

### 🧭 Tips for best results

- **Start with Clark and Washoe** — they hold most of Nevada's contractors.
- **Filter by classification** to target a specific trade (insurance and suppliers care about trade).
- **Keep `activeOnly` on** for outreach; turn it off for full historical coverage.
- **Use the phone number** as the primary contact channel — it's on nearly every record.
- **Schedule runs** to track new licenses, renewals and status changes over time.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **CRM / Sheets / Airtable / Make / Zapier / n8n:** push results automatically.
- **API:** run and fetch data with the Apify API or the JS / Python clients.
- **Scheduling:** run on a schedule to keep an always-fresh contractor database.

***

### ❓ FAQ

**Do I need an NSCB account or API key?**
No. You only need an Apify account.

**Which contractors are covered?**
Every contractor licensed by the Nevada State Contractors Board, across all 17 counties.

**Can I filter by trade?**
Yes — enter a class code (`C-2`) or a keyword (`electrical`, `plumbing`, `HVAC`).

**Is email included?**
No — the NSCB registry publishes phone and address, not email. Phone is available on nearly every record.

**Does it return duplicates?**
No. Contractors are de-duplicated by license number.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** license information that the Nevada State Contractors Board publishes for everyone to see. It does not log in or access private data. Respect the Board's terms of use and applicable law, and use the data for lawful purposes such as license verification, compliance, market research and B2B outreach.

***

### 🛟 Support

Need an extra field or hit an issue? Open a ticket from the actor's **Issues** tab with your input configuration.

Happy sourcing! 🏗️

# Actor input Schema

## `counties` (type: `array`):

Nevada counties to scrape. Leave empty to scrape all counties. Clark (Las Vegas) and Washoe (Reno) are the largest.

## `classification` (type: `string`):

Filter by trade classification. Enter a class code or keyword, e.g. "C-2" or "Electrical", "Plumbing", "General Building", "Roofing", "Painting". Leave empty for all trades.

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

Keep only contractors with an active license (recommended for outreach).

## `maxItems` (type: `integer`):

Maximum number of contractors to return across all counties. Set 0 for no limit.

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

Apify Proxy settings (US recommended, on by default).

## Actor input object example

```json
{
  "counties": [
    "clark"
  ],
  "activeOnly": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `licenseNumber` (type: `string`):

NSCB license number

## `businessName` (type: `string`):

Contractor business name

## `status` (type: `string`):

License status (Active, Inactive, ...)

## `phone` (type: `string`):

Phone number

## `street` (type: `string`):

Street address

## `city` (type: `string`):

City

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

State

## `zip` (type: `string`):

ZIP code

## `county` (type: `string`):

Nevada county searched

## `classifications` (type: `string`):

Trade classification(s)

## `monetaryLimit` (type: `string`):

Bond / monetary limit

## `expiresDate` (type: `string`):

License expiry date

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "counties": [
        "clark"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/nevada-contractor-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 = {
    "counties": ["clark"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/nevada-contractor-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 '{
  "counties": [
    "clark"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/nevada-contractor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nevada Contractor License Scraper — NSCB",
        "description": "Extract licensed contractors from the Nevada State Contractors Board (NSCB) by county & classification. Get license number, business name, phone, address, trade classification, bond/monetary limit, expiry date & status — for B2B leads, compliance & market research.",
        "version": "0.1",
        "x-build-id": "5aGDehcb9rykcwfNG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~nevada-contractor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-nevada-contractor-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/haketa~nevada-contractor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-nevada-contractor-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/haketa~nevada-contractor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-nevada-contractor-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": {
                    "counties": {
                        "title": "Counties",
                        "type": "array",
                        "description": "Nevada counties to scrape. Leave empty to scrape all counties. Clark (Las Vegas) and Washoe (Reno) are the largest.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "carson-city",
                                "churchill",
                                "clark",
                                "douglas",
                                "elko",
                                "esmeralda",
                                "eureka",
                                "humboldt",
                                "lander",
                                "lincoln",
                                "lyon",
                                "mineral",
                                "nye",
                                "pershing",
                                "storey",
                                "washoe",
                                "white-pine"
                            ],
                            "enumTitles": [
                                "Carson City",
                                "Churchill",
                                "Clark (Las Vegas)",
                                "Douglas",
                                "Elko",
                                "Esmeralda",
                                "Eureka",
                                "Humboldt",
                                "Lander",
                                "Lincoln",
                                "Lyon",
                                "Mineral",
                                "Nye",
                                "Pershing",
                                "Storey",
                                "Washoe (Reno)",
                                "White Pine"
                            ]
                        }
                    },
                    "classification": {
                        "title": "Classification / trade (optional)",
                        "type": "string",
                        "description": "Filter by trade classification. Enter a class code or keyword, e.g. \"C-2\" or \"Electrical\", \"Plumbing\", \"General Building\", \"Roofing\", \"Painting\". Leave empty for all trades."
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "Keep only contractors with an active license (recommended for outreach).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max contractors",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of contractors to return across all counties. Set 0 for no limit.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings (US recommended, on by default).",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```