# Yandex Market Scraper (`khadinakbar/yandex-market-scraper`) Actor

Scrape Yandex Market (Яндекс Маркет) product data by keyword search, category URL, or product/card URL. Returns title, price, SKU, seller, stock, images, and badges. Cookieless HTTP Impit. MCP-ready.

- **URL**: https://apify.com/khadinakbar/yandex-market-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Yandex Market Scraper

Scrape **public product cards** from Yandex Market (Яндекс Маркет). Paste search keywords or Market search, category, card, or product URLs and get one dataset row per product: title, price, currency, Market SKU, seller and shop IDs, stock signals, promo badges, and image URL when the public page exposes them.

Built for **price-monitoring teams, RU ecommerce researchers, and AI agents** that need a flat, billable product table from caller-supplied keywords or URLs — without a Yandex login.

### Best fit

Use this Actor when you already know what to search (for example `iPhone 15` or `наушники`) or you already have Market listing URLs and need priced product rows for monitoring, assortment research, or MCP/agent pipelines.

When you need place discovery on Yandex Maps, search with [Yandex Maps Scraper](https://apify.com/khadinakbar/yandex-maps-scraper), then for reviews continue with [Yandex Maps Reviews Scraper](https://apify.com/khadinakbar/yandex-maps-reviews-scraper). This Actor stays focused on Market product cards, not Maps places.

#### Designed for

- Keyword or URL → structured Market product rows with price and SKU.
- Pay per event pricing with caller-paid platform usage.
- Agent workflows that call `apify--yandex-market-scraper` for public product cards.

#### Scope

- Public Market listings and search results you are authorized to process.
- Optional product-page enrich for specs, rating, and brand when those pages are reachable.
- Sibling Maps Actors (linked above) cover places and reviews; keep this Actor on Market products.

### Practical scenario

A pricing analyst pastes `searchQueries: ["iPhone 15"]`, sets `maxResults` to `5`, leaves enrich off, and keeps Residential proxy on. The run returns five public cards with title, RUB price, Market SKU, stock, and badges. They export CSV for a competitor price sheet, then schedule the same input nightly. Empty or unusable input finishes `SUCCEEDED` / `INVALID_INPUT` without `product-scraped` charges; an upstream SoftBlock with zero rows finishes as `UPSTREAM_FAILED`.

### Quick start input

```json
{
  "searchQueries": ["iPhone 15"],
  "maxResults": 5,
  "enrichDetails": false,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "RU"
  }
}
```

You can also paste Market URLs under `startUrls` (search, catalog, category, card, or product paths on the Market host).

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `searchQueries` | array | Keywords in Russian or English. |
| `startUrls` | array | Market search / catalog / category / card / product URLs. |
| `maxResults` | integer | Cap on saved rows (default 20, max 500). Prefill 5 for cheap tests. |
| `minPrice` / `maxPrice` | integer | Optional ruble bounds on search. |
| `sortBy` | enum | `relevance`, `priceAsc`, `priceDesc`, `rating`, `popularity`. |
| `enrichDetails` | boolean | Optional product-page enrich for specs/rating/brand (captcha-sensitive). |
| `proxyConfiguration` | object | Recommended Residential with country `RU`. |

### What data you receive

One dataset item is one public product card (or enriched product row).

| Field | Meaning |
|---|---|
| `title`, `price`, `currency`, `productUrl` | Core listing identity and price. |
| `marketSku`, `modelId`, `oskuId` | Market identifiers for dedupe and tracking. |
| `shopId`, `businessId`, `stockCount`, `badges` | Seller and offer signals when exposed. |
| `imageUrl`, `description` | Media and short feature blurb from search JSON-LD. |
| `searchQuery`, `sourceUrl`, `scrapedAt` | Provenance for the row. |

```json
{
  "title": "Смартфон Apple iPhone 15 128 ГБ, черный, версия для рынка Китая",
  "productUrl": "https://market.yandex.ru/card/smartfon-apple-iphone-15-128-gb-chernyy-versiya-dlya-rynka-kitaya/6093276745",
  "price": 52591,
  "currency": "RUB",
  "marketSku": "6093276745",
  "isAvailable": true,
  "stockCount": 54,
  "badges": ["Скидка 52%"],
  "imageUrl": "https://avatars.mds.yandex.net/get-mpic/.../orig",
  "searchQuery": "iPhone 15",
  "sourceUrl": "https://market.yandex.ru/search?text=iPhone+15",
  "scrapedAt": "2026-09-17T13:14:00.455Z"
}
```

`OUTPUT` and `RUN_SUMMARY` in the default key-value store hold `outcome`, `itemsPushed`, and `chargedEventCounts`.

### Pricing

This Actor uses **Pay per event** plus **platform usage**. Event prices below are the launch defaults; treat the live Pricing tab on the Actor page as the current source of truth, because platform usage (compute and proxy) is billed to the caller in addition to named events.

| Event | Price |
|---|---|
| `apify-actor-start` | $0.00005 |
| `product-scraped` (primary) | $0.006 per saved product |

Empty inputs and zero-row empty searches skip the `product-scraped` event. Worked example: `maxResults: 5` on one keyword ≈ `$0.00005` start + `5 × $0.006` = about `$0.03005` in named events, plus platform usage.

### Best results

Start with `maxResults` at 5 while validating a query, then raise the cap once Residential RU is confirmed for your account. Keep `enrichDetails` off for reliable search-only runs; turn it on only when you need specs or ratings and can tolerate product-page SoftBlocks. Prefer complete Market search or card URLs when you already have them. Pagination uses `page=N` on search/category jobs until the result cap is reached.

### How it works

Market search and category pages server-render a schema.org `ItemList` of products plus `productSnippet` zone data. This Actor uses **Impit Chrome-TLS HTTP** with a homepage cookie warmup, merges those sources into one row per product, and paginates. Optional enrich opens card/product URLs for extra fields when they clear anti-bot checks.

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~yandex-market-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["iPhone 15"],"maxResults":5}'
```

### Use with AI agents through Apify MCP

> Search Yandex Market for "iPhone 15", return up to 5 products with title, price, currency, marketSku, and productUrl. Read the dataset plus OUTPUT for outcome and provenance, then confirm cost on the Pricing tab.

Connect via <https://mcp.apify.com>. Cost signal: about `$0.006` per saved product plus platform usage. Confirm current event prices on the Actor Pricing tab before large runs. Scope stays public product cards; pagination is controlled by `maxResults`.

### Outcomes

| Outcome | Meaning |
|---|---|
| `COMPLETE` | At least one product saved. |
| `PARTIAL` | Some jobs produced rows; others hit a SoftBlock or charge cap. |
| `VALID_EMPTY` | Jobs resolved but no public products matched. |
| `INVALID_INPUT` | No usable queries or Market URLs were provided. |
| `UPSTREAM_FAILED` | Transport or captcha with zero useful products. |

### Legal & responsible use

Use this Actor for **public** Yandex Market product content you are authorized to process under applicable laws and site terms. Respect rate limits and local commerce rules. Keep use cases to legitimate price monitoring, research, and analytics. Yandex and Yandex Market are trademarks of their owners. This independent Actor is not affiliated with, associated with, or endorsed by Yandex.

### Builder's note

I built this around Market search and category SSR HTML because those pages already embed a clean Product `ItemList` plus `productSnippet` offer metadata, so a browser is unnecessary for the primary path. In my testing, direct product and card pages SoftBlock more often with SmartCaptcha; Impit plus homepage cookie warmup and Residential session rotation cleared search reliably in the private release matrix, while enrich remains optional and fail-soft so search rows stay when a detail page SoftBlocks.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more Yandex Market search keywords (Russian or English), for example "iPhone 15" or "наушники". Each query starts a search job. Combined with startUrls. Leave empty only when you paste product or search URLs.

## `startUrls` (type: `array`):

Optional market.yandex.ru links: /search, /catalog--, /category/, /card/, or /product-- pages. Search/category URLs paginate; product/card URLs return one detail row. Non-Market hosts are ignored.

## `maxResults` (type: `integer`):

Hard cap on saved product rows across all queries and URLs. Prefill 5 keeps quality tests cheap. Maximum 500. Each saved row costs $0.006.

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

Optional lower bound in rubles applied to search URLs and client-side filtering. Leave empty for no minimum.

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

Optional upper bound in rubles applied to search URLs and client-side filtering. Leave empty for no maximum.

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

Search sort order mapped to Yandex Market how= parameter. Only applies to keyword search jobs, not pasted product URLs.

## `enrichDetails` (type: `boolean`):

When true, open each listing card/product URL for specs, rating, and brand. Product pages are captcha-sensitive; failed enrichments keep the search card and do not fail the run. Defaults to false for reliable search-only runs.

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

Recommended: Apify Residential with country RU. Direct Impit often works for search pages; product detail pages may require Residential to avoid SmartCaptcha.

## Actor input object example

```json
{
  "searchQueries": [
    "ноутбук",
    "iPhone 16"
  ],
  "startUrls": [
    {
      "url": "https://market.yandex.ru/search?text=iphone"
    }
  ],
  "maxResults": 5,
  "sortBy": "relevance",
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Yandex Market product.

## `output` (type: `string`):

Final outcome, itemsPushed, and chargedEventCounts.

## `runSummary` (type: `string`):

Per-job outcomes, enrich stats, blocked fetches, and billing counters.

# 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 = {
    "searchQueries": [
        "iPhone 15"
    ],
    "maxResults": 5,
    "sortBy": "relevance",
    "enrichDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/yandex-market-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 = {
    "searchQueries": ["iPhone 15"],
    "maxResults": 5,
    "sortBy": "relevance",
    "enrichDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/yandex-market-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 '{
  "searchQueries": [
    "iPhone 15"
  ],
  "maxResults": 5,
  "sortBy": "relevance",
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call khadinakbar/yandex-market-scraper --silent --output-dataset

```

## MCP server setup

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