# Holodilnik.ru Scraper (`crawlerbros/holodilnik-scraper`) Actor

Scrape Holodilnik.ru - a major Russian home-appliance retailer. Search products, browse curated categories (refrigerators, washing machines, TVs, built-in appliances and more), and fetch full product detail pages with price, specs, rating, images and breadcrumbs.

- **URL**: https://apify.com/crawlerbros/holodilnik-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **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/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

## Holodilnik.ru Scraper

Scrape [Holodilnik.ru](https://www.holodilnik.ru/) — Холодильник.РУ, one of Russia's largest home-appliance and electronics retailers. Search products, browse curated categories (refrigerators, washing machines, TVs, built-in appliances, and more), or fetch full product detail pages with price, specs, rating, images and breadcrumbs.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Search & category browse** use Holodilnik.ru's own public product-search service — fast, no proxy needed
- **Category browse goes beyond the search API's own 100-item-per-query cap**: it fans out across the category's own related-search suggestions (still validated against the category's real URL path), typically returning 2-4× more genuine in-category products than a single query — see the FAQ below
- **Product details** returns full specs, description, rating/review count, breadcrumbs, a full image gallery, and individual customer reviews (author, date, star rating, pros, cons, comment)
- **Filters:** brand, price range, in-stock only
- **Empty fields are omitted** — every field on every record is real data

### Output per product

#### `search` / `byCategory` (recordType: `product`)

- `productId`, `title`, `brand`
- `price`, `currency` (RUB)
- `available` — in stock right now
- `categoryId`, `categoryName`
- `imageUrl`, `imageUrls[]`
- `productUrl` — feed this into `productDetails`
- `searchScore` — relevance score from the search engine
- `recordType: "product"`, `scrapedAt`

#### `productDetails` (recordType: `productDetail`)

- `productId`, `sku`, `gtin`
- `title`, `brand`
- `price`, `currency`, `available`
- `rating`, `reviewCount`
- `description`
- `specs` — full key/value specification table (dimensions, energy class, capacity, etc. — varies by product type)
- `breadcrumbs[]` — `{name, url}` category trail
- `categoryName`
- `images[]`, `mainImage`
- `reviews[]` — `{reviewId, author, date, rating, pros, cons, comment}`, up to `maxReviewsPerProduct` (Holodilnik.ru renders these server-side directly into the product page — no extra request)
- `productUrl`
- `recordType: "productDetail"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `холодильник` | Free-text query (mode=search) |
| `category` | string | – | Curated category slug (mode=byCategory) — see the dropdown for the full list |
| `productUrls` | array | – | Full product page URLs (mode=productDetails) |
| `brandFilter` | string | – | Keep only products whose brand contains this text. In `search` mode, when set, the actor automatically re-queries the search API with the brand appended to your search term and merges in any newly-found products — this compensates for the search API's own 100-results-per-query relevance ranking, which can otherwise rank a real brand below the top 100 for a generic term (e.g. plain `"холодильник"` alone may not surface `Bosch` in its own top 100, even though Bosch refrigerators exist on the site) |
| `minPrice` / `maxPrice` | int | – | Price range in Russian rubles |
| `availableOnly` | bool | `false` | Only in-stock products |
| `maxReviewsPerProduct` | int | `20` | Cap on customer reviews kept per product (mode=productDetails); `0` disables review extraction |
| `maxItems` | int | `20` | Hard cap (1–300). `search` is limited by the search API's own 100-per-query cap; `byCategory` can exceed 100 via query fan-out (see FAQ) |
| `proxyConfiguration` | object | AUTO | Only used by `productDetails`, and only as a fallback if a direct page fetch is ever blocked |

#### Example: search for refrigerators under 40,000 RUB

```json
{
  "mode": "search",
  "searchQuery": "холодильник",
  "maxPrice": 40000,
  "maxItems": 30
}
````

#### Example: browse washing machines by a specific brand

```json
{
  "mode": "byCategory",
  "category": "washing_machines",
  "brandFilter": "Candy",
  "maxItems": 50
}
```

#### Example: fetch full product pages

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://www.holodilnik.ru/refrigerator/two_chambered_refrigerators/atlant/mxm_2835_00/"
  ]
}
```

### Use cases

- **Price monitoring** — track appliance prices and stock status over time
- **Market research** — compare brands, categories and price bands on a major Russian retailer
- **Catalog enrichment** — pull full specs and images for a product database
- **Competitive intelligence** — benchmark assortment and pricing against Holodilnik.ru

### Other Russian marketplace actors by CrawlerBros

| Actor | URL |
|---|---|
| Citilink Scraper - Russian Electronics Store Products | <https://apify.com/crawlerbros/citilink-scraper> |
| DNS-Shop Scraper | <https://apify.com/crawlerbros/dns-shop-scraper> |
| Eldorado Scraper | <https://apify.com/crawlerbros/eldorado-scraper> |
| ETM Electrical Equipment Scraper | <https://apify.com/crawlerbros/etm-scraper> |
| Holodilnik.ru Scraper (this actor) | <https://apify.com/crawlerbros/holodilnik-scraper> |
| Lemanapro Scraper | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Is this affiliated with Holodilnik.ru?** No — this is a third-party actor built on Holodilnik.ru's own public product-search service and product pages.

**Do I need a proxy?** No — leave `proxyConfiguration` at its default. It's only consulted by `productDetails`, and only as a fallback if a direct page fetch is ever blocked.

**Why is `category` a dropdown instead of free text?** Holodilnik.ru's catalog paths aren't discoverable through the public search API, so we curated the categories that are reliably reachable and mapped each to its real URL prefix, to guarantee `byCategory` returns products that genuinely belong to that category.

**Why does `byCategory` return more than 100 products per category?** A single search query is capped at 100 products by Holodilnik.ru's own search service. `byCategory` automatically issues extra queries using the site's own related-search suggestions for that category and keeps only the products that genuinely belong to it (verified via each product's own category URL), typically returning 2-4× more real in-category products than a single query.

**Why does `brandFilter` sometimes find more products in `search` mode?** A generic query can rank a specific brand below the search engine's own top-100 relevance window. When `brandFilter` is set, the actor also re-queries with the brand appended and merges in any newly-found matching products.

**Can I look up a product by ID instead of URL?** Not directly — Holodilnik.ru's product URLs are slug-based (e.g. `.../atlant/mxm_2835_00/`), not ID-based, and there's no public ID→URL redirect. Use `search` or `byCategory` first to discover `productUrl` values, then feed those into `productDetails`.

**What currency are prices in?** Russian rubles (RUB) — Holodilnik.ru is a Russia-only retailer.

**Where do the reviews come from?** Holodilnik.ru renders each product's customer reviews directly into the product page's HTML (no separate AJAX call, no login) — the actor parses them from the same page fetch used for the rest of `productDetails`, so there's no extra cost. Not every product has reviews; `reviews[]` is omitted when there are none.

**Why does `searchScore` only appear sometimes?** The search engine returns `NaN` for some results (typically exact/administrative matches); those are omitted rather than emitting a fake score.

# Actor input Schema

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

What to fetch.

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

Free-text product query, e.g. холодильник (refrigerator), стиральная машина (washing machine).

## `category` (type: `string`):

Curated product category to browse.

## `productUrls` (type: `array`):

Full Holodilnik.ru product page URLs to fetch, e.g. https://www.holodilnik.ru/refrigerator/two\_chambered\_refrigerators/atlant/mxm\_2835\_00/. Get these from the output of search or byCategory mode.

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

Only keep results whose brand contains this text (case-insensitive), e.g. Atlant, Bosch, Liebherr.

## `minPrice` (type: `integer`):

Drop products cheaper than this (in Russian rubles).

## `maxPrice` (type: `integer`):

Drop products more expensive than this (in Russian rubles).

## `availableOnly` (type: `boolean`):

Only emit products currently in stock.

## `maxReviewsPerProduct` (type: `integer`):

Holodilnik.ru renders customer reviews (author, date, 0-5 rating, pros, cons, comment) directly into the product page. Cap how many to keep per product; 0 disables review extraction.

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

Hard cap on emitted records. mode=search is limited to Holodilnik.ru's own search-API cap of 100 results per query. mode=byCategory fans out across the category's own related-search suggestions to gather more than one query's 100-item cap, so it accepts a higher ceiling. For mode=productDetails this also caps how many of the supplied productUrls are processed.

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

search and byCategory never need a proxy (they use Holodilnik.ru's public search API). productDetails fetches the live product page, which blocks non-Russian datacenter IPs with a static 403; the actor automatically escalates to a residential-proxy session (see README → Data Source) only when a direct/AUTO fetch is blocked.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "холодильник",
  "category": "refrigerators_two_chamber",
  "productUrls": [],
  "brandFilter": "",
  "availableOnly": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Holodilnik.ru 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": "холодильник",
    "category": "refrigerators_two_chamber",
    "productUrls": [],
    "brandFilter": "",
    "availableOnly": false,
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/holodilnik-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": "холодильник",
    "category": "refrigerators_two_chamber",
    "productUrls": [],
    "brandFilter": "",
    "availableOnly": False,
    "maxReviewsPerProduct": 20,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/holodilnik-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": "холодильник",
  "category": "refrigerators_two_chamber",
  "productUrls": [],
  "brandFilter": "",
  "availableOnly": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/holodilnik-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Holodilnik.ru Scraper",
        "description": "Scrape Holodilnik.ru - a major Russian home-appliance retailer. Search products, browse curated categories (refrigerators, washing machines, TVs, built-in appliances and more), and fetch full product detail pages with price, specs, rating, images and breadcrumbs.",
        "version": "1.0",
        "x-build-id": "yzgbBgCrINCDE60QP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~holodilnik-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-holodilnik-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~holodilnik-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-holodilnik-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~holodilnik-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-holodilnik-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",
                            "productDetails"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text product query, e.g. холодильник (refrigerator), стиральная машина (washing machine).",
                        "default": "холодильник"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "",
                            "refrigerators_two_chamber",
                            "refrigerators_one_chamber",
                            "refrigerators_mini",
                            "refrigerators_multi",
                            "freezers",
                            "built_in_refrigerators",
                            "washing_machines",
                            "dryers",
                            "dishwashers",
                            "air_conditioners",
                            "tvs",
                            "smart_speakers",
                            "kettles",
                            "kitchen_machines",
                            "built_in_microwaves",
                            "built_in_ovens",
                            "built_in_cooktops",
                            "gas_stoves",
                            "notebooks",
                            "smartphones",
                            "hair_dryers",
                            "robot_vacuums",
                            "handheld_vacuums",
                            "garden_lawnmowers",
                            "garden_petrol_saws",
                            "garden_trimmers",
                            "garden_cultivators",
                            "garden_snow_removal",
                            "garden_pumps",
                            "garden_shredders"
                        ],
                        "type": "string",
                        "description": "Curated product category to browse.",
                        "default": ""
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetails)",
                        "type": "array",
                        "description": "Full Holodilnik.ru product page URLs to fetch, e.g. https://www.holodilnik.ru/refrigerator/two_chambered_refrigerators/atlant/mxm_2835_00/. Get these from the output of search or byCategory mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandFilter": {
                        "title": "Brand filter (mode=search, byCategory)",
                        "type": "string",
                        "description": "Only keep results whose brand contains this text (case-insensitive), e.g. Atlant, Bosch, Liebherr.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Min price, RUB (mode=search, byCategory)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (in Russian rubles)."
                    },
                    "maxPrice": {
                        "title": "Max price, RUB (mode=search, byCategory)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (in Russian rubles)."
                    },
                    "availableOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Only emit products currently in stock.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product (mode=productDetails)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Holodilnik.ru renders customer reviews (author, date, 0-5 rating, pros, cons, comment) directly into the product page. Cap how many to keep per product; 0 disables review extraction.",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted records. mode=search is limited to Holodilnik.ru's own search-API cap of 100 results per query. mode=byCategory fans out across the category's own related-search suggestions to gather more than one query's 100-item cap, so it accepts a higher ceiling. For mode=productDetails this also caps how many of the supplied productUrls are processed.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "search and byCategory never need a proxy (they use Holodilnik.ru's public search API). productDetails fetches the live product page, which blocks non-Russian datacenter IPs with a static 403; the actor automatically escalates to a residential-proxy session (see README → Data Source) only when a direct/AUTO fetch is blocked.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
