# Dutchie Menu Scraper (`solidcode/dutchie-scraper`) Actor

\[💰 $2.5 / 1K] Extract full product menus from any Dutchie dispensary. Paste dispensary URLs to get every product and price variant — name, brand, category, strain type, THC/CBD potency, weight/size, price, active specials, images, and stock status.

- **URL**: https://apify.com/solidcode/dutchie-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

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

## Dutchie Menu Scraper

Extract the full product menu of any Dutchie dispensary — every product broken out to the individual price variant, with brand, category, strain type, THC/CBD potency, size, live price, active specials, and stock status. Built for cannabis retail analysts, brand managers, and dispensary operators who need live menu and pricing data across stores without checking each storefront by hand.

### Why This Scraper?

- **Every price variant as its own row** — a flower listing sold in 1g, 3.5g, 7g, and 28g becomes four separate rows, each with its own size, price, and special. No unpacking a single blob of comma-separated prices.
- **11 product categories, filtered at the source** — Flower, Pre-Rolls, Vaporizers, Concentrates, Edibles, Tinctures, Topicals, CBD, Seeds, Accessories, and Apparel; pick any subset and only those products come back.
- **Recreational and medical menus** — many dispensaries publish two separate menus at different prices; choose Recreational, Medical, or the store default, and every row is tagged with the menu it came from.
- **Live specials with the actual deal name** — catches sale-price markdowns, BOGO, and spend-threshold promotions, and labels each discounted variant with the real deal name (e.g. "Green Wednesday 20% Off").
- **THC and CBD potency on every product** — plus the potency unit (percentage for flower, milligrams for edibles) so you can compare like-for-like across categories.
- **Strain type and brand on each row** — Indica, Sativa, or Hybrid classification alongside brand and subcategory for clean product-level analysis.
- **Regular price, special price, and stock split into separate fields** — numeric `price` and `specialPrice` (never one merged number), plus `inStock` and on-hand `quantity` when the store publishes it.
- **Optional full product descriptions** — flip one switch to pull each product's complete long description, or leave it off for the fastest full-menu pull.
- **Bulk multi-dispensary input** — paste any number of dispensary URLs and get one combined dataset, where every row carries its store's name, slug, and URL.

### Use Cases

**Competitive Pricing Intelligence**
- Track a rival dispensary's per-gram flower pricing across every weight tier
- Compare the same brand's variant prices store-to-store in your market
- Benchmark your shelf prices against the local competition
- Detect price changes and fresh markdowns by re-running on a schedule

**Brand & Product Market Research**
- Map which brands and strains have the widest menu distribution
- Analyze category mix (flower vs. vape vs. edible) across a region
- Track new product launches and variant availability over time
- Study THC/CBD potency ranges and pricing by category

**Promotion & Deal Monitoring**
- Snapshot every active special with `offersOnly` to see who is discounting what
- Capture deal names and special prices for promotion calendars
- Watch competitor BOGO and spend-threshold offers as they go live

**Menu & Inventory Monitoring**
- Track in-stock vs. out-of-stock status across a store's full catalog
- Monitor on-hand quantity where dispensaries publish it
- Spot menu additions and removals between runs

**Data Products for Cannabis SaaS**
- Power pricing dashboards, menu-comparison tools, and market reports
- Enrich dispensary databases with live product and pricing data
- Feed retail-analytics and category-management platforms

### Getting Started

#### Scrape a Full Menu

The simplest run — one dispensary URL, entire menu:

```json
{
    "startUrls": ["https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"]
}
````

#### Filter by Category and Menu Type

Pull only flower and pre-rolls from the recreational menu, up to 500 products:

```json
{
    "startUrls": ["https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"],
    "menuType": "rec",
    "categories": ["Flower", "Pre-Rolls"],
    "maxProductsPerDispensary": 500
}
```

#### Multi-Store, Deals Only, with Descriptions

Track medical-menu specials across two stores with full descriptions:

```json
{
    "startUrls": [
        "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec",
        "https://dutchie.com/dispensary/resinate-worcester"
    ],
    "menuType": "med",
    "categories": ["Vaporizers", "Concentrate", "Edible"],
    "offersOnly": true,
    "includeDescriptions": true,
    "maxProductsPerDispensary": 0
}
```

### Input Reference

#### Dispensaries

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array of URLs | `[]` | One or more Dutchie dispensary URLs (e.g. `https://dutchie.com/dispensary/<store-slug>`). Paste the full address from your browser. The complete menu is collected for each store. |

#### Menu Selection & Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `menuType` | select | `Store default` | Which menu to read when a store offers both: **Store default**, **Recreational (adult-use)**, or **Medical**. |
| `categories` | multi-select | All categories | Restrict to chosen categories: Flower, Pre-Rolls, Vaporizers, Concentrates, Edibles, Tinctures, Topicals, CBD, Seeds, Accessories, Apparel. Leave empty for everything. |
| `offersOnly` | boolean | `Off` | Only collect products with an active deal or special price — ideal for promotion tracking. |

#### Collection Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxProductsPerDispensary` | integer | `0` (all) | Cap the products collected per store. `0` collects the entire menu. Collection stops at a page boundary once the cap is reached, so a small cap can return a few more than requested — never fewer, never a half-filled page. |
| `includeDescriptions` | boolean | `Off` | Also collect each product's full text description. Looks up products individually, so large menus take noticeably longer. Leave off for the fastest results. |

### Output

Each row is a single product price-variant. Here's a representative result:

```json
{
    "dispensaryName": "Quincy Cannabis Co.",
    "dispensarySlug": "quincy-cannabis-quincy-retail-rec",
    "dispensaryUrl": "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec",
    "menuType": "rec",
    "productId": "5f8c1e2b9a3d4c0012ab34cd",
    "productName": "Blue Dream",
    "brand": "Coastal Cultivars",
    "category": "Flower",
    "subcategory": "Bud",
    "strainType": "Hybrid",
    "thcContent": "24.6%",
    "cbdContent": "0.1%",
    "potencyUnit": "Percentage",
    "variantSize": "3.5g",
    "displayPrice": "$45.00",
    "price": 45,
    "specialPrice": 36,
    "onSpecial": true,
    "specialName": "Green Wednesday 20% Off",
    "description": "A sativa-dominant hybrid with sweet berry aromas and an uplifting, creative high.",
    "imageUrl": "https://images.dutchie.com/abc123/blue-dream.jpg",
    "productUrl": "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec/product/blue-dream",
    "inStock": true,
    "quantity": 42,
    "scrapedAt": "2026-07-25T14:30:00Z"
}
```

#### Dispensary & Run

| Field | Type | Description |
|-------|------|-------------|
| `dispensaryName` | string | Store name |
| `dispensarySlug` | string | Store slug taken from the URL |
| `dispensaryUrl` | string | Canonical dispensary URL |
| `menuType` | string | Which menu the row came from (`rec` or `med`) |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

#### Product Identity

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Dutchie product identifier |
| `productName` | string | Product title |
| `brand` | string | Brand name |
| `category` | string | Top-level category (Flower, Vaporizers, Edible, …) |
| `subcategory` | string | Sub-category (e.g. Bud, Disposables) |

#### Cannabis Attributes

| Field | Type | Description |
|-------|------|-------------|
| `strainType` | string | Indica, Sativa, Hybrid, or CBD |
| `thcContent` | string | THC potency as shown (e.g. "24.6%") |
| `cbdContent` | string | CBD potency as shown |
| `potencyUnit` | string | Potency unit — Percentage or Milligrams |

#### Pricing & Specials

| Field | Type | Description |
|-------|------|-------------|
| `variantSize` | string | The variant weight/size for this row (1/8oz, 1g, 3.5g, 1000mg, …) |
| `displayPrice` | string | Human-readable price as shown (e.g. "$45.00") |
| `price` | number | Numeric regular price |
| `specialPrice` | number | Numeric discounted price when on special (else null) |
| `onSpecial` | boolean | Whether an active deal applies to this variant |
| `specialName` | string | Name of the deal/special (nullable) |

#### Availability & Media

| Field | Type | Description |
|-------|------|-------------|
| `inStock` | boolean | Whether the variant is currently available |
| `quantity` | number | On-hand quantity when the store exposes it (nullable) |
| `imageUrl` | string | Primary product image URL |
| `productUrl` | string | Canonical product URL |
| `description` | string | Full product description (populated only when **Include Product Descriptions** is on) |

### Tips for Best Results

- **Start with a cap** — set `maxProductsPerDispensary` to 50-100 on your first run to preview a store's data shape before pulling the whole menu.
- **Compare rec vs. med on the same product** — run a store once with `menuType: "rec"` and again with `"med"`; medical menus are often priced differently, so the same product can carry two different prices worth tracking.
- **Snapshot promotions with `offersOnly`** — turn it on to pull only products that currently have an active deal. Each variant row keeps its own `onSpecial` flag and deal name, so you can see exactly which sizes are discounted — perfect for monitoring competitor promotions without pulling the full catalog.
- **Leave descriptions off for speed** — `includeDescriptions` fetches each product individually and slows large menus; enable it only when you need the long-form copy.
- **Remember one row per variant** — a single flower listing can expand into 4-5 rows (1g/3.5g/7g/28g), so size your product cap with that fan-out in mind.
- **Filter categories to stay focused** — selecting only the categories you care about returns a leaner, cleaner dataset.
- **Re-run on a schedule for price tracking** — pricing and specials change daily; a recurring run builds a time series you can diff for markdowns and new products.

### Pricing

**From $2.50 per 1,000 results** — the lowest per-result rate for live Dutchie menu data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one product price-variant row in your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly listed dispensary menu data for legitimate market research, competitive analysis, and business intelligence. Cannabis is regulated differently across jurisdictions — use this data only for lawful, licensed, or research purposes, and comply with all applicable local, state, and federal laws as well as Dutchie's Terms of Service. Do not use it to facilitate sales to minors or any activity prohibited where you operate.

# Actor input Schema

## `startUrls` (type: `array`):

One or more Dutchie dispensary URLs to scrape, for example https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec . Paste the full URL from your browser address bar. The complete product menu is collected for each store.

## `maxProductsPerDispensary` (type: `integer`):

The most products to collect from each dispensary. Set to 0 to collect the entire menu. Products are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return a few more than requested.

## `menuType` (type: `string`):

Which menu to read when a dispensary offers both a recreational and a medical menu. Leave on 'Store default' to use whatever the store shows first.

## `categories` (type: `array`):

Only collect products in these categories. Leave empty to collect every category.

## `offersOnly` (type: `boolean`):

Only collect products that currently have an active deal or special price. Useful for tracking promotions without pulling the full menu.

## `includeDescriptions` (type: `boolean`):

Also collect the full text description for each product. This looks up each product individually, so runs take noticeably longer on large menus. Leave off for the fastest results.

## Actor input object example

```json
{
  "startUrls": [
    "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"
  ],
  "categories": []
}
```

# Actor output Schema

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

Table of scraped products with key fields like dispensary, product name, brand, category, strain type, potency, size, price, and stock status.

## `detail` (type: `string`):

Complete product data including identifiers, brand, category and subcategory, strain type, THC/CBD potency, variant size, display and special pricing, description, image, product URL, and stock status.

# 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 = {
    "startUrls": [
        "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"
    ],
    "maxProductsPerDispensary": 0,
    "menuType": "",
    "categories": [],
    "offersOnly": false,
    "includeDescriptions": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/dutchie-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 = {
    "startUrls": ["https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"],
    "maxProductsPerDispensary": 0,
    "menuType": "",
    "categories": [],
    "offersOnly": False,
    "includeDescriptions": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/dutchie-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 '{
  "startUrls": [
    "https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec"
  ],
  "maxProductsPerDispensary": 0,
  "menuType": "",
  "categories": [],
  "offersOnly": false,
  "includeDescriptions": false
}' |
apify call solidcode/dutchie-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dutchie Menu Scraper",
        "description": "[💰 $2.5 / 1K] Extract full product menus from any Dutchie dispensary. Paste dispensary URLs to get every product and price variant — name, brand, category, strain type, THC/CBD potency, weight/size, price, active specials, images, and stock status.",
        "version": "1.0",
        "x-build-id": "DFdTMVoH47Htbmm15"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~dutchie-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-dutchie-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/solidcode~dutchie-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-dutchie-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/solidcode~dutchie-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-dutchie-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": {
                    "startUrls": {
                        "title": "Dutchie Dispensary URLs",
                        "type": "array",
                        "description": "One or more Dutchie dispensary URLs to scrape, for example https://dutchie.com/dispensary/quincy-cannabis-quincy-retail-rec . Paste the full URL from your browser address bar. The complete product menu is collected for each store.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerDispensary": {
                        "title": "Max Products per Dispensary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The most products to collect from each dispensary. Set to 0 to collect the entire menu. Products are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return a few more than requested."
                    },
                    "menuType": {
                        "title": "Menu Type",
                        "enum": [
                            "",
                            "rec",
                            "med"
                        ],
                        "type": "string",
                        "description": "Which menu to read when a dispensary offers both a recreational and a medical menu. Leave on 'Store default' to use whatever the store shows first."
                    },
                    "categories": {
                        "title": "Product Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect products in these categories. Leave empty to collect every category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Flower",
                                "Pre-Rolls",
                                "Vaporizers",
                                "Concentrate",
                                "Edible",
                                "Tincture",
                                "Topicals",
                                "CBD",
                                "Seeds",
                                "Accessories",
                                "Apparel"
                            ],
                            "enumTitles": [
                                "Flower",
                                "Pre-Rolls",
                                "Vaporizers",
                                "Concentrates",
                                "Edibles",
                                "Tinctures",
                                "Topicals",
                                "CBD",
                                "Seeds",
                                "Accessories",
                                "Apparel"
                            ]
                        }
                    },
                    "offersOnly": {
                        "title": "Deals & Specials Only",
                        "type": "boolean",
                        "description": "Only collect products that currently have an active deal or special price. Useful for tracking promotions without pulling the full menu."
                    },
                    "includeDescriptions": {
                        "title": "Include Product Descriptions",
                        "type": "boolean",
                        "description": "Also collect the full text description for each product. This looks up each product individually, so runs take noticeably longer on large menus. Leave off for the fastest results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
