# Yandex Lavka Scraper: Парсер Яндекс Лавка (`getascraper/yandex-lavka-scraper`) Actor

Get SKU-level product, price, discount, and stock data from Yandex Lavka quick-commerce grocery by category and city. No browser, no proxy required. Парсер товаров Яндекс Лавки.

- **URL**: https://apify.com/getascraper/yandex-lavka-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.98 / 1,000 product rows

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.md):

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

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

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

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

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

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

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

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

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


# README

## 🛒 Yandex Lavka Scraper: Парсер Яндекс Лавка

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FDF2EF;border:1px solid #F6CDC2;border-top:4px solid #D6300B;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Turn Yandex Lavka categories into ready-to-use grocery price and stock data.</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">Pull SKU-level prices, discounts, and stock status from Яндекс Лавка by category and city. No browser and no proxy required.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🥛 Full category pulls</span><br>
<span style="font-size:12px;color:#57534E">Every product in a category comes back in one run, no scrolling or pagination needed</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">💸 Full pricing picture</span><br>
<span style="font-size:12px;color:#57534E">Current price, old price, and discount percent on every row</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">📦 Real stock signals</span><br>
<span style="font-size:12px;color:#57534E">In-stock, low-stock, and coming-soon flags straight from Lavka's own data</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🏙️ Multi-city coverage</span><br>
<span style="font-size:12px;color:#57534E">Query Moscow, Saint Petersburg, or any custom depot coordinates in one run</span>
</td>
</tr>
</table>

Get structured data from **Яндекс Лавка**, Yandex's quick-commerce grocery delivery service in Russia. Give this Actor a list of category slugs and cities, and it returns one clean row per product per depot: title, pack size, current price, old price, discount, stock status, allergens, and an image. Built for grocery price monitoring, quick-commerce competitive intel, and any tool that needs clean, structured product data without checking one dark store at a time.

### 🔍 What does Yandex Lavka Scraper do?

This Actor pulls product data from **Яндекс Лавка** (lavka.yandex.ru), Yandex's quick-commerce grocery delivery service, by category and city.

Give it one or more category slugs, such as cheese, bread, or milk products, along with a city or custom coordinates, and it returns every product Lavka carries in that category at that depot: pack size, current price, old price, discount percent, stock flags, allergens, private-label status, and an image. Add as many categories and cities as you want, they all run in the same batch. It runs on the Apify platform with scheduling, integrations (Make, Zapier, Google Sheets), and run monitoring built in.

<table width="100%"><tr>
<td style="padding:12px 18px;background:#FDF2EF;border-left:4px solid #D6300B">
<span style="font-size:15px;color:#1C1917">⚡ <b>No proxy needed.</b> This Actor reaches Lavka's own product data directly, so runs start fast and stay cheap, no residential IPs required.</span>
</td>
</tr></table>

### 💡 Why use Yandex Lavka Scraper?

- **Grocery price and stock monitoring** - track price, discount, and stock across categories and cities without opening a single product page by hand.
- **Quick-commerce competitive intel** - see how a category is priced and stocked at Lavka's dark stores, run after run.
- **Sourcing and resale research** - spot markdowns and private-label products worth researching before anyone else does.
- **Building your own tools** - feed clean price and stock data straight into a monitoring, comparison, or catalog tool.

### 🚀 How to use Yandex Lavka Scraper

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Pick your categories</span><br>
<span style="font-size:12px;color:#57534E">Add one or more category slugs, or use "all" to cover every category.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Choose your cities</span><br>
<span style="font-size:12px;color:#57534E">Select named cities or add custom depot coordinates.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Start and export</span><br>
<span style="font-size:12px;color:#57534E">Download results as a spreadsheet or table, or pull them into your own tools.</span>
</td>
</tr>
</table>

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `categories` | array of category slugs | No | Category slugs to scrape (e.g. `cheese`, `hleb`, `milk_products`). Use `["all"]` to scrape every category discovered on the site at run time. |
| `cities` | array of city names | No | Named cities to scrape, each with a built-in depot coordinate. Supports `moscow` and `spb`. |
| `locations` | array of coordinate objects | No | Optional custom depot coordinates, used in addition to cities. Each item needs a latitude, longitude, and an optional label. |
| `maxItems` | integer | No | Maximum number of product rows to return across every category and city combined (0 = no limit, default 200). Keep this modest while testing. |
| `proxyConfiguration` | proxy configuration | No | Datacenter proxy (default) is sufficient. Lavka's product data does not require a residential proxy. |

### 📦 Output

Download the results as a spreadsheet, a table, or structured data ready for your own systems. Each row is one product at one depot:

````

{
"id": "28c176db05534c0f9f3fb7177dd6127f000100020000",
"deepLink": "syr-lamber-lajt-30percent-230-gram",
"title": "Сыр Ламбер Light",
"longTitle": "Сыр «Ламбер» Light 30%",
"amount": "230 г",
"currentPrice": 258,
"oldPrice": 369,
"discountPercent": 30,
"available": true,
"isLowStock": false,
"comingSoon": false,
"quantityLimit": 9,
"maxAmount": 9,
"allergens": "lactose, milk",
"customTags": "HighProtein, lowCarb",
"isMarkdown": false,
"imageUrl": "https://avatars.mds.yandex.net/get-grocery-goods/2888787/229bc081-3ddd-48ab-8edd-9cb62d1dea4f/600x600",
"categorySlug": "cheese",
"locationLabel": "Moscow",
"lat": 55.7647,
"lon": 37.6386,
"scrapedAt": "2026-07-10T00:53:46.334Z"
}

````

### 📊 Output data fields

| Field | Type | Description |
|---|---|---|
| `id` | string | Lavka's internal product identifier |
| `deepLink` | string | The product's URL slug on Lavka |
| `title` | string | Short product title |
| `longTitle` | string | Full product title, including size and strength where relevant |
| `amount` | string | Pack size as shown on Lavka (e.g. "230 г") |
| `currentPrice` | number | Current price |
| `oldPrice` | number | Price before a markdown, when Lavka shows one |
| `discountPercent` | number | Discount percentage, when Lavka reports one for this product |
| `discountLabel` | string | Lavka's own discount label text, when present |
| `available` | boolean | Whether the product currently shows as in stock |
| `isLowStock` | boolean | Whether Lavka flags the product as running low |
| `comingSoon` | boolean | Whether the product is listed as coming soon rather than available now |
| `quantityLimit` | number | Maximum quantity allowed per order, when Lavka sets one |
| `maxAmount` | number | Maximum purchasable amount, when Lavka sets one |
| `allergens` | string | Listed allergens, when Lavka provides them |
| `customTags` | string | Dietary or product tags Lavka attaches (e.g. high protein, low carb) |
| `privateLabelBrand` | string | Private-label brand name, when the product is one |
| `isMarkdown` | boolean | Whether the product is flagged as clearance stock |
| `imageUrl` | string | Product image link |
| `categorySlug` | string | Which category this row was found under |
| `locationLabel` | string | The city or depot label this row was queried against |
| `lat` | number | Latitude used for this depot query |
| `lon` | number | Longitude used for this depot query |
| `scrapedAt` | string | When the row was collected |

### 💰 Pricing

This Actor uses pay-per-result pricing: you pay for the products you actually get back, and nothing for an empty run. There is no subscription and no minimum spend. Use `maxItems` to control how many results a run returns.

### ⭐ Enjoying Yandex Lavka Scraper: Парсер Яндекс Лавка?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FDF2EF;border:1px solid #F6CDC2;border-left:5px solid #D6300B;border-radius:10px 10px 0 0">
<span style="font-size:20px;letter-spacing:4px">⭐ ⭐ ⭐ ⭐ ⭐</span><br>
<span style="font-size:17px;font-weight:800;color:#1C1917">Turning Yandex Lavka categories into structured grocery data, no browser needed?</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other researchers and sellers watching Russian grocery delivery find it. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#D6300B;border:1px solid #F6CDC2;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/yandex-lavka-scraper/reviews" style="display:block;padding:13px 16px;color:#FFFFFF;text-decoration:none;font-weight:800;font-size:15px;letter-spacing:0.3px">★&nbsp;&nbsp;Rate this Actor on Apify</a>
</td>
</tr>
</table>

### ✨ Tips

- Use `["all"]` in `categories` to cover every category Lavka has, instead of listing them one by one.
- Keep `maxItems` low while testing a new category list, then raise it once you know what it returns.
- Add custom `locations` when you need a specific dark store's coverage rather than a whole city's default point.
- Batch related categories in one run instead of starting a new run for every slug.

### ❓ FAQ, disclaimers, and support

**Что такое парсер Яндекс Лавки?** This Actor is a parser (парсер) for Yandex Lavka. Give it category slugs and cities, and it returns structured grocery product data: price, discount, stock status, and pack size for each matching product.

**Как собрать данные о товарах с Яндекс Лавки по категориям?** Add your category slugs to `categories`, pick a city or custom coordinates, and run the Actor. It returns every product in that category at that depot in one run.

**Why do results differ between cities?** Lavka serves each depot separately, so the same category can show different products, prices, and stock levels in Moscow versus Saint Petersburg.

**Do I need a proxy to run this?** No. Lavka's product data does not require a residential proxy. The default datacenter setting works out of the box.

**Does this show exact stock counts?** No. Lavka does not expose an exact on-hand quantity anonymously. This Actor reports the in-stock, low-stock, and coming-soon flags Lavka itself provides, rather than guessing a number.

**Is scraping Yandex Lavka data legal?** This Actor collects publicly available product data. You are responsible for complying with Yandex Lavka's Terms of Service and applicable laws in your use of the data.

**Found a bug or need a field added?** Open an issue on the Actor's **Issues** tab. Custom solutions are available on request.

### 🔗 Other actors

- [Yandex Eda Scraper](https://apify.com/getascraper/yandex-eda-scraper) ↗ - extracts restaurant menus and pricing from Russia's food-delivery platform.
- [Yandex Market Scraper](https://apify.com/getascraper/yandex-market-scraper) ↗ - searches Yandex Market by keyword for pricing and seller data.
- [Detmir Scraper](https://apify.com/getascraper/detmir-scraper) ↗ - collects product and pricing data from the Detsky Mir marketplace.
- [Uzum Scraper](https://apify.com/getascraper/uzum-scraper) ↗ - extracts marketplace product data from Uzbekistan's Uzum.
- [Magnit Market Scraper](https://apify.com/getascraper/magnit-market-scraper) ↗ - extracts product data from the Magnit/KazanExpress marketplace.

# Actor input Schema

## `categories` (type: `array`):

Category slugs to scrape (e.g. "cheese", "hleb", "milk_products"). Use ["all"] to scrape every category slug discovered on the site at run time.
## `cities` (type: `array`):

Named cities to scrape, each with a built-in depot coordinate. Supported values: "moscow", "spb".
## `locations` (type: `array`):

Optional custom depot coordinates, used in addition to Cities. Each item: { "lat": 55.75, "lon": 37.61, "label": "My depot" }.
## `maxItems` (type: `integer`):

Maximum number of product rows to return across all category x location pairs combined (0 = no limit). Keep this modest during testing.
## `proxyConfiguration` (type: `object`):

Yandex Lavka's category API requires a Russian residential IP in production (Apify's shared datacenter pool gets redirected).

## Actor input object example

```json
{
  "categories": [
    "cheese"
  ],
  "cities": [
    "moscow"
  ],
  "locations": [],
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
````

# Actor output Schema

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

No description

# 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 = {
    "categories": [
        "cheese"
    ],
    "cities": [
        "moscow"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/yandex-lavka-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 = {
    "categories": ["cheese"],
    "cities": ["moscow"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/yandex-lavka-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 '{
  "categories": [
    "cheese"
  ],
  "cities": [
    "moscow"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call getascraper/yandex-lavka-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Lavka Scraper: Парсер Яндекс Лавка",
        "description": "Get SKU-level product, price, discount, and stock data from Yandex Lavka quick-commerce grocery by category and city. No browser, no proxy required. Парсер товаров Яндекс Лавки.",
        "version": "0.1",
        "x-build-id": "ytUi9bffWEkw8qL0T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~yandex-lavka-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-yandex-lavka-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/getascraper~yandex-lavka-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-yandex-lavka-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/getascraper~yandex-lavka-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-yandex-lavka-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",
                "properties": {
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Category slugs to scrape (e.g. \"cheese\", \"hleb\", \"milk_products\"). Use [\"all\"] to scrape every category slug discovered on the site at run time.",
                        "default": [
                            "cheese"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Named cities to scrape, each with a built-in depot coordinate. Supported values: \"moscow\", \"spb\".",
                        "default": [
                            "moscow"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Custom locations",
                        "type": "array",
                        "description": "Optional custom depot coordinates, used in addition to Cities. Each item: { \"lat\": 55.75, \"lon\": 37.61, \"label\": \"My depot\" }.",
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of product rows to return across all category x location pairs combined (0 = no limit). Keep this modest during testing.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Yandex Lavka's category API requires a Russian residential IP in production (Apify's shared datacenter pool gets redirected).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
