# Michigan Contractor License Lookup & Verify (LARA) (`fried_calamaries/michigan-contractor-license-lookup`) Actor

Verify any Michigan contractor by license number or name — Residential Builders, M\&A, and trade licenses: type, status, issue & expiration dates, city — from the official LARA registry.

- **URL**: https://apify.com/fried\_calamaries/michigan-contractor-license-lookup.md
- **Developed by:** [ByteMe](https://apify.com/fried_calamaries) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.004 / verified license records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Michigan Contractor License Lookup & Verify (LARA)

### Pain points

- Verifying a Michigan contractor on LARA's Accela portal is one slow, stateful lookup at a time.
- The portal is an ASP.NET WebForms app — hard to automate, paginated 10 at a time, and returns HTML, not JSON.
- Checking license type, status, and expiration across many Residential Builders or trades by hand doesn't scale.

### What we solve

- Verify any Michigan LARA licensee by license number or business/contractor name — one search.
- Covers Residential Builders, Maintenance & Alteration contractors, and electrical/mechanical/plumbing trades.
- Returns license type, status, issue & expiration dates, city, and ZIP from the official registry.
- Handles the Accela VIEWSTATE flow and pagination automatically — just provide a query; pay per match, empty searches free.

### Summary

Look up and verify any Michigan contractor from a single search — type a LARA license number (e.g. '6102064') or a business/contractor name and get back the license type, status, issue and expiration dates, city, and ZIP, straight from the official Michigan LARA (Bureau of Construction Codes) registry on the Accela Citizen Access portal. It drives Accela's stateful ASP.NET search and pagination for you and enriches every match with its detail-page status and issue date. Built for fast verification, compliance checks, subcontractor vetting, and enriching a license number or name into a structured record.

### Who it's for

- GCs and hiring managers vetting Michigan subcontractors and Residential Builders before award
- Insurance underwriters and lenders running KYC on Michigan contractors
- Compliance teams and marketplaces verifying LARA license standing
- RevOps and BD teams enriching contractor lead lists with official license data

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "query": "CONSTRUCTION",
  "licenseType": "Residential Builder Company",
  "maxResults": 25
}
````

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `state` | Always 'MI' for this actor |
| `license_number` | Michigan LARA license number (e.g. '6102064') |
| `business_name` | Licensed business name |
| `person_name` | License holder's name (first / middle / last), for individual licensees |
| `license_type` | License type (e.g. 'Residential Builder Company', 'Electrical Contractor') |
| `status` | License status from the detail page (e.g. 'Issued', 'Lapsed', 'Expired') |
| `issue_date` | License issue date (from the detail page) |
| `expiration_date` | License expiration date |
| `city` | Business city |
| `zip_code` | Business ZIP code |
| `matched_by` | Which search surfaced this match: 'license\_number' or 'business\_name' |
| `source_url` | Direct link to the LARA/Accela licensee detail page |

Sample:

```json
{
  "state": "MI",
  "license_number": "6102064",
  "business_name": "CONSTRUCTION SERVICE CO",
  "person_name": "ROBERT J PATTISON",
  "license_type": "Electrical Contractor",
  "status": "Lapsed",
  "issue_date": "01/01/1983",
  "expiration_date": "12/31/2024",
  "city": "FENTON",
  "county": null,
  "address": null,
  "zip_code": "48430",
  "phone": null,
  "matched_by": "business_name",
  "source_url": "https://aca-prod.accela.com/LARA/GeneralProperty/LicenseeDetail.aspx?LicenseeNumber=6102064&LicenseeType=Electrical+Contractor"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `query` | yes | string | `"CONSTRUCTION"` | A Michigan LARA license number (digits, e.g. '6102064') OR a business/contractor name. Digit-only queries are looked up by license number; anything else searches the business-name index (substring). |
| `licenseType` | no | string | — | Optional exact license-type filter, e.g. 'Residential Builder Company', 'Residential Builder M and A Company', 'Electrical Contractor', 'Mechanical Contractor', 'Plumbing Contractor'. Leave blank to search all types. |
| `maxResults` | no | integer | `50` | Cap on the number of matches returned (and enriched) in a single run. Paging is automatic. Defaults to 50. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional. The Michigan LARA / Accela portal is reachable from Apify datacenter IPs, so a proxy is off by default. Enable one if you hit rate limiting on very large runs. |

### Pricing (Pay Per Event)

You pay per result (`dataset-item`) — **no charge for empty runs**. Example: **100 verified license records** at *$0.004/result* ≈ **$0.40**.

Illustrative — the final per-result price is set at publish time. Apify platform usage (compute) is billed separately per your plan.

### Use cases

- License verification — confirm a Michigan contractor's type, status, and expiration before hiring or onboarding.
- Residential Builder checks — verify a Residential Builder or Maintenance & Alteration contractor's standing straight from LARA.
- Record enrichment — turn a license number or business name into a full structured record for a CRM, marketplace, or vetting workflow.
- Lender / insurer due diligence — pull authoritative LARA data on demand to verify a contractor's standing.

### Why this actor

- Straight from the official Michigan LARA (Bureau of Construction Codes) registry on Accela — authoritative, not a stale third-party copy.
- Handles the Accela ASP.NET VIEWSTATE search + pagination automatically — no browser required, fast and cheap.
- Search by license number or business/contractor name, with an optional exact license-type filter; results deduped by license #.
- Every match enriched with detail-page status + issue date. Pay per match; searches with no results are free.

### Limitations & updates

Covers Michigan's LARA (Bureau of Construction Codes) public licensee registry on Accela only. Results reflect the live registry and change as it updates. A name search matches the business-name index (substring); very broad names may return many pages — refine the name or set 'licenseType' to narrow, and runs are bounded by maxResults (default 50). Detail pages supply status and issue date; street address, phone, county, bond, and insurance are not published in this view and are returned null.

### FAQ

**Where does the data come from?**

The official Michigan LARA (Department of Licensing and Regulatory Affairs, Bureau of Construction Codes) public licensee search on the Accela Citizen Access portal — authoritative public-record data.

**What can I search by?**

A license number (digits, e.g. '6102064') or a business/contractor name (substring). Digit-only queries are looked up by license number; anything else searches the business-name index. Add an optional 'licenseType' to filter to an exact type such as 'Residential Builder Company'.

**What license types are covered?**

Everything LARA's Bureau of Construction Codes publishes — Residential Builders (Company, Individual, Branch), Maintenance & Alteration contractors, and Electrical, Mechanical, Plumbing, Elevator and Boiler trades, among others.

**What fields do I get?**

License number, business name, contractor name, license type, status, issue and expiration dates, city, and ZIP. Status and issue date come from each licensee's detail page.

**How am I charged?**

Pay-per-result — per license match returned. No charge for searches with no results.

**Is this personal data?**

It's public professional-license data (business and license-holder records as LARA publishes them on its public portal); we add no personal/PII enrichment.

**How current is it?**

It reflects the live LARA/Accela record at lookup time — the same data you'd see on the public portal.

### Which actor to choose

Part of the contractor-license verification suite — pick the one that fits your goal:

- **California Contractor License Lookup & Verify (CSLB)** — You need a California contractor verified — by license number, business, or owner/personnel name (CSLB).
- **Florida Contractor License Lookup & Verify (DBPR)** — You're verifying a Florida contractor or tradesperson — type, status, expiration, county (DBPR).
- **Louisiana Contractor License Lookup** — You want the full Louisiana roster — 50,000+ commercial, residential & specialty licenses as data (LSLBC).
- **Multi-State Contractor & Trade License Lookup** — You don't know the state, or want the same contractor checked across WA, OR, TX & CT in one run.
- **Nevada Contractor License Lookup & Verify (NSCB)** — You need a Nevada contractor's status, trade classifications, bond & principals (NSCB).
- **New Mexico Contractor License Lookup & Verify (NM CID)** — You're verifying a New Mexico contractor — license #, status, city/ZIP, expiry (NM CID).
- **North Carolina Contractor License Lookup & Verify (NCLBGC)** — You're verifying a North Carolina general contractor — classification, status, expiration (NCLBGC).
- **Oregon Contractor License Lookup & Verify (CCB)** — You're verifying an Oregon contractor — status, bond, insurance & RMI (CCB).
- **South Carolina Contractor License Lookup & Verify (SC LLR)** — You're searching or verifying South Carolina contractors — by name, license, city, or classification (SC LLR).
- **Tennessee Contractor License Lookup & Verify (TN DOCI)** — You're verifying a Tennessee contractor or tradesperson — type, status, city & county (TN DOCI).
- **Texas Contractor & Trade License Lookup (TDLR)** — You're verifying a Texas electrician, HVAC or trade license — type, expiration, county & owner (TDLR).
- **Virginia Contractor License Lookup (DPOR Bulk)** — You want the full Virginia roster — 50,000+ Class A/B/C and trade licenses as bulk data (DPOR).
- **Washington Contractor License Lookup & Verify (L\&I)** — You're verifying a Washington contractor — type, status, expiration, principal (L\&I).
- **Alabama Contractor License Lookup & Verify (LBGC)** — You're verifying an Alabama general contractor — classification, city, phone, expiration (LBGC).
- **Arkansas Contractor License Lookup & Verify (ACLB)** — You're verifying an Arkansas contractor — validity, type, expiration, city & county (ACLB).
- **Minnesota Contractor License Lookup & Verify (DLI)** — You're verifying a Minnesota residential contractor — subtype, status, expiration, enforcement flags (DLI).
- **Massachusetts Construction License Lookup & Verify (CSL)** — You're verifying a Massachusetts Construction Supervisor License — type, status, expiration (CSL).

# Actor input Schema

## `query` (type: `string`):

A Michigan LARA license number (digits, e.g. '6102064') OR a business/contractor name. Digit-only queries are looked up by license number; anything else searches the business-name index (substring).

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

Optional exact license-type filter, e.g. 'Residential Builder Company', 'Residential Builder M and A Company', 'Electrical Contractor', 'Mechanical Contractor', 'Plumbing Contractor'. Leave blank to search all types.

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

Cap on the number of matches returned (and enriched) in a single run. Paging is automatic. Defaults to 50.

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

Optional. The Michigan LARA / Accela portal is reachable from Apify datacenter IPs, so a proxy is off by default. Enable one if you hit rate limiting on very large runs.

## Actor input object example

```json
{
  "query": "6102064",
  "licenseType": "Residential Builder Company",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Each row is one Michigan LARA contractor-license record.

# 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 = {
    "query": "CONSTRUCTION"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fried_calamaries/michigan-contractor-license-lookup").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 = { "query": "CONSTRUCTION" }

# Run the Actor and wait for it to finish
run = client.actor("fried_calamaries/michigan-contractor-license-lookup").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 '{
  "query": "CONSTRUCTION"
}' |
apify call fried_calamaries/michigan-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Michigan Contractor License Lookup & Verify (LARA)",
        "description": "Verify any Michigan contractor by license number or name — Residential Builders, M&A, and trade licenses: type, status, issue & expiration dates, city — from the official LARA registry.",
        "version": "0.0",
        "x-build-id": "lU1XrWabJonUPU5gU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fried_calamaries~michigan-contractor-license-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fried_calamaries-michigan-contractor-license-lookup",
                "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/fried_calamaries~michigan-contractor-license-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fried_calamaries-michigan-contractor-license-lookup",
                "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/fried_calamaries~michigan-contractor-license-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fried_calamaries-michigan-contractor-license-lookup",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "A Michigan LARA license number (digits, e.g. '6102064') OR a business/contractor name. Digit-only queries are looked up by license number; anything else searches the business-name index (substring)."
                    },
                    "licenseType": {
                        "title": "License type filter (optional)",
                        "type": "string",
                        "description": "Optional exact license-type filter, e.g. 'Residential Builder Company', 'Residential Builder M and A Company', 'Electrical Contractor', 'Mechanical Contractor', 'Plumbing Contractor'. Leave blank to search all types."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on the number of matches returned (and enriched) in a single run. Paging is automatic. Defaults to 50.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The Michigan LARA / Accela portal is reachable from Apify datacenter IPs, so a proxy is off by default. Enable one if you hit rate limiting on very large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```