# Yandex Market Reviews Scraper (`apt_marble/yandex-market-reviews-scraper`) Actor

Collect customer reviews for any Yandex Market product as a clean table: star rating, review text, what buyers liked and disliked as separate columns, author, date, helpful votes and photo counts. Order by newest, lowest rated or most helpful, and filter by stars.

- **URL**: https://apify.com/apt\_marble/yandex-market-reviews-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 review collecteds

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?

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

## Yandex Market Reviews Scraper

Turn the customer reviews on any Yandex Market product into a clean, analysable
table. For every review you get the star rating, the free-text opinion, and —
because this marketplace asks its shoppers for them separately — **what the
buyer liked and what they disliked as two distinct columns**, ready for analysis
without any text-splitting of your own. Add the author, the publication date,
the helpful votes, the number of photos attached, and the exact product version
that was reviewed. Point it at one product or at a list of hundreds, choose
whether you want the newest reviews, the angriest ones or the most helpful, and
run it on a schedule to watch what buyers are saying over time.

Built for product managers, brand owners, marketplace sellers and market
researchers who need real customer language about a product rather than a star
average.

### What you can do with it

- **Mine complaints at scale.** Order by lowest rated first and pull every
  one-star and two-star review for your product and your competitors', with the
  "disliked" column already separated out.
- **Track sentiment after a launch or a change.** Order by newest first, run it
  weekly, and see how the rating and the wording move.
- **Benchmark against competitors.** Give it a list of rival products and get
  one table with every review side by side, ready for a pivot table.
- **Feed a language model or a sentiment tool** with structured opinion text
  instead of screenshots — each row already separates praise from criticism.
- **Find your product's real selling points** by counting what buyers put in the
  "liked" column most often, in their own words.
- **Spot review-worthy quality problems early** by watching which product version
  the low ratings cluster around.

### What you get

One row per review. An abridged real record:

```json
{
  "productId": "1912483624",
  "productTitle": "Смартфон Apple iPhone 15",
  "productUrl": "https://market.yandex.ru/product/1912483624",
  "purchasedVariant": "Смартфон Apple iPhone 15 128Gb 2SIM черный",
  "reviewId": "324998227",
  "rating": 5,
  "text": "мне понравился.",
  "pros": "Качество сборки и дизайн, производительность, качество камеры",
  "cons": "Высокая цена, ограниченные настройки",
  "authorName": "дмитрий андреев",
  "authorPublicId": "b08e6dmyw0m11d1zr41jrxhqy8",
  "publishedAt": "2024-07-21",
  "publishedAtText": "21 июля 2024",
  "usefulCount": 5,
  "notUsefulCount": 5,
  "commentCount": 0,
  "photoCount": 0,
  "photoUrls": [],
  "page": 1,
  "positionOnPage": 1,
  "sortOrder": "useful",
  "sortRequested": "useful",
  "market": "ru",
  "regionId": 213,
  "regionName": "Москва",
  "collectedAt": "2026-08-17T10:00:00.000Z"
}
```

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `productUrls` | list of links | — | Product pages on Yandex Market whose reviews you want. Copy the address of a product page and paste it in. |
| `productIds` | list of text | — | The numbers that identify products, if you already have them. Use these, the links above, or both. |
| `maxReviewsPerProduct` | number | `100` | How many reviews to collect for each product, up to 510 — the most the marketplace will serve for any one product. |
| `sortBy` | choice | `useful` | Which reviews you want first: **Most helpful**, **Newest**, **Highest rated** or **Lowest rated**. This decides what you get when a product has more reviews than you asked for. |
| `minRating` | number | `1` | Keep only reviews of at least this many stars. |
| `maxRating` | number | `5` | Keep only reviews of at most this many stars. Set both to `1` for one-star reviews only. |
| `market` | choice | `ru` | The market the reviews belong to. This marketplace publishes one public pool of product reviews, so it is fixed and shown for clarity. |
| `productsAtOnce` | number | `3` | How many products the run works through side by side, up to 10. Higher finishes a long list sooner. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `productId` | text | The number that identifies the product on the marketplace. |
| `productTitle` | text | The product's name as the marketplace publishes it. |
| `productUrl` | text | Link to the product page. |
| `purchasedVariant` | text | The exact version the reviewer bought — colour, storage size and so on — where the marketplace attaches one. |
| `reviewId` | text | The number that identifies this review. |
| `rating` | number | Stars, 1 to 5. |
| `text` | text | The free-text body of the review. |
| `pros` | text | What the buyer said they liked, as a separate field. |
| `cons` | text | What the buyer said they disliked, as a separate field. |
| `authorName` | text | The display name the reviewer publishes. |
| `authorPublicId` | text | The public profile identifier the marketplace shows alongside the review. |
| `publishedAt` | text | The publication day as `YYYY-MM-DD`. |
| `publishedAtText` | text | The date exactly as the marketplace prints it, so you can always check the line above. |
| `usefulCount` | number | How many shoppers marked the review helpful. |
| `notUsefulCount` | number | How many marked it not helpful. |
| `commentCount` | number | Replies attached to the review. |
| `photoCount` | number | Photos attached to the review. |
| `photoUrls` | list of text | Links to those photos at full size. |
| `page` | number | Which batch of the product's review list this came from. |
| `positionOnPage` | number | Where it sat inside that batch. |
| `sortOrder` | text | The ordering the marketplace actually applied, read back from its own answer. Empty if it did not say. |
| `sortRequested` | text | The ordering you asked for, kept beside the line above so the two can never be confused. |
| `market` | text | The market the reviews belong to. |
| `regionId` | number | The market identifier the answer came back stamped with. |
| `regionName` | text | The market's name as the marketplace prints it. |
| `collectedAt` | text | When this run collected the row. |

Any field the marketplace does not publish for a given review comes back empty
rather than guessed, and the column is still there — so your spreadsheet keeps
stable headings.

### Pricing

You pay for what you actually receive.

| You are charged | How much |
| --- | --- |
| For every review written to your table | $0.0015 (that is $1.50 per 1,000 reviews) |
| For every product the actor works through | $0.020 |

The per-product charge covers the work of opening and checking a product's
review list, which is the same job whether that product has four reviews or four
hundred. A product that turns out to have no reviews to return is still charged
for, because it was still checked. Two things are **not** charged: a product the
marketplace refuses to show, and a product number the marketplace does not
recognise at all — a stale or mistyped ID costs you nothing.

**Worked example.** 50 products at 200 reviews each:
50 × $0.020 = $1.00, plus 10,000 × $0.0015 = $15.00 — **$16.00** in total.
A weekly watch over 10 products, 20 newest reviews each, costs **$0.50** a run.

### Limits & what this actor cannot do

- **Results are a snapshot.** Reviews arrive on the marketplace continuously and
  a product's rating moves; every row is stamped with the moment it was taken.
- **The marketplace serves at most 510 reviews for any one product.** That is a
  wall on its side, not a setting on this one: a product listing five thousand
  reviews still stops there, and no actor can go past it. A quiet product
  returns the handful it has, and that is the honest answer, not a failure. Set
  the per-product number to what you need up to 510; for wider coverage, run
  more products rather than deeper ones.
- **A deep pull can come back with fewer than 510 even on a busy product.** The
  marketplace repeats some reviews as you go down its list, and a repeat is not
  a second review: it is served once here, and you are charged once. On a
  heavily reviewed product measured at the full depth, 510 places on the list
  held 444 distinct reviews. Every one of them is a real review, and none of
  them is a duplicate row.
- **Reviews are in the language shoppers write them in**, which on this
  marketplace is overwhelmingly Russian. Nothing is translated.
- **Only the day of publication is published, never a time.** Where the
  marketplace writes "today" or "yesterday" instead of a date, that is resolved
  against the day the run happened, and the original wording is kept in
  `publishedAtText` so you can always check.
- **One market.** This marketplace publishes a single public pool of product
  reviews and does not accept a different market, so there is no city or country
  to choose. Every row is stamped with the market its answer came back for.
- **Nothing behind a sign-in.** The actor reports what the marketplace publishes
  to the public. It does not sign in, sees nothing private, and cannot reveal a
  detail the marketplace keeps back — including a reviewer's real identity,
  their contact details or their purchase history.
- **Not every review carries every field.** Plenty of shoppers leave a rating
  and a "liked" line and nothing else. Those fields come back empty rather than
  invented.
- **Product links must be product links.** A link to one seller's listing of an
  item does not carry the product number, and the actor tells you so instead of
  quietly returning an empty result. Copy the address of the product page.
- **A seller, brand or category link is refused before the run starts.** Each of
  those addresses carries a number that is not a product number, and the
  marketplace answers it with a page that reads exactly like a product with no
  reviews — so they are rejected by name rather than turned into a confident
  empty result you would be charged for.
- **A narrow star range takes longer** and can return fewer reviews than you
  asked for, simply because fewer of that product's reviews match it.
- **A product the marketplace refuses to show is reported as a failed product**,
  counted separately in the run summary — never as "no reviews found". That
  distinction is the whole point: an empty result you can trust is worth more
  than a fast one you cannot.
- **A product number the marketplace does not recognise gets its own line too.**
  A stale or mistyped number is served the same page as a real product with no
  reviews yet — same heading, same size, same everything a reader can see — so a
  weaker tool tells you a product you no longer stock has zero reviews. This one
  reads the marketplace's own internal key for the product it resolved, says
  "the source does not recognise this product ID", counts it under
  `productsNotFound`, and does not charge you for it.
- **Speed depends on the size of the job** and on how quickly the marketplace
  answers on the day. No fixed rate is promised.
- **Reviews are written by private individuals.** Treat the author name, public
  profile identifier and review text as personal data: collect only what you
  need, keep it no longer than you need it, and handle it in line with
  applicable privacy law, including GDPR and Russian personal data law where
  they apply. The marketplace's own terms govern automated access, and you are
  responsible for using the data lawfully and in line with those terms.

### FAQ

**Do I need an account on the marketplace?**
No. Nothing is needed but the product links you want reviews for.

**Does it need my login or password?**
No. The actor never signs in anywhere and has no place to put a password.

**Can I schedule it?**
Yes. Set it to run daily or weekly on Apify and each run writes a fresh table,
which is the usual way people track how sentiment moves after a launch, a price
change or a bad batch.

**Why are "liked" and "disliked" separate columns?**
Because the marketplace asks shoppers for them separately, and they arrive that
way. It is the single most useful thing about this source: you get structured
praise and structured criticism without doing any text analysis yourself.

**Can I get every review a product has ever had?**
You can go a long way down — far further than the marketplace shows on its own
first screen — but no source publishes an unlimited archive, and this one is no
exception. Set `maxReviewsPerProduct` to what you need, choose the ordering that
matters to you, and the run reports exactly how many it collected.

**What happens if a product has no reviews?**
You get no rows for it and the run summary counts it under "products without
reviews", clearly separated from products that could not be read at all — and
also separately from products that *have* reviews of which none fall inside the
star range you asked for. Those get their own line, so a one-star-only run never
reads as "most of this catalogue is unreviewed".

**What happens if one of my product numbers is wrong or out of date?**
The run tells you so by name. It is counted under `productsNotFound` in the run
summary and logged as "the source does not recognise this product ID" — never as
"this product has no reviews" — and it is not charged. This matters most when you
feed a long list from your own catalogue: the products that genuinely have no
reviews and the numbers that no longer exist are two different answers, and you
can see which is which.

**Can I filter to one-star reviews only?**
Yes. Set both `minRating` and `maxRating` to `1`, and choose "Lowest rated
first" so the run finds them quickly.

# Actor input Schema

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

Product pages on Yandex Market whose customer reviews you want. Open a product on the marketplace and copy the address of that page. Use this, the product numbers field below, or both.

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

The numbers that identify products on Yandex Market, if you already have them — for example from an earlier run. One per line.

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

How many reviews to collect for each product. The source serves at most 510 reviews for any one product, however many it says the product has, so 510 is the highest this can be set to. A product simply returns everything it has if that is fewer.

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

Which reviews you want first. This decides what you get when you collect fewer reviews than a product has: newest first for monitoring what buyers are saying now, lowest rated first for complaint analysis, most helpful first for a balanced read.

## `minRating` (type: `integer`):

Only keep reviews rated at least this many stars. Leave at 1 to keep every rating.

## `maxRating` (type: `integer`):

Only keep reviews rated at most this many stars. Set both fields to 1 to collect one-star reviews only.

## `market` (type: `string`):

The market whose reviews you get. This marketplace publishes one pool of product reviews to the public, so this is fixed — it is shown here so what you receive is never in doubt. Every row is also stamped with the market the answer actually came back for.

## `productsAtOnce` (type: `integer`):

How many products the run works through side by side. Higher finishes a long list sooner; lower is gentler and steadier. Leave it at 3 unless you have a large list.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://market.yandex.ru/product/1912483624"
    }
  ],
  "productIds": [
    "1912483624",
    "934253548"
  ],
  "maxReviewsPerProduct": 50,
  "sortBy": "useful",
  "minRating": 1,
  "maxRating": 5,
  "market": "ru",
  "productsAtOnce": 3
}
```

# Actor output Schema

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

Every collected review, one row per review.

## `overview` (type: `string`):

The columns a review analysis needs, in reading order.

## `csv` (type: `string`):

The same rows as a spreadsheet file.

## `summary` (type: `string`):

What was collected, which products had nothing to return, which product IDs the marketplace does not recognise, and which could not be read.

# 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 = {
    "productUrls": [
        {
            "url": "https://market.yandex.ru/product/1912483624"
        }
    ],
    "maxReviewsPerProduct": 50,
    "sortBy": "useful",
    "minRating": 1,
    "maxRating": 5,
    "market": "ru",
    "productsAtOnce": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/yandex-market-reviews-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 = {
    "productUrls": [{ "url": "https://market.yandex.ru/product/1912483624" }],
    "maxReviewsPerProduct": 50,
    "sortBy": "useful",
    "minRating": 1,
    "maxRating": 5,
    "market": "ru",
    "productsAtOnce": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/yandex-market-reviews-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 '{
  "productUrls": [
    {
      "url": "https://market.yandex.ru/product/1912483624"
    }
  ],
  "maxReviewsPerProduct": 50,
  "sortBy": "useful",
  "minRating": 1,
  "maxRating": 5,
  "market": "ru",
  "productsAtOnce": 3
}' |
apify call apt_marble/yandex-market-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/yandex-market-reviews-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/13jVCbxbJNYwK7Q21/builds/bUBqdaowKkJPdErcH/openapi.json