# Ozon, Wildberries, Yandex Market, Avito Scraper & Monitor (`isolovyev/ru-marketplaces-price-monitor`) Actor

Search and monitor product listings across Ozon, Wildberries, Yandex Market and Avito in one Actor. Unified schema, scheduled price-change monitoring (alert-only), and underpriced-listing detection.

- **URL**: https://apify.com/isolovyev/ru-marketplaces-price-monitor.md
- **Developed by:** [Ivan Solovyev](https://apify.com/isolovyev) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

## Russian Marketplaces Scraper & Price Monitor

**Scrape and price-monitor Ozon, Wildberries, Yandex Market, and Avito - one Actor, one unified schema.**

Search product cards by keyword across all four major Russian marketplaces, or schedule a price
monitor that reports only what changed. Built to survive the aggressive anti-bot on RU platforms -
where most Western monitor actors simply don't go.

---

### Why this Actor

Western price-monitor actors avoid Russian marketplaces because of hard anti-bot protection.
Existing RU scrapers cover one platform each, with different output formats you have to reconcile
yourself. This Actor does both jobs in one call:

- **4-in-1, one schema.** Ozon + Wildberries + Yandex Market + Avito in a single run, identical
  fields on output. No stitching four different scrapers together.
- **Price monitor with change tracking.** State persists between runs in the KV Store. Each card
  gets `changeType`, `previousPrice`, `priceChangePct`.
- **Fewer paid results in monitor mode.** `alertOnly` returns only changed cards, keeping scheduled
  monitoring economical on expensive stealth traffic (you still pay platform usage for the full scan).

---

### Features

- **Unified output schema** across all four marketplaces - `platform, query, id, title, url,
  price, currency, scrapedAt`.
- **Two modes:** `search` (find cards by keyword) and `monitor` (track price changes on schedule).
- **RU residential proxy** (Apify, country-RU) for access to RU platforms. The person who runs
  the Actor pays for the traffic.
- **Anti-bot resilience:** Camoufox (open-source, Firefox-based stealth browser), retry-with-new-IP
  on silent blocks (especially Wildberries), and honest stale-selector detection - the Actor tells
  you if a platform changed its markup instead of silently returning nothing.
- **Normalized keyword filters:** `includeKeywords` / `excludeKeywords` match across variants -
  "2 ТБ" catches "2TB" / "2ТБ" / "2 tb", part numbers across any separator.
- **Price band + volume caps:** `minPrice`, `maxPrice`, `maxItemsPerQuery`.
- **Underpriced detector** (`flagUnderpriced`): flags cards well below the query median, or below
  a supplied `referencePrice`. Brand-agnostic - works for any product.
- **Optional webhook:** POST a summary of changes (integrate with Telegram or your own service).

---

### Supported platforms & output fields

| Platform | Key | search | monitor |
|---|---|---|---|
| Ozon | `ozon` | yes | yes |
| Wildberries | `wildberries` | yes | yes |
| Yandex Market | `yandexmarket` | yes | yes |
| Avito | `avito` | yes | yes |

**Output fields (unified across all platforms):**

| Field | Type | Notes |
|---|---|---|
| `platform` | string | ozon / wildberries / yandexmarket / avito |
| `query` | string | the search query this card came from |
| `id` | string | marketplace card id |
| `title` | string | card title |
| `url` | string | card URL |
| `price` | number | current price |
| `currency` | string | RUB |
| `scrapedAt` | string | ISO timestamp |
| `isUnderpriced` | boolean | only when `flagUnderpriced=true` |
| `deviationPct` | number | deviation from median or `referencePrice` |
| `changeType` | string | monitor mode: new / price_up / price_down / removed |
| `previousPrice` | number | monitor mode: price on the previous run |
| `priceChangePct` | number | monitor mode: percent change |

---

### Use cases

- **Seller repricing** - keep your prices in the market across all platforms at once.
- **Arbitrage / deal hunting** - catch underpriced lots below the category median.
- **SKU price monitoring with Telegram alerts** - scheduled monitor, `alertOnly` + webhook.
- **Category market research** - one unified dataset across four platforms for a price landscape.
- **Brand protection / anti-counterfeit signal** - flag suspiciously low prices vs the official
  price (`referencePrice`) for a brand or rights holder.

See `USE_CASES.md` for detailed input examples for each.

---

### Quick start

**Search mode** - find cards by keyword:

```json
{
  "mode": "search",
  "platforms": ["ozon", "wildberries", "yandexmarket"],
  "queries": ["Samsung 990 Pro 2TB", "MZ-V9P2T0CW"],
  "includeKeywords": ["990 Pro", "2TB"],
  "minPrice": 10000,
  "maxItemsPerQuery": 60
}
````

**Monitor mode** - track changes on a schedule, alert only on changes:

```json
{
  "mode": "monitor",
  "platforms": ["ozon", "wildberries"],
  "queries": ["Samsung 990 Pro 2TB"],
  "includeKeywords": ["990 Pro", "2TB"],
  "alertOnly": true,
  "notifyWebhookUrl": "https://example.com/hooks/price-alerts"
}
```

Set a schedule under **Schedules** in the Apify Console to run `monitor` mode periodically. State
carries over between runs via the KV Store.

***

### Pricing and cost control

This Actor uses Apify's Pay-per-event pricing model. You are charged per result written to the
default dataset, and Apify platform usage costs (compute + residential proxy) are billed to the
account that runs the Actor.

For a low-cost test run, start with one platform, one query, and a small `maxItemsPerQuery`. For
scheduled monitoring, use `alertOnly=true` to write (and pay for) only new or changed cards. Set a
max cost per run in the Apify Console before larger jobs to keep spending predictable.

***

### Honest limitations (please read)

- **Matching is done by the marketplace's own fuzzy search.** Your precise control is
  `includeKeywords`, which narrows results down to the SKU you want. A part number is the best
  identity key. Example: a search for "Samsung 990 Pro 2TB" / "MZ-V9P2T0CW" returned the whole
  990 Pro family (1/2/4 TB, box/OEM) on Ozon; the marketplace matched the model to the right SKU.
- **`flagUnderpriced` is noisy on mixed results.** If one query mixes 1/2/4 TB variants, the
  median blurs. Use one variant per query, or set `referencePrice`.
- **Wildberries has the toughest anti-bot and is currently best-effort.** It serves an active JS
  challenge that the Actor does not reliably pass on Apify's residential pool, so Wildberries may
  return empty. Ozon, Yandex Market, and Avito return results reliably.
- **Cross-platform comparison of the same product** by a single id is not automated yet (part-number
  matching is planned). Platforms are collected in parallel into one dataset.
- **Residential traffic is paid** (on Apify). For high-volume production monitoring you need a paid plan.

***

### Keywords

ozon scraper, wildberries scraper, yandex market scraper, avito scraper, russian marketplace price
monitor, ru marketplace scraper, price tracking, price change alerts, ozon price monitor,
wildberries price monitor, competitor price monitoring, brand protection russia.

***

### RU / На русском

**Один актор для сбора и мониторинга цен на Ozon, Wildberries, Яндекс.Маркете и Avito - единая
схема полей на выходе.**

Западные монитор-акторы обходят жёсткий антибот RU-площадок стороной, а существующие RU-скрейперы
покрывают по одной площадке каждый, с разным форматом. Этот актор делает обе задачи разом:

- **4-в-1, единая схема** - все четыре площадки за один прогон, одинаковые поля.
- **Мониторинг изменения цен** - состояние между прогонами в KV Store, по каждой карточке
  `changeType` / `previousPrice` / `priceChangePct`.
- **Меньше платных результатов в мониторе** - режим `alertOnly` пишет (и тарифицирует) только изменившиеся карточки; usage за полный скан всё равно платит запускающий.
- **Устойчивость к антиботу** - Camoufox (open-source стелс-браузер на базе Firefox), ретрай с
  новым IP при «тихих» блокировках (особенно Wildberries), честный сигнал о смене вёрстки площадки.
- **Фильтры** - нормализованные `includeKeywords` / `excludeKeywords` («2 ТБ» ловит
  «2TB»/«2ТБ»/«2 tb»), `minPrice`/`maxPrice`, `maxItemsPerQuery`.
- **Детектор низкой цены** (`flagUnderpriced`) - ниже медианы выдачи или ниже эталонной
  `referencePrice`; работает по любому товару.

**Честные ограничения:** матчинг делает фаззи-поиск площадки (точный контроль - через
`includeKeywords`, лучший ключ - партномер); на смешанной выдаче детектор низкой цены шумит;
Wildberries сейчас best-effort - отдаёт активный JS-челлендж, который на residential-пуле Apify
проходится нестабильно (может вернуть пусто), а Ozon, Яндекс.Маркет и Avito отдают данные надёжно;
кросс-площадочное сравнение одной SKU по единому id пока не автоматизировано; residential-трафик РФ
платный. Оплата - по модели Pay-per-event: тарифицируются результаты в dataset, а platform
usage/proxy начисляются отдельно по правилам аккаунта Apify. Подробные примеры входа - в `USE_CASES.md`.

# Actor input Schema

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

search = one-shot scrape; monitor = scheduled price-change tracking (uses stored state).

## `platforms` (type: `array`):

Which marketplaces to query.

## `queries` (type: `array`):

Keywords to search for. Any product / brand.

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

Direct category or product URLs to scrape or monitor.

## `maxPagesPerQuery` (type: `integer`):

Capped by each platform's internal maximum.

## `maxItemsPerQuery` (type: `integer`):

Cap the number of items kept per query after scraping. Leave empty for no cap.

## `includeKeywords` (type: `array`):

Keep only titles containing at least one of these.

## `excludeKeywords` (type: `array`):

Drop titles containing any of these.

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

Keep only items priced at or above this value (RUB).

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

Keep only items priced at or below this value (RUB).

## `flagUnderpriced` (type: `boolean`):

Mark listings priced far below the result median or below referencePrice.

## `referencePrice` (type: `integer`):

If set, listings below referencePrice\*(1 - underpriceThresholdPct/100) are flagged.

## `underpriceThresholdPct` (type: `integer`):

How far below the reference or median price counts as underpriced, in percent.

## `alertOnly` (type: `boolean`):

Monitor mode — output only changed listings (recommended for cost).

## `priceChangeThresholdPct` (type: `integer`):

Monitor mode: minimum price change (percent) to report when alert-only is on.

## `notifyWebhookUrl` (type: `string`):

Monitor mode: optional URL to POST a summary of detected changes to after each run.

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

Residential RU proxy recommended for reliable access.

## Actor input object example

```json
{
  "mode": "search",
  "platforms": [
    "ozon",
    "wildberries",
    "yandexmarket",
    "avito"
  ],
  "queries": [
    "робот пылесос"
  ],
  "maxPagesPerQuery": 3,
  "flagUnderpriced": false,
  "underpriceThresholdPct": 50,
  "alertOnly": true,
  "priceChangeThresholdPct": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# 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 = {
    "queries": [
        "робот пылесос"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("isolovyev/ru-marketplaces-price-monitor").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 = { "queries": ["робот пылесос"] }

# Run the Actor and wait for it to finish
run = client.actor("isolovyev/ru-marketplaces-price-monitor").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 '{
  "queries": [
    "робот пылесос"
  ]
}' |
apify call isolovyev/ru-marketplaces-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=isolovyev/ru-marketplaces-price-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ozon, Wildberries, Yandex Market, Avito Scraper & Monitor",
        "description": "Search and monitor product listings across Ozon, Wildberries, Yandex Market and Avito in one Actor. Unified schema, scheduled price-change monitoring (alert-only), and underpriced-listing detection.",
        "version": "0.1",
        "x-build-id": "Xlj7tPTTgU6NuHHKn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/isolovyev~ru-marketplaces-price-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-isolovyev-ru-marketplaces-price-monitor",
                "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/isolovyev~ru-marketplaces-price-monitor/runs": {
            "post": {
                "operationId": "runs-sync-isolovyev-ru-marketplaces-price-monitor",
                "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/isolovyev~ru-marketplaces-price-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-isolovyev-ru-marketplaces-price-monitor",
                "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": [
                    "platforms"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "monitor"
                        ],
                        "type": "string",
                        "description": "search = one-shot scrape; monitor = scheduled price-change tracking (uses stored state).",
                        "default": "search"
                    },
                    "platforms": {
                        "title": "Marketplaces",
                        "type": "array",
                        "description": "Which marketplaces to query.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ozon",
                                "wildberries",
                                "yandexmarket",
                                "avito"
                            ]
                        },
                        "default": [
                            "ozon",
                            "wildberries",
                            "yandexmarket",
                            "avito"
                        ]
                    },
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search for. Any product / brand.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Category / product URLs (optional)",
                        "type": "array",
                        "description": "Direct category or product URLs to scrape or monitor.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerQuery": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Capped by each platform's internal maximum.",
                        "default": 3
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query (optional)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap the number of items kept per query after scraping. Leave empty for no cap."
                    },
                    "includeKeywords": {
                        "title": "Include keywords (optional)",
                        "type": "array",
                        "description": "Keep only titles containing at least one of these.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords (optional)",
                        "type": "array",
                        "description": "Drop titles containing any of these.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only items priced at or above this value (RUB)."
                    },
                    "maxPrice": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only items priced at or below this value (RUB)."
                    },
                    "flagUnderpriced": {
                        "title": "Flag underpriced listings",
                        "type": "boolean",
                        "description": "Mark listings priced far below the result median or below referencePrice.",
                        "default": false
                    },
                    "referencePrice": {
                        "title": "Reference price (optional, RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "If set, listings below referencePrice*(1 - underpriceThresholdPct/100) are flagged."
                    },
                    "underpriceThresholdPct": {
                        "title": "Underprice threshold %",
                        "minimum": 1,
                        "maximum": 99,
                        "type": "integer",
                        "description": "How far below the reference or median price counts as underpriced, in percent.",
                        "default": 50
                    },
                    "alertOnly": {
                        "title": "Monitor: alert-only",
                        "type": "boolean",
                        "description": "Monitor mode — output only changed listings (recommended for cost).",
                        "default": true
                    },
                    "priceChangeThresholdPct": {
                        "title": "Monitor: price-change threshold %",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Monitor mode: minimum price change (percent) to report when alert-only is on.",
                        "default": 1
                    },
                    "notifyWebhookUrl": {
                        "title": "Monitor: webhook URL (optional)",
                        "type": "string",
                        "description": "Monitor mode: optional URL to POST a summary of detected changes to after each run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential RU proxy recommended for reliable access.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
