# Wildberries Scraper — Products & Reviews | Парсер Вайлдберриз (`actorforgehq/wildberries-scraper`) Actor

Scrape Wildberries products, prices and reviews as clean JSON. Russian marketplace (wildberries.ru) product data API, no browser: search the catalog by keyword or pull product IDs, region-pinned pricing, newest reviews. Парсер Вайлдберриз (WB parser): товары, цены, отзывы. Honest, documented limits.

- **URL**: https://apify.com/actorforgehq/wildberries-scraper.md
- **Developed by:** [ActorForge](https://apify.com/actorforgehq) (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.50 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Products & Reviews | Парсер Вайлдберриз

Scrape **Wildberries** (wildberries.ru) product data as clean JSON: search catalogs, product
cards, prices and reviews. A product data API for the Russian marketplace — API-level and fast,
no brittle browser automation. *Парсер Вайлдберриз: товары, цены, отзывы.*

### What you get

Give it a search phrase or product IDs. The dataset contains **two kinds of item**, tagged by a
`type` field. Products and reviews are separate rows, joined by `nmId` / `imtId`.

**Product:**

```json
{
  "type": "product",
  "nmId": 1097975275,
  "imtId": 2227481309,
  "name": "Wireless Headphones XYZ",
  "brand": "XYZ",
  "supplier": "TechLine LLC",
  "price": 2490,
  "basicPrice": 3990,
  "rating": 4.7,
  "feedbacks": 1523,
  "url": "https://www.wildberries.ru/catalog/1097975275/detail.aspx"
}
```

`price` is what the customer actually pays; `basicPrice` is the price before discount. Both are
in roubles (the raw Wildberries API returns kopecks — we convert). A product that cannot currently
be bought in the region you pinned with `dest` carries no price at all rather than a zero, so
`price` and `basicPrice` may be absent — that reflects the live state of the product card, and the
same article may well be priced again tomorrow or in another region.

**Review** (only when `includeReviews` is on):

```json
{
  "type": "review",
  "imtId": 2227481309,
  "nmId": 1097975275,
  "reviewId": "DdAOL5cB0x_abc",
  "text": "Great sound, fast delivery.",
  "pros": "battery life",
  "cons": "",
  "stars": 5,
  "date": "2026-07-13T08:48:38Z",
  "size": "M",
  "color": "black",
  "author": "Anna",
  "photos": 2,
  "hasVideo": false,
  "sellerAnswer": "Thank you for your review!",
  "url": "https://www.wildberries.ru/catalog/1097975275/detail.aspx"
}
```

`pros` and `cons` are separate fields from `text` and are often empty — for sentiment work you
want all three. `photos` is a count, and both `photos` and `hasVideo` are absent when the review
has no media. `sellerAnswer` is the seller's public reply, when there is one.

### Use cases

- **Price & assortment monitoring** across Wildberries catalogs.
- **Review mining** for product research and sentiment.
- **Market intelligence** for e-commerce teams that need WB data in a clean, English-documented API.

### Input

| Field | Type | Description |
|---|---|---|
| `queries` | string\[] | Search phrases to resolve into product catalogs. |
| `productIds` | string\[] | Specific `nmId` values to fetch full cards for. |
| `includeReviews` | boolean | Also fetch reviews. Reviews are charged as a separate event. |
| `maxReviewsPerProduct` | integer | Most recent reviews to keep per product (default 20). |
| `dest` | string | Region code affecting price and delivery estimates (optional). |
| `maxItems` | integer | Hard cap on scraped products, applied per search query and to the article-number list. Reviews are capped separately by `maxReviewsPerProduct`. |
| `proxyConfiguration` | object | Proxy rotation. On by default — leave it on (see reliability numbers below). |

### How to use it

1. Click **Try for free** / **Start** on this page.
2. Put one or more phrases into **Search queries** (for example `наушники`), or paste specific
   article numbers into **Product IDs (nmId)** if you already know what you track. You can use
   both at once; searches and IDs are collected into the same dataset.
3. Optionally switch on **Include reviews** and set **Max reviews per product**. Reviews arrive
   as separate rows and are billed as a separate event, so leave it off if you only need prices.
4. Set **Max items** to cap how many products each search query returns, and how many article
   numbers are taken from your list. Reviews are *not* counted against it — cap those with
   **Max reviews per product**, which applies to every product separately. Two queries with
   `Max items` at 100 and 20 reviews each can therefore bill up to 200 products and 4,000 reviews.
5. Leave **Proxy configuration** on Apify Proxy — the reliability numbers below are measured
   with rotation on, and a single unproxied IP degrades badly.
6. Run it. Watch the **Output** tab: the *Products* view shows catalog rows, the *Reviews* view
   shows review rows. Export as JSON, CSV, Excel or pull the data over the API.

To run it on a schedule, use Apify **Schedules**; to call it from your own code, use the
[Apify API](https://docs.apify.com/api/v2) or one of the official clients. Every field in the
output is described in this Actor's dataset schema, so AI agents calling it through the Apify
MCP server get typed field metadata rather than raw JSON.

### Why this scraper

- **Measured reliability, honestly reported.** Running on Apify with proxy rotation:
  **100% task success across 50 runs** (80 tasks, 500 items; 4 transient blocks absorbed by
  retries). The same code from a **single unproxied datacenter IP** degrades instead — four
  50-run measurements gave **91.2%, 98.75%, 90.14%, 77.94%** in that order, and a 12-hour rest
  did *not* restore it. That contrast is why this Actor is built for rotation, and why you
  should keep proxy on for anything beyond a trial run. Transient blocks are retried with
  backoff instead of being silently dropped, and a run that gets truncated reports the
  truncation rather than passing it off as a complete result.
- **It knows where Wildberries lies.** The search endpoint does not end a result set with an
  empty page — it starts serving page 1 again, and it sometimes answers HTTP 200 with a
  substituted body. Both are detected explicitly, so you get a truncated dataset reported as a
  failure rather than presented as a complete run.
- **English documentation** — every field explained, no guesswork.
- **Schema-validated output** — every item is checked against a schema before it reaches your
  dataset, so a change on Wildberries' side surfaces as a loud failure, not as `undefined` in
  your price feed.

### Limits (honest)

- **Reviews are capped at 1000 per product by Wildberries itself**, newest first, and that
  endpoint has no pagination. For a product with 130k reviews you get a recent-1000 sample, not
  the full corpus. The product-level `rating` and `feedbacks` count still reflect all reviews.
- **Search results are finite.** Past the last real page Wildberries repeats page 1; the scraper
  stops there. Very broad queries will not yield their full advertised `total`.
- **Night window (00:00–06:00 UTC): search is throttled harder.** Wildberries rate-limits its
  search endpoint noticeably more at night (early morning Moscow time) — measured on weeks of
  nightly runs, not guessed. The Actor absorbs this with patient retries and, when retries alone
  are not enough, falls back to a mobile proxy for the search step, so night runs still succeed —
  they just take longer than the same run during the day. Product cards and reviews are not
  affected. If a night search still fails after every retry, the run reports a failure instead of
  passing off a truncated dataset as complete — and with per-result pricing a slower run does not
  cost you more.
- Public data only; no login, no bypassing of access controls. Requests are paced to respect
  Wildberries' rate limits.
- Price and delivery estimates vary by `dest` region — the scraper pins one region per run so
  your time series stays comparable.

### Pricing

Pay-per-event: a charge per run start, a charge per scraped product, and a separate charge per
scraped review (so runs without `includeReviews` never pay for review capacity). See the Store
page for current rates.

#### What you get for $1

| Event | Rate |
|---|---|
| Actor start | $0.02 per run |
| `product-scraped` | $3.50 per 1,000 products ($0.0035 each) |
| `review-scraped` | $2.00 per 1,000 reviews ($0.002 each) |

One dollar covers a run start plus **~280 product cards** ((1 − 0.02) / 0.0035 ≈ 280), or **~490
reviews** if you scrape reviews only. There is no subscription and no minimum: billing is strictly
per event, so autonomous AI agents can call this actor and pay as they go — through the **Apify MCP
server**, or via the **x402** (USDC on Base) and **Skyfire** agentic payment rails. Rates shown as
of the last README update; the Store page stays authoritative.

### FAQ

**Do I need a Wildberries account or an API key?**
No. The Actor reads only publicly available data and never logs in.

**Can I use the official Wildberries API instead?**
Only for your own shop. The official seller API (dev.wildberries.ru) requires a seller token and
returns data about your own store — the public catalog of other sellers is not available through
it. This Actor reads the public catalog, which is exactly the part the official API does not
cover.

**Why is `price` sometimes missing?**
Because the product is currently unavailable. Wildberries reports no price at all in that case,
and the Actor passes that through instead of inventing a `0` that would poison your averages.

**Why do I get fewer products than the `total` Wildberries advertises?**
Wildberries does not end a result set with an empty page — past the last real page it starts
serving page 1 again. The Actor detects that repetition and stops, so a broad query returns the
pages that actually exist rather than looping forever.

**Why do I get at most 1000 reviews for a product with far more?**
That is Wildberries' own cap on the reviews endpoint, newest first, and it has no pagination.
The product-level `rating` and `feedbacks` count still reflect every review.

**Can I get reviews without products?**
No — reviews are addressed by `imtId`, which comes from the product card, so products are always
fetched first. Setting `maxReviewsPerProduct` low keeps the review cost small.

**Does the region code matter?**
Yes. Prices and availability differ by region, so the Actor pins one `dest` per run. Leave it
empty for the Moscow default and keep it stable if you are building a price time series.

**Why is my scheduled night run slower than the same run during the day?**
Because Wildberries throttles its search endpoint harder between roughly 00:00 and 06:00 UTC.
The Actor retries with backoff and falls back to a mobile proxy when needed, so night runs
complete — just more slowly. If timing is flexible, schedule search-heavy runs outside that
window; you pay per result either way, so the slowdown costs nothing extra.

**Can I run it without a proxy?**
You can, but you should not. Measured on the same code: 100% task success across 50 proxied
runs, versus a decline to 77.94% from a single unproxied datacenter IP that a 12-hour rest did
not repair.

### Other Actors by ActorForge

- [Avito Real Estate Scraper](https://apify.com/actorforgehq/avito-real-estate-scraper) — full
  property inventory from Avito with freshness stamps, for new-listing alerts and comps.
- [Lazada Reviews Scraper](https://apify.com/actorforgehq/lazada-reviews-scraper) — ratings,
  review text and buyer media from Lazada across the SEA marketplaces.

Need a marketplace we do not cover yet, or card-level enrichment beyond what is listed here?
Open an issue from the Actor's page and tell us what you need.

### Disclaimer

This is an **unofficial** scraper. It is not affiliated with, endorsed by, or connected to
Wildberries in any way. It collects only data that Wildberries publishes publicly, without
logging in and without circumventing access controls. You are responsible for ensuring your
use of the collected data complies with applicable law and with Wildberries' terms.

### Changelog

See the repository `CHANGELOG.md`.

# Actor input Schema

## `queries` (type: `array`):

Wildberries search phrases, e.g. "headphones". Each is resolved to a catalog of products. Russian phrases match the catalogue best, since that is the language Wildberries indexes.

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

Specific Wildberries product ids to fetch full cards for. Use this when you already know the articles you track; it skips search entirely and is the cheapest way to refresh a fixed basket.

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

Also fetch product reviews. Reviews are written as separate dataset rows and billed as a separate event, so runs that leave this off never pay for review capacity.

## `maxReviewsPerProduct` (type: `integer`):

How many of the most recent reviews to keep per product when "Include reviews" is on. Wildberries returns at most 1000 reviews per product in total, newest first.

## `dest` (type: `string`):

Wildberries geo `dest` code affecting price and availability. Leave empty for the default region (Moscow). Pin one region per run so a price time series stays comparable.

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

Hard cap on scraped products, applied per search query and to the list of article numbers. Reviews are not counted against it — use Max reviews per product to cap those.

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

Keep proxy on. Measured: 100% task success across 50 runs with rotation, versus 91.2% → 77.94% degradation from a single unproxied datacenter IP.

## Actor input object example

```json
{
  "queries": [
    "наушники",
    "кофеварка"
  ],
  "productIds": [
    "16530335",
    "1097975275"
  ],
  "includeReviews": true,
  "maxReviewsPerProduct": 50,
  "dest": "-1257786",
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Scraped product cards: name, brand, seller, price and price before discount (₽), rating and review count.

## `reviews` (type: `string`):

Individual reviews, produced only when "Include reviews" is enabled. Join back to products by imtId / nmId.

# 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 = {
    "queries": [
        "наушники"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorforgehq/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 = { "queries": ["наушники"] }

# Run the Actor and wait for it to finish
run = client.actor("actorforgehq/wildberries-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "наушники"
  ]
}' |
apify call actorforgehq/wildberries-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,actorforgehq/wildberries-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HTfQ2mywRW6CO4o6B/builds/0CfK5kc1Ku4ZgdB4s/openapi.json