# Virginia DPOR Professional License Scraper (`haketa/virginia-dpor-license-scraper`) Actor

Scrape contractor and tradesman license records from Virginia DPOR (Department of Professional and Occupational Regulation). Downloads bulk regulant lists — Class A/B/C contractors, electricians, plumbers, HVAC techs, gas fitters and more. No browser needed, direct file download.

- **URL**: https://apify.com/haketa/virginia-dpor-license-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.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

## Virginia DPOR Contractor & Tradesman License Scraper

### What does Virginia DPOR License Scraper do?

Virginia DPOR License Scraper extracts **contractor and tradesman license records** from the [Virginia Department of Professional and Occupational Regulation (DPOR)](https://www.dpor.virginia.gov/). It downloads bulk regulant list files and returns structured data including license numbers, firm names, specialty codes, expiration dates, addresses, and email contacts.

The scraper covers **10 license categories**: Class A/B/C contractors, electricians, plumbers, HVAC technicians, gas fitters, elevator mechanics, backflow prevention workers, water well providers, energy analysts, and fire sprinkler inspectors — totaling **45,000+ records** across all categories.

No browser required. No API keys. No login. Just direct file download and parsing.

### Why scrape Virginia DPOR license data?

Virginia's contractor licensing system is one of the most structured in the United States. The state enforces a **three-tier contractor classification** (Class A/B/C based on project value) and a separate **tradesman certification program** with Journeyman and Master levels for electrical, plumbing, HVAC, and gas fitting trades.

Here's why this data is valuable:

- 🏗️ **Subcontractor due diligence** — General contractors can verify a sub's Class A/B/C license and specialty codes before awarding contracts in the Northern Virginia / DC Metro market
- 🛡️ **Insurance underwriting** — Insurers can validate license classification and expiration status before writing contractor policies
- 📧 **Marketing & lead generation** — Build targeted CRM lists of active HVAC techs, electricians, or plumbers filtered by specialty, location, and email availability
- 📊 **Workforce analytics** — Analyze distribution of trade certifications, specialty concentration, and qualification levels across Virginia
- 🔄 **Compliance monitoring** — Schedule monthly runs to track license expirations, new issuances, and status changes over time

The Apify platform adds **scheduling, API access, webhook integrations, and proxy rotation** — turning a one-time scrape into an automated compliance monitoring pipeline.

### How to scrape Virginia DPOR license data

1. Go to the [Virginia DPOR License Scraper](https://apify.com/haketa/virginia-dpor-license-scraper) on Apify Store
2. Click **Try for free** to open the Actor in Apify Console
3. Select which license codes to scrape (or leave empty for all 10 categories)
4. Choose a status filter — **Active Only** to get current licenses, or **All Statuses** to include expired/suspended
5. Set **Max Records** (0 = unlimited) and click **Start**
6. Download your dataset in **JSON, CSV, Excel, or XML** format — or connect it via API to your own systems

Each run completes in under 30 seconds for all 10 categories. No proxies needed.

### What data can you extract from Virginia DPOR?

| Field | Description | Example |
|---|---|---|
| License Number | DPOR certificate number | `030496` |
| Business Name | Firm/company name | `FLUOR ENTERPRISES INC` |
| Individual Name | Person name (tradesmen) | `JOHN A. SMITH` |
| License Type | Human-readable category | `Class A Contractor` |
| Classification | License rank | `A`, `TRAD` |
| Specialties | Specialty/trade codes | `["CBC", "RBC", "ELE"]` |
| Status | Derived from expiration date | `Active`, `Expired` |
| Issue Date | Certification date (YYYY-MM-DD) | `1988-08-08` |
| Expiration Date | License expiry (YYYY-MM-DD) | `2026-08-31` |
| Address | Full street address | `100 FLUOR DANIEL DR C102B` |
| City | City | `GREENVILLE` |
| State | State abbreviation | `SC` |
| ZIP Code | ZIP (cleaned, no -0000) | `29607` |
| Email | Email address on file | `amanda.garland@fluor.com` |

### Virginia DPOR license codes explained

| Code | License Type | Records | Scope |
|---|---|---|---|
| `2701` | Class A Contractor | ~3,800 | Firms — $120K+ annual revenue |
| `2705b` | Class B Contractor | ~8,700 | Firms — $10K–$120K range |
| `2705c` | Class C Contractor | ~11,500 | Firms — $1K–$10K range |
| `2710` | Tradesman Combined | ~30,200 | Individuals — ELE/PLB/HVA/GFC |
| `2709` | Residential Tradesman | varies | Individual residential trade licenses |
| `2717` | Backflow Prevention | varies | Certified backflow specialists |
| `2718` | Elevator Mechanic | varies | Elevator installation & maintenance |
| `2719` | Water Well Provider | varies | Water well drilling & servicing |
| `2722` | Energy Analyst | varies | Home energy audit certification |
| `2723` | Fire Sprinkler Inspector | varies | Fire sprinkler system inspection |

#### Contractor specialty codes

Contractor files (2701/2705b/2705c) include specialty codes in the `specialties` field:

`CBC` (Commercial Building), `RBC` (Residential Building), `H` (Highway/Heavy), `ELE` (Electrical), `EMC` (Electronic/Mechanical), `EEC` (Elevator/Escalator), `VCC` (Vessel Construction), `CIC` (Commercial Improvement), `RFC` (Roofing), `MCC` (Marine Construction)

#### Tradesman designation codes

Tradesman files (2710/2709) include trade designation codes:

`MELE` / `JELE` (Master/Journeyman Electrician), `MPLB` / `JPLB` (Master/Journeyman Plumber), `MHVA` / `JHVA` (Master/Journeyman HVAC), `MGFC` / `JGFC` (Master/Journeyman Gas Fitter), `MLPG` (Master Liquefied Petroleum Gas), `MNGF` (Master Natural Gas Fitter)

### Output example

```json
{
  "licenseNumber": "032609",
  "individualName": null,
  "businessName": "FLUOR ENTERPRISES INC",
  "name": "FLUOR ENTERPRISES INC",
  "licenseType": "Class A Contractor",
  "licenseCode": "2701",
  "board": "27",
  "occupation": "01",
  "classification": "A",
  "specialties": ["RBC", "CBC", "ELE", "CIC", "H", "EMC"],
  "status": "Active",
  "issueDate": "1988-08-08",
  "expirationDate": "2026-08-31",
  "address": "100 FLUOR DANIEL DR C102B",
  "city": "GREENVILLE",
  "state": "SC",
  "zipCode": "29607",
  "country": null,
  "email": "amanda.garland@fluor.com",
  "scrapedAt": "2026-04-21T15:16:49.801Z"
}
````

### How much does it cost to scrape Virginia DPOR?

Virginia DPOR License Scraper uses a **pay-per-result** pricing model. You only pay for the records you extract:

| Plan | Price per 1,000 records | Full scrape (~45K records) | Example: Class A only (~3,800) |
|---|---|---|---|
| Free (No discount) | $2.00 | ~$90 | ~$7.60 |
| Bronze | $1.75 | ~$79 | ~$6.65 |
| Silver | $1.50 | ~$68 | ~$5.70 |
| Gold | $1.25 | ~$56 | ~$4.75 |

The Actor itself runs on **~0.001 CU per run** — the file download and parsing cost is negligible. You can try it for free with a limited number of records on the Apify Free plan.

### Input configuration

Click on the [Input tab](https://apify.com/haketa/virginia-dpor-license-scraper/input-schema) for full details. Key parameters:

| Parameter | Default | Description |
|---|---|---|
| License Codes | `["2701"]` | DPOR codes to scrape. Leave empty for all 10 |
| Status Filter | `all` | `active` = current licenses only |
| Max Records | `200` | Record cap. Set `0` for unlimited |
| Request Delay | `200` ms | Delay between file downloads |

### Integrations and API access

You can connect Virginia DPOR License Scraper with almost any cloud service or web app via the Apify platform's built-in [integrations](https://apify.com/integrations). Connect with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more. You can also access datasets programmatically via the [Apify API](https://docs.apify.com/api).

### FAQ

#### Is it legal to scrape Virginia DPOR data?

Virginia DPOR publishes regulant lists as **public records** at fixed URLs specifically for bulk download. No login, no terms of service agreement, and no CAPTCHA. This Actor downloads the same files any browser would access. The data contains business names, addresses, and professional license information — all public record under Virginia's Freedom of Information Act.

#### How often is DPOR data updated?

DPOR updates regulant list files periodically. For compliance monitoring, we recommend scheduling monthly runs using Apify's [scheduling feature](https://docs.apify.com/platform/schedules).

#### What does "status" mean in the output?

DPOR files don't include an explicit status column. This Actor **derives status from the expiration date**: if `expirationDate >= today` → "Active", otherwise → "Expired". Records with no expiration date show "Unknown".

#### Can I filter by specialty or location?

The Actor downloads complete files. You can filter results by specialty codes, city, state, or ZIP code using Apify's dataset filtering or by post-processing the JSON/CSV output.

#### Where can I get support?

For issues or feature requests, use the **Issues tab** on the Actor page. I actively monitor feedback and respond promptly. For custom solutions, feel free to reach out.

### Other license scrapers

Looking for license data from other states? Check out:

- 🏗️ [Minnesota DLI License Scraper](https://apify.com/haketa/minnesota-dli-license-scraper) — 200K+ contractor, electrician, plumber, and HVAC bond records from Minnesota

# Actor input Schema

## `licenseCodes` (type: `array`):

DPOR license type codes to scrape. Each code downloads a separate regulant list file. Available codes: '2701' (Class A Contractor), '2705b' (Class B Contractor), '2705c' (Class C Contractor), '2710' (Tradesman Combined — ELE/PLB/HVA/GFC), '2709' (Residential Tradesman), '2717' (Backflow Prevention Device Worker), '2718' (Certified Elevator Mechanic), '2719' (Certified Water Well Systems Provider), '2722' (Residential Building Energy Analyst), '2723' (Automatic Fire Sprinkler Inspector). Leave empty to scrape all codes.

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

Filter records by license status. 'active' = only active licenses, 'all' = include expired/suspended/revoked.

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

Maximum total records to save across all license types. Set 0 for unlimited.

## `requestDelay` (type: `integer`):

Delay between file downloads in milliseconds. DPOR files are static, low delay is fine.

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

Optional proxy settings. Usually not needed — DPOR serves public files without restrictions.

## Actor input object example

```json
{
  "licenseCodes": [
    "2701"
  ],
  "statusFilter": "all",
  "maxRecords": 200,
  "requestDelay": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

DPOR certificate/registration number

## `individualName` (type: `string`):

Person name (for individual licenses)

## `businessName` (type: `string`):

Firm/company name (for contractor licenses)

## `name` (type: `string`):

Merged name — businessName if available, else individual

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

Human-readable license type label

## `licenseCode` (type: `string`):

DPOR code (2701, 2705b, 2710 etc.)

## `board` (type: `string`):

Regulatory board code

## `occupation` (type: `string`):

Occupation code from DPOR

## `classification` (type: `string`):

License rank (A/B/C for contractors, TRAD for tradesmen)

## `specialties` (type: `string`):

Specialty/designation codes (MELE, CBC, RBC, H etc.)

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

Derived status: Active, Expired, or Unknown

## `issueDate` (type: `string`):

Certification/issue date (YYYY-MM-DD)

## `expirationDate` (type: `string`):

License expiration date (YYYY-MM-DD)

## `address` (type: `string`):

Full address (line 1 + line 2 + PO Box merged)

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

City

## `state` (type: `string`):

State abbreviation

## `zipCode` (type: `string`):

ZIP code (cleaned, no -0000 suffix)

## `country` (type: `string`):

Country (usually null for domestic)

## `email` (type: `string`):

Email address on file

## `scrapedAt` (type: `string`):

ISO timestamp when record was scraped

# 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 = {
    "licenseCodes": [
        "2701"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/virginia-dpor-license-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 = {
    "licenseCodes": ["2701"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/virginia-dpor-license-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 '{
  "licenseCodes": [
    "2701"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/virginia-dpor-license-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Virginia DPOR Professional License Scraper",
        "description": "Scrape contractor and tradesman license records from Virginia DPOR (Department of Professional and Occupational Regulation). Downloads bulk regulant lists — Class A/B/C contractors, electricians, plumbers, HVAC techs, gas fitters and more. No browser needed, direct file download.",
        "version": "0.0",
        "x-build-id": "7Qr0j7CulIHLC2HeO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~virginia-dpor-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-virginia-dpor-license-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/haketa~virginia-dpor-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-virginia-dpor-license-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/haketa~virginia-dpor-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-virginia-dpor-license-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",
                "properties": {
                    "licenseCodes": {
                        "title": "License Codes",
                        "type": "array",
                        "description": "DPOR license type codes to scrape. Each code downloads a separate regulant list file. Available codes: '2701' (Class A Contractor), '2705b' (Class B Contractor), '2705c' (Class C Contractor), '2710' (Tradesman Combined — ELE/PLB/HVA/GFC), '2709' (Residential Tradesman), '2717' (Backflow Prevention Device Worker), '2718' (Certified Elevator Mechanic), '2719' (Certified Water Well Systems Provider), '2722' (Residential Building Energy Analyst), '2723' (Automatic Fire Sprinkler Inspector). Leave empty to scrape all codes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statusFilter": {
                        "title": "License Status Filter",
                        "enum": [
                            "active",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter records by license status. 'active' = only active licenses, 'all' = include expired/suspended/revoked.",
                        "default": "all"
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total records to save across all license types. Set 0 for unlimited.",
                        "default": 200
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between file downloads in milliseconds. DPOR files are static, low delay is fine.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Usually not needed — DPOR serves public files without restrictions."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
