# Oregon Contractor License Scraper — CCB (`haketa/oregon-contractor-scraper`) Actor

Extract licensed contractors from the Oregon Construction Contractors Board (CCB). Get license number, business name, phone, address, license type, bond & liability insurance details, RMI and expiry date — for B2B leads, insurance, compliance & market research.

- **URL**: https://apify.com/haketa/oregon-contractor-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## Oregon Contractor License Scraper — CCB

Extract **licensed contractors from the Oregon Construction Contractors Board (CCB)** — the official registry of licensed contractors in Oregon. Filter by county and license type, and get clean records for every contractor: **license number, business name, phone, address, license type, bond details, liability insurance, responsible managing individual (RMI), endorsements and expiry date**.

No code, no login. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, HubSpot, Make, Zapier and n8n.

> **🏗️ Built for B2B lead generation, compliance & insurance.** Every record carries the **license, phone, bond and liability-insurance details** — a rare combination that makes this ideal for insurance, bonding, supplier and compliance use cases.

---

### 📋 What this scraper does

The Oregon CCB licenses every construction contractor operating in the state (~56,000 licensees). This actor turns that public registry into a clean, structured dataset you can filter, analyse or feed into a CRM.

Pick your counties and license types, and it will:

- ✅ Collect every matching licensed contractor
- ✅ Return the **license number, type and status** (Active / Expired)
- ✅ Capture the **business name, phone and full address**
- ✅ Include **bond company + amount** and **liability insurance company + amount**
- ✅ Add the **Responsible Managing Individual (RMI)** and **endorsements**
- ✅ Report license and registration dates
- ✅ Filter to **active licenses only** and by **license type**
- ✅ De-duplicate every contractor by license number

---

### ⭐ Why choose this scraper

- **Bond + insurance details.** Most state registries don't publish these — Oregon does, and this actor captures them. Perfect for insurance and surety products.
- **Official license data.** Straight from the Oregon Construction Contractors Board.
- **Ready-to-use leads.** Business name, phone and address for every licensed contractor.
- **Trade & region targeting.** Filter by license type (residential/commercial/specialty) and county.
- **Fast and complete.** The entire state in a single run — no anti-bot, no slow browser.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Insurance & bonding** | Reach contractors by type, bond and insurance limits for liability, WC and surety products. |
| **B2B lead generation** | Build targeted lists of licensed contractors for suppliers, SaaS and services. |
| **License & compliance verification** | Check license number, status, expiry, bond and insurance for due diligence. |
| **Construction market research** | Measure contractors, types and coverage across Oregon counties. |
| **Supplier & distributor sales** | Find contractors by type and county to sell materials and equipment. |
| **Data products & dashboards** | Feed a clean licensed-contractor feed into BI tools or a database. |

---

### 🚀 Quick start

1. (Optional) Enter one or more **Counties** (e.g. `Multnomah`, `Washington`, `Lane`).
2. (Optional) Pick **License types** (e.g. `RGC — Residential General Contractor`).
3. Keep **Active licenses only** on for outreach.
4. Set **Max contractors** and click **Start**.
5. Download your data from the **Storage → Dataset** tab.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Counties** | array | Oregon counties, e.g. `Multnomah`, `Washington`, `Clackamas`, `Lane`. Empty = all of Oregon. |
| **License types** | multi-select | Filter by CCB license type (RGC, RSC, CGC1/2, CSC1/2, LBPR, ...). Empty = all. |
| **Active licenses only** | boolean | Keep only non-expired licenses (recommended). |
| **Max contractors** | integer | Cap on total contractors. `0` = all (~56,000). |
| **Proxy** | object | Optional — the open-data API has no anti-bot. |

#### Example 1 — Residential general contractors in Portland metro

```json
{
  "counties": ["Multnomah", "Washington", "Clackamas"],
  "licenseTypes": ["RGC"],
  "activeOnly": true,
  "maxItems": 2000
}
````

#### Example 2 — All commercial contractors statewide

```json
{
  "licenseTypes": ["CGC1", "CGC2", "CSC1", "CSC2"],
  "activeOnly": true,
  "maxItems": 5000
}
```

#### Example 3 — Everything in Lane County

```json
{
  "counties": ["Lane"],
  "activeOnly": true,
  "maxItems": 1000
}
```

***

### 📦 Output

Each contractor becomes one dataset record:

```json
{
  "licenseNumber": "100310",
  "businessName": "HABITAT FOR HUMANITY PORTLAND METRO EAST",
  "licenseType": "RGC",
  "status": "Active",
  "phone": "9713034180",
  "address": "...",
  "city": "PORTLAND",
  "state": "OR",
  "zip": "97211",
  "county": "Multnomah",
  "rmiName": "JESSE GUINN WITHERS",
  "bondCompany": "TRAVELERS CASUALTY & SURETY CO OF AMERICA",
  "bondAmount": "25000",
  "bondExpires": "07/30/2026",
  "insuranceCompany": "ACE AMERICAN INSURANCE CO",
  "insuranceAmount": "1000000",
  "insuranceExpires": "07/30/2026",
  "endorsements": "Residential General Contractor",
  "licenseExpires": "07/30/2026",
  "originalRegistration": "06/20/1994",
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `licenseNumber` | CCB license number (used for de-duplication). |
| `businessName` | Business / licensee name. |
| `licenseType` | License type (RGC, RSC, CGC1/2, ...). |
| `status` | Active or Expired (by license expiry date). |
| `phone` / `address` / `city` / `state` / `zip` | Contact and location. |
| `county` | Oregon county. |
| `rmiName` | Responsible Managing Individual. |
| `bondCompany` / `bondAmount` / `bondExpires` | Surety bond details. |
| `insuranceCompany` / `insuranceAmount` / `insuranceExpires` | Liability insurance details. |
| `endorsements` | License endorsements. |
| `licenseExpires` / `originalRegistration` | License dates. |
| `scrapedAt` | Extraction timestamp. |

***

### 🏗️ License types

`RGC` Residential General Contractor · `RSC` Residential Specialty Contractor · `CGC1/CGC2` Commercial General Contractor (Level 1/2) · `CSC1/CSC2` Commercial Specialty Contractor (Level 1/2) · `LBPR` Lead-Based Paint Renovator · `RLC` Residential Limited Contractor · `RD/CD` Developer · plus locksmith, home inspector, home services and energy-score endorsements.

***

### 🗺️ Counties

All 36 Oregon counties are supported — e.g. **Multnomah (Portland), Washington, Clackamas, Lane (Eugene), Marion (Salem), Deschutes (Bend), Jackson (Medford)**. Leave empty for the whole state.

***

### 🧭 Tips for best results

- **Use bond & insurance fields** — they're the differentiator for insurance and surety outreach.
- **Filter by license type** to target residential vs commercial contractors.
- **Keep `activeOnly` on** for outreach; turn it off for full historical coverage.
- **Leave counties empty** for the whole state in one run.
- **Schedule runs** to track new licenses, renewals and expirations over time.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **CRM / Sheets / Airtable / Make / Zapier / n8n:** push results automatically.
- **API:** run and fetch data with the Apify API or the JS / Python clients.
- **Scheduling:** run on a schedule to keep an always-fresh contractor database.

***

### ❓ FAQ

**Do I need a CCB account or API key?**
No. You only need an Apify account.

**Which contractors are covered?**
Every contractor licensed by the Oregon Construction Contractors Board (~56,000).

**Does it include bond and insurance?**
Yes — bond company/amount and liability insurance company/amount are included, which most states don't publish.

**Is email included?**
No — the CCB registry publishes phone and address, not email. Phone is on nearly every record.

**Does it return duplicates?**
No. Contractors are de-duplicated by license number.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** license information that the Oregon Construction Contractors Board publishes as open data. It does not log in or access private data. Respect the Board's terms of use and applicable law, and use the data for lawful purposes such as license verification, compliance, insurance, market research and B2B outreach.

***

### 🛟 Support

Need an extra field or hit an issue? Open a ticket from the actor's **Issues** tab with your input configuration.

Happy sourcing! 🏗️

# Actor input Schema

## `counties` (type: `array`):

Oregon counties to include, e.g. "Multnomah", "Washington", "Clackamas", "Lane", "Deschutes". Leave empty for all of Oregon.

## `licenseTypes` (type: `array`):

Filter by Oregon CCB license type. Leave empty for all types.

## `activeOnly` (type: `boolean`):

Keep only contractors whose license has not expired (recommended for outreach).

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

Maximum number of contractors to return. Set 0 for no limit (all ~56,000).

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

Apify Proxy settings. The Oregon open-data API has no anti-bot, so a proxy is optional.

## Actor input object example

```json
{
  "counties": [],
  "activeOnly": true,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

CCB license number

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

Business / licensee name

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

License type (RGC, RSC, ...)

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

Active or Expired (by license expiry date)

## `phone` (type: `string`):

Phone number

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

Street address

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

City

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

State

## `zip` (type: `string`):

ZIP code

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

Oregon county

## `rmiName` (type: `string`):

Responsible managing individual

## `bondCompany` (type: `string`):

Surety bond company

## `bondAmount` (type: `string`):

Bond amount

## `bondExpires` (type: `string`):

Bond expiry date

## `insuranceCompany` (type: `string`):

Liability insurance company

## `insuranceAmount` (type: `string`):

Insurance amount

## `insuranceExpires` (type: `string`):

Insurance expiry date

## `endorsements` (type: `string`):

License endorsements

## `licenseExpires` (type: `string`):

License expiry date

## `originalRegistration` (type: `string`):

Original registration date

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

Extraction timestamp

# 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 = {
    "counties": [],
    "maxItems": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/oregon-contractor-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 = {
    "counties": [],
    "maxItems": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/oregon-contractor-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 '{
  "counties": [],
  "maxItems": 1000
}' |
apify call haketa/oregon-contractor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Oregon Contractor License Scraper — CCB",
        "description": "Extract licensed contractors from the Oregon Construction Contractors Board (CCB). Get license number, business name, phone, address, license type, bond & liability insurance details, RMI and expiry date — for B2B leads, insurance, compliance & market research.",
        "version": "0.1",
        "x-build-id": "CU6fCY5htHcaC5heU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~oregon-contractor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-oregon-contractor-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~oregon-contractor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-oregon-contractor-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~oregon-contractor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-oregon-contractor-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": {
                    "counties": {
                        "title": "Counties",
                        "type": "array",
                        "description": "Oregon counties to include, e.g. \"Multnomah\", \"Washington\", \"Clackamas\", \"Lane\", \"Deschutes\". Leave empty for all of Oregon.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseTypes": {
                        "title": "License types",
                        "type": "array",
                        "description": "Filter by Oregon CCB license type. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RGC",
                                "RSC",
                                "CGC1",
                                "CGC2",
                                "CSC1",
                                "CSC2",
                                "LBPR",
                                "RLC",
                                "RD",
                                "CD",
                                "RLSC",
                                "RHISC",
                                "OCHI",
                                "OCLS",
                                "RHSC",
                                "RHEPSC",
                                "CF",
                                "RRC"
                            ],
                            "enumTitles": [
                                "RGC — Residential General Contractor",
                                "RSC — Residential Specialty Contractor",
                                "CGC1 — Commercial General Contractor Level 1",
                                "CGC2 — Commercial General Contractor Level 2",
                                "CSC1 — Commercial Specialty Contractor Level 1",
                                "CSC2 — Commercial Specialty Contractor Level 2",
                                "LBPR — Lead-Based Paint Renovator",
                                "RLC — Residential Limited Contractor",
                                "RD — Residential Developer",
                                "CD — Commercial Developer",
                                "RLSC — Residential Locksmith Services",
                                "RHISC — Residential Home Inspector Services",
                                "OCHI — Home Inspector Certification",
                                "OCLS — Locksmith Certification",
                                "RHSC — Residential Home Services",
                                "RHEPSC — Home Energy Performance Score",
                                "CF — Contractor (other)",
                                "RRC — Restoration Contractor"
                            ]
                        }
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "Keep only contractors whose license has not expired (recommended for outreach).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max contractors",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of contractors to return. Set 0 for no limit (all ~56,000).",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. The Oregon open-data API has no anti-bot, so a proxy is optional.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```