# Washington DOL License Lookup Scraper (`crawlerbros/washington-dol-license-lookup-scraper`) Actor

Search Washington State's unified professional/business license lookup (professions.dol.wa.gov) covering 35+ license categories in one tool. No login required.

- **URL**: https://apify.com/crawlerbros/washington-dol-license-lookup-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 DOL License Lookup Scraper

Scrape **Washington State's Department of Licensing (DOL) License Lookup**, the state's unified professional and business license verification tool covering **35 license categories in one search** — Real Estate, Notary Public, Cosmetology, Engineers, Architects, Private Investigators, Bail Bonds, Auctioneers, Home Inspectors, and more. Look up an exact license number within a profession and get licensee/business name, license number, credential type, status, and issue/expiration dates. No login required.

### What this actor does

- **35 license categories in one tool** — the key differentiator vs. single-profession state actors
- **Exact license-number lookup**, scoped to a profession category (the same number can independently exist under different professions)
- **Batch lookup:** pass a list of license numbers via `licenseNumbers` to check a whole roster in one run (all within the same profession)
- **Detail enrichment (optional):** current issue date, original (first) issue date, expiration date, state, ZIP code
- **Filters:** license status, Washington county
- **Empty fields are omitted** — every record only contains fields DOL actually returned

### Output per license record

- `licenseeType` — `Individual` or `Business`, DOL's own record-type classification
- `licenseeName` — for individual licensees, or `businessName` for business/firm licenses
- `firstName`, `middleName`, `lastName`, `priorName` — for individual licensees, when on file
- `licenseNumber` — the numeric license identifier
- `licenseUniqueId` — the number plus credential type (DOL's own composite key)
- `credentialType` — e.g. `Notary Public`, `Real Estate Broker`, `Cosmetologist`
- `profession` — the license category searched
- `status` — `Active` / `Inactive` / `Expired` / `Suspended` / `Revoked` / `Canceled`
- `statusCategory` — normalized: `active` / `inactive` / `expired` / `suspended` / `revoked` / `canceled`
- `subStatus` — e.g. `Deceased`, when on file
- `hasDisciplinaryAction` — boolean
- `issueDate`, `originalIssueDate`, `expirationDate`
- `city`, `county`, `state`, `zip`
- `employeeFirm` — sponsoring firm/employer, when on file
- `relatedLicenseUniqueId` — a linked license record, when applicable
- `sourceUrl` — the DOL license-lookup portal URL
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `profession` | string | `Notary Public` | License category to search within (35 options) |
| `licenseNumber` | string | `9999` | Exact license number to look up |
| `licenseNumbers` | array | – | Optional extra license numbers to batch-lookup in the same profession |
| `statusFilter` | string | `any` | `any` / `active` / `inactive` / `expired` / `suspended` / `revoked` / `canceled` |
| `county` | string | – | Washington county filter (40 options incl. "Out of State") |
| `fetchDetails` | boolean | `true` | Enrich each result with its detail record (dates, ZIP, state) |
| `maxItems` | int | `10` | Hard cap (1–50). A single lookup typically returns 1–2 records; raise for batches |

#### Example: look up a notary commission

```json
{
  "profession": "Notary Public",
  "licenseNumber": "9999"
}
````

#### Example: look up a real estate license, active only

```json
{
  "profession": "Real Estate",
  "licenseNumber": "20512345",
  "statusFilter": "active"
}
```

#### Example: look up a business/firm license

```json
{
  "profession": "Cosmetology",
  "licenseNumber": "9999",
  "fetchDetails": true
}
```

#### Example: batch-check a roster of notary commissions

```json
{
  "profession": "Notary Public",
  "licenseNumber": "9999",
  "licenseNumbers": ["10000", "10001", "10002"],
  "maxItems": 20
}
```

### Use cases

- **Employment & vendor screening** — confirm a professional's license is active before engaging them
- **Compliance teams** — verify notary commissions, real estate licenses, or contractor credentials
- **Consumer protection** — check a private investigator, security guard company, or home inspector's status
- **Due diligence** — pull disciplinary-action flags and expiration dates for a known license number
- **Real estate & title** — verify a broker's or firm's license before closing

### FAQ

**What is the data source?**
The Washington State Department of Licensing's public License Lookup tool (professions.dol.wa.gov). Data is refreshed every morning by 6am Pacific.

**Is this affiliated with the Washington State Department of Licensing?**
No. This is an independent third-party actor that uses DOL's public license-lookup feature.

**Why do I need to know the license number in advance?**
DOL's public license-lookup tool offers two search paths: an exact license-number lookup (used by this actor) and a separate "Advanced Search" by name/county, which DOL gates behind a visible Google reCAPTCHA challenge that must be solved by a human in a browser. This actor does not use paid CAPTCHA-solving services, so only the exact license-number path is automated. If you don't already have the license number, look up the licensee by name once at professions.dol.wa.gov, then use this actor for structured/repeat lookups by number.

**Why does the same license number sometimes return two records?**
A license number is scoped to a profession category but not to individual-vs-business record type — some categories (e.g. Cosmetology) issue the same number to both an individual license and a business license independently. The actor returns every match.

**Why are some fields missing on certain records?**
Business licenses don't have a `licenseeName`/`firstName`/`lastName`; individual licenses don't have a `businessName`. Detail-only fields (dates, state, ZIP) only appear when `fetchDetails` is enabled.

**How fresh is the data?**
DOL states its license-lookup data is updated every morning by 6am and may not reflect same-day changes.

**Can this be used for commercial purposes?**
Per Washington's Revised Code of Washington (RCW 42.56), use of lists of individuals from this public record for commercial purposes is prohibited. This actor is intended for individual license-verification lookups, not for building mailing/marketing lists.

# Actor input Schema

## `profession` (type: `string`):

The DOL profession/license category to search within. Washington's license-lookup tool covers many professions in one place — pick the category the license number belongs to.

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

Exact license number to look up within the selected profession, e.g. `9999`. This is a numeric identifier assigned per profession category (the same number can independently exist under different professions).

## `licenseNumbers` (type: `array`):

Optional extra license numbers to look up in the same run, within the same `profession` — for checking a list of licensees in one call (e.g. a roster of notaries or brokers). Each number runs its own search; duplicates (incl. duplicates of `licenseNumber`) are skipped. Raise `maxItems` to fit the batch size.

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

Filter results by license status category.

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

Filter results to a single Washington county (applied after lookup).

## `fetchDetails` (type: `boolean`):

Enrich each result with its detail record (issue date, original issue date, expiration date, state, ZIP). Uses one extra request per result.

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

Hard cap on emitted license records. A single license-number lookup typically returns 1-2 records (e.g. an individual and a business sharing the same number); raise this when supplying multiple numbers via `licenseNumbers`.

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

Not needed in normal operation (professions.dol.wa.gov is publicly reachable). Used automatically as a fallback only if the source starts blocking direct requests.

## Actor input object example

```json
{
  "profession": "Notary Public",
  "licenseNumber": "9999",
  "licenseNumbers": [],
  "statusFilter": "any",
  "county": "",
  "fetchDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `licenses` (type: `string`):

Dataset containing all scraped Washington DOL license records.

# 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 = {
    "profession": "Notary Public",
    "licenseNumber": "9999",
    "licenseNumbers": [],
    "statusFilter": "any",
    "county": "",
    "fetchDetails": true,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/washington-dol-license-lookup-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profession": "Notary Public",
    "licenseNumber": "9999",
    "licenseNumbers": [],
    "statusFilter": "any",
    "county": "",
    "fetchDetails": True,
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/washington-dol-license-lookup-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profession": "Notary Public",
  "licenseNumber": "9999",
  "licenseNumbers": [],
  "statusFilter": "any",
  "county": "",
  "fetchDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/washington-dol-license-lookup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Washington DOL License Lookup Scraper",
        "description": "Search Washington State's unified professional/business license lookup (professions.dol.wa.gov) covering 35+ license categories in one tool. No login required.",
        "version": "1.0",
        "x-build-id": "WL2EGsEykq6CawCiV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~washington-dol-license-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-washington-dol-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~washington-dol-license-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-washington-dol-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~washington-dol-license-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-washington-dol-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profession",
                    "licenseNumber"
                ],
                "properties": {
                    "profession": {
                        "title": "Profession / license category",
                        "enum": [
                            "Appraisal Management Companies",
                            "Appraisers - Real Estate",
                            "Architect Firms",
                            "Architects",
                            "Auctioneers and Auction Company",
                            "Bail Bonds",
                            "Body Art and Body Piercing",
                            "Camping Resorts",
                            "CDL Training and Examining",
                            "Cemeteries",
                            "Collection Agency",
                            "Combative Sports",
                            "Commercial Telephone Solicitors",
                            "Cosmetology",
                            "Court Reporters",
                            "Driver Training School",
                            "Employment Agencies",
                            "Engineers",
                            "Funerals",
                            "Geologist",
                            "Home Inspector",
                            "Landscape Architects",
                            "Land Surveyors",
                            "Manufactured Homes",
                            "Motorcycle Safety",
                            "Notary Public",
                            "On-Site Wastewater",
                            "Private Investigator",
                            "Private Investigator Agencies",
                            "Real Estate",
                            "Security Guards",
                            "Sellers of Travel",
                            "Telephone Solicitors",
                            "Timeshares",
                            "Whitewater River Outfitters"
                        ],
                        "type": "string",
                        "description": "The DOL profession/license category to search within. Washington's license-lookup tool covers many professions in one place — pick the category the license number belongs to.",
                        "default": "Notary Public"
                    },
                    "licenseNumber": {
                        "title": "License number",
                        "type": "string",
                        "description": "Exact license number to look up within the selected profession, e.g. `9999`. This is a numeric identifier assigned per profession category (the same number can independently exist under different professions).",
                        "default": ""
                    },
                    "licenseNumbers": {
                        "title": "Additional license numbers (batch lookup)",
                        "type": "array",
                        "description": "Optional extra license numbers to look up in the same run, within the same `profession` — for checking a list of licensees in one call (e.g. a roster of notaries or brokers). Each number runs its own search; duplicates (incl. duplicates of `licenseNumber`) are skipped. Raise `maxItems` to fit the batch size.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "statusFilter": {
                        "title": "License status filter",
                        "enum": [
                            "any",
                            "active",
                            "inactive",
                            "expired",
                            "suspended",
                            "revoked",
                            "canceled"
                        ],
                        "type": "string",
                        "description": "Filter results by license status category.",
                        "default": "any"
                    },
                    "county": {
                        "title": "Washington county",
                        "enum": [
                            "",
                            "Adams",
                            "Asotin",
                            "Benton",
                            "Chelan",
                            "Clallam",
                            "Clark",
                            "Columbia",
                            "Cowlitz",
                            "Douglas",
                            "Ferry",
                            "Franklin",
                            "Garfield",
                            "Grant",
                            "Grays Harbor",
                            "Island",
                            "Jefferson",
                            "King",
                            "Kitsap",
                            "Kittitas",
                            "Klickitat",
                            "Lewis",
                            "Lincoln",
                            "Mason",
                            "Okanogan",
                            "Pacific",
                            "Pend Oreille",
                            "Pierce",
                            "San Juan",
                            "Skagit",
                            "Skamania",
                            "Snohomish",
                            "Spokane",
                            "Stevens",
                            "Thurston",
                            "Wahkiakum",
                            "Walla Walla",
                            "Whatcom",
                            "Whitman",
                            "Yakima",
                            "Out of State"
                        ],
                        "type": "string",
                        "description": "Filter results to a single Washington county (applied after lookup).",
                        "default": ""
                    },
                    "fetchDetails": {
                        "title": "Fetch full detail record per result",
                        "type": "boolean",
                        "description": "Enrich each result with its detail record (issue date, original issue date, expiration date, state, ZIP). Uses one extra request per result.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Hard cap on emitted license records. A single license-number lookup typically returns 1-2 records (e.g. an individual and a business sharing the same number); raise this when supplying multiple numbers via `licenseNumbers`.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Not needed in normal operation (professions.dol.wa.gov is publicly reachable). Used automatically as a fallback only if the source starts blocking direct requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
