# Komissionki Product Search Scraper (`stealth_mode/komissionki-product-search-scraper`) Actor

Scrape product listings from Komissionki.ru with precision. Capture prices, barcode data, shop locations, cashback offers, booking status, and 38+ product attributes per item — ideal for price monitoring, inventory analysis, and marketplace research.

- **URL**: https://apify.com/stealth\_mode/komissionki-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 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.

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

## Komissionki.ru Product Scraper: Extract Secondhand Product Data

---

### What Is Komissionki.ru?

Komissionki.ru is a Russian online marketplace specializing in secondhand and discounted products across multiple categories including electronics, phones, clothing, and more. The platform connects individual sellers and retailers with millions of daily visitors seeking deals. Manually extracting product data from thousands of listings is inefficient — the **Komissionki Product Search Scraper** automates this process, delivering structured product records with complete pricing, availability, and specification data.

---

### Overview

The **Komissionki Product Search Scraper** extracts comprehensive product information from category and search pages on Komissionki.ru, transforming raw product listings into clean, structured datasets. It is ideal for:

- **Price monitoring tools** tracking secondhand product market dynamics
- **E-commerce analysts** benchmarking pricing across Komissionki inventory
- **Data researchers** studying Russian secondary markets and consumer behavior
- **Marketplace aggregators** building product databases across multiple sellers
- **Business intelligence teams** analyzing regional pricing and product availability

Key features include flexible item limits, automatic handling of failed URLs, and collection of rich product metadata including stock status, payment options, location data, and promotional details.

---

### Input Format

The scraper accepts a JSON configuration object with three main parameters:

```json
{
  "urls": [
    "https://komissionki.ru/catalog/telefony/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | List of Komissionki product category or search result page URLs to scrape |
| `ignore_url_failures` | Boolean | If `true`, continues scraping even if individual URLs fail; if `false`, stops on error |
| `max_items_per_url` | Integer | Maximum number of products to extract per URL (default: 20, max: 200) |

**Input Requirements:**

- Provide complete URLs pointing to category pages or search results (e.g., `/catalog/telefony/`)
- URLs should be product listing pages, not individual product detail pages
- Each URL typically contains 20–50+ products depending on search filters
- Set `max_items_per_url` between 20–200 based on your data volume needs

***

### Output Format

**Sample output**

```json
{
  "barcode": "2019500908479",
  "barcode_shop_uniq": "2019500908479-1",
  "booking_to": null,
  "brand": {
    "code": "xiaomi",
    "id": 41,
    "name": "Xiaomi",
    "sort": 9999980,
    "title": "Xiaomi",
    "title_search": "Xiaomi"
  },
  "cashback": null,
  "category": {
    "code": "sotovye-telefony",
    "id": 74,
    "name": "Сотовые телефоны",
    "sort": 920,
    "title": "Сотовые телефоны"
  },
  "characteristic_ids": null,
  "city": [
    {
      "code": "krasnoyarsk",
      "code_ru": "красноярск",
      "id": 10,
      "name": "Красноярск",
      "sort": 400,
      "title": "Красноярск"
    }
  ],
  "code": "xiaomi-redmi-note-14-pro-12512-gb-2019500908479-1",
  "created_at": "2026-06-13T03:01:33Z",
  "description": "б\\к",
  "discount_percent": null,
  "filial": [
    {
      "balance": 1,
      "city_id": 10,
      "id": 94,
      "reserve": 0
    }
  ],
  "has_photos": true,
  "id": 3937089,
  "is_active": true,
  "is_booking": false,
  "is_credit": false,
  "is_credit_and_installment": false,
  "is_delete": false,
  "is_installment": false,
  "model": {
    "code": "redmi-note-14-pro",
    "id": 491021,
    "name": "Redmi Note 14 Pro",
    "release_date": "2025-09-23T10:57:53Z",
    "sort": 1000,
    "title": "Redmi Note 14 Pro",
    "title_search": "Redmi Note 14 Pro"
  },
  "model_specification": {
    "code": "12512-gb",
    "id": 17691,
    "name": "12/512 ГБ",
    "title": "12/512 ГБ",
    "title_search": "12/512 ГБ"
  },
  "name": "Xiaomi Redmi Note 14 Pro 12/512 ГБ",
  "old_price": null,
  "parent_category": {
    "code": "telefony",
    "id": 68,
    "name": "Телефоны",
    "sort": 1000,
    "title": "Телефоны"
  },
  "photos_resized": {
    "h_n_x_t4_e_h_b_h0_y_lq_x9_y_c": 1,
    "p_y_jeb2_jn_rr_u_k_r_r_y_y_c": 0
  },
  "presentation": "хорошее",
  "price": 15990,
  "shop_id": 1,
  "status": "sync",
  "system_payment": {
    "id": 131,
    "system_payment_company_credit_id": null,
    "system_payment_company_installment_id": null
  },
  "title": "Xiaomi Redmi Note 14 Pro 12/512 ГБ",
  "title_suggest": "Xiaomi Redmi Note 14 Pro 12/512 ГБ",
  "title_suggest_ngram": "Xiaomi Redmi Note 14 Pro 12/512 ГБ",
  "updated_at": "2026-06-13T03:31:07Z",
  "video": null,
  "from_url": "https://komissionki.ru/catalog/telefony/"
}
```

Each scraped product returns a comprehensive record with 38 fields covering identification, pricing, location, inventory status, and specifications:

#### Product Identification & Classification

| Field | Purpose |
|---|---|
| `ID` | Unique product identifier in Komissionki system |
| `Title` | Product name as displayed on the marketplace |
| `Title Suggest` | Auto-completed suggestion version of the title |
| `Title Suggest Ngram` | N-gram tokenized title for search optimization |
| `Code` | Internal product code |
| `Barcode` | Product barcode (if available) |
| `Barcode Shop Uniq` | Shop-specific barcode identifier |
| `Brand` | Product manufacturer or brand name |
| `Model` | Product model designation |
| `Model Specification` | Detailed specification string for the model |
| `Category` | Primary product category |
| `Parent Category` | Higher-level category classification |

#### Pricing & Financial Terms

| Field | Purpose |
|---|---|
| `Price` | Current asking price in rubles |
| `Old Price` | Previous or original price (for discount tracking) |
| `Discount Percent` | Percentage discount offered (0–100) |
| `Cashback` | Cashback amount or percentage available |
| `Is Credit` | Boolean: whether product qualifies for credit payment |
| `Is Installment` | Boolean: whether installment plans are available |
| `Is Credit And Installment` | Boolean: both payment options available |
| `System Payment` | Payment system or method identifier |

#### Availability & Booking

| Field | Purpose |
|---|---|
| `Is Active` | Boolean: whether the listing is currently active |
| `Is Booking` | Boolean: whether the product can be pre-booked |
| `Booking To` | Booking deadline date (if applicable) |
| `Is Delete` | Boolean: whether the listing is marked for deletion |
| `Status` | Current listing status (active, inactive, archived, etc.) |

#### Location & Seller Information

| Field | Purpose |
|---|---|
| `City` | City where the product is located |
| `Filial` | Store branch or location code |
| `Shop ID` | Unique seller/shop identifier |

#### Media & Presentation

| Field | Purpose |
|---|---|
| `Has Photos` | Boolean: whether photos are attached |
| `Photos Resized` | Resized photo URLs and dimensions |
| `Presentation` | Marketing presentation or description text |
| `Video` | Video link or embedded video URL |
| `Description` | Detailed product description (if provided) |

#### Metadata & Timestamps

| Field | Purpose |
|---|---|
| `Created At` | Listing creation timestamp |
| `Updated At` | Last update timestamp |
| `Characteristic IDs` | Array of product feature identifiers |

***

### How to Use

1. **Identify target URLs** — Browse Komissionki.ru and find category or search pages you want to scrape (e.g., `/catalog/telefony/` for phones).
2. **Copy listing page URLs** — Add the full page URLs to the `urls` array in your configuration.
3. **Configure parameters** — Set `max_items_per_url` based on how much data you need (20–200 products per page).
4. **Enable failure handling** — Keep `ignore_url_failures: true` for robust, uninterrupted collection.
5. **Execute the scraper** — Start the run and monitor progress in real-time.
6. **Download results** — Export data as JSON, CSV, or Excel for analysis.

**Best practices:**

- Test with `max_items_per_url: 20` first to validate output structure
- Use `ignore_url_failures: true` when scraping multiple URLs to prevent pipeline breaks
- Cache results locally to avoid re-scraping the same URLs
- Respect Komissionki.ru's robots.txt and rate limits during large-scale runs

***

### Use Cases & Business Value

- **Competitive pricing intelligence:** Monitor secondhand product prices across regions and categories
- **Market research:** Analyze Komissionki inventory trends, seller concentration, and product availability
- **Algorithmic price detection:** Identify underpriced items or anomalies in the marketplace
- **Inventory aggregation:** Build comprehensive product feeds for multi-marketplace analytics
- **Academic studies:** Research secondhand market dynamics and consumer behavior in Russia

Extracting data manually from thousands of product listings would require weeks of effort. This scraper delivers complete, machine-readable datasets in minutes, enabling faster decision-making and competitive advantage.

***

### Conclusion

The **Komissionki.ru Product Search Scraper** is the efficient solution for capturing secondhand marketplace data at scale. With 38 output fields and intelligent error handling, it unlocks insights into pricing, availability, and market trends that inform smarter inventory and business decisions. Start scraping today and transform raw marketplace listings into actionable intelligence.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://komissionki.ru/catalog/telefony/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://komissionki.ru/catalog/telefony/"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/komissionki-product-search-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 = {
    "urls": ["https://komissionki.ru/catalog/telefony/"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/komissionki-product-search-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 '{
  "urls": [
    "https://komissionki.ru/catalog/telefony/"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/komissionki-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Komissionki Product Search Scraper",
        "description": "Scrape product listings from Komissionki.ru with precision. Capture prices, barcode data, shop locations, cashback offers, booking status, and 38+ product attributes per item — ideal for price monitoring, inventory analysis, and marketplace research.",
        "version": "0.0",
        "x-build-id": "gcjy1vSHwxHf80kfu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~komissionki-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-komissionki-product-search-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/stealth_mode~komissionki-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-komissionki-product-search-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/stealth_mode~komissionki-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-komissionki-product-search-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",
                "properties": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
