# CSLB California Contractor License Scraper (`ws_tony/cslb-california-scraper`) Actor

Bulk CSLB contractor license scraper for California. Full public record per license: status, all classifications, bond info, workers-comp, disciplinary actions, personnel. Search by license number or business name; narrow by city, county, ZIP, classification, or status. Pay-per-result.

- **URL**: https://apify.com/ws\_tony/cslb-california-scraper.md
- **Developed by:** [Tony](https://apify.com/ws_tony) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.

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

## CSLB California Contractor License Scraper

> Bulk-scrape California contractor licenses from the CSLB (Contractors State License Board) public database. One result = one California contractor's **full public record** — license status, all classifications, bond info, workers-comp coverage, disciplinary history, personnel, and addresses.

Built for compliance teams verifying subcontractors, insurance underwriters pricing contractor policies, construction PMs vetting subs, and B2B sales teams prospecting California contractors (roofing, HVAC, electrical, plumbing, general building — every CSLB classification is searchable).

### What makes this actor different

CSLB publishes one of the richest public contractor datasets of any state board — bond info, workers-comp, and disciplinary history are all on file. **Most competing CSLB scrapers return only license number, name, and status.** This actor returns all of it, with a stable JSON schema.

| Feature | This actor | Typical CSLB actor |
|---|---|---|
| Search by license number | ✅ | ✅ |
| Search by business name | ✅ | Partial |
| Narrow by city / county / ZIP / classification / status | ✅ | ❌ |
| All license classifications per row | ✅ | Primary only |
| Bond info (company, amount, effective / cancellation dates) | ✅ | ❌ |
| Workers-comp (carrier, policy number, effective / expiration dates) | ✅ | ❌ |
| Disciplinary actions | ✅ | ❌ |
| ZIP → county auto-fill (all 58 CA counties) | ✅ | ❌ |
| Transparent pay-per-result pricing | ✅ | Often pay-per-event, opaque |

### How search works

Pick ONE **primary search** field:

- `licenseNumber` — direct lookup (fastest, cheapest)
- `businessName` — partial or full, matched case-insensitively against **both the legal business name and associated personnel/owner names**. `"Acme"` matches `"Acme Construction Co"`, `"Acme Plumbing Inc"`, etc.; `"Smith"` also matches `"Johnie Cement Work"` (owned by John Smith). If you need strict business-name-only matching, filter downstream on the `business_name` output field.

Optionally **narrow the results** with any combination of `city`, `county`, `zipCode`, `classification`, and `status`. These filters apply client-side after the primary search (CSLB doesn't publish a way to enumerate contractors by city/county alone — so a primary search is required).

### Example inputs

**Single-license lookup** — cheapest, one record:

```json
{
    "licenseNumber": "123456"
}
````

**Find SMITH-named contractors in the City of Los Angeles, cap at 25:**

```json
{
    "businessName": "SMITH",
    "city": "Los Angeles",
    "maxResults": 25
}
```

**Find every "Green Building" in the ZIP 94703, active status:**

```json
{
    "businessName": "Green Building",
    "zipCode": "94703",
    "status": "active"
}
```

**Bulk scrape "Acme" businesses, cap at 1,000:**

```json
{
    "businessName": "Acme",
    "maxResults": 1000
}
```

### Example output (one record)

```json
{
    "license_number": "123456",
    "business_name": "ACME CONSTRUCTION CO",
    "business_address": "123 MAIN ST, LOS ANGELES, CA 90012",
    "business_phone": "(213) 555-1234",
    "mailing_address": null,
    "city": "Los Angeles",
    "county": "Los Angeles",
    "zip_code": "90012",
    "issue_date": "2015-06-14",
    "expiration_date": "2026-06-30",
    "status": "active",
    "entity_type": "corporation",
    "classifications": [
        { "code": "B", "description": "GENERAL BUILDING CONTRACTOR" },
        { "code": "C-10", "description": "ELECTRICAL" }
    ],
    "qualifiers": [
        { "name": "JANE SMITH", "association": "RESPONSIBLE MANAGING OFFICER" }
    ],
    "bonds": [
        {
            "type": "contractor_bond",
            "company": "OLD REPUBLIC SURETY",
            "amount_usd": 25000,
            "effective_date": "2023-07-01",
            "cancellation_date": null
        }
    ],
    "workers_comp": {
        "carrier": "STATE COMPENSATION INSURANCE FUND",
        "policy_number": "9999999",
        "effective_date": "2024-01-01",
        "expiration_date": "2025-01-01"
    },
    "disciplinary_actions": [],
    "source_url": "https://www.cslb.ca.gov/OnlineServices/CheckLicenseII/LicenseDetail.aspx?LicNum=123456",
    "scraped_at": "2026-04-22T10:00:00.000Z"
}
```

#### Field notes

- `license_number` is the stable primary key — use it to deduplicate across runs.
- `classifications`, `qualifiers`, `bonds`, and `disciplinary_actions` are always arrays (may be empty `[]`, never `null`).
- `workers_comp` is an object or `null` (null when the contractor has a valid exemption).
- `county` is derived from `zip_code` via a bundled 2,623-ZIP California crosswalk; out-of-state mailing addresses return `null`.
- `mailing_address` is always `null` from this source — CSLB's detail page does not expose it separately from the business address. (Kept in schema for downstream compatibility.)
- Dates are ISO-8601 (`YYYY-MM-DD`); `scraped_at` is ISO-8601 UTC.

### Common use cases

- **Lead generation** for companies selling TO California contractors — insurance, fleet, SaaS, equipment, supplies, workwear. Filter by classification (C-10 electrical, C-36 plumbing, C-20 HVAC, C-33 painting, C-39 roofing, C-27 landscaping, B general building, A general engineering) and `status: active` for a clean ICP list.
- **Subcontractor due diligence** — verify license status, bond coverage, workers-comp, and disciplinary history before hiring. Pull by `licenseNumber` or business name.
- **Insurance underwriting** — score contractors by active disciplinary actions, bond cancellation history, and workers-comp status.
- **Compliance monitoring** — schedule weekly runs to flag newly expired, suspended, or revoked licenses in your vendor list.
- **Market research** — count active C-10 electrical contractors per county, map bond-amount distributions, track new-license issuance trends.

### Pricing

Pay-per-result. See the Store listing for the current per-1,000-records rate.

Only fully-formed records are pushed to the Dataset. If a scrape fails mid-record we discard the row — **you don't pay for broken data**. The `maxResults` input caps spend per run.

### Limitations

- **California only.** For Texas licenses, see the companion TDLR Texas Contractor License Scraper. For other states, see the portfolio.
- **No email addresses.** CSLB's public record set does not include contractor emails — only business phone and address. For email enrichment, feed the business name + address to LinkedIn, Apollo, ZoomInfo, or Clearbit downstream.
- **Mailing address is always `null`.** CSLB's public detail page does not separate mailing from business address.
- **Disciplinary action summaries are short codes only** (e.g. `"10/16/2023 - WC EXEMPT CANCELLED-LIC INACTIVATED"`). Full complaint narratives live on a separate CSLB page and are not scraped here.
- **Workers-comp data lags real-world changes** by up to ~30 days (CSLB filing delay, not this actor).
- CSLB occasionally rate-limits aggressive scraping. Default `maxConcurrency: 8` and 3 retries handle this; lower concurrency further if needed.
- **Not affiliated with CSLB or the State of California.** Only publicly available data is scraped.

### FAQ

**Is scraping CSLB legal?** Yes. California license data is public record by statute (Business and Professions Code §7000 et seq.) and explicitly published by CSLB for public use. This actor does not use login, does not bypass any paywall, and collects only data CSLB publishes on its public license-check pages.

**Does this include contractor email addresses?** No — CSLB's public record set does not include email. You get `business_phone` and `business_address` on every record (plus a full personnel list with names and titles). If you need emails, pipe `business_name` + `business_address` into LinkedIn Sales Navigator, Apollo, ZoomInfo, or Clearbit — the combo resolves most CA contractors cleanly.

**Why does `businessName: "Smith"` return a contractor whose business name doesn't contain "Smith"?** CSLB's name search matches against **both the legal business name and associated personnel/owner names**. So `"Smith"` returns `Smith Construction Co` (business-name match) *and* `Johnie Cement Work` owned by John Smith (personnel match). This is useful for due-diligence and background-check workflows — you can find every CA license associated with a person, not just the ones with their name on the door. If you need strict business-name-only matching, filter the output downstream on the `business_name` field.

**How fresh is the data?** Each record is scraped live at run time — data is as current as CSLB's published detail page (typically same-day for most fields; workers-comp and bond filings can lag 1–30 days upstream of CSLB).

**Can I run this on a schedule?** Yes. Apify Schedules handles cron. Weekly is a common cadence for keeping a contractor database fresh; daily is fine for narrow active-status monitoring.

**How do I export to Google Sheets / CSV / Airbyte / my database?** Every field is available via the Apify Dataset API in JSON, CSV, Excel, and HTML formats. Native integrations cover Zapier, Make, n8n, Airbyte, and direct Google Sheets push.

**Can I call this from Claude / Cursor / Cline or another MCP client?** Yes — any Apify actor is callable via Apify's official MCP server. Point your MCP client at `apify-mcp-server` and invoke this actor with the same input shape documented above.

**Why isn't there a "search everything" option (no primary filter)?** CSLB's public search doesn't expose a way to enumerate every California contractor — you must search by license number or business name (which as noted above also matches personnel/owner names). City, county, ZIP, and classification are narrowing filters only. This is a CSLB constraint, not a product choice.

**How do I deduplicate across runs?** Use `license_number` — it's CSLB's stable primary key. Re-running the same search returns the same license numbers.

**Can you add TDLR Texas / Florida DBPR / other state contractor boards?** Yes — that's the roadmap. Each state ships as a separate actor so you only pay for the states you need.

### Changelog

- `0.1` (April 2026) — Initial release. Direct license lookup, business-or-owner-name search with pagination (matches CSLB's native business + personnel name index), post-filters for city/county/ZIP/classification/status, ZIP→county auto-fill for all 58 California counties, normalized status and classification codes, full schema per record.

# Actor input Schema

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

Exact CSLB license number (e.g. '123456'). Use this for a direct single-record lookup — the fastest and cheapest path. If set, other search fields are ignored.

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

Full or partial name. CSLB matches case-insensitively against the legal business name AND associated personnel/owner names — so 'Smith' returns both 'Smith Construction Co' (business name) and 'Johnie Cement Work' (owned by John Smith). This is how CSLB's native search works — use the narrow-results filters below (city, county, ZIP, classification, status) to tighten your ICP.

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

Narrow the primary search to a California city, e.g. 'Los Angeles'. Matched case-insensitively against the business address city.

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

Narrow to a California county, e.g. 'Los Angeles', 'Orange', 'San Diego'. Do not include the word 'County'. ZIP-to-county mapping is applied automatically.

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

5-digit California ZIP code, e.g. '90012'.

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

CSLB classification code. Common codes: 'B' (General Building), 'A' (General Engineering), 'C-10' (Electrical), 'C-36' (Plumbing), 'C-20' (HVAC), 'C-33' (Painting), 'C-39' (Roofing), 'C-27' (Landscaping). See cslb.ca.gov for the full classification list.

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

Filter by current license status. 'Active' is the common choice for lead-generation and insurance use cases.

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

Hard cap on records pushed to the Dataset. Protects you from accidental large runs — billing is per record pushed. Start low (50–100) to validate output quality before scaling up.

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

Apify Proxy is recommended and covers most runs. Switch to residential only if you see repeated blocks on CSLB (very rare).

## `maxConcurrency` (type: `integer`):

Parallel request slots. Measured peak throughput plateaus at concurrency 4 for this actor because search pagination is inherently sequential. Default 8 gives a safe margin; lower to 2–4 for the gentlest footprint.

## Actor input object example

```json
{
  "licenseNumber": "123456",
  "businessName": "Acme Construction",
  "status": "any",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "maxConcurrency": 8
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("ws_tony/cslb-california-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    } }

# Run the Actor and wait for it to finish
run = client.actor("ws_tony/cslb-california-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call ws_tony/cslb-california-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CSLB California Contractor License Scraper",
        "description": "Bulk CSLB contractor license scraper for California. Full public record per license: status, all classifications, bond info, workers-comp, disciplinary actions, personnel. Search by license number or business name; narrow by city, county, ZIP, classification, or status. Pay-per-result.",
        "version": "0.1",
        "x-build-id": "XayloFfRcapm6rpu8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ws_tony~cslb-california-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ws_tony-cslb-california-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/ws_tony~cslb-california-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ws_tony-cslb-california-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/ws_tony~cslb-california-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ws_tony-cslb-california-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": {
                    "licenseNumber": {
                        "title": "License number (primary search)",
                        "type": "string",
                        "description": "Exact CSLB license number (e.g. '123456'). Use this for a direct single-record lookup — the fastest and cheapest path. If set, other search fields are ignored."
                    },
                    "businessName": {
                        "title": "Business or owner name (primary search)",
                        "type": "string",
                        "description": "Full or partial name. CSLB matches case-insensitively against the legal business name AND associated personnel/owner names — so 'Smith' returns both 'Smith Construction Co' (business name) and 'Johnie Cement Work' (owned by John Smith). This is how CSLB's native search works — use the narrow-results filters below (city, county, ZIP, classification, status) to tighten your ICP."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Narrow the primary search to a California city, e.g. 'Los Angeles'. Matched case-insensitively against the business address city."
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Narrow to a California county, e.g. 'Los Angeles', 'Orange', 'San Diego'. Do not include the word 'County'. ZIP-to-county mapping is applied automatically."
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "5-digit California ZIP code, e.g. '90012'."
                    },
                    "classification": {
                        "title": "License classification",
                        "type": "string",
                        "description": "CSLB classification code. Common codes: 'B' (General Building), 'A' (General Engineering), 'C-10' (Electrical), 'C-36' (Plumbing), 'C-20' (HVAC), 'C-33' (Painting), 'C-39' (Roofing), 'C-27' (Landscaping). See cslb.ca.gov for the full classification list."
                    },
                    "status": {
                        "title": "License status",
                        "enum": [
                            "any",
                            "active",
                            "expired",
                            "suspended",
                            "revoked",
                            "canceled",
                            "inactive"
                        ],
                        "type": "string",
                        "description": "Filter by current license status. 'Active' is the common choice for lead-generation and insurance use cases.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on records pushed to the Dataset. Protects you from accidental large runs — billing is per record pushed. Start low (50–100) to validate output quality before scaling up.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is recommended and covers most runs. Switch to residential only if you see repeated blocks on CSLB (very rare)."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Parallel request slots. Measured peak throughput plateaus at concurrency 4 for this actor because search pagination is inherently sequential. Default 8 gives a safe margin; lower to 2–4 for the gentlest footprint.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
