# Trolley Grocery Price Comparison Scraper (`crawlerbros/trolley-grocery-price-scraper`) Actor

Scrape UK grocery prices from Trolley.co.uk - compare Tesco, Asda, Sainsbury's, Morrisons, Waitrose, Ocado & more. Search, browse categories, get per-retailer price comparisons with weekly history, or list current retailer deals.

- **URL**: https://apify.com/crawlerbros/trolley-grocery-price-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% 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

## Trolley Grocery Price Comparison Scraper

Scrape **Trolley.co.uk** — a UK grocery & household price comparison service covering Tesco, Asda, Sainsbury's, Morrisons, Co-op, ALDI, Waitrose, Ocado, Iceland, Boots, Superdrug, Poundland, Savers, Amazon, Ebay, Pets At Home and more. Search for any product by keyword (with sort, dietary, brand, size and retailer filters), browse curated "Top products" categories, pull a full per-retailer price comparison with weekly price history for a specific product, or list today's live deals at a chosen retailer. HTTP-only, no auth, no login, no proxy required.

### What this actor does

- **Four modes:** `search`, `byCategory`, `byProductIds`, `dealsByStore`
- **Multi-retailer price comparison:** see the same product's price across up to 16 UK retailers side by side
- **Weekly price history:** up to 52 weeks of historical pricing per product (mode = `byProductIds`)
- **Live deals feed:** current price-cut deals at a specific retailer (mode = `dealsByStore`)
- **Search filters:** sort by price, dietary tag (vegetarian/organic/vegan/halal/kosher/not tested on animals), brand, pack size, and retailer — all applied server-side by Trolley.co.uk
- **Star ratings** on every product record, plus review snippets, category rankings, allergen/dietary info, alternate pack sizes, and related products on the full product-detail lookup
- **Related searches** surfaced alongside keyword search results
- **Filters:** min/max price, filter results to a specific retailer
- **Empty fields are omitted** — a field only appears on a record when real data was found for it

### Output: per-product (mode = `search` / `byCategory` / `dealsByStore`)

- `productId` — Trolley.co.uk product ID (e.g. `MOZ184`)
- `productUrl` — canonical product page URL
- `name` — full product title, including pack size
- `brand`
- `description` — short product description (without brand/size)
- `size` — pack size / volume (e.g. `2l`, `900ml`)
- `imageUrl`
- `price` — lowest listed price found on the page (GBP)
- `currency` — always `GBP`
- `pricePerUnit` — e.g. `£0.13 per 100ml` (mode = `search` / `dealsByStore`)
- `rating` — average shopper star rating, 0–5
- `storePrices[]` — per-retailer `{store, price, currency}` snapshot (mode = `byCategory` only)
- `storeCount` — number of retailers with a listed price (mode = `byCategory` only)
- `promotionalOffer` — e.g. `2 FOR £4`, when present
- `wasPrice`, `savingText` — original price and saving description, for deals
- `dealAge` — how long ago the deal was spotted (mode = `dealsByStore`)
- `store` — retailer name (mode = `dealsByStore`)
- `reviewCount`
- `sampleReviews[]` — a few real shopper review snippets (mode = `byCategory` only)
- `relatedSearches[]` — related keyword suggestions shown alongside the results (mode = `search` only)
- `recordType`, `scrapedAt`

### Output: per-product detail (mode = `byProductIds`)

- `productId`, `productUrl`, `name`, `brand`, `description`, `size`, `imageUrl`
- `storePrices[]` — full per-retailer comparison: `{store, price, currency, pricePerUnit, promotionalOffer, visitUrl}`
- `storeCount` — number of retailers compared
- `price`, `currency` — the lowest price across all compared retailers
- `lowestPriceStore` — which retailer has the lowest price
- `priceHistory[]` — `{week, price}` for up to the last 52 weeks
- `rating` — average shopper star rating, 0–5
- `sampleReviews[]` — real shopper review text from the product page
- `productInfo` — allergen/ingredient/origin facts shown in the product's "Good to know" panel, e.g. `{"Contains": "Milk and Lactose"}`
- `dietaryBadges[]` — dietary badges shown on the product, e.g. `["Vegetarian"]`
- `categoryRankings[]` — `{rank, category, categorySlug}` for any "#1 in X" category leaderboard the product appears on
- `otherSizes[]` — alternate pack sizes of the same product, each `{productId, size, price, currency, pricePerUnit, badge, isCurrentSize}`
- `relatedProducts[]` — other products from the same brand shown on the product page
- `recordType`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byProductIds` / `dealsByStore` |
| `searchQuery` | string | `milk` | Free-text product search (mode=search) |
| `categorySlug` | string | `vanilla-ice-creams` | Category slug from a Trolley.co.uk `/explore/...` URL (mode=byCategory) |
| `productIds` | array | – | Product IDs, paths, or full URLs (mode=byProductIds) |
| `store` | string | `tesco` | Retailer to pull deals from — one of 16 retailers: `asda` / `tesco` / `sainsburys` / `morrisons` / `coop` / `iceland` / `boots` / `superdrug` / `aldi` / `waitrose` / `poundland` / `savers` / `ocado` / `amazon` / `ebay` / `petsathome` (mode=dealsByStore) |
| `sortOrder` | string | `relevance` | `relevance` or `price` (lowest price first) — mode=search |
| `dietary` | string | – | Filter by dietary tag: `vegetarian` / `organic` / `vegan` / `halal` / `kosher` / `not tested on animals` — mode=search |
| `brandFilter` | string | – | Only return results from this brand, e.g. `Arla` — mode=search |
| `sizeFilter` | string | – | Only return results of this pack size, e.g. `1l` — mode=search |
| `minPrice` | number | – | Drop products cheaper than this (GBP) |
| `maxPrice` | number | – | Drop products more expensive than this (GBP) |
| `filterByStore` | string | – | Only keep products confirmed sold at this retailer (one of the same 16 retailers). Applied server-side for mode=search; applied to per-retailer data on other modes |
| `maxItems` | int | `20` | Hard cap on emitted records (1–500) |

#### Example: search for a product

```json
{
  "mode": "search",
  "searchQuery": "chocolate",
  "maxPrice": 3,
  "maxItems": 30
}
````

#### Example: search with sort, dietary and retailer filters

```json
{
  "mode": "search",
  "searchQuery": "milk",
  "sortOrder": "price",
  "dietary": "organic",
  "filterByStore": "Waitrose",
  "maxItems": 20
}
```

#### Example: browse a curated category

```json
{
  "mode": "byCategory",
  "categorySlug": "single-malt-whiskeys",
  "maxItems": 20
}
```

#### Example: full price comparison + history for specific products

```json
{
  "mode": "byProductIds",
  "productIds": ["MOZ184", "SOY634"]
}
```

#### Example: today's deals at a retailer

```json
{
  "mode": "dealsByStore",
  "store": "tesco",
  "filterByStore": "Tesco",
  "maxItems": 20
}
```

### Use cases

- **Price-comparison shopping apps** — power a "cheapest place to buy X" feature across UK supermarkets
- **Grocery budgeting tools** — track weekly price history to time purchases
- **Market research** — monitor retailer pricing strategy and promotional cadence for a product category
- **Deal-alert services** — surface today's live price cuts at a favourite retailer
- **CPG brand monitoring** — see how a brand's products are priced across the UK grocery market

### FAQ

**What is the data source?**
All data comes from the public pages of [Trolley.co.uk](https://www.trolley.co.uk), a UK price-comparison website that aggregates live pricing from major UK grocery and health & beauty retailers.

**Is this affiliated with Trolley.co.uk or any retailer it compares?**
No. This is an independent, third-party actor that reads Trolley.co.uk's public web pages. It is not affiliated with Trolley.co.uk, Tesco, Asda, Sainsbury's, or any other retailer mentioned.

**Why do some products only show 3-4 retailer prices while the site shows more?**
Trolley.co.uk requires a free account login to reveal additional retailer prices beyond the first few on some products. This actor only extracts what's publicly visible without logging in.

**Does this cover fresh in-store prices or online prices?**
Prices reflect what each retailer lists online at the time Trolley.co.uk last checked, and may differ slightly from in-store pricing.

**Which retailers are covered?**
Trolley.co.uk tracks 16 retailers: Tesco, Asda, Sainsbury's, Morrisons, Co-op, ALDI, Waitrose, Ocado, Iceland, Boots, Superdrug, Poundland, Savers, Amazon, Ebay and Pets At Home. Coverage per individual product varies — not every retailer stocks every product.

**Is this UK-only?**
Yes — Trolley.co.uk covers UK retailers and prices in GBP.

**How far back does the price history go?**
Up to 52 weeks (about a year) where available.

**What happens if a search or category returns no results?**
The run finishes successfully with 0 items and a status message explaining why (e.g. unknown category slug, no matches for the query).

# Actor input Schema

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

What to fetch.

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

Free-text product search, e.g. `milk`, `chocolate`, `washing pods`.

## `categorySlug` (type: `string`):

A Trolley.co.uk `/explore/` category slug, e.g. `vanilla-ice-creams`, `salted-butter`, `single-malt-whiskeys`. Also accepts a full `https://www.trolley.co.uk/explore/...` URL.

## `productIds` (type: `array`):

Trolley.co.uk product IDs (e.g. `MOZ184`), product paths (`/product/x/MOZ184`), or full product URLs.

## `store` (type: `string`):

Retailer to pull current deals from.

## `sortOrder` (type: `string`):

How to order search results. `Lowest price first` sorts by each product's best listed price across all retailers.

## `dietary` (type: `string`):

Only return search results tagged with this dietary attribute on Trolley.co.uk.

## `brandFilter` (type: `string`):

Only return search results from this brand, e.g. `Arla`, `Tesco`, `Yeo Valley`. Must match a brand name Trolley.co.uk shows for the given search query — check a plain search first if unsure.

## `sizeFilter` (type: `string`):

Only return search results of this pack size, e.g. `1l`, `500ml`, `2l`. Must match a size Trolley.co.uk shows for the given search query — check a plain search first if unsure.

## `minPrice` (type: `number`):

Drop products cheaper than this (best/lowest listed price).

## `maxPrice` (type: `number`):

Drop products more expensive than this (best/lowest listed price).

## `filterByStore` (type: `string`):

Only keep products/comparisons that include this retailer, e.g. `Tesco`, `Asda`, `Sainsbury's`. For mode=search this is applied server-side (a real Trolley.co.uk filter); for other modes it's applied to the retailers found on each record.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "milk",
  "categorySlug": "vanilla-ice-creams",
  "productIds": [],
  "store": "tesco",
  "sortOrder": "relevance",
  "dietary": "",
  "maxItems": 20
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Trolley.co.uk products.

# 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": "search",
    "searchQuery": "milk",
    "categorySlug": "vanilla-ice-creams",
    "productIds": [],
    "store": "tesco",
    "sortOrder": "relevance",
    "dietary": "",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/trolley-grocery-price-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": "search",
    "searchQuery": "milk",
    "categorySlug": "vanilla-ice-creams",
    "productIds": [],
    "store": "tesco",
    "sortOrder": "relevance",
    "dietary": "",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/trolley-grocery-price-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": "search",
  "searchQuery": "milk",
  "categorySlug": "vanilla-ice-creams",
  "productIds": [],
  "store": "tesco",
  "sortOrder": "relevance",
  "dietary": "",
  "maxItems": 20
}' |
apify call crawlerbros/trolley-grocery-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trolley Grocery Price Comparison Scraper",
        "description": "Scrape UK grocery prices from Trolley.co.uk - compare Tesco, Asda, Sainsbury's, Morrisons, Waitrose, Ocado & more. Search, browse categories, get per-retailer price comparisons with weekly history, or list current retailer deals.",
        "version": "1.0",
        "x-build-id": "arfgX3QyYfLaaYtPE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~trolley-grocery-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-trolley-grocery-price-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~trolley-grocery-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-trolley-grocery-price-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~trolley-grocery-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-trolley-grocery-price-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": [
                            "search",
                            "byCategory",
                            "byProductIds",
                            "dealsByStore"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text product search, e.g. `milk`, `chocolate`, `washing pods`.",
                        "default": "milk"
                    },
                    "categorySlug": {
                        "title": "Category slug (mode=byCategory)",
                        "type": "string",
                        "description": "A Trolley.co.uk `/explore/` category slug, e.g. `vanilla-ice-creams`, `salted-butter`, `single-malt-whiskeys`. Also accepts a full `https://www.trolley.co.uk/explore/...` URL."
                    },
                    "productIds": {
                        "title": "Product IDs (mode=byProductIds)",
                        "type": "array",
                        "description": "Trolley.co.uk product IDs (e.g. `MOZ184`), product paths (`/product/x/MOZ184`), or full product URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "store": {
                        "title": "Retailer (mode=dealsByStore)",
                        "enum": [
                            "asda",
                            "tesco",
                            "sainsburys",
                            "morrisons",
                            "coop",
                            "iceland",
                            "boots",
                            "superdrug",
                            "aldi",
                            "waitrose",
                            "poundland",
                            "savers",
                            "ocado",
                            "amazon",
                            "ebay",
                            "petsathome"
                        ],
                        "type": "string",
                        "description": "Retailer to pull current deals from.",
                        "default": "tesco"
                    },
                    "sortOrder": {
                        "title": "Sort order (mode=search)",
                        "enum": [
                            "relevance",
                            "price"
                        ],
                        "type": "string",
                        "description": "How to order search results. `Lowest price first` sorts by each product's best listed price across all retailers.",
                        "default": "relevance"
                    },
                    "dietary": {
                        "title": "Dietary filter (mode=search)",
                        "enum": [
                            "",
                            "vegetarian",
                            "organic",
                            "vegan",
                            "halal",
                            "kosher",
                            "not tested on animals"
                        ],
                        "type": "string",
                        "description": "Only return search results tagged with this dietary attribute on Trolley.co.uk.",
                        "default": ""
                    },
                    "brandFilter": {
                        "title": "Brand filter (mode=search)",
                        "type": "string",
                        "description": "Only return search results from this brand, e.g. `Arla`, `Tesco`, `Yeo Valley`. Must match a brand name Trolley.co.uk shows for the given search query — check a plain search first if unsure."
                    },
                    "sizeFilter": {
                        "title": "Pack size filter (mode=search)",
                        "type": "string",
                        "description": "Only return search results of this pack size, e.g. `1l`, `500ml`, `2l`. Must match a size Trolley.co.uk shows for the given search query — check a plain search first if unsure."
                    },
                    "minPrice": {
                        "title": "Min price (GBP)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "number",
                        "description": "Drop products cheaper than this (best/lowest listed price)."
                    },
                    "maxPrice": {
                        "title": "Max price (GBP)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "number",
                        "description": "Drop products more expensive than this (best/lowest listed price)."
                    },
                    "filterByStore": {
                        "title": "Filter results to a retailer",
                        "enum": [
                            "Asda",
                            "Tesco",
                            "Sainsbury's",
                            "Morrisons",
                            "Co-op",
                            "Iceland",
                            "Boots",
                            "Superdrug",
                            "ALDI",
                            "Waitrose",
                            "Poundland",
                            "Savers",
                            "Ocado",
                            "Amazon",
                            "Ebay",
                            "Pets At Home"
                        ],
                        "type": "string",
                        "description": "Only keep products/comparisons that include this retailer, e.g. `Tesco`, `Asda`, `Sainsbury's`. For mode=search this is applied server-side (a real Trolley.co.uk filter); for other modes it's applied to the retailers found on each record."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
