# Onlinetrade.ru Scraper (`crawlerbros/onlinetrade-scraper`) Actor

Scrape onlinetrade.ru (Онлайн Трейд) - a major Moscow electronics and appliances retailer. Search products, browse by category, or fetch full product details: price, discount, rating, reviews, brand, specifications, images.

- **URL**: https://apify.com/crawlerbros/onlinetrade-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

## Onlinetrade.ru Scraper

Extract product data from [onlinetrade.ru](https://www.onlinetrade.ru) (Онлайн Трейд) — a
long-running Moscow electronics and home-appliances retailer — without writing a single
line of code. Search by keyword, browse any category page, or pull full product details
from a list of URLs. Get clean, structured data on price, discounts, ratings, reviews,
brand, specifications, and images, ready for spreadsheets, price-monitoring dashboards,
or market research.

### What this actor does

- **Search onlinetrade.ru by keyword** — the same search box you'd use on the site
  (`ноутбук`, `холодильник`, `наушники`), returned as structured JSON instead of a web
  page.
- **Browse any category page** — pass an onlinetrade.ru catalog/category URL and get
  every product listed on it, paginated automatically up to your item limit.
- **Fetch full product details** — give it product URLs (or bare numeric product IDs)
  and get back the complete product record: brand, specifications, gallery images,
  breadcrumbs, stock status, and more.
- **Filter and sort results** by price range, minimum rating, discount status, and stock
  status, and sort by popularity, price, rating, or newest — no need to post-process the
  output yourself.
- **Empty fields are omitted** — a record only ever contains the fields onlinetrade.ru
  actually exposed for that product; there are no `null` or empty placeholders to filter
  out.

### Output per product

Every record includes as many of the following fields as onlinetrade.ru exposes for that
product:

| Field | Description |
|---|---|
| `title` | Product name |
| `brand` | Brand/manufacturer name |
| `price` | Current price in Russian rubles (RUB) |
| `originalPrice` | Pre-discount price, if the product is on sale |
| `discountPercent` | Discount percentage, derived from price vs. original price |
| `currency` | Price currency (normally `RUB`) |
| `rating` | Average customer rating (1–5) |
| `reviewCount` | Number of customer reviews |
| `reviews` | Array of individual reviews (`author`, `rating`, `text`, `date`), where the product page exposes structured review data (product detail pages) |
| `sellerName` | Name of the merchant/seller fulfilling the listing |
| `sellerUrl` | Seller's storefront/profile URL, where exposed (product detail pages) |
| `availability` | Stock status (`in stock` / `out of stock`) |
| `images` | Array of product image URLs |
| `category` | Product category |
| `breadcrumbs` | Full category breadcrumb trail (product detail pages) |
| `specifications` | Key/value map of technical specifications (product detail pages) |
| `description` | Product description |
| `sku` | Seller/manufacturer SKU |
| `mpn` | Manufacturer part number, where distinct from `sku` (product detail pages) |
| `ean` | EAN/GTIN barcode identifier, where exposed (product detail pages) |
| `videoUrl` | Product video URL, where the product page embeds one (product detail pages) |
| `productId` | onlinetrade.ru's numeric product ID |
| `productUrl` | Canonical product page URL |
| `recordType` | Always `"product"` |
| `scrapedAt` | UTC timestamp of when the record was scraped |

On the rare run where onlinetrade.ru's anti-bot check blocks every attempt, the actor
falls back to Google's own index of the storefront. Fallback records only ever contain
`title`, `productId`, `productUrl`, and — where Google's own rich result surfaced them —
`price`, `currency`, `availability`, and `description`; all other fields are simply
omitted rather than guessed.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search`, `byCategory`, or `productDetails` |
| `searchQuery` | string | – | Keyword to search for (mode=`search`), e.g. `ноутбук` |
| `categoryUrls` | array | `[]` | Full onlinetrade.ru catalog/category URLs to browse (mode=`byCategory`) |
| `productUrls` | array | `[]` | Product page URLs or bare numeric IDs (mode=`productDetails`) |
| `sortBy` | string | – (site relevance) | `popular`, `priceAsc`, `priceDesc`, `rating`, `new` (mode=`search`/`byCategory`) |
| `minPrice` | integer | – | Drop products cheaper than this, in RUB |
| `maxPrice` | integer | – | Drop products more expensive than this, in RUB |
| `minRating` | integer | – | Minimum rating filter (1–5) |
| `onSaleOnly` | boolean | `false` | Only return products currently discounted |
| `inStockOnly` | boolean | `false` | Only return products currently marked in stock |
| `maxItems` | integer | `20` | Maximum number of products to return (1–500) |
| `proxyConfiguration` | object | Russian residential | Apify proxy configuration — required; see FAQ |

#### Example: search for laptops

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

#### Example: browse a category, on-sale items only

```json
{
  "mode": "byCategory",
  "categoryUrls": ["https://www.onlinetrade.ru/catalogue/noutbuki-c9.html"],
  "onSaleOnly": true,
  "maxItems": 50
}
```

#### Example: fetch product details

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://www.onlinetrade.ru/item/apple-macbook-air-13-m2-512345/",
    "654321"
  ]
}
```

#### Example: in-stock fridges under a price cap, sorted by rating

```json
{
  "mode": "search",
  "searchQuery": "холодильник",
  "maxPrice": 60000,
  "inStockOnly": true,
  "sortBy": "rating",
  "maxItems": 30
}
```

### Use cases

- **Price monitoring** — track prices and discounts for specific products or an entire
  category over time.
- **Competitive research** — compare assortments, pricing, and ratings against other
  Russian electronics retailers.
- **Catalog enrichment** — pull structured product data (brand, specifications, images)
  for a known list of product URLs.
- **Market research** — analyze rating/review distributions across a product category.
- **Stock tracking** — monitor which products go in and out of stock.

### 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 (this actor) | <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

**Do I need to configure the proxy myself?**
No — the default proxy configuration (Russian residential) is already set up and
required for this actor to return data. You can leave it as-is.

**Why is residential proxy required?**
onlinetrade.ru's pages are protected by a WAF that blocks non-Russian and datacenter
IPs with a persistent CAPTCHA challenge. Russian residential IPs pass through normally.
The actor is pre-configured with the required residential proxy setting.

**Why did my run return 0 results?**
onlinetrade.ru's anti-bot protection is session-based and can occasionally block an
individual run. Simply run the actor again — each run opens a fresh proxy session. If a
specific search or category consistently returns nothing, double-check that the
query/URL is correct on onlinetrade.ru itself.

**Why do some records have far fewer fields than others?**
On a run where onlinetrade.ru's anti-bot check blocks every direct attempt, the actor
falls back to Google's own index of the site to still return real products. Those
fallback records only carry the fields Google itself surfaced (title, URL, and
sometimes price/availability/description) — never fabricated values.

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

**Can I look up a product by its numeric ID instead of a URL?**
Yes — `productUrls` accepts bare numeric IDs as well as full product URLs.

**Does `categoryUrls` accept any onlinetrade.ru catalog page?**
Yes — any full category/catalog listing URL from the site works; the actor appends
sorting and pagination parameters automatically.

**Does this scraper work for other Онлайн Трейд regional domains?**
This actor targets `onlinetrade.ru`, the primary retailer domain.

**Does search work correctly with Cyrillic (Russian) queries?**
Yes — `searchQuery` fully supports Cyrillic terms like `ноутбук` or `холодильник`.

**Is this actor affiliated with onlinetrade.ru?**
No, this is a third-party actor that reads onlinetrade.ru's own public storefront pages.

# Actor input Schema

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

What to fetch.

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

Free-text keyword search, e.g. `ноутбук` (laptop), `холодильник` (fridge).

## `categoryUrls` (type: `array`):

Full onlinetrade.ru catalog/category URLs to browse, e.g. `https://www.onlinetrade.ru/catalogue/noutbuki-c9.html`.

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

Full product URLs (`https://www.onlinetrade.ru/item/...`) or bare numeric product IDs.

## `sortBy` (type: `string`):

How to sort results. Only applies to search and category browsing.

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

Drop products cheaper than this (in Russian rubles).

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

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

## `minRating` (type: `integer`):

Drop products rated below this (1-5 scale).

## `onSaleOnly` (type: `boolean`):

Only emit products that currently have a discount applied.

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

Only emit products currently marked in stock.

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

Hard cap on emitted records.

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

Used by the primary Camoufox browser path. onlinetrade.ru is protected by a ServicePipe WAF that serves a persistent rotate-image CAPTCHA to non-Russian IPs, so a Russian residential proxy is required there. If that path still emits nothing (the CAPTCHA persists on the rotated session), the actor automatically falls back to Apify's own GOOGLESERP proxy to retrieve Google-indexed product data -- this setting does not affect that fallback.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "ноутбук",
  "categoryUrls": [],
  "productUrls": [],
  "sortBy": "",
  "onSaleOnly": false,
  "inStockOnly": false,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

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

Dataset containing all scraped onlinetrade.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": "ноутбук",
    "categoryUrls": [],
    "productUrls": [],
    "sortBy": "",
    "onSaleOnly": false,
    "inStockOnly": false,
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/onlinetrade-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": "ноутбук",
    "categoryUrls": [],
    "productUrls": [],
    "sortBy": "",
    "onSaleOnly": False,
    "inStockOnly": False,
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/onlinetrade-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": "ноутбук",
  "categoryUrls": [],
  "productUrls": [],
  "sortBy": "",
  "onSaleOnly": false,
  "inStockOnly": false,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call crawlerbros/onlinetrade-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Onlinetrade.ru Scraper",
        "description": "Scrape onlinetrade.ru (Онлайн Трейд) - a major Moscow electronics and appliances retailer. Search products, browse by category, or fetch full product details: price, discount, rating, reviews, brand, specifications, images.",
        "version": "1.0",
        "x-build-id": "qWxdBzQkpd9wgsTyQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~onlinetrade-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-onlinetrade-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~onlinetrade-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-onlinetrade-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~onlinetrade-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-onlinetrade-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 keyword search, e.g. `ноутбук` (laptop), `холодильник` (fridge)."
                    },
                    "categoryUrls": {
                        "title": "Category URLs (mode=byCategory)",
                        "type": "array",
                        "description": "Full onlinetrade.ru catalog/category URLs to browse, e.g. `https://www.onlinetrade.ru/catalogue/noutbuki-c9.html`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs or IDs (mode=productDetails)",
                        "type": "array",
                        "description": "Full product URLs (`https://www.onlinetrade.ru/item/...`) or bare numeric product IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order (mode=search / byCategory)",
                        "enum": [
                            "",
                            "popular",
                            "priceAsc",
                            "priceDesc",
                            "rating",
                            "new"
                        ],
                        "type": "string",
                        "description": "How to sort results. Only applies to search and category browsing.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (in Russian rubles)."
                    },
                    "maxPrice": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (in Russian rubles)."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products rated below this (1-5 scale)."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only emit products that currently have a discount applied.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently marked in stock.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Used by the primary Camoufox browser path. onlinetrade.ru is protected by a ServicePipe WAF that serves a persistent rotate-image CAPTCHA to non-Russian IPs, so a Russian residential proxy is required there. If that path still emits nothing (the CAPTCHA persists on the rotated session), the actor automatically falls back to Apify's own GOOGLESERP proxy to retrieve Google-indexed product data -- this setting does not affect that fallback.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
