# Lemanapro Scraper (`crawlerbros/lemanapro-scraper`) Actor

Scrape Lemanapro.ru (Leroy Merlin Russia) product data - search by keyword, browse by category, or fetch full product details: price, availability, rating, images, brand, SKU.

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

## Lemanapro Scraper

Scrape [Lemanapro.ru](https://lemanapro.ru) — Leroy Merlin's rebranded Russian home-improvement and DIY retailer — for product data. Search by keyword, browse a category, or fetch full details for specific product URLs: price, old/discounted price, currency, brand, availability, rating, review count, image gallery, SKU, category breadcrumbs, a full specifications table, and live delivery/stock info.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Rich product data:** title, price, old price + discount %, currency, brand, availability, rating, review count, image gallery, SKU
- **Full product-page detail** (mode=`productDetails`): category breadcrumb trail, a specifications/characteristics table, and live delivery/stock info (available quantity, delivery region, pickup and courier-delivery estimates), in addition to everything listing mode returns
- **Curated category list** with a free-text override for any catalogue slug
- **Empty fields are omitted** — every record only contains fields that were actually found

### Output per product

- `title` — product name
- `price`, `currency` — numeric price and currency code (e.g. `RUB`)
- `oldPrice`, `discountPercent` — pre-discount price and computed discount percentage, when the product is on sale
- `brand` — manufacturer / brand name
- `sku` — article / SKU number
- `availability` — `In stock`, `Out of stock`, `Preorder`, or `Limited availability`
- `rating` — average customer rating (0-5)
- `reviewCount` — number of customer reviews
- `imageUrl`, `images[]` — product photo URL(s); `images[]` is a full gallery (mode=`productDetails`)
- `description` — product description (mode=`productDetails`, where available)
- `breadcrumbs`, `categoryPath`, `category` — full category breadcrumb trail, the trail minus the trailing product-name crumb, and its last segment (mode=`productDetails`)
- `specifications[]` — `{name, value}` pairs from the product's characteristics table (mode=`productDetails`, where the page exposes one)
- `stockAvailabilityText` — live stock-quantity sentence from the product page's delivery widget, e.g. `"Доступно для заказа 156 кор."` (mode=`productDetails`)
- `deliveryRegion` — the delivery region the price/stock above applies to, e.g. `"Москва, Московская область"` (mode=`productDetails`)
- `pickupText` — in-store/pickup-point availability sentence, e.g. `"Самовывоз сегодня бесплатно"` (mode=`productDetails`, where offered)
- `deliveryEstimateText` — courier-delivery estimate sentence, e.g. `"Доставим сегодня от 390 ₽"` (mode=`productDetails`, where offered)
- `productUrl` — canonical product page URL
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `ламинат` | Free-text search query (mode=`search`) |
| `category` | string | – | Curated category (mode=`byCategory`) |
| `customCategorySlug` | string | – | Any catalogue slug, overrides `category` |
| `productUrls` | array | – | Product page URLs (mode=`productDetails`) |
| `maxItems` | int | `10` | Hard cap on emitted products (1–500) |
| `proxyConfiguration` | object | Residential (RU) | **Required** — see "Why does this actor need a residential proxy?" in the FAQ |

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "ламинат",
  "maxItems": 20
}
````

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "plitka-keramicheskaya",
  "maxItems": 50
}
```

#### Example: fetch specific products

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://lemanapro.ru/product/laminat-artens-12345678/"
  ]
}
```

### Use cases

- **Price monitoring** — track Lemanapro prices for building materials and home-improvement goods
- **Market research** — compare product ranges, brands, and availability across categories
- **Catalog enrichment** — pull structured product data (images, SKUs, ratings) for cross-listing
- **Competitive intelligence** — monitor a Russian DIY retailer's assortment and pricing over time
- **Fulfillment/logistics research** — see live stock quantity, pickup and courier-delivery estimates per product (mode=`productDetails`)

### 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 (this actor) | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <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

**Why does this actor need a residential proxy?** Lemanapro.ru blocks traffic from non-residential and non-Russian IP addresses with an anti-bot / WAF layer — a Russian residential proxy is required for every request to load successfully, so `proxyConfiguration` is a required input pinned to `RESIDENTIAL` + `RU` by default.

**Does this actor respect Lemanapro's `robots.txt`?** `robots.txt` disallows crawling `/search/`, which mode=`search` uses — that path is the only keyword-search entry point the storefront itself exposes to end users, so this actor uses it the same way a visitor's browser would. Browsing by category (`byCategory`) and fetching specific product pages by URL (`productDetails`) use paths that are not disallowed.

**What's the difference between `category` and `customCategorySlug`?** `category` is a curated dropdown of common top-level categories. `customCategorySlug` lets you target any other catalogue slug as it appears in a Lemanapro category URL (`lemanapro.ru/catalogue/<slug>/`) — it overrides `category` when set.

**Can I fetch a product by URL directly?** Yes — use `mode=productDetails` with one or more URLs in `productUrls`.

**Are prices in Russian rubles?** Yes, `currency` is normally `RUB`.

**What if a field is missing from a record?** Only fields that were actually found on the page are included — empty/unavailable fields are omitted rather than shown as null or "N/A".

**What region does `stockAvailabilityText` / `deliveryRegion` reflect?** Whatever region the scraping session's residential proxy IP resolved to (normally Moscow, since the proxy is pinned to Russia broadly, not a specific city) — `deliveryRegion` is included on every `productDetails` record precisely so you can see which region the stock/delivery figures apply to. This actor does not currently support requesting a different delivery region.

**Is this actor affiliated with Lemanapro or Leroy Merlin?** No, this is a third-party actor that reads Lemanapro.ru's publicly browsable storefront pages; it is not affiliated with, endorsed by, or operated by Lemanapro or Leroy Merlin.

# Actor input Schema

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

What to fetch.

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

Free-text search query, e.g. ламинат (laminate), краска (paint), дверь (door).

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

Curated top-level category. Use `customCategorySlug` instead to target any other category slug from the site's catalogue navigation.

## `customCategorySlug` (type: `string`):

Overrides `category`. Any catalogue slug as it appears in a Lemanapro category URL, e.g. `https://lemanapro.ru/catalogue/<slug>/` → `<slug>`.

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

Full Lemanapro product page URLs to fetch detailed data for.

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

Hard cap on emitted product records.

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

Lemanapro.ru is protected by QRATOR (JS-challenge + IP-reputation WAF) that blocks all non-residential and non-Russian IPs — including full real browsers. A Russian residential proxy is required to load any page.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "ламинат",
  "category": "laminat",
  "productUrls": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Lemanapro 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": "ламинат",
    "category": "laminat",
    "productUrls": [],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/lemanapro-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": "ламинат",
    "category": "laminat",
    "productUrls": [],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/lemanapro-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": "ламинат",
  "category": "laminat",
  "productUrls": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call crawlerbros/lemanapro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lemanapro Scraper",
        "description": "Scrape Lemanapro.ru (Leroy Merlin Russia) product data - search by keyword, browse by category, or fetch full product details: price, availability, rating, images, brand, SKU.",
        "version": "1.0",
        "x-build-id": "eSnToM1oWUtMGjWDp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~lemanapro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-lemanapro-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~lemanapro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-lemanapro-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~lemanapro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-lemanapro-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",
                    "maxItems",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text search query, e.g. ламинат (laminate), краска (paint), дверь (door).",
                        "default": "ламинат"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "",
                            "laminat",
                            "plitka-keramicheskaya",
                            "oboi",
                            "kraski",
                            "santehnika",
                            "instrumenty",
                            "osveshchenie",
                            "mebel",
                            "dveri",
                            "okna",
                            "napolnye-pokrytiya",
                            "stroitelnye-materialy",
                            "sadovaya-tehnika-i-instrumenty",
                            "elektrika",
                            "krepyozh",
                            "otdelochnye-materialy",
                            "vodosnabzhenie-i-otoplenie",
                            "kuhni",
                            "dekor",
                            "khranenie-i-organizatsiya"
                        ],
                        "type": "string",
                        "description": "Curated top-level category. Use `customCategorySlug` instead to target any other category slug from the site's catalogue navigation.",
                        "default": ""
                    },
                    "customCategorySlug": {
                        "title": "Custom category slug (mode=byCategory)",
                        "type": "string",
                        "description": "Overrides `category`. Any catalogue slug as it appears in a Lemanapro category URL, e.g. `https://lemanapro.ru/catalogue/<slug>/` → `<slug>`."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetails)",
                        "type": "array",
                        "description": "Full Lemanapro product page URLs to fetch detailed data for.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted product records.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Lemanapro.ru is protected by QRATOR (JS-challenge + IP-reputation WAF) that blocks all non-residential and non-Russian IPs — including full real browsers. A Russian residential proxy is required to load any page.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```