# West Virginia Insurance License Lookup (NAIC SBS) (`ws_tony/west-virginia-insurance-license`) Actor

Search and verify insurance producer licenses in West Virginia via the NAIC State Based Systems public API. Returns NPN, license type, lines of authority, status, and expiration date.

- **URL**: https://apify.com/ws\_tony/west-virginia-insurance-license.md
- **Developed by:** [Tony](https://apify.com/ws_tony) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## West Virginia Insurance License Lookup (NAIC SBS)

Verify insurance producer licenses in West Virginia using the NAIC State Based Systems public API. Returns name, NPN, license type, lines of authority, status, expiration date, and address. Best for NPN-based verification of specific producers — name searches are capped at 25 results by the API. No proxy required — this actor calls a government JSON endpoint directly.

**Who is this for?** Compliance teams at carriers, MGAs, and agencies who need to verify that their appointed producers hold an active license in West Virginia. If you manage a book of producers and need auditable proof of licensure, this actor automates what would otherwise be a manual lookup on the NAIC website — at $0.005 per record.

> **Part of a 25-state portfolio.** Separate actors exist for every NAIC SBS state (IL, IA, NC, NJ, MO, TN, WI, CT, and more). Run each state actor independently and join results on the `npn` field to build a cross-state compliance report.

---

### ⚠️ Important: use NPN lookup, not name search

The NAIC SBS API returns **at most 25 results per query** — a hard server-side limit with no pagination. Searching by last name for a common surname ("Smith", "Johnson") will silently truncate at 25 results.

**The right workflow for compliance verification:**

1. Export your producer list from your AMS as a CSV
2. Copy the NPN column
3. Paste NPNs into the **NPN List** field (one per line)
4. Run — you get back exactly one record per NPN, no truncation risk

> **What is an NPN?** A National Producer Number (NPN) is the unique ID assigned to every licensed insurance producer by the NIPR. You can find it on a producer's license certificate, in your AMS, or by searching [nipr.com](https://nipr.com).

Name search is best for one-off spot checks on a specific person, not bulk verification.

---

### Input

#### NPN List *(recommended for bulk runs)*

Paste one National Producer Number per line in the **NPN List** field (replace the example values with your own before running):

````

1234567
9876543
5551234

````

Each NPN is looked up independently. Results are deduplicated automatically.

**Run time and cost:** 100 NPNs ≈ 60 seconds, ~$0.50. 500 NPNs ≈ 5 minutes, ~$2.50.

**Large batches:** For runs over 500 NPNs, the actor processes queries sequentially with a 500 ms delay between requests. If the NAIC API returns an error for a specific query, that query is skipped and logged — the run continues for all remaining NPNs. To check for skipped queries after a run, open your run in the Apify Console and click the **Log** tab — search for `[ERROR]` lines.

#### One-Off Search

Fill in **Last Name** (and optionally **First Name**) for a one-off search. Remember the 25-result cap applies here.

#### Other options

| Field | Default | Description |
|---|---|---|
| Active Licenses Only | **On** | Excludes expired, inactive, and terminated licenses. Turn off only if you need a full license history — unchecking will surface expired and terminated records going back to the producer's first license date. |
| Entity Type | Individual | Switch to Business/Agency for agency lookups |
| State | WV | Pre-filled — only change if searching a different SBS state |

---

### Output Behavior

#### Not found / no active license

Two special sentinel records can appear in your results — understanding them is important before wiring this actor into a pipeline:

- If an NPN has **no license on record** in West Virginia, the actor writes a record with `"status": "NOT FOUND"` and `"is_active": false`.
- If an NPN exists but **all licenses are expired or terminated** (and **Active Licenses Only** is on), the actor writes `"status": "NO ACTIVE LICENSE"` and `"is_active": false`.

Both sentinel records include every output field (nulls/empty arrays for unresolvable fields) so your spreadsheet or AMS ingestion doesn't get column-count mismatches.

Sentinel records are charged at the same rate as normal records ($0.005 each) — you're paying for the verification, not just the record. A NOT FOUND result is still a confirmed compliance check.

#### Unknown status values

The `status` field reflects exactly what the NAIC API returns. Known values are listed in the output table below, but NAIC may introduce new status strings over time. If you encounter an unknown value, the `is_active` boolean is still reliable — it is derived solely from the exact string `"Active"`, so any unknown status will always produce `is_active: false`.

---

### Output

Each row in the Dataset is one license record. Key fields:

| Field | Example | Notes |
|---|---|---|
| `npn` | `"1234567"` | National Producer Number — use this to join results across states |
| `license_number` | `"1234567"` | State license number (often same as NPN on SBS states) |
| `name` | `"Mary Ann Johnson"` | Title-cased, First Last order |
| `first_name` | `"Mary"` | First word of given name |
| `middle_name` | `"Ann"` | Middle name/initial if present; `null` otherwise |
| `last_name` | `"Johnson"` | Surname |
| `license_type` | `"Insurance Producer"` | License class |
| `license_type_code` | `"PRO"` | Short code for license class. Known values: `PRO` (Insurance Producer), `SAJ` (Staff Adjuster), `ADJ` (Adjuster), `CSL` (Consultant) |
| `status` | `"Active"` | One of: `Active`, `Expired`, `Inactive`, `Terminated`, `Surrendered`, `Revoked`, `NOT FOUND`, `NO ACTIVE LICENSE`. Additional values may exist — see Output Behavior above. |
| `is_active` | `true` | Boolean — use this for filtering; reliable even for unknown status values |
| `lines_of_authority` | `[{"loa": "Life", "effective_date": "2010-06-01"}]` | Array of LOA objects. Each has `loa` (string) and `effective_date` (ISO date or `null`). Empty array if no LOAs assigned. |
| `effective_date` | `"2010-06-01"` | Date this license version became effective (ISO 8601) |
| `expiration_date` | `"2027-05-31"` | License expiration date (ISO 8601) |
| `residency` | `"Resident"` | `Resident` or `Non-Resident` |
| `business_phone` | `"304-555-0100"` | Formatted as XXX-XXX-XXXX |
| `address_city` | `"Charleston"` | Title-cased city parsed from source |
| `address_state` | `"WV"` | Producer's home state (may differ from search jurisdiction for non-residents) |
| `address_zip` | `"25301"` | 5-digit ZIP (or ZIP+4 if available); `null` if not present in source data |
| `address_raw` | `"CHARLESTON, WV 25301"` | Unmodified source address — use as a fallback if the parsed city/state/ZIP fields produce unexpected results |
| `dba_name` | — | DBA name — present and populated for Business/Agency records only |
| `fein` | — | Federal EIN — present and populated for Business/Agency records only |
| `designated_home_state` | `null` | Reserved for compact/non-resident workflows; always `null` on NAIC SBS states |

#### Example record (Individual)

```json
{
    "npn": "1234567",
    "license_number": "1234567",
    "jurisdiction": "WV",
    "licensee_type": "Individual",
    "name": "Mary Ann Johnson",
    "first_name": "Mary",
    "middle_name": "Ann",
    "last_name": "Johnson",
    "license_type_code": "PRO",
    "license_type": "Insurance Producer",
    "lines_of_authority": [
        { "loa": "Life", "effective_date": "2010-06-01" },
        { "loa": "Accident and Health", "effective_date": "2010-06-01" }
    ],
    "status": "Active",
    "is_active": true,
    "residency": "Resident",
    "designated_home_state": null,
    "effective_date": "2010-06-01",
    "expiration_date": "2027-05-31",
    "business_phone": "304-555-0100",
    "address_city": "Charleston",
    "address_state": "WV",
    "address_zip": "25301",
    "address_raw": "CHARLESTON, WV 25301",
    "source_url": "https://sbs.naic.org/solar-external-lookup/?jurisdiction=WV&searchType=Licensee",
    "scraped_at": "2026-05-27T12:00:00.000Z"
}
````

> Business/Agency records include two additional fields: `dba_name` (string or null) and `fein` (string or null).

#### Exporting results

After a run completes, click the **Export** button in the Dataset tab to download your results as CSV or Excel. This works directly in the Apify Console — no additional tools needed.

***

### Pricing

**Pay-per-event** at **$0.005 per license record** returned. Sentinel records (NOT FOUND, NO ACTIVE LICENSE) are charged at the same rate — you're paying for the verification, not just the record. Empty searches are never charged. A typical bulk run of 100 NPNs costs $0.50.

***

### States in this portfolio

AL · AK · AR · CT · DC · ID · IL · IA · KS · MO · MT · NH · NJ · NM · NC · ND · OK · OR · RI · SD · TN · VT · **WV** · WI

***

### Data source

[NAIC State Based Systems External Lookup](https://sbs.naic.org/solar-external-lookup/) — public government data, no authentication required.

# Actor input Schema

## `npnList` (type: `string`):

Paste one National Producer Number (NPN) per line — replace the example values below with your own before running. NPNs are 6–10 digit numbers found on a producer's license certificate, on NIPR.com, or in your AMS. This is the most reliable search method — each NPN returns exactly one record with no truncation risk. 100 NPNs ≈ 60 seconds and ~$0.50.

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

When checked, only records with an Active license status are returned. Expired, Inactive, Terminated, and Surrendered licenses are excluded. Recommended for most compliance workflows. Turn off only if you need a full license history — unchecking will include expired and terminated records going back to the producer's first license date.

## `entityType` (type: `string`):

Search for individual producers or business/agency licensees.

## `lastName` (type: `string`):

Search by last name instead of NPN. The API returns at most 25 results per name search — use NPN List above for bulk verification.

## `firstName` (type: `string`):

Optional. Narrows a last-name search.

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

Optional. Direct lookup by state license number.

## `jurisdiction` (type: `string`):

Two-letter state code. Pre-filled for this state's actor — only change this if you need to search a different SBS state.

## Actor input object example

```json
{
  "npnList": "1234567\n9876543\n5551234",
  "activeOnly": true,
  "entityType": "IND",
  "jurisdiction": "WV"
}
```

# 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 = {
    "npnList": `1234567
9876543
5551234`
};

// Run the Actor and wait for it to finish
const run = await client.actor("ws_tony/west-virginia-insurance-license").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 = { "npnList": """1234567
9876543
5551234""" }

# Run the Actor and wait for it to finish
run = client.actor("ws_tony/west-virginia-insurance-license").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 '{
  "npnList": "1234567\\n9876543\\n5551234"
}' |
apify call ws_tony/west-virginia-insurance-license --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ws_tony/west-virginia-insurance-license",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "West Virginia Insurance License Lookup (NAIC SBS)",
        "description": "Search and verify insurance producer licenses in West Virginia via the NAIC State Based Systems public API. Returns NPN, license type, lines of authority, status, and expiration date.",
        "version": "0.1",
        "x-build-id": "u4Xu6nxazYFrto9Oy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ws_tony~west-virginia-insurance-license/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ws_tony-west-virginia-insurance-license",
                "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/ws_tony~west-virginia-insurance-license/runs": {
            "post": {
                "operationId": "runs-sync-ws_tony-west-virginia-insurance-license",
                "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/ws_tony~west-virginia-insurance-license/run-sync": {
            "post": {
                "operationId": "run-sync-ws_tony-west-virginia-insurance-license",
                "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": [
                    "jurisdiction"
                ],
                "properties": {
                    "npnList": {
                        "title": "NPN List (one per line)",
                        "type": "string",
                        "description": "Paste one National Producer Number (NPN) per line — replace the example values below with your own before running. NPNs are 6–10 digit numbers found on a producer's license certificate, on NIPR.com, or in your AMS. This is the most reliable search method — each NPN returns exactly one record with no truncation risk. 100 NPNs ≈ 60 seconds and ~$0.50."
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "When checked, only records with an Active license status are returned. Expired, Inactive, Terminated, and Surrendered licenses are excluded. Recommended for most compliance workflows. Turn off only if you need a full license history — unchecking will include expired and terminated records going back to the producer's first license date.",
                        "default": true
                    },
                    "entityType": {
                        "title": "Entity Type",
                        "enum": [
                            "IND",
                            "BUS"
                        ],
                        "type": "string",
                        "description": "Search for individual producers or business/agency licensees.",
                        "default": "IND"
                    },
                    "lastName": {
                        "title": "Last Name (single lookup)",
                        "type": "string",
                        "description": "Search by last name instead of NPN. The API returns at most 25 results per name search — use NPN List above for bulk verification."
                    },
                    "firstName": {
                        "title": "First Name",
                        "type": "string",
                        "description": "Optional. Narrows a last-name search."
                    },
                    "licenseNumber": {
                        "title": "License Number",
                        "type": "string",
                        "description": "Optional. Direct lookup by state license number."
                    },
                    "jurisdiction": {
                        "title": "State (Jurisdiction)",
                        "enum": [
                            "AL",
                            "AK",
                            "AR",
                            "CT",
                            "DC",
                            "ID",
                            "IL",
                            "IA",
                            "KS",
                            "MO",
                            "MT",
                            "NH",
                            "NJ",
                            "NM",
                            "NC",
                            "ND",
                            "OK",
                            "OR",
                            "RI",
                            "SD",
                            "TN",
                            "VT",
                            "WV",
                            "WI"
                        ],
                        "type": "string",
                        "description": "Two-letter state code. Pre-filled for this state's actor — only change this if you need to search a different SBS state.",
                        "default": "WV"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
