# Technopark.ru Scraper - Products, Categories & Search (`crawlerbros/technopark-scraper`) Actor

Scrape Technopark.ru, a major Russian consumer-electronics retailer. Search products, browse categories, or fetch full product details - prices, ratings, availability, images, and specs.

- **URL**: https://apify.com/crawlerbros/technopark-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (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 $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

## Technopark.ru Scraper

Scrape **technopark.ru** — a major Russian consumer-electronics retailer covering laptops, smartphones, TVs, home appliances, gaming gear, and more. Search by keyword, browse any category with automatic multi-page pagination, or fetch full details for specific products: price, rating, stock status, specs, images, and description.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Search** — free-text query, e.g. `ноутбук` (notebook) or a brand/model name
- **Browse a category** — pass a category URL or bare slug (e.g. `noutbuki`); the actor automatically walks the category's pages (`?p=2`, `?p=3`, ...) to collect every product, up to your item limit
- **Product details** — pass one or more full product page URLs and get the complete record parsed from the page's `schema.org/Product` structured data (the same data Technopark feeds to Google/Yandex for rich search results — the most reliable source the site exposes)
- **Filters:** price range, minimum rating, in-stock-only
- **Empty fields are omitted** — no `null` placeholders in the output

### Output per product

| Field | Description |
|---|---|
| `productUrl` | Canonical product page URL |
| `productId` | Technopark's internal numeric product ID |
| `sku` | Product code shown on the listing card ("Код: ...") |
| `name` | Product title |
| `brand` | Brand/manufacturer (mode=`productDetails` only) |
| `category` | Category name |
| `breadcrumbs` | Full breadcrumb trail as shown on the page (mode=`productDetails` only) |
| `breadcrumbPath` | Breadcrumb trail as a clean ordered array, e.g. `["Главная", "Компьютеры и ноутбуки", "Ноутбуки", "Lenovo"]` (mode=`productDetails` only) |
| `description` | Product description (mode=`productDetails` only) |
| `price`, `currency` | Current price and currency (`RUB`) |
| `creditMonthlyPrice` | Monthly installment price, when the product offers one (listing pages only) |
| `rating` | Aggregate rating, 0–5 |
| `reviewCount` | Number of reviews (mode=`productDetails` only) |
| `reviews` | Individual reviews (author, rating, text, date), when the page's structured data includes them (mode=`productDetails` only) |
| `inStock` | `true` / `false` stock status |
| `imageUrl` | Primary product image URL |
| `images` | Full image gallery (mode=`productDetails` only) |
| `specs` | Key spec highlights (listing cards: highlighted specs shown on the card; mode=`productDetails`: the fuller structured spec table, when the page exposes one) |
| `mpn` | Manufacturer part number, when present and distinct from `sku` (mode=`productDetails` only) |
| `model` | Model designation, when present (mode=`productDetails` only) |
| `gtin` | GTIN/EAN/UPC barcode identifier, when present (mode=`productDetails` only) |
| `recordType` | Always `"product"` |
| `scrapedAt` | UTC timestamp of when the record was scraped |

Optional fields (`reviews`, `mpn`, `model`, `gtin`, and the fuller `productDetails` `specs` table) are only included when Technopark's own page data actually carries them — some products' structured data is minimal (e.g. no `additionalProperty`/`review` blocks), in which case those keys are simply omitted from that record rather than emitted as `null` or guessed.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `ноутбук` | Free-text query (mode=`search`) |
| `categoryUrl` | string | – | Full category URL or bare slug, e.g. `noutbuki` (mode=`byCategory`) |
| `productUrls` | array | – | Full technopark.ru product page URLs (mode=`productDetails`) |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–500) |
| `minPrice` / `maxPrice` | integer | – | Price range filter in RUB |
| `minRating` | select | (no minimum) | Drop products rated below this (1–5); products without a visible rating are kept |
| `minReviewCount` | integer | – | Drop products with fewer reviews than this. Only populated on `productDetails` records (listing cards don't show review counts); products without a known review count are kept |
| `inStockOnly` | boolean | `false` | Only emit products marked "В наличии" (in stock); products with unknown stock status are kept |
| `proxyConfiguration` | object | Residential, RU | Required — see "Why is residential proxy required?" in the FAQ |

#### Example: search for laptops

```json
{
  "mode": "search",
  "searchQuery": "ноутбук",
  "maxItems": 20
}
````

#### Example: browse the Laptops category, in stock only, min 4-star rating

```json
{
  "mode": "byCategory",
  "categoryUrl": "noutbuki",
  "inStockOnly": true,
  "minRating": "4",
  "maxItems": 50
}
```

#### Example: single product lookup

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://www.technopark.ru/noutbuk-lenovo-ideapad-slim-3-15amn8-82xq00maps-782156/"
  ]
}
```

### Use cases

- **Price monitoring** — track competitor pricing across laptops, smartphones, and appliances
- **Market research** — analyze rating distribution and stock availability for a category
- **Catalog enrichment** — pull specs, images, and descriptions for a known list of product URLs
- **Deal discovery** — filter by price range and rating to surface the best-value products

### 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 | <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 (this actor) | <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 Technopark?** No — this is an independent third-party actor that reads technopark.ru's publicly visible product pages. It is not affiliated with or endorsed by Technopark.

**Why do I need a residential proxy — can't I use the free datacenter proxy?** technopark.ru's Qrator WAF blocks Apify's datacenter (`AUTO`) proxy pool outright, and even a browser that clears the JS challenge is then blocked by an explicit non-Russian-IP geography gate. A Russian residential proxy is required and pre-filled by default.

**What currency are prices in?** Russian rubles (`RUB`), as shown on the site.

**How does `byCategory`/`search` pagination work?** Technopark renders one page's worth of products per load (no infinite scroll, no "show more" button), then paginates further pages via its own `?p=N` URL query parameter. The actor walks `?p=2`, `?p=3`, ... automatically, collecting products from each page until your `maxItems` is reached or the catalog runs out.

**Can I look up a product by just its numeric ID?** Not currently — Technopark's canonical product URLs embed a descriptive slug alongside the numeric ID, so a full product page URL is required for `productDetails` mode.

**How fresh is the pricing data?** Live — every run fetches current pages; prices and stock status reflect what's shown to a live visitor at scrape time.

# Actor input Schema

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

What to fetch.

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

Free-text search query, e.g. `ноутбук` (notebook) or a brand/model name.

## `categoryUrl` (type: `string`):

A full Technopark.ru category URL (e.g. `https://www.technopark.ru/noutbuki/`) or a bare slug (e.g. `noutbuki`). Find category slugs by browsing the site's catalog menu.

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

Full Technopark.ru product page URLs to fetch full details for.

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

Hard cap on emitted records.

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

Drop products cheaper than this (Russian rubles).

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

Drop products more expensive than this (Russian rubles).

## `minRating` (type: `string`):

Drop products rated below this (1-5). Products without a visible rating are kept.

## `minReviewCount` (type: `integer`):

Drop products with fewer reviews than this. Only populated on mode=productDetails records (review counts aren't shown on listing cards); products without a known review count are kept.

## `inStockOnly` (type: `boolean`):

Only emit products currently marked "В наличии" (in stock). Products with unknown stock status are kept.

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

Apify residential proxy restricted to Russia — required to bypass Technopark's QRATOR WAF and IP-geography gate (see README "Data Source").

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "ноутбук",
  "categoryUrl": "noutbuki",
  "productUrls": [
    "https://www.technopark.ru/noutbuk-lenovo-ideapad-slim-3-15amn8-82xq00maps-782156/"
  ],
  "maxItems": 10,
  "minRating": "",
  "inStockOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Technopark.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": "ноутбук",
    "categoryUrl": "noutbuki",
    "productUrls": [
        "https://www.technopark.ru/noutbuk-lenovo-ideapad-slim-3-15amn8-82xq00maps-782156/"
    ],
    "maxItems": 10,
    "minRating": "",
    "inStockOnly": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/technopark-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": "ноутбук",
    "categoryUrl": "noutbuki",
    "productUrls": ["https://www.technopark.ru/noutbuk-lenovo-ideapad-slim-3-15amn8-82xq00maps-782156/"],
    "maxItems": 10,
    "minRating": "",
    "inStockOnly": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/technopark-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": "ноутбук",
  "categoryUrl": "noutbuki",
  "productUrls": [
    "https://www.technopark.ru/noutbuk-lenovo-ideapad-slim-3-15amn8-82xq00maps-782156/"
  ],
  "maxItems": 10,
  "minRating": "",
  "inStockOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call crawlerbros/technopark-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Technopark.ru Scraper - Products, Categories & Search",
        "description": "Scrape Technopark.ru, a major Russian consumer-electronics retailer. Search products, browse categories, or fetch full product details - prices, ratings, availability, images, and specs.",
        "version": "1.0",
        "x-build-id": "E3DXMqEG1FEKErXVD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~technopark-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-technopark-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~technopark-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-technopark-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~technopark-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-technopark-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",
                    "proxyConfiguration"
                ],
                "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 search query, e.g. `ноутбук` (notebook) or a brand/model name.",
                        "default": "ноутбук"
                    },
                    "categoryUrl": {
                        "title": "Category URL or slug (mode=byCategory)",
                        "type": "string",
                        "description": "A full Technopark.ru category URL (e.g. `https://www.technopark.ru/noutbuki/`) or a bare slug (e.g. `noutbuki`). Find category slugs by browsing the site's catalog menu."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetails)",
                        "type": "array",
                        "description": "Full Technopark.ru product page URLs to fetch full details for.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "minPrice": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (Russian rubles)."
                    },
                    "maxPrice": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (Russian rubles)."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Drop products rated below this (1-5). Products without a visible rating are kept.",
                        "default": ""
                    },
                    "minReviewCount": {
                        "title": "Min review count",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop products with fewer reviews than this. Only populated on mode=productDetails records (review counts aren't shown on listing cards); products without a known review count are kept."
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently marked \"В наличии\" (in stock). Products with unknown stock status are kept.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify residential proxy restricted to Russia — required to bypass Technopark's QRATOR WAF and IP-geography gate (see README \"Data Source\").",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
