# Massachusetts Construction License Lookup & Verify (CSL) (`fried_calamaries/massachusetts-construction-license-lookup`) Actor

Verify any Massachusetts Construction Supervisor License (CSL) by license number or last name — type, status, expiration & address — from the official state registry.

- **URL**: https://apify.com/fried\_calamaries/massachusetts-construction-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

## Massachusetts Construction License Lookup & Verify (CSL)

### Pain points

- Verifying a Massachusetts Construction Supervisor License means one slow manual lookup at a time on a clunky state portal.
- The MyLicense portal isn't built for compliance workflows, vetting pipelines, or CRM enrichment.
- Checking status and expiration across many licensees by hand doesn't scale for hiring or underwriting teams.

### What we solve

- Verify any MA Construction Supervisor License by license number or last name — one search.
- Returns license type, status, expiration, and address from the official state registry.
- Enrich a license number or name into a full structured record; pay per match, empty searches free.

### Summary

Look up and verify any Massachusetts Construction Supervisor License from a single search — type a license number (e.g. CS-093362) or a last name and get back the license type, status, expiration, and address, straight from the Commonwealth's official MyLicense registry (Office of Public Safety and Inspections). Covers all three CSL subtypes: Construction Supervisor, 1 & 2 Family, and Specialty. Each match is optionally enriched with its full detail record. Built for fast verification, compliance checks, and enriching a license number or name into a structured record.

### Who it's for

- GCs and hiring managers vetting Massachusetts subcontractors
- Insurance underwriters and lenders running KYC on contractors
- Compliance teams and marketplaces verifying CSL licenses
- RevOps and BD teams enriching contractor records

### 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": "Smith",
  "licenseType": "",
  "includeDetails": true,
  "maxResults": 40
}
````

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

### What you get

One row per record:

| Field | Description |
|---|---|
| `state` | Always 'MA' for this actor |
| `license_number` | MA Construction Supervisor License number (e.g. CS-093362) |
| `person_name` | Individual licensee full name |
| `business_name` | Doing-business-as name, when on file (detail) |
| `license_type` | Construction Supervisor, 1 & 2 Family, or Specialty |
| `status` | License status (e.g. Active, Expired, Null and Void, Suspended) |
| `issue_date` | Original licensure date (detail) |
| `expiration_date` | License expiration date (detail) |
| `city` | Licensee city (detail) |
| `address` | Street address (detail) |
| `zip_code` | ZIP code (detail) |
| `matched_by` | Which search surfaced this match: license\_number or last\_name |
| `source_url` | Link to the official MyLicense record |

Sample:

```json
{
  "state": "MA",
  "license_number": "CS-093362",
  "person_name": "CHARLES JOHNSON IV",
  "business_name": null,
  "license_type": "Construction Supervisor",
  "status": "Null and Void",
  "issue_date": "2/9/2010",
  "expiration_date": "2/9/2014",
  "city": "Salisbury",
  "address": "17 LENA MAES WAY",
  "zip_code": "01952",
  "matched_by": "license_number",
  "source_url": "https://madpl.mylicense.com/Verification/Details.aspx?result=e42cc6bc-9d25-4fa1-a73b-656980e54be9"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `query` | yes | string | `"Smith"` | A Massachusetts Construction Supervisor License number (e.g. 'CS-093362' or just the digits) OR a last name. A license number is looked up directly; anything else is searched against the last-name index. Both return the matching licenses, deduped by license number. |
| `licenseType` | no | string | `""` | Restrict the search to one Construction Supervisor License subtype. Default searches all three. |
| `statusFilter` | no | string | — | Exact license-status text to keep, e.g. 'Active', 'Expired', 'Null and Void', 'Suspended', 'Revoked'. Default: no filter (all statuses). |
| `includeDetails` | no | boolean | `true` | When on (default), each match is enriched with its full Details.aspx record — address, city, ZIP, and issue/expiration dates. Turn off for a faster, lighter result list (name, license #, type, status). |
| `maxResults` | no | integer | `50` | Cap on the number of matches returned (and enriched) in a single run. The portal itself caps each individual search at ~40 rows per page — narrow the query (name, license type, status) to get under that. Default 50. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional. The MyLicense portal is usually reachable directly; enable a proxy (e.g. residential) only if a run is blocked or served a challenge. |

### 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 MA Construction Supervisor's license type, status, and expiration before hiring or onboarding.
- Record enrichment — turn a license number or name into a full structured record for a CRM, marketplace, or vetting workflow.
- Compliance checks — pull authoritative state registry data on demand for audits and due diligence.
- Lender / insurer due diligence — verify a contractor's standing straight from the state registry.

### Why this actor

- Straight from the official Massachusetts MyLicense registry — authoritative, not a stale third-party copy.
- Search by license number or last name; results deduped by license #.
- Pay per match; searches with no results are free.

### Limitations & updates

Covers the Construction Supervisor License (CSL) only — Home Improvement Contractor (HIC) registration is a separate Salesforce portal and is out of scope. Each individual search (one license type at a time) is capped at ~40 results by the portal itself; narrow by license type, status, or name to stay under it. Phone, county, bond, and insurance fields are included in the schema for suite consistency but this registry does not publish them (returned null).

### FAQ

**Where does the data come from?**

The official Massachusetts MyLicense 'Verification' registry (madpl.mylicense.com), run by the Office of Public Safety and Inspections — public, authoritative license data.

**What can I search by?**

A Construction Supervisor License number (e.g. CS-093362) or a last name. Both return the matching licenses, deduped by license number.

**Does this cover Home Improvement Contractor (HIC) registration too?**

No — HIC registration lives on a separate Salesforce portal (contractorhub.mass.gov) and isn't covered by this actor. This actor covers the Construction Supervisor License (CSL) only.

**What fields do I get?**

License number, licensee name, license type, status, and expiration, plus address and issue date when detail enrichment is on.

**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 (licensee records as the Commonwealth publishes them); we add no personal/PII enrichment.

**How current is it?**

It reflects the live MyLicense record at lookup time.

### 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).
- **Michigan Contractor License Lookup & Verify (LARA)** — You're verifying a Michigan builder or trade contractor — type, status, expiration (LARA).
- **Minnesota Contractor License Lookup & Verify (DLI)** — You're verifying a Minnesota residential contractor — subtype, status, expiration, enforcement flags (DLI).

# Actor input Schema

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

A Massachusetts Construction Supervisor License number (e.g. 'CS-093362' or just the digits) OR a last name. A license number is looked up directly; anything else is searched against the last-name index. Both return the matching licenses, deduped by license number.

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

Restrict the search to one Construction Supervisor License subtype. Default searches all three.

## `statusFilter` (type: `string`):

Exact license-status text to keep, e.g. 'Active', 'Expired', 'Null and Void', 'Suspended', 'Revoked'. Default: no filter (all statuses).

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

When on (default), each match is enriched with its full Details.aspx record — address, city, ZIP, and issue/expiration dates. Turn off for a faster, lighter result list (name, license #, type, status).

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

Cap on the number of matches returned (and enriched) in a single run. The portal itself caps each individual search at ~40 rows per page — narrow the query (name, license type, status) to get under that. Default 50.

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

Optional. The MyLicense portal is usually reachable directly; enable a proxy (e.g. residential) only if a run is blocked or served a challenge.

## Actor input object example

```json
{
  "query": "Smith",
  "licenseType": "",
  "includeDetails": true,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `matches` (type: `string`):

The matched licenses — type, status, expiration, and address when enriched.

# 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": "Smith"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fried_calamaries/massachusetts-construction-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": "Smith" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Massachusetts Construction License Lookup & Verify (CSL)",
        "description": "Verify any Massachusetts Construction Supervisor License (CSL) by license number or last name — type, status, expiration & address — from the official state registry.",
        "version": "0.0",
        "x-build-id": "DLjDGq8Pc9gFpHZdP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fried_calamaries~massachusetts-construction-license-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fried_calamaries-massachusetts-construction-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~massachusetts-construction-license-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fried_calamaries-massachusetts-construction-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~massachusetts-construction-license-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fried_calamaries-massachusetts-construction-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 Massachusetts Construction Supervisor License number (e.g. 'CS-093362' or just the digits) OR a last name. A license number is looked up directly; anything else is searched against the last-name index. Both return the matching licenses, deduped by license number."
                    },
                    "licenseType": {
                        "title": "License type",
                        "enum": [
                            "",
                            "Construction Supervisor",
                            "Construction Supervisor 1 & 2 Family",
                            "Construction Supervisor Specialty"
                        ],
                        "type": "string",
                        "description": "Restrict the search to one Construction Supervisor License subtype. Default searches all three.",
                        "default": ""
                    },
                    "statusFilter": {
                        "title": "License status filter",
                        "type": "string",
                        "description": "Exact license-status text to keep, e.g. 'Active', 'Expired', 'Null and Void', 'Suspended', 'Revoked'. Default: no filter (all statuses)."
                    },
                    "includeDetails": {
                        "title": "Include full license detail",
                        "type": "boolean",
                        "description": "When on (default), each match is enriched with its full Details.aspx record — address, city, ZIP, and issue/expiration dates. Turn off for a faster, lighter result list (name, license #, type, status).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on the number of matches returned (and enriched) in a single run. The portal itself caps each individual search at ~40 rows per page — narrow the query (name, license type, status) to get under that. Default 50.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The MyLicense portal is usually reachable directly; enable a proxy (e.g. residential) only if a run is blocked or served a challenge.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```