# Wildberries Scraper (`crawlerbros/wildberries-scraper`) Actor

Scrape Wildberries.ru - Russia's largest online marketplace. Search by keyword, browse by category, or fetch full product details (price, rating, description, characteristics, images) by article number or product URL.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Wildberries Scraper

Scrape [Wildberries.ru](https://www.wildberries.ru) — Russia's largest online marketplace, with tens of millions of products across fashion, electronics, home, beauty, and more. Search by keyword, browse any category, pull full product details (description, grouped spec sheet, aggregate rating breakdown, seller info, images) by article number or product URL, or fetch individual customer reviews. No login, no cookies, no paid proxy required.

### What this actor does

- **Four modes:** `search`, `byCategory`, `productDetails`, `reviews`
- **Search & category filters:** price range, minimum rating, in-stock only, brand contains, sort order
- **Rich product details:** full description, grouped spec sheet ("characteristics" + `specGroups`), color/size variant IDs, current price
- **Real aggregate ratings:** average rating, per-star distribution, and review-with-photo/text/video counts (`productDetails` mode)
- **Real seller/shop info:** registered shop name, legal company name, and legal address for the seller behind each product (`productDetails` mode)
- **Customer reviews:** individual review text, star rating, author, pros/cons, photo/video presence, helpfulness votes (`reviews` mode)
- **Images:** resolves real CDN image URLs for every product
- **Empty fields are always omitted** — every field in the output actually has data

### Output per product

#### `search` / `byCategory` mode

- `nmId` — Wildberries article number
- `name`, `brand`, `brandId`
- `supplierName`, `supplierId`, `supplierRating`
- `rating`, `feedbacksCount`
- `priceCurrent`, `priceOriginal`, `discountPercent`, `currency` (RUB)
- `inStock`, `stockQuantity`
- `colors[]`
- `categoryId`, `categoryParentId`
- `weightKg`, `volumeLiters`
- `photoCount`, `imageUrl`, `images[]`
- `productUrl`, `sourceUrl`
- `recordType: "product"`, `scrapedAt`

#### `productDetails` mode

- `nmId`, `imtId`, `name`, `brand`, `slug`, `vendorCode`
- `description` — full product description text
- `category`, `categoryRoot`, `categoryId`, `categoryRootId`
- `characteristics[]` — `{name, value}` flat spec sheet
- `specGroups[]` — `{groupName, options: [{name, value}]}` the same spec sheet grouped exactly as Wildberries' own product page groups it (e.g. "Экран", "Память", "Процессор", "Габариты")
- `colorName`, `variantNmIds[]`, `variantCount` — sibling color/size article numbers
- `priceCurrent`, `currency`, `priceUpdatedAt`
- `photoCount`, `imageUrl`, `images[]`
- `ratingAverage`, `reviewsCount`, `reviewsWithPhotoCount`, `reviewsWithTextCount`, `reviewsWithVideoCount`, `ratingDistribution` (`{"1":N, "2":N, …, "5":N}`) — real aggregate rating data (toggle with `includeReviews`)
- `supplierId`, `supplierName`, `supplierFullName`, `supplierInn`, `supplierLegalAddress`, `supplierTrademark` — real seller/shop info (toggle with `includeSellerInfo`)
- `createdAt`, `updatedAt`
- `productUrl`, `sourceUrl`
- `recordType: "productDetail"`, `scrapedAt`

#### `reviews` mode

- `nmId` — the article number you requested
- `imtId` — the product-model ID the review is attached to (Wildberries aggregates reviews per model, across color/size variants)
- `reviewId`, `reviewNmId` — the specific variant article number the reviewer actually bought
- `authorName`, `authorCountry`
- `rating` — the reviewer's 1–5 star rating
- `text`, `pros`, `cons`
- `color`, `size` — the variant the review was left for
- `photoCount`, `hasVideo` — whether the review includes real customer photos/video
- `votesHelpful`, `votesUnhelpful`
- `createdAt`
- `productUrl`, `sourceUrl`
- `recordType: "review"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` / `reviews` |
| `searchQuery` | string | `iphone` | Free-text keyword (mode=search) |
| `category` | string | – | Category to browse — pick from the dropdown (mode=byCategory) |
| `categoryCustom` | string | – | Any other category name in Russian, not in the dropdown (overrides `category`) |
| `productIds` | array | – | Article numbers or full product URLs (mode=productDetails / reviews) |
| `sortBy` | string | relevance | `popular` / `newly` / `rate` / `priceup` / `pricedown`. `priceup`/`pricedown`/`rate` are guaranteed exact (sorted locally by `priceCurrent`/`rating` after fetching); `popular`/`newly` are a best-effort relevance hint only — see FAQ |
| `minPrice` / `maxPrice` | integer | – | Price range in RUB |
| `minRating` | integer | – | Drop products rated below this (0–5); in mode=reviews, filters individual reviews by star rating |
| `inStockOnly` | boolean | `false` | Only emit products currently in stock |
| `brand` | string | – | Only emit products whose brand contains this text |
| `includeImages` | boolean | `true` | Resolve and attach image URLs |
| `includeReviews` | boolean | `true` | Attach the real aggregate rating breakdown to productDetails records |
| `includeSellerInfo` | boolean | `true` | Attach real seller/shop info to productDetails records |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–2000) |
| `proxyConfiguration` | object | AUTO group | search.wb.ru is reachable directly under normal conditions; the AUTO proxy group is wired in automatically as a fallback for reliability if a run hits a sustained rate-limit burst |

#### Example: search with filters

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "minPrice": 50000,
  "maxPrice": 150000,
  "minRating": 4,
  "inStockOnly": true,
  "sortBy": "priceup",
  "maxItems": 50
}
````

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "женские платья и сарафаны",
  "sortBy": "rate",
  "maxItems": 100
}
```

#### Example: full product details

```json
{
  "mode": "productDetails",
  "productIds": [
    "863160611",
    "https://www.wildberries.ru/catalog/12345678/detail.aspx"
  ]
}
```

#### Example: customer reviews

```json
{
  "mode": "reviews",
  "productIds": ["863160611"],
  "minRating": 4,
  "maxItems": 100
}
```

### Use cases

- **Price & stock monitoring** — track `priceCurrent`, `discountPercent`, and `inStock` across a catalog of article numbers over time
- **Competitive intelligence** — compare brands, ratings, and pricing across a category or search result
- **Seller & marketplace research** — pull registered shop name, legal company name, and address behind any listing
- **Voice-of-customer analysis** — mine `reviews` mode text, pros/cons, and star ratings for product feedback themes
- **Catalog enrichment** — bulk-fetch full spec sheets, images, and descriptions for a list of known article numbers
- **Market research** — gauge category popularity via review counts and rating distributions before entering a niche

### 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 (this actor) | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Is this affiliated with Wildberries?**
No, this is a third-party actor using Wildberries' own public product data — the same information your browser loads when you browse wildberries.ru search, category, product, and review pages.

**Do I need a Wildberries account or proxy?**
No. The actor works out of the box on the free Apify plan with no login, cookies, or paid proxy required.

**Which Wildberries region does the data reflect?**
Pricing and stock reflect the Moscow marketplace region, which is Wildberries' default for shoppers without a specified delivery location.

**Can I browse a category that isn't in the dropdown?**
The `category` input is a dropdown of popular categories with readable Russian names. For any other category, use the `categoryCustom` text field with the category's exact Russian name as it appears on wildberries.ru (e.g. `детские велосипеды`) — categories are matched by name, not by numeric ID, the same way Wildberries' own category pages work.

**Is `sortBy` order guaranteed?**
For `priceup`, `pricedown`, and `rate` — yes, the actor re-sorts the matching batch locally by the real `priceCurrent`/`rating` output field before emitting, so the order you get is exact. `popular` and `newly` remain a best-effort relevance hint from Wildberries rather than a guaranteed ordering. Use `minPrice`/`maxPrice`/`minRating` to bound results reliably regardless of sort choice.

**Why is `priceCurrent` in `productDetails` mode sometimes a day or two old?**
`productDetails` mode reads Wildberries' own price-history feed, which is refreshed roughly daily. `search` and `byCategory` mode always return live, real-time pricing.

**Does this cover all of Wildberries' regional domains?**
Currently the actor targets `wildberries.ru`, Wildberries' primary and largest marketplace, covering the Russian Federation.

**Why do some products return fewer reviews than the `reviewsCount` I see?**
`reviewsCount` (and the star-rating distribution) is Wildberries' true total for the product model. The individual `reviews` mode records only cover reviews that include written text — Wildberries only publishes full review objects for text reviews, not the (typically larger) pool of star-only ratings with no text.

**Why does a review's `imtId` sometimes cover a different color or size than the one I requested?**
Wildberries aggregates reviews per *product model* (`imtId`), not per individual color/size article number (`nmId`) — a review left on the blue variant shows up when you request the orange variant's article number too, because they're the same underlying product model.

**Why does opening `productUrl` in a plain HTTP request (not a browser) show a verification page instead of the product?**
`productUrl` is the correct, canonical Wildberries product page link and opens normally for a shopper in a real browser. Wildberries places a browser-verification check in front of its HTML pages, so a non-browser request (e.g. a bare `curl`) sees a challenge screen instead — this doesn't affect any data field returned by the actor.

**Can I get a seller's full catalog?**
Not directly — `includeSellerInfo` returns the seller's registered shop name, legal company name, and address for products you already look up via `productDetails`, but there's no dedicated seller-catalog mode in this actor.

# Actor input Schema

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

What to fetch.

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

Free-text keyword search, e.g. `iphone`, `кроссовки nike`.

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

Pick a popular category, or use `categoryCustom` below for any other category (in Russian, as it appears on wildberries.ru).

## `categoryCustom` (type: `string`):

Any other category name, in Russian, not covered by the dropdown above (e.g. `детские велосипеды`).

## `productIds` (type: `array`):

Wildberries article numbers (nmId, e.g. `863160611`) or full product URLs (e.g. `https://www.wildberries.ru/catalog/863160611/detail.aspx`).

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

How Wildberries should order results.

## `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: `integer`):

Drop products with a customer rating below this (0-5). In mode=reviews, filters individual reviews by their star rating instead.

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

Only emit products that currently have stock available.

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

Only emit products whose brand name contains this text (case-insensitive).

## `includeImages` (type: `boolean`):

Resolve and attach product image URLs. Adds a small number of extra CDN lookups per product.

## `includeReviews` (type: `boolean`):

Attach the real aggregate review data (average rating, per-star distribution, review counts) to each product-details record. Adds one extra lookup per product.

## `includeSellerInfo` (type: `boolean`):

Attach the seller's registered shop name, legal name, and address to each product-details record. Adds one extra lookup per unique seller.

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

Hard cap on emitted records.

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

search.wb.ru is reachable without a proxy under normal conditions; the free Apify AUTO group (datacenter, zero extra cost) is wired in as an automatic fallback for the rare sustained-429 edge burst so a single blocked run can't return zero results.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "category": "женские платья и сарафаны",
  "productIds": [],
  "sortBy": "",
  "inStockOnly": false,
  "includeImages": true,
  "includeReviews": true,
  "includeSellerInfo": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Wildberries 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": "iphone",
    "category": "женские платья и сарафаны",
    "productIds": [],
    "sortBy": "",
    "inStockOnly": false,
    "includeImages": true,
    "includeReviews": true,
    "includeSellerInfo": true,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wildberries-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",
    "category": "женские платья и сарафаны",
    "productIds": [],
    "sortBy": "",
    "inStockOnly": False,
    "includeImages": True,
    "includeReviews": True,
    "includeSellerInfo": True,
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wildberries-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",
  "category": "женские платья и сарафаны",
  "productIds": [],
  "sortBy": "",
  "inStockOnly": false,
  "includeImages": true,
  "includeReviews": true,
  "includeSellerInfo": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/wildberries-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wildberries Scraper",
        "description": "Scrape Wildberries.ru - Russia's largest online marketplace. Search by keyword, browse by category, or fetch full product details (price, rating, description, characteristics, images) by article number or product URL.",
        "version": "1.0",
        "x-build-id": "4GzTeG4jg2xjOiA00"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~wildberries-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-wildberries-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~wildberries-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-wildberries-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~wildberries-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-wildberries-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `iphone`, `кроссовки nike`."
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "женские блузки и рубашки",
                            "женские брюки",
                            "женская верхняя одежда",
                            "детская обувь",
                            "обувь для девочек",
                            "обувь для мальчиков",
                            "детское белье",
                            "детские блузки и рубашки",
                            "детские брюки и шорты",
                            "мужские брюки",
                            "мужская верхняя одежда",
                            "мужские джемперы и кардиганы",
                            "аксессуары для туалета",
                            "держатели для дома",
                            "корзинки для дома",
                            "средства для бритья",
                            "средства для ванны и душа",
                            "средства для макияжа",
                            "аксессуары для волос",
                            "аксессуары для одежды",
                            "ноутбуки",
                            "спортивные кроссовки",
                            "игрушки антистресс",
                            "игрушки для малышей",
                            "бизиборды игровые центры",
                            "кровати",
                            "шкафы",
                            "диваны",
                            "женские платья и сарафаны",
                            "женские футболки и топы",
                            "мужские джинсы",
                            "автомобильные шины",
                            "автомобили",
                            "художественная литература",
                            "проза книги",
                            "подвески и шармы",
                            "колье цепи шнурки",
                            "грунты для растений",
                            "семена овощей",
                            "рыбий жир омега",
                            "витамин D",
                            "блокноты канцтовары",
                            "ежедневники записные книжки",
                            "товары для кошек",
                            "корм и лакомства для животных",
                            "техника для приготовления блюд",
                            "техника для приготовления напитков"
                        ],
                        "type": "string",
                        "description": "Pick a popular category, or use `categoryCustom` below for any other category (in Russian, as it appears on wildberries.ru).",
                        "default": "женские платья и сарафаны"
                    },
                    "categoryCustom": {
                        "title": "Custom category (mode=byCategory, overrides dropdown)",
                        "type": "string",
                        "description": "Any other category name, in Russian, not covered by the dropdown above (e.g. `детские велосипеды`)."
                    },
                    "productIds": {
                        "title": "Article IDs / product URLs (mode=productDetails / reviews)",
                        "type": "array",
                        "description": "Wildberries article numbers (nmId, e.g. `863160611`) or full product URLs (e.g. `https://www.wildberries.ru/catalog/863160611/detail.aspx`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order (mode=search / byCategory)",
                        "enum": [
                            "",
                            "popular",
                            "newly",
                            "rate",
                            "priceup",
                            "pricedown"
                        ],
                        "type": "string",
                        "description": "How Wildberries should order results.",
                        "default": ""
                    },
                    "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",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products with a customer rating below this (0-5). In mode=reviews, filters individual reviews by their star rating instead."
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products that currently have stock available.",
                        "default": false
                    },
                    "brand": {
                        "title": "Brand contains",
                        "type": "string",
                        "description": "Only emit products whose brand name contains this text (case-insensitive)."
                    },
                    "includeImages": {
                        "title": "Include image URLs",
                        "type": "boolean",
                        "description": "Resolve and attach product image URLs. Adds a small number of extra CDN lookups per product.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include rating breakdown (mode=productDetails)",
                        "type": "boolean",
                        "description": "Attach the real aggregate review data (average rating, per-star distribution, review counts) to each product-details record. Adds one extra lookup per product.",
                        "default": true
                    },
                    "includeSellerInfo": {
                        "title": "Include seller/shop info (mode=productDetails)",
                        "type": "boolean",
                        "description": "Attach the seller's registered shop name, legal name, and address to each product-details record. Adds one extra lookup per unique seller.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "search.wb.ru is reachable without a proxy under normal conditions; the free Apify AUTO group (datacenter, zero extra cost) is wired in as an automatic fallback for the rare sustained-429 edge burst so a single blocked run can't return zero results.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
