# Washington Contractor License Search — Official L\&I Open Data (`keeganlabs/wa-contractor-licenses`) Actor

Every registered Washington State contractor from the Dept. of Labor & Industries official open-data feed (~161k licenses, ~75k active), refreshed daily. Name, license number, type & status, owner, specialties, dates, address, phone, UBI. Filter by city, type, status, name, specialty, or number.

- **URL**: https://apify.com/keeganlabs/wa-contractor-licenses.md
- **Developed by:** [Keegan Labs](https://apify.com/keeganlabs) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Washington Contractor License Search 🔨🏗️⚡

**Every registered Washington State contractor — from the official source.** Straight from
the **Washington State Department of Labor & Industries (L&I)** open-data feed on
[data.wa.gov](https://data.wa.gov/resource/m8qx-ubtq) — **~161,000 contractor licenses
(~75,000 active), refreshed by the state every day.** No CAPTCHAs, no brittle search-form
scraping, no stale lists. General and specialty construction, electrical, plumbing, and
elevator contractors — filterable and normalized into clean, structured records.

Contractor-license lookup is the single hottest category on Apify Store, but every
incumbent scrapes L&I's fragile "Verify a Contractor" search UI. **This actor pulls the
authoritative L&I open dataset directly** — faster, more complete, and it doesn't break
when the state tweaks its website.

---

### Who buys this

- **Construction lead-gen & sales teams** — build and refresh territory lead lists of every
  active contractor by city, trade, and specialty.
- **Materials, tool & equipment suppliers** — reach newly licensed and re-licensing
  contractors the day they come online.
- **Surety bond & insurance underwriters** — pull the registry to source, verify, and
  monitor contractors (status, effective/expiration/suspend dates, principal of record).
- **Background-check & KYB/verification providers** — confirm a Washington contractor's
  license number, status, business type, UBI, and owner against the official state record.
- **Staffing & subcontractor marketplaces** — vet and enrich contractor profiles at scale.

---

### What you get

Filterable, normalized records with a stable schema. Filters (all optional):

| Input | Meaning |
| --- | --- |
| `city` | City (partial, case-insensitive) — e.g. `Seattle`, `Spokane`, `Vancouver` |
| `licenseType` | L&I type code (exact) — `CC` Construction · `EC` Electrical · `PC` Plumbing · `LC` Elevator |
| `status` | Status code (`A` Active, `E` Expired, `S` Suspended, `R` Re-Licensed, `O` Out of Business) or status text — defaults to **Active** |
| `includeAllStatuses` | Return every status, not just active |
| `licenseNumber` | Exact contractor license number (e.g. `04CONCL862CR`) |
| `nameContains` | Substring matched against **business name** OR **primary principal** name |
| `specialtyContains` | Substring matched against specialty descriptions (`GENERAL`, `RESIDENTIAL`, `PLUMBING`, …) |
| `effectiveFrom` / `effectiveTo` | Effective (issue) date range (ISO `YYYY-MM-DD`) — great for "newly licensed this month" pulls |
| `maxRecords` | Cap on results (default 5,000) |
| `socrataAppToken` | Optional Socrata app token to raise rate limits (not required) |

**License types:** `CC` Construction Contractor (~148k) · `EC` Electrical Contractor (~9k) ·
`PC` Plumbing Contractor (~3k) · `LC` Elevator Contractor (~120).

#### Example output record

```json
{
  "licenseNumber": "04CONCL862CR",
  "ubi": "603320569",
  "businessName": "04 CONSTRUCTION LLC",
  "licenseType": "CC",
  "licenseTypeLabel": "Construction Contractor",
  "licenseStatus": "Active",
  "statusCode": "A",
  "rawStatus": "ACTIVE",
  "businessTypeCode": "L",
  "businessType": "Limited Liability Company",
  "primaryPrincipalName": "OCHOA, ERIC JAMES",
  "specialties": [
    { "code": "01", "description": "GENERAL" }
  ],
  "effectiveDate": "2014-02-19",
  "expirationDate": "2028-03-03",
  "suspendDate": null,
  "address": {
    "street": "1900 Ne 3rd St Ste 106",
    "street2": "PMB219",
    "city": "BEND",
    "state": "OR",
    "zip": "97701",
    "country": "United States"
  },
  "phone": "(541) 410-2249",
  "sourceDataset": "m8qx-ubtq",
  "sourceUrl": "https://data.wa.gov/resource/m8qx-ubtq.json"
}
````

Names are whitespace-cleaned and uppercased, UBI/phone are de-noised (Socrata's trailing
`.0` stripped, phones formatted `(NNN) NNN-NNNN`), ZIPs are ZIP+4 formatted, addresses are
structured, and all dates are ISO `YYYY-MM-DD`. (Some registrants have out-of-state mailing
addresses — the `address.state` field reflects the licensee's address of record.)

***

### Example runs

- **Every active construction contractor in Seattle:**
  `{ "city": "Seattle", "licenseType": "CC" }`
- **Electrical contractors newly licensed this year statewide:**
  `{ "licenseType": "EC", "effectiveFrom": "2026-01-01" }`
- **Look up one license by number:** `{ "licenseNumber": "04CONCL862CR", "includeAllStatuses": true }`
- **All plumbing specialties in Spokane, any status:**
  `{ "city": "Spokane", "licenseType": "PC", "includeAllStatuses": true }`

***

### Data source & freshness

- **Dataset:** `m8qx-ubtq` — *L\&I Contractor License Data – General* on data.wa.gov (Socrata SODA API).
- **Volume:** ~161,002 total records; ~75,259 currently **Active** (as of 2026-07-22).
- **Refresh:** updated by the state **daily** (dataset `rowsUpdatedAt` verified 2026-07-22 UTC).
- **Access:** affirmatively public open data on Washington's open-data portal — no login,
  no CAPTCHA. This actor uses the documented SODA API with a descriptive User-Agent,
  server-side `$where` filtering, polite paging, and exponential backoff.

Companion L\&I open datasets exist (insurance `ciwg-agsx`, principals `4xk5-x9j6`, bonds
`bzff-4fmt`) and can be layered on for underwriting workflows; this actor keeps the core
lean on the richest single feed so you get status, type, principal, specialties, dates,
address, phone, and UBI in one record.

***

### Pricing

Pay-per-event — you only pay for what you pull:

| Event | Price (USD) |
| --- | --- |
| Actor start | **$0.005** |
| License record | **$0.003** |

A typical city pull of 1,000 active contractors costs **~$3.01**. The whole active-license
universe (~75k rows) runs ~$226 for a full statewide refresh — a fraction of what any list
broker charges for a one-time, un-sourced CSV, and yours is re-runnable daily against the
authoritative state registry.

**Why these numbers:** priced to the pattern of our other government-open-data actors
(actor-start $0.005 + per-record $0.003, matching the Texas TABC liquor-license actor).
Contractor-license lookup is the highest-demand category on Apify (top scrapers run
1,000–2,200+ times), yet every competitor scrapes L\&I's brittle search UI — so a
dedicated, authoritative, daily-fresh open-data feed is priced to be an obvious yes for a
supplier, underwriter, or lead-gen team building a Washington book of business.

***

*Data is sourced from the Washington State Department of Labor & Industries public
open-data portal (data.wa.gov). This actor is an independent tool and is not affiliated
with or endorsed by L\&I or the State of Washington.*

# Actor input Schema

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

Filter by city (partial match, case-insensitive). Example: Seattle, Spokane, Vancouver, Tacoma.

## `licenseType` (type: `string`):

L\&I contractor license-type code (exact match). CC = Construction Contractor, EC = Electrical Contractor, PC = Plumbing Contractor, LC = Elevator Contractor.

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

Filter by license status. Accepts a one-letter status code (A=Active, E=Expired, S=Suspended, R=Re-Licensed, O=Out of Business, I=Inactive) or a status text substring. Defaults to Active unless 'Include all statuses' is on.

## `includeAllStatuses` (type: `boolean`):

If true and no explicit status is set, returns licenses of every status (active, expired, suspended, out of business, etc.).

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

Exact contractor license number (UBI-style L\&I number), e.g. ECOSTSC758NN. Case-insensitive.

## `nameContains` (type: `string`):

Free-text substring matched against both the business name and the primary principal (owner/officer) name, case-insensitive.

## `specialtyContains` (type: `string`):

Substring matched against the license specialty descriptions (e.g. GENERAL, RESIDENTIAL, PLUMBING, ELECTRICAL, HEAT/AC).

## `effectiveFrom` (type: `string`):

Only include licenses whose effective (issue) date is on or after this date (ISO YYYY-MM-DD). Great for 'newly licensed this month' lead pulls.

## `effectiveTo` (type: `string`):

Only include licenses whose effective (issue) date is on or before this date (ISO YYYY-MM-DD).

## `maxRecords` (type: `integer`):

Hard cap on the number of license records to return. The full dataset is ~161k rows (~75k Active).

## `socrataAppToken` (type: `string`):

Optional data.wa.gov / Socrata application token to raise API throttling limits. Not required — the API works without one.

## Actor input object example

```json
{
  "city": "Seattle",
  "licenseType": "CC",
  "status": "A",
  "includeAllStatuses": false,
  "licenseNumber": "ECOSTSC758NN",
  "nameContains": "construction",
  "specialtyContains": "GENERAL",
  "effectiveFrom": "2026-01-01",
  "effectiveTo": "2026-12-31",
  "maxRecords": 5000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("keeganlabs/wa-contractor-licenses").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("keeganlabs/wa-contractor-licenses").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 '{}' |
apify call keeganlabs/wa-contractor-licenses --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Washington Contractor License Search — Official L&I Open Data",
        "description": "Every registered Washington State contractor from the Dept. of Labor & Industries official open-data feed (~161k licenses, ~75k active), refreshed daily. Name, license number, type & status, owner, specialties, dates, address, phone, UBI. Filter by city, type, status, name, specialty, or number.",
        "version": "1.0",
        "x-build-id": "zYpA7rmJ5zRlo1cCv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/keeganlabs~wa-contractor-licenses/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-keeganlabs-wa-contractor-licenses",
                "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/keeganlabs~wa-contractor-licenses/runs": {
            "post": {
                "operationId": "runs-sync-keeganlabs-wa-contractor-licenses",
                "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/keeganlabs~wa-contractor-licenses/run-sync": {
            "post": {
                "operationId": "run-sync-keeganlabs-wa-contractor-licenses",
                "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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city (partial match, case-insensitive). Example: Seattle, Spokane, Vancouver, Tacoma."
                    },
                    "licenseType": {
                        "title": "License type code",
                        "enum": [
                            "CC",
                            "EC",
                            "PC",
                            "LC"
                        ],
                        "type": "string",
                        "description": "L&I contractor license-type code (exact match). CC = Construction Contractor, EC = Electrical Contractor, PC = Plumbing Contractor, LC = Elevator Contractor."
                    },
                    "status": {
                        "title": "License status",
                        "type": "string",
                        "description": "Filter by license status. Accepts a one-letter status code (A=Active, E=Expired, S=Suspended, R=Re-Licensed, O=Out of Business, I=Inactive) or a status text substring. Defaults to Active unless 'Include all statuses' is on."
                    },
                    "includeAllStatuses": {
                        "title": "Include all statuses (not just Active)",
                        "type": "boolean",
                        "description": "If true and no explicit status is set, returns licenses of every status (active, expired, suspended, out of business, etc.).",
                        "default": false
                    },
                    "licenseNumber": {
                        "title": "Contractor license number",
                        "type": "string",
                        "description": "Exact contractor license number (UBI-style L&I number), e.g. ECOSTSC758NN. Case-insensitive."
                    },
                    "nameContains": {
                        "title": "Business or principal name contains",
                        "type": "string",
                        "description": "Free-text substring matched against both the business name and the primary principal (owner/officer) name, case-insensitive."
                    },
                    "specialtyContains": {
                        "title": "Specialty contains",
                        "type": "string",
                        "description": "Substring matched against the license specialty descriptions (e.g. GENERAL, RESIDENTIAL, PLUMBING, ELECTRICAL, HEAT/AC)."
                    },
                    "effectiveFrom": {
                        "title": "License effective on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only include licenses whose effective (issue) date is on or after this date (ISO YYYY-MM-DD). Great for 'newly licensed this month' lead pulls."
                    },
                    "effectiveTo": {
                        "title": "License effective on/before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only include licenses whose effective (issue) date is on or before this date (ISO YYYY-MM-DD)."
                    },
                    "maxRecords": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Hard cap on the number of license records to return. The full dataset is ~161k rows (~75k Active).",
                        "default": 5000
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional data.wa.gov / Socrata application token to raise API throttling limits. Not required — the API works without one."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
