# Maxidom Scraper (`crawlerbros/maxidom-scraper`) Actor

Scrape Maxidom.ru - a major Russian home-improvement, DIY and power-tools retailer. Search products, browse categories, and fetch full product details: price, stock, brand, images, specs and descriptions.

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

## Maxidom Scraper

Scrape [Maxidom.ru](https://www.maxidom.ru) — one of Russia's largest home-improvement, DIY and power-tools retailers. Search products, browse a category, fetch full product details (price, stock, brand, images, specifications, description) by URL, or pull customer reviews and ratings. No login, no cookies, no residential proxy required.

### What this actor does

- **Four modes:** `search`, `byCategory`, `productDetails`, `reviews`
- **Search** — free-text product search (Russian or English keywords), with full pagination through every real result page
- **Browse a category** — pass a category slug or URL, get every product in that category across all of Maxidom's own result pages
- **Product lookup** — pass one or more product page URLs to get full detail records
- **Reviews** — pass one or more product page URLs to get customer reviews, star ratings and a per-product rating summary
- **Sort** — relevance (default), price low→high, price high→low
- **Filters** — min/max price (RUB), in-stock only
- **Discount info** — old price and discount percent are included whenever a product has an active price cut
- **Empty fields are omitted** — every record only contains fields Maxidom actually published for that product

### Output per product

- `productId` — Maxidom's internal numeric product code
- `title`, `url`
- `price` (integer, RUB), `oldPrice`, `discountPercent` (only present on an active price cut), `currency`
- `imageUrl`, `images[]` (up to 10 photos, listing and product detail modes)
- `category`, `categoryPath[]`, `categorySlug`
- `brand`, `sku` (product detail mode, when published)
- `attributes` — key/value specification table (model, power, chuck size, etc.)
- `description` (product detail mode)
- `inStock`, `availabilityText`
- `productCode` (product detail mode)
- `recordType: "product"`, `scrapedAt`

### Output: per-review and per-product summary (mode = `reviews`)

Two record types are emitted, both tagged with `recordType`:

**`recordType: "reviewSummary"`** — one per product:
- `productId`, `productUrl`
- `reviewsTotalCount` — total published reviews for the product
- `averageRating` — mean star rating (1–5 scale), rounded to 2 decimals
- `recommendsTotalCount` — how many reviewers marked the product as recommended
- `ratingBreakdown` — count of reviews per star value, e.g. `{"4": 1, "5": 3}`
- `scrapedAt`

**`recordType: "review"`** — one per individual review:
- `productId`, `productUrl`, `reviewId`
- `author`
- `rating` (1–5)
- `recommends` (boolean, when the reviewer indicated it)
- `pros`, `cons`, `comment` — free-text review body fields, whichever the reviewer filled in
- `publishDate`
- `images[]` — reviewer-submitted photos, when present
- `scrapedAt`

A product with zero reviews emits no records for that `productUrl`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` / `reviews` |
| `searchQuery` | string | `дрель` | Free-text query (mode=search) |
| `category` | string | – | Category slug or URL (mode=byCategory) |
| `productUrls` | array | – | Full product page URLs (mode=productDetails, reviews) |
| `sortBy` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` (mode=search, byCategory) |
| `inStockOnly` | bool | `false` | Only emit in-stock products (mode=search, byCategory) |
| `priceMin` | int | – | Drop products cheaper than this, RUB (mode=search, byCategory) |
| `priceMax` | int | – | Drop products more expensive than this, RUB (mode=search, byCategory) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–200) |
| `proxyConfiguration` | object | AUTO | Apify proxy (free datacenter group is sufficient) |

#### Example: search for a power drill, cheapest first

```json
{
  "mode": "search",
  "searchQuery": "перфоратор",
  "sortBy": "priceAsc",
  "inStockOnly": true,
  "maxItems": 20
}
````

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "dreli-shurupoverty-akkumulyatornye",
  "maxItems": 30
}
```

#### Example: fetch specific products

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/1001193148/"
  ]
}
```

#### Example: fetch reviews for a product

```json
{
  "mode": "reviews",
  "productUrls": [
    "https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/1001193148/"
  ]
}
```

### Use cases

- **Price monitoring** — track power-tool and hardware prices, and discount events, across Maxidom's catalog
- **Market research** — compare brand assortment and pricing for a category
- **Product data enrichment** — pull specifications, images and descriptions for a known list of products
- **Availability tracking** — check stock status for specific SKUs before purchasing
- **Reputation analysis** — pull star ratings and review text to gauge customer sentiment for a product line

### 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 (this actor) | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**What's Maxidom?** A major Russian home-improvement / DIY retailer (maxidom.ru) selling power tools, hand tools, building materials, plumbing, and household goods, with stores across Russia and nationwide delivery.

**Do I need to log in or supply cookies?** No — search, category and product pages are all publicly accessible.

**Why is `productUrls` required instead of bare product IDs?** Maxidom product URLs are keyed by both category slug and numeric ID (`/catalog/<slug>/<id>/`); there is no ID-only lookup route, so the actor needs the full URL (as copied from the site or from a prior `search`/`byCategory` run's `url` field).

**How many results does `search` / `byCategory` return per query?** The actor pages through Maxidom's own real result pages (following the site's own "next page" link) until it reaches `maxItems` or the query/category's actual last page — it never stops after page 1 and never pads output with placeholder records.

**Why is `attributes` different per product?** Maxidom publishes a different specification table per product category (a drill has "chuck diameter", a tile has "size" and "finish"). The actor passes through whatever key/value pairs the product page actually lists.

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

**When do `oldPrice` and `discountPercent` appear?** Only on products with an active price cut, as published on Maxidom's own listing pages — a product at full price will not have either field.

**How does `mode=reviews` work?** For each `productUrls` entry the actor calls Maxidom's own public reviews endpoint (keyed by the product's numeric code) and emits one `reviewSummary` record plus one `review` record per published review. A product with no reviews yet simply produces no records for that URL — there is no synthetic "0 reviews" placeholder.

**Is this affiliated with Maxidom?** No — this is a third-party actor that reads Maxidom's publicly available store pages; it is not operated by or affiliated with Maxidom.ru.

# Actor input Schema

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

What to fetch.

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

Free-text search query in Russian or English (mode=search), e.g. дрель, перфоратор, шуруповерт.

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

Category slug or full category URL, e.g. `dreli-shurupoverty-akkumulyatornye` or `https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/`.

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

Full Maxidom product page URLs, e.g. `https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/1001193148/`. Bare numeric product IDs cannot be resolved on their own — Maxidom URLs are keyed by category slug + ID.

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

Sort order for search/category results.

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

Only emit products currently in stock.

## `priceMin` (type: `integer`):

Drop products cheaper than this (in Russian rubles).

## `priceMax` (type: `integer`):

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

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

Hard cap on emitted records. For search/byCategory, the actor follows Maxidom's own server-rendered pagination (page after page) until this cap is reached or the category/query's real last page is hit. For mode=reviews, this caps the total review + review-summary records emitted across all productUrls.

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

Apify proxy (free AUTO/datacenter group is sufficient — Maxidom does not block datacenter IPs).

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "дрель",
  "productUrls": [],
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Maxidom 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": "дрель",
    "productUrls": [],
    "sortBy": "relevance",
    "inStockOnly": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/maxidom-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": "дрель",
    "productUrls": [],
    "sortBy": "relevance",
    "inStockOnly": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/maxidom-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": "дрель",
  "productUrls": [],
  "sortBy": "relevance",
  "inStockOnly": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/maxidom-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Maxidom Scraper",
        "description": "Scrape Maxidom.ru - a major Russian home-improvement, DIY and power-tools retailer. Search products, browse categories, and fetch full product details: price, stock, brand, images, specs and descriptions.",
        "version": "1.0",
        "x-build-id": "6iunWbSL0lmbkLeBP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~maxidom-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-maxidom-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~maxidom-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-maxidom-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~maxidom-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-maxidom-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search query in Russian or English (mode=search), e.g. дрель, перфоратор, шуруповерт.",
                        "default": "дрель"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "type": "string",
                        "description": "Category slug or full category URL, e.g. `dreli-shurupoverty-akkumulyatornye` or `https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/`."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetails, reviews)",
                        "type": "array",
                        "description": "Full Maxidom product page URLs, e.g. `https://www.maxidom.ru/catalog/dreli-shurupoverty-akkumulyatornye/1001193148/`. Bare numeric product IDs cannot be resolved on their own — Maxidom URLs are keyed by category slug + ID.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc"
                        ],
                        "type": "string",
                        "description": "Sort order for search/category results.",
                        "default": "relevance"
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Only emit products currently in stock.",
                        "default": false
                    },
                    "priceMin": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (in Russian rubles)."
                    },
                    "priceMax": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (in Russian rubles)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records. For search/byCategory, the actor follows Maxidom's own server-rendered pagination (page after page) until this cap is reached or the category/query's real last page is hit. For mode=reviews, this caps the total review + review-summary records emitted across all productUrls.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy (free AUTO/datacenter group is sufficient — Maxidom does not block datacenter IPs).",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
