# Weedmaps Scraper — Cannabis Dispensaries & Products (`crawlerbros/weedmaps-scraper`) Actor

Scrape Weedmaps.com for cannabis dispensaries, products, and deals. Filter by state, city, dispensary type, product category, strain type, and more. Returns ratings, hours, menus, THC/CBD content, pricing and availability.

- **URL**: https://apify.com/crawlerbros/weedmaps-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Integrations
- **Stats:** 1 total users, 0 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Weedmaps Scraper — Cannabis Dispensaries, Products & Deals

Scrape Weedmaps.com for cannabis dispensaries, delivery services, products, and deals. Filter by state, city, dispensary type, product category, strain type, rating, and more. Returns comprehensive data including ratings, hours, menus, THC/CBD content, pricing, and availability.

### What it does

- **Dispensaries** — search storefronts, delivery services, and medical marijuana doctors by state/city
- **Products** — search cannabis products (flower, edibles, concentrates, vapes, etc.) with strain type, THC/CBD levels, and pricing
- **Deals** — find current dispensary promotions and discounts by state

No API key or account required. Uses Weedmaps' public discovery API.

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `dispensaries` (default), `products`, `deals` |
| `stateSlug` | select | US state or Canadian province (e.g., `california`, `colorado`) |
| `citySlug` | string | City slug for narrower search (e.g., `los-angeles`, `denver`) |
| `dispensaryType` | select | `dispensary`, `delivery`, or `doctor` |
| `productCategory` | select | Product category: flower, edible, concentrate, vape, etc. |
| `searchQuery` | string | Free-text product search (mode=products) |
| `strainType` | select | `indica`, `sativa`, `hybrid`, `cbd` |
| `licenseType` | select | `recreational`, `medical`, or `hybrid` |
| `isVerified` | boolean | Verified listings only |
| `hasDelivery` | boolean | Only dispensaries with delivery |
| `hasPickup` | boolean | Only dispensaries with pickup |
| `isOpenNow` | boolean | Only currently open dispensaries |
| `minRating` | number | Minimum star rating (0–5) |
| `maxItems` | integer | Max results (1–500, default 20) |

#### Example inputs

**California dispensaries:**
```json
{
  "mode": "dispensaries",
  "stateSlug": "california",
  "maxItems": 20
}
````

**Flower products in Colorado:**

```json
{
  "mode": "products",
  "stateSlug": "colorado",
  "productCategory": "flower",
  "strainType": "sativa",
  "maxItems": 30
}
```

**Deals in Los Angeles:**

```json
{
  "mode": "deals",
  "stateSlug": "california",
  "citySlug": "los-angeles",
  "maxItems": 25
}
```

**Delivery services in Denver:**

```json
{
  "mode": "dispensaries",
  "stateSlug": "colorado",
  "citySlug": "denver",
  "dispensaryType": "delivery",
  "hasDelivery": true,
  "maxItems": 20
}
```

### Output — Dispensary records

| Field | Description |
|---|---|
| `name` | Dispensary name |
| `slug` | URL slug |
| `url` | Weedmaps listing URL |
| `wmid` | Weedmaps' internal numeric dispensary ID |
| `type` | Type: `dispensary`, `delivery`, or `doctor` |
| `address` | Street address |
| `city` | City |
| `state` | State name |
| `zipCode` | ZIP/postal code |
| `country` | Country |
| `lat` | Latitude |
| `lng` | Longitude |
| `phone` | Phone number |
| `email` | Email address |
| `licenseType` | License type: `recreational`, `medical`, `hybrid` |
| `rating` | Star rating (0–5) |
| `reviewCount` | Number of reviews |
| `isOpen` | Currently open (boolean) |
| `todaysHours` | Today's hours string |
| `timezone` | Timezone |
| `services` | Available services list |
| `hasDelivery` | Offers delivery (boolean) |
| `hasPickup` | Offers pickup (boolean) |
| `hasCurbsidePickup` | Offers curbside pickup |
| `paymentMethods` | Accepted payments |
| `avatarUrl` | Logo/avatar image URL |
| `menuItemsCount` | Total menu item count |
| `hasFeaturedDeal` | Has active featured deal |
| `hasSaleItems` | Has at least one item currently on sale (boolean) |
| `closesInMinutes` | Minutes until closing (when open) |
| `hasAgeGate` | Requires an age-verification gate to view the menu (boolean) |
| `minAge` | Minimum age required, when `hasAgeGate` is true |
| `endorsementBadgeCount` | Number of customer endorsement badges |
| `promoCode` | Active storewide promo code, when available (`code`, `title`, `discount`, `discountType`, `appliesTo`) |
| `verifiedMenuItemsCount` | Number of menu items with a verified license match |
| `bestOfWeedmaps` | Holds a "Best of Weedmaps" award (boolean) |
| `socialEquity` | Registered social-equity business (boolean) |
| `packageLevel` | Weedmaps listing/subscription tier (e.g. `listing_plus`) |
| `regionId` | Weedmaps' internal numeric region ID |
| `description` | Business description |
| `sourceUrl` | Source URL |
| `scrapedAt` | UTC timestamp |
| `recordType` | Always `dispensary` |

### Output — Product records

| Field | Description |
|---|---|
| `name` | Product name |
| `url` | Weedmaps product URL |
| `category` | Category (Indica, Sativa, Flower, Edible, etc.) |
| `strainType` | Strain type (Indica/Sativa/Hybrid/CBD) |
| `brand` | Brand name |
| `price` | Price in USD |
| `onSale` | Whether on sale |
| `originalPrice` | Original price if on sale |
| `pricesByWeight` | Price per weight (eighth, quarter, half, ounce) |
| `thcContent` | THC percentage |
| `cbdContent` | CBD percentage |
| `cannabinoids` | Full cannabinoid data |
| `effects` | Effects list |
| `flavors` | Flavor list |
| `rating` | Product rating |
| `reviewCount` | Number of reviews |
| `imageUrl` | Product image URL |
| `isOnlineOrderable` | Orderable online |
| `createdAt` | When this product was added to the menu (ISO timestamp) |
| `updatedAt` | When the menu item was last updated (ISO timestamp) |
| `currentDealTitle` | Active deal summary for this product, e.g. `"10+ deals available"` (omitted when there's no active deal) |
| `discountLabel` | Discount badge when on sale (e.g. `-35%`) |
| `productId` | Weedmaps' internal numeric product ID |
| `menuId` | Menu-item ID for this product at the dispensary |
| `slug` | Product URL slug |
| `brandSlug` | Brand URL slug |
| `topCategory` | Top-level category (e.g. `Flower`) |
| `subCategory` | Sub-category (e.g. `Big Buds`) |
| `strains` | Strain name(s) list |
| `licenseType` | License type of the offering dispensary (`recreational`, `medical`, `hybrid`) |
| `priceLabel` | Human-readable price unit label (e.g. `each`) |
| `priceUnit` | Price unit code (e.g. `unit`, `gram`) |
| `thcUnit` | Unit for `thcContent` (e.g. `%`, `mg`) |
| `cbdUnit` | Unit for `cbdContent` (e.g. `%`, `mg`) |
| `isBadged` | Whether the product carries a Weedmaps badge (boolean) |
| `sourceUrl` | Source URL |
| `scrapedAt` | UTC timestamp |
| `recordType` | Always `product` |

### Output — Deal records

| Field | Description |
|---|---|
| `title` | Deal title |
| `body` | Deal description |
| `dealType` | Type of deal |
| `categories` | Deal category tag(s), e.g. `["Flower"]`, `["Edibles"]` |
| `productCategories` | Product category name(s) the deal applies to, e.g. `["Edible"]` |
| `isStorewide` | Applies storewide |
| `isFirstTimeCustomer` | First-time customer deal |
| `dispensaryName` | Offering dispensary name |
| `dispensaryCity` | Dispensary city |
| `dispensaryState` | Dispensary state |
| `dispensaryUrl` | Dispensary Weedmaps URL |
| `dispensaryWmid` | Offering dispensary's Weedmaps ID |
| `dispensaryType` | Dispensary type (`dispensary`, `delivery`, `doctor`) |
| `dispensaryRating` | Dispensary star rating |
| `dispensaryLicenseType` | Dispensary license type |
| `dispensaryHasDelivery` | Dispensary offers delivery (boolean) |
| `dispensaryHasPickup` | Dispensary offers pickup (boolean) |
| `imageUrl` | Deal image URL |
| `dealId` | Weedmaps' internal numeric deal ID |
| `slug` | Deal URL slug |
| `claimedCount` | Number of times the deal has been claimed |
| `likes` | Number of likes on the deal |
| `expiresIn` | Seconds until the deal expires |
| `sourceUrl` | Source URL |
| `scrapedAt` | UTC timestamp |
| `recordType` | Always `deal` |

### Supported states

All major US cannabis markets: California, Colorado, Washington, Oregon, Nevada, Arizona, Michigan, Illinois, Massachusetts, New York, New Jersey, New Mexico, Connecticut, Maryland, and more. Canadian provinces: British Columbia, Alberta, Ontario, Quebec.

### Frequently Asked Questions

**Do I need an account or API key?**
No. This actor uses Weedmaps' public discovery API, which requires no authentication.

**Can I filter by city?**
Yes — use the `citySlug` field with the city name in slug format: `los-angeles`, `san-francisco`, `denver`, `chicago`, etc.

**What product categories are available?**
flower, pre-roll, edible, concentrate, vape, tincture, topical, gear, clone, seed

**How accurate are the hours?**
The `isOpen` field and `todaysHours` reflect real-time data from Weedmaps at the time of scraping.

**Can I get delivery services only?**
Yes — set `dispensaryType` to `delivery` and `hasDelivery` to `true`.

**What's the THC/CBD data from?**
Cannabis product potency data is self-reported by dispensaries or from lab test results (where `is_badged` is true).

**How do I get the most local results?**
Combine `stateSlug` + `citySlug` for the most relevant results. Leave `citySlug` empty for statewide results.

# Actor input Schema

## `mode` (type: `string`):

What to scrape from Weedmaps.

## `stateSlug` (type: `string`):

US state or Canadian province to search in.

## `citySlug` (type: `string`):

City to filter by (slug format, e.g. "los-angeles", "san-francisco", "denver"). Leave empty for all cities in the state.

## `dispensaryType` (type: `string`):

Filter by dispensary type (mode=dispensaries only).

## `productCategory` (type: `string`):

Filter products by category (mode=products only).

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

Free-text search for products (mode=products only). Example: "blue dream", "gummies".

## `strainType` (type: `string`):

Filter products by cannabis strain type (mode=products only).

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

Filter by license type (medical, recreational, or both).

## `isVerified` (type: `boolean`):

Only include listings with verified menus (mode=dispensaries).

## `hasDelivery` (type: `boolean`):

Only include dispensaries that offer delivery.

## `hasPickup` (type: `boolean`):

Only include dispensaries that offer pickup.

## `isOpenNow` (type: `boolean`):

Only include dispensaries currently open.

## `minRating` (type: `number`):

Only include listings with rating >= this value (0-5).

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

Maximum number of records to return.

## Actor input object example

```json
{
  "mode": "dispensaries",
  "stateSlug": "california",
  "dispensaryType": "dispensary",
  "isVerified": false,
  "hasDelivery": false,
  "hasPickup": false,
  "isOpenNow": false,
  "maxItems": 20
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of all scraped dispensary, product, or deal records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "dispensaries",
    "stateSlug": "california",
    "dispensaryType": "dispensary",
    "isVerified": false,
    "hasDelivery": false,
    "hasPickup": false,
    "isOpenNow": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/weedmaps-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 = {
    "mode": "dispensaries",
    "stateSlug": "california",
    "dispensaryType": "dispensary",
    "isVerified": False,
    "hasDelivery": False,
    "hasPickup": False,
    "isOpenNow": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/weedmaps-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 '{
  "mode": "dispensaries",
  "stateSlug": "california",
  "dispensaryType": "dispensary",
  "isVerified": false,
  "hasDelivery": false,
  "hasPickup": false,
  "isOpenNow": false,
  "maxItems": 20
}' |
apify call crawlerbros/weedmaps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Weedmaps Scraper — Cannabis Dispensaries & Products",
        "description": "Scrape Weedmaps.com for cannabis dispensaries, products, and deals. Filter by state, city, dispensary type, product category, strain type, and more. Returns ratings, hours, menus, THC/CBD content, pricing and availability.",
        "version": "1.0",
        "x-build-id": "byKNNaYDfhDdmgaHm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~weedmaps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-weedmaps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~weedmaps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-weedmaps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~weedmaps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-weedmaps-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "dispensaries",
                            "products",
                            "deals"
                        ],
                        "type": "string",
                        "description": "What to scrape from Weedmaps.",
                        "default": "dispensaries"
                    },
                    "stateSlug": {
                        "title": "State",
                        "enum": [
                            "california",
                            "colorado",
                            "washington",
                            "oregon",
                            "nevada",
                            "arizona",
                            "michigan",
                            "illinois",
                            "massachusetts",
                            "new-york",
                            "new-jersey",
                            "new-mexico",
                            "connecticut",
                            "maryland",
                            "new-hampshire",
                            "vermont",
                            "maine",
                            "rhode-island",
                            "alaska",
                            "montana",
                            "missouri",
                            "virginia",
                            "ohio",
                            "oklahoma",
                            "florida",
                            "delaware",
                            "minnesota",
                            "north-dakota",
                            "south-dakota",
                            "louisiana",
                            "wyoming",
                            "hawaii",
                            "utah",
                            "georgia",
                            "texas",
                            "kentucky",
                            "tennessee",
                            "north-carolina",
                            "south-carolina",
                            "alabama",
                            "west-virginia",
                            "pennsylvania",
                            "nebraska",
                            "iowa",
                            "idaho",
                            "indiana",
                            "kansas",
                            "wisconsin",
                            "british-columbia",
                            "alberta",
                            "ontario",
                            "quebec"
                        ],
                        "type": "string",
                        "description": "US state or Canadian province to search in.",
                        "default": "california"
                    },
                    "citySlug": {
                        "title": "City slug",
                        "type": "string",
                        "description": "City to filter by (slug format, e.g. \"los-angeles\", \"san-francisco\", \"denver\"). Leave empty for all cities in the state."
                    },
                    "dispensaryType": {
                        "title": "Dispensary type",
                        "enum": [
                            "dispensary",
                            "delivery",
                            "doctor"
                        ],
                        "type": "string",
                        "description": "Filter by dispensary type (mode=dispensaries only).",
                        "default": "dispensary"
                    },
                    "productCategory": {
                        "title": "Product category",
                        "enum": [
                            "flower",
                            "pre-roll",
                            "edible",
                            "concentrate",
                            "vape",
                            "tincture",
                            "topical",
                            "gear",
                            "clone",
                            "seed"
                        ],
                        "type": "string",
                        "description": "Filter products by category (mode=products only)."
                    },
                    "searchQuery": {
                        "title": "Product search query",
                        "type": "string",
                        "description": "Free-text search for products (mode=products only). Example: \"blue dream\", \"gummies\"."
                    },
                    "strainType": {
                        "title": "Strain type",
                        "enum": [
                            "indica",
                            "sativa",
                            "hybrid",
                            "cbd"
                        ],
                        "type": "string",
                        "description": "Filter products by cannabis strain type (mode=products only)."
                    },
                    "licenseType": {
                        "title": "License type",
                        "enum": [
                            "recreational",
                            "medical",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter by license type (medical, recreational, or both)."
                    },
                    "isVerified": {
                        "title": "Verified listings only",
                        "type": "boolean",
                        "description": "Only include listings with verified menus (mode=dispensaries).",
                        "default": false
                    },
                    "hasDelivery": {
                        "title": "Has delivery",
                        "type": "boolean",
                        "description": "Only include dispensaries that offer delivery.",
                        "default": false
                    },
                    "hasPickup": {
                        "title": "Has pickup",
                        "type": "boolean",
                        "description": "Only include dispensaries that offer pickup.",
                        "default": false
                    },
                    "isOpenNow": {
                        "title": "Open now only",
                        "type": "boolean",
                        "description": "Only include dispensaries currently open.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include listings with rating >= this value (0-5)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
