# Russkiy Svet (rs24.ru) Electrical Equipment Scraper (`crawlerbros/russkiysvet-scraper`) Actor

Scrape rs24.ru (Русский Свет) - a major Russian B2B electrical-equipment distributor with ~850,000 SKUs. Search products, browse categories, and fetch full product details: prices, specifications, brands, images, stock status.

- **URL**: https://apify.com/crawlerbros/russkiysvet-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Russkiy Svet (rs24.ru) Electrical Equipment Scraper

Scrape **rs24.ru** — the online storefront of "Русский Свет" (Russkiy Svet), one of Russia's largest electrical-equipment distributors with roughly 850,000 SKUs across 2,000+ categories and 178 branches in Russia, Belarus, Kazakhstan, and the wider CIS. Search products, browse any category, or fetch rich product detail pages including specifications, brand, SKU, images, and stock status.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Free-text product search** across the entire rs24.ru catalog
- **Category browsing** with automatic pagination — follows the "next page" link rs24.ru's own catalog UI renders, so it keeps working across the site's actual page count rather than a guessed page-size
- **Full product detail extraction** — price, brand, SKU, specifications table, full image gallery, breadcrumb category path (with clickable category URLs), rating
- **Per-branch regional stock** — live warehouse quantities across rs24.ru's branch network (product detail mode)
- **Related / similar products** — the "you may also like" widget on a product page, when rs24.ru renders one (product detail mode)
- **Prices normalized** from Russian formatting (`1 124,84 руб.`) into clean numeric values with currency
- **Empty fields are omitted** — every record only contains fields that were actually found on the page

### Output per product

- `productId` — numeric rs24.ru product ID
- `title`
- `price`, `oldPrice`, `currency` — normalized numeric price in RUB. Always populated in `productDetails` mode (via the page's own schema.org JSON-LD) and typically populated in `byCategory` mode. **`search` mode listing cards frequently omit price/brand/availability text entirely** (observed live: 0/8 on a representative `лампа` search run, vs. 6/6 populated on a `byCategory` run for the same site) — rs24.ru's `/search.htm` results template renders differently from its `/catalog/` category template. If your workflow needs price, prefer `byCategory` for browsing or follow up `search` results with `productDetails` calls.
- `brand` — same `search`-mode caveat as `price` above
- `sku` — manufacturer article/SKU (product detail mode)
- `description` (product detail mode)
- `specifications` — key/value technical specification table (product detail mode)
- `categoryPath` — breadcrumb trail as text, e.g. `Розетки / Компьютерные розетки` (product detail mode)
- `categoryBreadcrumbs[]` — the same trail as structured `{name, url}` entries, so you can re-crawl the category tree (product detail mode)
- `imageUrl`, `images[]` (product detail mode returns the full gallery; search/category return the card thumbnail)
- `availability` — stock status text as shown on the page (product detail mode; rarely present on `search`-mode cards — see the `price` note above)
- `stockByBranch[]` — per-branch warehouse quantities, `{branch, quantity}` (product detail mode, when rs24.ru's internal warehouse-list endpoint responds)
- `totalStock` — sum of `stockByBranch[].quantity` across all branches (product detail mode, only when every branch reported a numeric quantity)
- `relatedProducts[]` — `{productId, url, title}` entries from the page's own "similar/related products" widget, when rs24.ru rendered one (product detail mode)
- `rating`, `reviewCount` (when present)
- `url` — canonical product page URL
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `розетка` | Free-text query (mode=search) |
| `categoryUrls` | array | – | rs24.ru category page URLs (mode=byCategory) |
| `productUrls` | array | – | Product page URLs or bare numeric IDs (mode=productDetails) |
| `maxItems` | int | `10` | Hard cap on emitted records (1–500) |
| `proxyConfiguration` | object | RESIDENTIAL | **Required.** Apify residential proxy to pass rs24.ru's WAF challenge |

#### Example: search for cables

```json
{
  "mode": "search",
  "searchQuery": "кабель",
  "maxItems": 20,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "categoryUrls": ["https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239"],
  "maxItems": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

#### Example: fetch specific product pages

```json
{
  "mode": "productDetails",
  "productUrls": ["https://rs24.ru/product/66065", "2168098"],
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Use cases

- **Price monitoring** — track electrical-equipment pricing across brands and SKUs
- **Procurement & sourcing** — build a catalog of available electrical components for B2B purchasing
- **Market research** — analyze category breadth and brand assortment of a major Russian electrical distributor
- **Catalog enrichment** — pull structured specifications and images into your own product database
- **Competitive intelligence** — compare stock availability and pricing against other electrical suppliers

### 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 (this actor) | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Is this affiliated with rs24.ru or Русский Свет?**
No. This is an independent, third-party scraper that reads publicly available pages on rs24.ru.

**Why is residential proxy required?**
rs24.ru's pages are protected by an Ngenix Web Application Firewall, which issues a JavaScript proof-of-work challenge to every visitor. Datacenter IPs get an HTTP 503 challenge followed by a hard HTTP 403 block page ("Доступ временно ограничен" — "Access temporarily restricted"). Residential IPs pass the challenge reliably, which is why `proxyConfiguration` is a required input, pre-set to the `RESIDENTIAL` group. The actor fails fast without a residential proxy configured.

**Why do some products have no `sku`, `specifications`, or `images`?**
Those fields are only populated when they are present on the given page. Search/category results are lighter cards than full product pages — use `mode=productDetails` for the richest data.

**What currency are prices in?**
Russian rubles (RUB). rs24.ru does not publish other currencies.

**Why do some products have no `stockByBranch` or `totalStock`?**
These come from rs24.ru's internal per-branch warehouse-quantity endpoint, fetched only in `mode=productDetails`. If that endpoint returns no data for a given product (e.g. a discontinued SKU), the fields are simply omitted rather than filled with a guess.

**Why is `maxItems` capped at 500?**
Each page requires a full browser render through a residential proxy to pass the WAF challenge, which is materially slower and more resource-intensive than a plain HTTP request. 500 keeps runs reliable within a reasonable time budget.

**Why do some products have no `relatedProducts`?**
Only populated in `mode=productDetails` when rs24.ru actually rendered a "similar/related products" widget on that specific product page — not every page has one, and the field is omitted rather than guessed when it's absent.

**Why did my `byCategory` category URL return 0 items?**
rs24.ru's catalog has both broad "hub" categories (e.g. `/catalog/rozetki-22`) that only render subcategory tiles with no products of their own, and leaf categories (e.g. `/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239`) that render the actual product grid. Pass a leaf category URL — find one via a product's `categoryBreadcrumbs[]` (from `mode=productDetails`) or by clicking through rs24.ru's own category tree until the page shows products.

**Does this work for the Belarus/Kazakhstan branches?**
The scraper reads the main rs24.ru catalog, which serves the full CIS-wide product range from a single storefront.

**How fresh is the data?**
Every run fetches live pages at request time — prices and stock status reflect what rs24.ru shows at that moment.

# Actor input Schema

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

What to fetch.

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

Free-text product search (mode=search), e.g. `розетка`, `кабель`, `лампа`, `автомат`.

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

One or more rs24.ru category page URLs, e.g. `https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239`. Use a leaf (most specific) category — a broad parent category page (e.g. `/catalog/rozetki-22`) only renders subcategory tiles with no products of its own and will return 0 items.

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

Full product URLs (e.g. `https://rs24.ru/product/66065`) or bare numeric product IDs (e.g. `66065`).

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

Hard cap on emitted records per run.

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

rs24.ru fronts an Ngenix WAF that returns a JS proof-of-work challenge to every datacenter IP (503, then a hard 403 'Доступ временно ограничен' block page) — a residential proxy is required to pass the challenge. See the README's Data Source section for the exact block signals observed.

## Actor input object example

```json
{
  "mode": "productDetails",
  "searchQuery": "розетка",
  "categoryUrls": [
    "https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239"
  ],
  "productUrls": [
    "https://rs24.ru/product/66065"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing all scraped rs24.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": "productDetails",
    "searchQuery": "розетка",
    "categoryUrls": [
        "https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239"
    ],
    "productUrls": [
        "https://rs24.ru/product/66065"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/russkiysvet-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": "productDetails",
    "searchQuery": "розетка",
    "categoryUrls": ["https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239"],
    "productUrls": ["https://rs24.ru/product/66065"],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/russkiysvet-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": "productDetails",
  "searchQuery": "розетка",
  "categoryUrls": [
    "https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239"
  ],
  "productUrls": [
    "https://rs24.ru/product/66065"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/russkiysvet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Russkiy Svet (rs24.ru) Electrical Equipment Scraper",
        "description": "Scrape rs24.ru (Русский Свет) - a major Russian B2B electrical-equipment distributor with ~850,000 SKUs. Search products, browse categories, and fetch full product details: prices, specifications, brands, images, stock status.",
        "version": "1.0",
        "x-build-id": "0qCosjgiepCmZNOHZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~russkiysvet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-russkiysvet-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~russkiysvet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-russkiysvet-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~russkiysvet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-russkiysvet-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",
                        "type": "string",
                        "description": "Free-text product search (mode=search), e.g. `розетка`, `кабель`, `лампа`, `автомат`.",
                        "default": "розетка"
                    },
                    "categoryUrls": {
                        "title": "Category URLs (mode=byCategory)",
                        "type": "array",
                        "description": "One or more rs24.ru category page URLs, e.g. `https://rs24.ru/catalog/rozetka-mednaya-kommunikatsionnaya-vitaya-para-2239`. Use a leaf (most specific) category — a broad parent category page (e.g. `/catalog/rozetki-22`) only renders subcategory tiles with no products of its own and will return 0 items.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs or IDs (mode=productDetails)",
                        "type": "array",
                        "description": "Full product URLs (e.g. `https://rs24.ru/product/66065`) or bare numeric product IDs (e.g. `66065`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records per run.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "rs24.ru fronts an Ngenix WAF that returns a JS proof-of-work challenge to every datacenter IP (503, then a hard 403 'Доступ временно ограничен' block page) — a residential proxy is required to pass the challenge. See the README's Data Source section for the exact block signals observed.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
