# California Cannabis License Search Scraper (`automation-lab/california-cannabis-license-search-scraper`) Actor

Export California Department of Cannabis Control license records with statuses, business names, contacts, addresses, dates, and coordinates.

- **URL**: https://apify.com/automation-lab/california-cannabis-license-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## California Cannabis License Search Scraper

Export public California Department of Cannabis Control (DCC) cannabis license records from the Cannabis Unified License Search.

This actor collects license numbers, statuses, business names, DBA names, owner names, addresses, counties, contact details, license dates, coordinates, and source metadata from the official California DCC public search API.

### What does this actor do?

The California Cannabis License Search Scraper turns the public DCC license search into a structured dataset.

It is designed for recurring compliance and market-monitoring workflows where teams need a machine-readable export instead of manually searching the state website.

Typical results include active and inactive licenses, legal business names, trade names, license types, issue dates, expiration dates, county, address, phone, email, latitude, longitude, and data refresh timestamps.

### Why use it?

California cannabis licensing data changes over time.

Operators open, close, surrender licenses, renew licenses, and update public contact or premise information.

A repeatable actor run helps you capture the same fields in the same format every time.

You can load the output into spreadsheets, CRMs, compliance systems, BI tools, or downstream enrichment pipelines.

### Data source

The actor uses the public California DCC Cannabis Unified License Search.

Website: https://search.cannabis.ca.gov/

Public API base: https://as-dcc-pub-cann-w-p-002.azurewebsites.net

No account, login, CAPTCHA solving, or private token is required for the default search workflow.

### Example use cases

- Monitor active cannabis retailers in a county.
- Build a lead list of licensed California cannabis businesses.
- Check license expiration dates before outreach.
- Compare license coverage by city or county.
- Feed compliance dashboards with official state license records.
- Enrich B2B vendor, insurance, lending, or real-estate datasets.
- Track surrendered, suspended, expired, or revoked licenses.
- Audit business names and DBA names against internal records.

### Who is it for?

This actor is useful for cannabis compliance teams, wholesalers, distributors, lenders, insurers, attorneys, consultants, real-estate teams, site-selection analysts, and B2B data providers.

It can also help journalists, researchers, and public-policy analysts who need structured access to California cannabis licensing data.

### Input overview

You can run the actor with a free-text search query, optional filters, and a maximum item limit.

Leave the query empty when you want to export all matching records.

Use filters when you need a narrower subset, such as active licenses in a specific county.

### Search query

The `searchQuery` field is passed to the DCC search endpoint.

It can match business names, DBA names, owners, addresses, cities, license numbers, or other searchable text supported by the public site.

Example queries:

- `dispensary`
- `Los Angeles`
- `C10-0000038-LIC`
- `cultivation`
- `delivery`

### Status filter

Use `licenseStatus` to narrow results by public license status.

Common values include:

- `Active`
- `Expired`
- `Surrendered`
- `Suspended`
- `Revoked`

The DCC API controls the exact values returned.

### License type filter

Use `licenseType` to focus on a business category.

Examples include retailer, distributor, cultivator, manufacturer, testing laboratory, microbusiness, event organizer, or other DCC license classifications.

Because public API values may contain prefixes or spacing, use the wording visible in the DCC search interface when you need exact filtering.

### Location filters

The actor supports county, city, and ZIP code filters.

Useful examples:

- `premiseCounty`: `Los Angeles`
- `premiseCounty`: `Riverside`
- `premiseCity`: `Sacramento`
- `premiseZipCode`: `92530`

Location filters are helpful for territory planning and local compliance checks.

### Pagination controls

`maxItems` controls how many license records are saved.

`pageSize` controls how many records are requested per API page and is capped at 100.

`startPage` lets you resume a large export from a later API page.

The default input is intentionally modest so test runs finish quickly.

### Detail endpoint option

The `includeDetails` option fetches `/licenses/{id}` for each license returned by search.

The default is `false` because the search response already includes the core fields most users need.

Turn this option on if you want the actor to verify detail endpoint data for every row.

For large exports, leaving it off is faster and cheaper.

### Output fields

The dataset can include these fields:

- `id`
- `licenseNumber`
- `licenseStatus`
- `licenseStatusDate`
- `licenseTerm`
- `licenseType`
- `licenseDesignation`
- `issueDate`
- `expirationDate`
- `licensingAuthorityId`
- `licensingAuthority`
- `businessLegalName`
- `businessDbaName`
- `businessOwnerName`
- `businessStructure`
- `activity`
- `premiseStreetAddress`
- `premiseCity`
- `premiseState`
- `premiseCounty`
- `premiseZipCode`
- `businessEmail`
- `businessPhone`
- `parcelNumber`
- `premiseLatitude`
- `premiseLongitude`
- `dataRefreshedDate`
- `source`
- `sourceUrl`
- `detailUrl`
- `scrapedAt`

### Example output item

```json
{
  "id": 6371,
  "licenseNumber": "C10-0000038-LIC",
  "licenseStatus": "Active",
  "licenseType": "Commercial -  Retailer",
  "licenseDesignation": "Adult-Use and Medicinal",
  "businessLegalName": "Lake Elsinore Community Investment Corp",
  "businessDbaName": "Mr Nice Guy Marijuana Cannabis Dispensary Lake Elsinore",
  "businessOwnerName": "Joseph Martin",
  "premiseCity": "Lake Elsinore",
  "premiseCounty": "Riverside",
  "businessEmail": "example@example.com",
  "businessPhone": "(949) 293-2370",
  "sourceUrl": "https://search.cannabis.ca.gov/results"
}
````

### How to run

1. Open the actor input page.
2. Enter a search query or leave it blank.
3. Add optional filters such as status or county.
4. Choose a maximum number of licenses.
5. Start the run.
6. Download the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Example input: active Riverside dispensaries

```json
{
  "searchQuery": "dispensary",
  "licenseStatus": "Active",
  "premiseCounty": "Riverside",
  "maxItems": 100,
  "pageSize": 100,
  "includeDetails": false
}
```

### Example input: statewide export sample

```json
{
  "searchQuery": "",
  "maxItems": 500,
  "pageSize": 100,
  "includeDetails": false
}
```

### Example input: one known license

```json
{
  "searchQuery": "C10-0000038-LIC",
  "maxItems": 10,
  "includeDetails": true
}
```

### Pricing

This actor uses pay-per-event pricing.

A small start event of $0.005 is charged once per run.

A license-record event is charged for each dataset item saved.

| Tier | Price per license record |
|---|---:|
| Free | $0.000025036 |
| Bronze | $0.00002177 |
| Silver | $0.000016981 |
| Gold | $0.000013062 |
| Platinum | $0.00001 |
| Diamond | $0.00001 |

Higher Apify plans receive volume discounts.

### Performance notes

The actor uses the public HTTP API directly and does not start a browser.

This keeps memory use low and makes large exports faster than browser automation.

The default page size is 100, which the API accepts during validation.

### Data freshness

The DCC API includes a `dataRefreshedDate` field on license records.

That timestamp comes from the source and is saved to the dataset when present.

The actor also adds `scrapedAt`, which records when the actor collected the row.

### Data quality notes

Some fields may contain `Data Not Available` or null values.

That reflects the public source data.

The actor does not invent missing emails, phone numbers, or parcel numbers.

Downstream workflows should treat blank values as unavailable public data.

### Limitations

The actor depends on the public DCC search API.

If California changes the API, field names, or filtering behavior, the actor may require an update.

The actor does not verify license compliance beyond returning public records.

It is not legal advice.

### Troubleshooting

If you receive fewer rows than expected, broaden the query or remove filters.

If an exact filter returns nothing, try the same wording in the DCC website and copy the visible value.

For very large exports, increase `maxItems` and keep `includeDetails` disabled unless you specifically need detail endpoint checks.

### Integration ideas

- Schedule the actor daily or weekly to monitor changes.
- Compare exports over time in a database.
- Trigger alerts for expiration dates or status changes.
- Join records to territory, sales, or lending pipelines.
- Use coordinates for mapping and site-selection analysis.

### API usage

You can run this actor from the Apify API, Apify Client libraries, schedules, integrations, or webhooks.

#### Node.js API example

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/california-cannabis-license-search-scraper').call({
  searchQuery: 'dispensary',
  licenseStatus: 'Active',
  premiseCounty: 'Riverside',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/california-cannabis-license-search-scraper').call(run_input={
    'searchQuery': 'dispensary',
    'licenseStatus': 'Active',
    'premiseCounty': 'Riverside',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL API example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~california-cannabis-license-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQuery":"dispensary","licenseStatus":"Active","premiseCounty":"Riverside","maxItems":20}'
```

### MCP

You can use this actor from MCP-compatible assistants through the Apify MCP server.

Example Claude CLI setup:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors automation-lab/california-cannabis-license-search-scraper
```

Example MCP server JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "automation-lab/california-cannabis-license-search-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts:

- "Run the California cannabis license scraper for active Riverside County dispensaries and summarize the business names."
- "Export 100 statewide California cannabis license records and identify records with missing email addresses."
- "Look up license C10-0000038-LIC and tell me the public status, owner, city, and expiration date."

The structured dataset output is suitable for agent workflows that need to answer questions such as "which active retailers are in Riverside County?" or "which licenses expire soon?".

### Legality and compliance

The data is public licensing information, but your use of it may be subject to internal policies, customer contracts, outreach rules, or regulatory requirements.

Review your intended use before contacting businesses or making compliance decisions.

This actor returns source data and does not provide legal advice.

### FAQ

#### Does this actor require a California DCC account?

No. It uses the public license search API.

#### Can I export all California cannabis licenses?

Yes. Leave `searchQuery` empty and raise `maxItems` to the number of records you need.

#### Why are some emails or parcel numbers missing?

The actor preserves the public source values. Missing or `Data Not Available` fields mean the DCC API did not provide that data for the record.

#### Does the actor use a browser?

No. It uses the public HTTP API directly.

### Related actors

This actor fits a cannabis compliance and licensing-data workflow alongside other state cannabis license scrapers, business directory scrapers, government registry scrapers, and lead-enrichment actors.

Use it as the California source in a broader state-by-state license monitoring pipeline.

### Support

If the actor stops returning data, include your run ID, input, and a short description of the expected records when reporting the issue.

This helps reproduce the problem against the public DCC API quickly.

### Changelog

Initial version exports California DCC cannabis license search records with pagination, filters, optional detail fetching, and structured dataset output.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text query for license number, business name, owner, address, city, county, or other searchable DCC fields. Leave empty to export all matching licenses.

## `licenseStatus` (type: `string`):

Optional status filter, for example Active, Expired, Revoked, Suspended, or Surrendered.

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

Optional DCC license type filter such as Retailer, Distributor, Cultivator, Manufacturer, Testing Laboratory, or Microbusiness.

## `licenseDesignation` (type: `string`):

Optional designation filter, for example Adult-Use and Medicinal.

## `licensingAuthority` (type: `string`):

Optional historical licensing authority filter such as Bureau of Cannabis Control (BCC).

## `premiseCounty` (type: `string`):

Optional California county filter, for example Los Angeles, Riverside, Alameda, or Sacramento.

## `premiseCity` (type: `string`):

Optional city filter for the licensed premise.

## `premiseZipCode` (type: `string`):

Optional ZIP code filter for the licensed premise.

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

Maximum number of license records to save. Increase this to export more of the statewide public registry.

## `pageSize` (type: `integer`):

Number of records requested per API page. The actor caps this at 100, which is accepted by the public DCC API.

## `startPage` (type: `integer`):

Start from a later API page when resuming a large export.

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

Fetch /licenses/{id} for each row. The search API already returns the main fields, so leave this off for faster large runs.

## Actor input object example

```json
{
  "searchQuery": "dispensary",
  "licenseStatus": "Active",
  "premiseCounty": "Riverside",
  "maxItems": 20,
  "pageSize": 20,
  "startPage": 1,
  "includeDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchQuery": "dispensary",
    "licenseStatus": "Active",
    "premiseCounty": "Riverside",
    "maxItems": 20,
    "pageSize": 20,
    "startPage": 1,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/california-cannabis-license-search-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 = {
    "searchQuery": "dispensary",
    "licenseStatus": "Active",
    "premiseCounty": "Riverside",
    "maxItems": 20,
    "pageSize": 20,
    "startPage": 1,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/california-cannabis-license-search-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 '{
  "searchQuery": "dispensary",
  "licenseStatus": "Active",
  "premiseCounty": "Riverside",
  "maxItems": 20,
  "pageSize": 20,
  "startPage": 1,
  "includeDetails": false
}' |
apify call automation-lab/california-cannabis-license-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "California Cannabis License Search Scraper",
        "description": "Export California Department of Cannabis Control license records with statuses, business names, contacts, addresses, dates, and coordinates.",
        "version": "0.1",
        "x-build-id": "KpPkz93jdw97h45gg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~california-cannabis-license-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-california-cannabis-license-search-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/automation-lab~california-cannabis-license-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-california-cannabis-license-search-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/automation-lab~california-cannabis-license-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-california-cannabis-license-search-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query for license number, business name, owner, address, city, county, or other searchable DCC fields. Leave empty to export all matching licenses."
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "type": "string",
                        "description": "Optional status filter, for example Active, Expired, Revoked, Suspended, or Surrendered."
                    },
                    "licenseType": {
                        "title": "License type",
                        "type": "string",
                        "description": "Optional DCC license type filter such as Retailer, Distributor, Cultivator, Manufacturer, Testing Laboratory, or Microbusiness."
                    },
                    "licenseDesignation": {
                        "title": "License designation",
                        "type": "string",
                        "description": "Optional designation filter, for example Adult-Use and Medicinal."
                    },
                    "licensingAuthority": {
                        "title": "Licensing authority",
                        "type": "string",
                        "description": "Optional historical licensing authority filter such as Bureau of Cannabis Control (BCC)."
                    },
                    "premiseCounty": {
                        "title": "Premise county",
                        "type": "string",
                        "description": "Optional California county filter, for example Los Angeles, Riverside, Alameda, or Sacramento."
                    },
                    "premiseCity": {
                        "title": "Premise city",
                        "type": "string",
                        "description": "Optional city filter for the licensed premise."
                    },
                    "premiseZipCode": {
                        "title": "Premise ZIP code",
                        "type": "string",
                        "description": "Optional ZIP code filter for the licensed premise."
                    },
                    "maxItems": {
                        "title": "Maximum licenses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of license records to save. Increase this to export more of the statewide public registry.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of records requested per API page. The actor caps this at 100, which is accepted by the public DCC API.",
                        "default": 20
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Start from a later API page when resuming a large export.",
                        "default": 1
                    },
                    "includeDetails": {
                        "title": "Fetch detail endpoint",
                        "type": "boolean",
                        "description": "Fetch /licenses/{id} for each row. The search API already returns the main fields, so leave this off for faster large runs.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
