# Wildberries Scraper: Products & Reviews, $3.50/1K | Парсер WB (`actorforgehq/wildberries-scraper`) Actor

Russian marketplace Wildberries. Input: keywords or product IDs. Output: one JSON row per product with price, price before discount, rating, review count, seller; optional specs, price history, newest reviews. $3.50 per 1,000 products, $2 per 1,000 reviews, plus $0.02 per run. Парсер Вайлдберриз.

- **URL**: https://apify.com/actorforgehq/wildberries-scraper.md
- **Developed by:** [Sluicebox](https://apify.com/actorforgehq) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 57 total users, 17 monthly users, 97.7% 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Wildberries Scraper — Products & Reviews | Парсер Вайлдберриз

Scrape **Wildberries** (wildberries.ru) product data as clean JSON: search catalogs, product
cards, prices and reviews, plus optional card details: specifications, the seller's legal entity
and Wildberries' own price history. Data is fetched over plain HTTP. A real browser starts once per run,
and only to clear the marketplace's anti-bot check. *Парсер Вайлдберриз: товары, цены, отзывы.*

### 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.

**Product with `includeDetails` on** adds the card's own data to the same row:

```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",
  "description": "Wireless in-ear headphones with active noise cancelling and a charging case.",
  "specs": [
    { "name": "Тип подключения", "value": "беспроводное" },
    { "name": "Время зарядки", "value": "1 час" }
  ],
  "category": "Наушники беспроводные",
  "categoryRoot": "Смартфоны и гаджеты",
  "vendorCode": "XYZ-100-BLK",
  "color": "черный",
  "photoCount": 5,
  "sellerId": 571710,
  "sellerLegalName": "ООО «ТехЛайн»",
  "sellerInn": "7700000000",
  "sellerOgrn": "1027700000000",
  "sellerTrademark": "XYZ",
  "priceHistory": [
    { "date": "2026-07-18", "price": 1188 },
    { "date": "2026-08-08", "price": 772 },
    { "date": "2026-09-05", "price": 1982 }
  ]
}
```

`specs` is the card's specification list as name and value pairs, in the language Wildberries
publishes them (Russian). `priceHistory` is the price series Wildberries itself keeps for the card:
dated points in roubles, oldest first. In our sample runs the points were weekly and went back up
to twelve weeks, with some weeks absent, so treat it as a weekly series, not a daily feed. It is
present even for a product that currently has no price. `sellerLegalName`, `sellerInn` and
`sellerOgrn` identify the seller's legal entity as Wildberries shows it on the card: the INN and
OGRN for Russian sellers, the home-country registration id in `sellerInn` for cross-border ones.
These fields
come from Wildberries' static card storage, which the public API does not expose, and any of them
is absent when the corresponding card file is missing.

**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.
- **Card enrichment**: specifications, category, seller legal entity and price history for the
  articles you track.
- **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. |
| `includeDetails` | boolean | Also fetch each product's description, specs, category, seller legal details and price history. Part of the product event, no separate charge. |
| `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 | Optional, off by default. The run goes out from the container's own address, which is free and fastest. Turn a proxy on only if you need a specific region: the whole run then uses one sticky session, because the anti-bot token is bound to the exit address. |

### 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. Switch on **Include product details** if you want the description, specifications, category,
   seller legal details and price history on every product row. It adds three small requests and
   about a second per product, and no separate charge.
4. 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.
5. 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.
6. Leave **Proxy configuration** off unless you need a specific region. The run then goes out from
   the container's own address, which cleared the anti-bot check fastest in our measurements and
   costs nothing extra.
7. Run it. Watch the **Output** tab: the *Products* view shows catalog rows, the *Product details*
   view shows the enrichment fields, 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.** On 22 September 2026 Wildberries closed its
  public API domains and moved the storefront behind an anti-bot check. This Actor moved with it:
  a real browser clears the check once per run, then the data is fetched over plain HTTP.
  Measured the same day: the check clears in 7 to 26 seconds from the container's own address,
  and a search page then answers in about one second with 100 products. 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.
- **Card data the public API does not carry.** With `includeDetails` the Actor reads Wildberries'
  static card storage, which needs no anti-bot token: description, specification list, category,
  the seller's legal entity and the price history Wildberries keeps for the card.
- **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`.
- **The storefront sits behind an anti-bot check.** Since 22 September 2026 the public API
  domains answer 403, and the storefront hands out a session token instead. The Actor takes that
  token with a real browser once per run, which cost 7 to 26 seconds in our measurements. A
  session can also be revoked mid-run, and the Actor then takes a fresh one, up to five per run.
  Measured on 22 September 2026: 30 search requests in a row and 61 product-card requests in a
  row went through on a single session. Reviews are not affected at all, that endpoint still
  answers without a token. If the check cannot be cleared, the run reports a failure instead of
  passing off an empty dataset as complete, and with per-result pricing a slower run does not
  cost you more.
- **Card details come from a static copy.** Wildberries serves the card files with a 24-hour
  public cache, so a description or specification edit can take up to a day to show up. Price
  history is whatever Wildberries publishes for the card: weekly points going back up to about
  twelve weeks in our sample runs, with some weeks absent, not a daily series. The seller's tax
  and registration numbers are absent for some sellers, and a few cards have no price history or
  seller file at all, mostly brand-new ones. In our measured runs of 20 and 100 products every
  product got its card, 18 of 20 and 83 of 100 got a price history, 19 of 20 and 86 of 100 a
  seller record. The product row is always delivered, with whatever detail fields exist, and the
  run's status message says how many articles had no card at all.
- **Short run timeouts.** The Actor watches your run's timeout. When the next request could not
  finish before it, the Actor stops starting new requests, keeps everything already scraped and
  says so in the run's status message, instead of being cut off mid-request. A run that stopped
  this way with some data counts as succeeded, and one with no data counts as failed. With the
  default one-hour timeout this only matters for very large runs.
- 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). Product details
(`includeDetails`) are part of the product event and carry no separate charge. 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.

**Does "Include product details" cost extra?**
No. The detail fields are part of the product row and of the product event. The run takes a
little longer, because each product needs three small extra requests, and with per-result pricing
that time is not billed.

**Why are the detail fields missing for some products?**
Because Wildberries has no card file for that article in its static storage, which happens with
brand-new and delisted products. The product row is still written with the data from the catalog,
and the run's status message says how many articles were affected.

**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 does the first request of a run take half a minute?**
Because the run starts a real browser once to clear the marketplace's anti-bot check. That took
7 to 26 seconds in our measurements. Everything after it is plain HTTP, so the rest of the run
runs at normal speed, and you pay per result either way.

**Do I need a proxy?**
Usually not. The run goes out from the container's own address by default, which cleared the
check fastest in our measurements and costs nothing. Turn a proxy on when you need prices for a
specific region. One sticky session is then used for the whole run, because the anti-bot token
is bound to the exit address.

**Can I run it on a schedule, from code or from an AI agent?**
Yes. Use Apify **Schedules** for recurring runs, the [Apify API](https://docs.apify.com/api/v2)
or an official client from your own code, and the **Apify MCP server** for AI agents. Every
output field is described in the dataset schema, so an agent gets typed field metadata.

**What does a typical run cost?**
The rates are in Pricing above: $0.02 per run start, $0.0035 per product and $0.002 per review.
A daily price check of 100 article numbers without reviews costs $0.02 plus 100 products at
$0.0035, so $0.37 per run. Adding 20 reviews per product adds 2,000 reviews, so $4 more.

### Rate this Actor

If this Actor saved you time, a short rating or review on its Store page helps other people find
it. Missing a field, or did something break? Open the **Issues** tab on this page and tell us.

### Need a custom scraper?

We can build a custom version of this Actor, for example with extra fields, other filters or another output format, or a new Actor for a site we do not cover yet. It runs on Apify like this one. Email actorforge.hq+orders@gmail.com with the site, the data you need and how often you need it.

### Other Actors

- [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 fields 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.

## `includeDetails` (type: `boolean`):

Also fetch each product's description, specification list, category, seller's legal details and Wildberries' own price history. Three small requests per product go to Wildberries' static card storage, which needs no anti-bot token. Part of the product event, no separate charge.

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

Optional. Wildberries is fetched from the container's own address by default, which is free and fastest. Turn a proxy on only if you need a specific region: the whole run then goes through one sticky session, because the Wildberries anti-bot token is bound to the exit address.

## Actor input object example

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

# 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.

## `details` (type: `string`):

Products with card details, produced only when "Include product details" is enabled: category, seller legal entity, price history, specifications and description.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "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/dcyaW6yW6v22uQtDJ/openapi.json