# Yandex Market Pro Scraper (`crawlerbros/yandex-pro-scraper`) Actor

Scrape Yandex Market - Russia's largest e-commerce and price-comparison platform. Search products, browse categories, pull full product details with specs and images, and collect product reviews - with no login, no cookies, and no paid proxy required.

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

## Yandex Market Pro Scraper

Scrape **Yandex Market** (market.yandex.ru) — Russia's largest e-commerce and price-comparison platform. Search by keyword, browse a category, fetch full product specs, or collect customer reviews. Reads the page's own server-rendered data directly, so it stays accurate as the site's visual design changes, and runs without a proxy for most requests.

### What this actor does

- **Four modes** — `search`, `byCategory`, `productDetails`, `reviews` covering keyword search, category browsing, full product specs, and customer reviews
- **No login, no cookies, no CAPTCHA-solving required** — search, category browse, product details, and reviews all work directly against Yandex Market's public pages
- **Proxy is optional, not mandatory** — runs from Apify's free datacenter IPs by default; enable the optional proxy toggle only if you see 0 results or a CAPTCHA/VPN block
- **Rich filtering** — price range, minimum rating, minimum discount %, brand, in-stock-only, and sort order
- **Empty fields are omitted** — a field only appears on a record when Yandex Market actually returned that data

### Output per product / offer record (`search`, `byCategory`)

- `recordType` — `"product"` (aggregate model across sellers) or `"offer"` (a single seller's listing)
- `productId` / `offerId` — Yandex Market's internal id (product records use `productId`, offer records use `offerId`)
- `title`
- `productUrl`
- `slug` — URL slug segment
- `price` — current price in RUB
- `priceMin`, `priceMax`, `priceAvg` — price range across sellers (product records, when multiple offers exist)
- `oldPrice` — pre-discount price
- `discountPercent`
- `currency` — always `RUB`
- `offersCount` — number of sellers currently offering this product (product records)
- `sellerId`, `sellerName`, `sellerRating` — seller identity and rating (offer records only)
- `brand` — resolved from the offer's vendor (offer records only)
- `vendorId`
- `rating`, `reviewsCount`
- `deliveryTimeText` — human-readable delivery estimate, e.g. `27 июля`
- `inStock`, `freeDelivery`, `pickupAvailable`, `expressDelivery` — live delivery flags from the seller's own delivery block (offer records only)
- `guaranteedDelivery` — `true` when the order is fulfilled/guaranteed under Yandex Market's own delivery-and-payment program, `false` for third-party-fulfilled offers (offer records only)
- `bnplAvailable` — buy-now-pay-later available
- `isAvailableForBusiness`
- `categoryIds[]`
- `images[]`
- `scrapedAt`

### Output per product details record (`productDetails`)

All fields from the product/offer record above, plus:

- `recordType: "productDetails"`
- `specs` — full specification table as key/value pairs, e.g. `{"Бренд": "LUNNEN", "Артикул Маркета": "4347177021"}`
- `description` — the product's own marketing description text, when Yandex Market exposes one
- `breadcrumbs[]` — the category path shown on the page, e.g. `["Электроника", "Смартфоны и гаджеты", "Мобильные телефоны", "Мобильные телефоны Apple"]`
- `questionsCount` — number of buyer Q&A questions posted for this product
- `stockLeft` — remaining unit count, only present when Yandex Market is showing a low-stock warning (e.g. `"Осталась 1 шт"`); omitted for normally-stocked listings
- `sellerLogo` — seller's storefront logo image URL
- `sellerOrdersText` — seller's order-volume text as shown on the page, e.g. `"2.2K заказов"`
- `sellerSubscribersText` — seller's follower-count text as shown on the page, e.g. `"846 подписчиков"`
- `sellerAge` — how long the seller has been on Yandex Market, e.g. `"1 год на Маркете"`

### Output per review record (`reviews`)

- `recordType: "review"`
- `reviewId`
- `productId`, `productTitle`, `productUrl` — the reviewed product
- `author`
- `rating`
- `text`
- `pros`, `cons`
- `date` — `YYYY-MM-DD`, when Yandex Market exposes a structured timestamp
- `dateText` — human-readable relative date (e.g. `2 июля`), used as a fallback when no structured `date` is available
- `helpfulVotes`
- `photos[]`
- `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` / `reviews` |
| `searchQuery` | string | `iphone 15` | Free-text search query (mode=search) |
| `categoryName` | string | – | Category / product-type name, e.g. `ноутбуки` (mode=byCategory) |
| `categoryId` | string | – | Optional category `hid` to narrow results further (mode=byCategory) |
| `productUrls` | array | – | Full product URLs or bare numeric product IDs (mode=productDetails, reviews) |
| `sortOrder` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `popularity` / `rating` (mode=search, byCategory) |
| `minPrice` | integer | – | Drop products cheaper than this, in RUB |
| `maxPrice` | integer | – | Drop products more expensive than this, in RUB |
| `minRating` | string | `any` | `any` / `3` / `3.5` / `4` / `4.5` — only keep products at or above this rating |
| `minDiscount` | integer | – | Only keep products discounted by at least this percentage |
| `brand` | string | – | Only keep products whose brand contains this text (case-insensitive). Listings with no discoverable brand info are kept, not dropped |
| `inStockOnly` | boolean | `false` | Only keep currently orderable listings |
| `reviewsSortOrder` | string | `newest` | `newest` / `highestRating` / `lowestRating` / `mostHelpful` (mode=reviews) |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–1000); per query for search/byCategory, per URL for productDetails/reviews |
| `proxyConfiguration` | proxy | disabled | Optional Apify proxy (free AUTO group works well as a fallback) |

#### Example: search with filters

```json
{
  "mode": "search",
  "searchQuery": "iphone 15",
  "sortOrder": "priceAsc",
  "minPrice": 30000,
  "maxPrice": 80000,
  "minRating": "4",
  "inStockOnly": true,
  "maxItems": 50
}
````

#### Example: browse a category by name

```json
{
  "mode": "byCategory",
  "categoryName": "ноутбуки",
  "sortOrder": "rating",
  "minDiscount": 10,
  "maxItems": 100
}
```

#### Example: full product details

```json
{
  "mode": "productDetails",
  "productUrls": [
    "https://market.yandex.ru/product--noutbuk-lunnen-ground-16-ll6fawg07/816830091"
  ]
}
```

#### Example: customer reviews

```json
{
  "mode": "reviews",
  "productUrls": ["816830091"],
  "reviewsSortOrder": "mostHelpful",
  "maxItems": 20
}
```

### Use cases

- **Price monitoring** — track price and discount changes across product searches or categories over time
- **Competitor intelligence** — benchmark pricing, ratings, and review volume against Yandex Market listings
- **Product research** — collect specs, ratings, and customer feedback before entering the Russian market
- **Category analysis** — pull all listings in a category to understand price ranges and brand distribution

### Other Russian marketplace actors by CrawlerBros

| Actor | URL |
|---|---|
| Citilink Scraper - Russian Electronics Store Products | <https://apify.com/crawlerbros/citilink-scraper> |
| DNS-Shop Scraper | <https://apify.com/crawlerbros/dns-shop-scraper> |
| Eldorado Scraper | <https://apify.com/crawlerbros/eldorado-scraper> |
| ETM Electrical Equipment Scraper | <https://apify.com/crawlerbros/etm-scraper> |
| Holodilnik.ru Scraper | <https://apify.com/crawlerbros/holodilnik-scraper> |
| Lemanapro Scraper | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <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 (this actor) | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Does this work for Russian-language searches?**
Yes — search queries can be in Russian or English; Yandex Market returns matching results either way.

**Do I need a proxy?**
No, not usually. Yandex Market's search, category, product, and review pages are typically reachable directly. The optional `proxyConfiguration` input is there as a fallback if you hit a CAPTCHA or a "using a VPN" block.

**How many results can I get per query?**
Up to 1000 per run (set `maxItems`). Pagination follows Yandex Market's own page-count signal.

**Can I look up multiple products at once?**
Yes — pass multiple URLs (or bare product IDs) in `productUrls` for `productDetails` or `reviews` mode.

**What's the difference between a `product` record and an `offer` record?**
A `product` record is an aggregate model summary (e.g. price range across all sellers, no single seller). An `offer` record is one specific seller's listing for that model, which is why seller name/rating, brand, and live delivery flags only appear on `offer` records.

**What does `guaranteedDelivery` mean?**
It reflects Yandex Market's own fulfillment flag — `true` when the order is fulfilled and guaranteed under Yandex Market's own delivery-and-payment program, `false` when a third-party seller fulfills it directly.

**Why do some category pages behave differently?**
Some category pages on Yandex Market require picking a delivery address before showing results. `byCategory` mode routes around this by using Yandex Market's own category-scoped search, which returns the same product data without needing an address.

**Why might I not get every historical review for a very popular product?**
Review volume reflects what Yandex Market embeds on the product page (and its review sub-pages, when available); extremely high-review products may not expose every historical review in a single page load.

**Is this affiliated with Yandex Market?**
No — this is a third-party actor that reads Yandex Market's own publicly served pages. It is not affiliated with or endorsed by Yandex.

# Actor input Schema

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

What to fetch.

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

Free-text query, e.g. `iphone 15` (mode=search).

## `categoryName` (type: `string`):

Category / product-type name to browse, e.g. `ноутбуки`, `laptops`, `наушники`.

## `categoryId` (type: `string`):

Optional Yandex Market category `hid` to narrow results further, e.g. `54726` (from a `/catalog--slug/54726` URL). Leave empty to browse by name only.

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

Full `market.yandex.ru/product--...` URLs, or bare numeric product IDs.

## `sortOrder` (type: `string`):

Result ordering (mode=search, byCategory).

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

Drop products cheaper than this, in Russian rubles.

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

Drop products more expensive than this, in Russian rubles.

## `minRating` (type: `string`):

Only keep products rated at or above this value.

## `minDiscount` (type: `integer`):

Only keep products discounted by at least this percentage off the original price.

## `brand` (type: `string`):

Only keep products whose brand contains this text (case-insensitive), e.g. `Apple`, `Samsung`. Listings that don't expose brand info at all (common for `offer` records without a linked vendor) are kept rather than dropped, since their brand can't be confirmed either way.

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

Only keep listings that show a delivery estimate (i.e. are currently orderable).

## `reviewsSortOrder` (type: `string`):

How to order returned reviews.

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

Hard cap on emitted records (per query/URL for productDetails/reviews; total for search/byCategory).

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

Optional. Yandex Market's search and product pages are normally reachable without a proxy from Apify's datacenter IPs. Enable this (AUTO group is free) only if you see 0 results or a CAPTCHA/VPN block in the run log.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone 15",
  "productUrls": [
    "https://market.yandex.ru/product--vosstanovlennyy-apple-smartfon-iphone-15-simesim-6128-gb-chernyy/1912483624"
  ],
  "sortOrder": "relevance",
  "minRating": "any",
  "inStockOnly": false,
  "reviewsSortOrder": "newest",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped Yandex Market records.

# 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": "iphone 15",
    "productUrls": [
        "https://market.yandex.ru/product--vosstanovlennyy-apple-smartfon-iphone-15-simesim-6128-gb-chernyy/1912483624"
    ],
    "sortOrder": "relevance",
    "minRating": "any",
    "inStockOnly": false,
    "reviewsSortOrder": "newest",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/yandex-pro-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": "iphone 15",
    "productUrls": ["https://market.yandex.ru/product--vosstanovlennyy-apple-smartfon-iphone-15-simesim-6128-gb-chernyy/1912483624"],
    "sortOrder": "relevance",
    "minRating": "any",
    "inStockOnly": False,
    "reviewsSortOrder": "newest",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/yandex-pro-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": "iphone 15",
  "productUrls": [
    "https://market.yandex.ru/product--vosstanovlennyy-apple-smartfon-iphone-15-simesim-6128-gb-chernyy/1912483624"
  ],
  "sortOrder": "relevance",
  "minRating": "any",
  "inStockOnly": false,
  "reviewsSortOrder": "newest",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/yandex-pro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Market Pro Scraper",
        "description": "Scrape Yandex Market - Russia's largest e-commerce and price-comparison platform. Search products, browse categories, pull full product details with specs and images, and collect product reviews - with no login, no cookies, and no paid proxy required.",
        "version": "1.0",
        "x-build-id": "97wyc6yyMMYkafPWM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~yandex-pro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-yandex-pro-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~yandex-pro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-yandex-pro-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~yandex-pro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-yandex-pro-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 query, e.g. `iphone 15` (mode=search).",
                        "default": "iphone 15"
                    },
                    "categoryName": {
                        "title": "Category name (mode=byCategory)",
                        "type": "string",
                        "description": "Category / product-type name to browse, e.g. `ноутбуки`, `laptops`, `наушники`."
                    },
                    "categoryId": {
                        "title": "Category ID / hid (mode=byCategory, optional)",
                        "type": "string",
                        "description": "Optional Yandex Market category `hid` to narrow results further, e.g. `54726` (from a `/catalog--slug/54726` URL). Leave empty to browse by name only."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=productDetails, reviews)",
                        "type": "array",
                        "description": "Full `market.yandex.ru/product--...` URLs, or bare numeric product IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "popularity",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Result ordering (mode=search, byCategory).",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this, in Russian rubles."
                    },
                    "maxPrice": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this, in Russian rubles."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "enum": [
                            "any",
                            "3",
                            "3.5",
                            "4",
                            "4.5"
                        ],
                        "type": "string",
                        "description": "Only keep products rated at or above this value.",
                        "default": "any"
                    },
                    "minDiscount": {
                        "title": "Min discount %",
                        "minimum": 0,
                        "maximum": 99,
                        "type": "integer",
                        "description": "Only keep products discounted by at least this percentage off the original price."
                    },
                    "brand": {
                        "title": "Brand filter",
                        "type": "string",
                        "description": "Only keep products whose brand contains this text (case-insensitive), e.g. `Apple`, `Samsung`. Listings that don't expose brand info at all (common for `offer` records without a linked vendor) are kept rather than dropped, since their brand can't be confirmed either way."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Only keep listings that show a delivery estimate (i.e. are currently orderable).",
                        "default": false
                    },
                    "reviewsSortOrder": {
                        "title": "Reviews sort order (mode=reviews)",
                        "enum": [
                            "newest",
                            "highestRating",
                            "lowestRating",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "How to order returned reviews.",
                        "default": "newest"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records (per query/URL for productDetails/reviews; total for search/byCategory).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Yandex Market's search and product pages are normally reachable without a proxy from Apify's datacenter IPs. Enable this (AUTO group is free) only if you see 0 results or a CAPTCHA/VPN block in the run log.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
