# DNS-Shop Scraper (`crawlerbros/dns-shop-scraper`) Actor

Scrape dns-shop.ru, a major Russian electronics retailer. Search products, browse categories, or fetch a single product's price, rating, images, and specs.

- **URL**: https://apify.com/crawlerbros/dns-shop-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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

## DNS-Shop Scraper

Scrape **dns-shop.ru** — one of Russia's largest electronics and appliance retailers, covering smartphones, laptops, PC components, TVs, home appliances, and more. Search by keyword, browse any category, or fetch full details for a single product: current price, rating, review count, stock status, images, and key specs.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Full pricing:** current price, monthly installment price, currency
- **Ratings & reviews:** aggregate rating (0–5), review count, and (in `productDetails`) a full star-count breakdown plus per-aspect sub-ratings
- **Price history:** weekly price points and min/max over the last several months (mode=`productDetails`)
- **Stock status:** in stock / out of stock / available soon
- **Key specs:** processor, display, memory, camera, etc. on every record; the **complete grouped technical spec sheet** (every characteristic DNS-shop publishes) on `productDetails`
- **Sibling variants:** for products sold in multiple colors/memory sizes/models, the full list of sibling SKUs with their own URL, stock status, and distinguishing attributes (mode=`productDetails`)
- **Filters:** price range, minimum rating, in-stock-only, sort order
- **Empty fields are omitted**

### Output per product

- `productId` — dns-shop.ru's internal SKU
- `title`
- `url` — canonical product page URL
- `price`, `currency` (`RUB`)
- `installmentPrice` — monthly installment price shown on listing pages, when available
- `rating` — 0–5 aggregate rating
- `reviewCount`
- `ratingBreakdown` — star-count histogram, e.g. `{"5": 36, "4": 3, "3": 0, "2": 0, "1": 1}` (mode=`productDetails` only, omitted for products with no reviews yet)
- `subRatings` — per-aspect ratings reviewers left, e.g. `{"Дисплей": 4.7, "Производительность": 4.7}` (mode=`productDetails` only, when the site shows them)
- `priceHistory[]` — weekly `{period, price}` points covering the last several months; `priceHistoryMin`, `priceHistoryMax`, `priceHistoryRangeText` (mode=`productDetails` only)
- `availability` — `In stock` / `Out of stock` / `Available soon`
- `imageUrl`, `images[]` — full product gallery (mode=`productDetails` only)
- `brand` (mode=`productDetails` only)
- `description` (mode=`productDetails` only)
- `categoryPath[]` — breadcrumb trail (mode=`productDetails` only)
- `specs` — key spec highlights (processor, display, memory, camera, etc.) on every record
- `fullSpecs` — the complete technical spec sheet grouped by section, e.g. `{"Процессор": {"Модель процессора": "Intel Core i3-1305U", ...}, "Экран": {...}, ...}` (mode=`productDetails` only)
- `variants[]` — every sibling SKU of a multi-configuration product (other colors, memory sizes, models, etc.), each with its own `productId`, `url`, `availability`, and distinguishing `attributes` (e.g. `{"Цвет": "Голубой", "Память (ГБ)": "256 ГБ"}`); the current record's own entry carries `isCurrent: true` (mode=`productDetails` only, omitted for single-SKU products with no variant picker)
- `cityName` — resolved delivery city, e.g. `Москва`; `deliveryText` — the site's own delivery estimate, e.g. "Доставим на дом за 2 часа" (mode=`productDetails` only)
- `storeAvailabilityText` — the site's own in-store stock summary, e.g. "В наличии в 277 магазинах"; `storeCount` — number of physical stores currently carrying it (mode=`productDetails` only)
- `reviews[]` — individually-authored reviews from the product's first reviews page (a real, if partial, sample — not the exhaustive set for high-review-count products), each with `author`, `date`, `rating` (1–5), `usageDuration`, `pros`, `cons`, `comment`, `photoCount` (only the fields that reviewer actually filled in) (mode=`productDetails` only, omitted when the page has no reviews)
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `iphone` | Free-text query (mode=search) |
| `category` | string | – | Curated top-level category (mode=byCategory) |
| `categoryUrl` | string | – | Full category URL override, for sub-categories not in the curated list (mode=byCategory) |
| `productUrl` | string | – | Full product URL (mode=productDetails) |
| `sortBy` | string | `popularity` | `popularity` / `priceAsc` / `priceDesc` / `rating` / `new` — **search/byCategory only** |
| `priceMin` | int | – | Drop products cheaper than this (RUB) — **search/byCategory only** |
| `priceMax` | int | – | Drop products more expensive than this (RUB) — **search/byCategory only** |
| `minRating` | number | – | Drop products rated below this (0–5) — **search/byCategory only** |
| `inStockOnly` | bool | `false` | Only emit in-stock products — **search/byCategory only** |
| `maxItems` | int | `20` | Hard cap (1–500) |
| `proxyConfiguration` | object | Off (no proxy) | Optional — see "Do I need a proxy?" below |

> `sortBy`, `priceMin`, `priceMax`, `minRating`, and `inStockOnly` only apply to `search`/`byCategory` listing runs. `mode=productDetails` always looks up the exact product at `productUrl` and ignores all five — a single explicit lookup is never "filtered out" or reordered.
>
> `minRating`/`inStockOnly` never drop a listing whose corresponding field the source card doesn't expose — an unknown value is treated as "not disqualified" rather than silently discarded, so those filters only ever remove listings that are *known* to be out of range. `priceMin`/`priceMax` are the one exception: dns-shop.ru's "similar/analog" substitute cards (discontinued items shown in place of an out-of-stock match) carry no price at all, so when a price filter is set those price-less listings are excluded rather than passed through — otherwise a price filter would be silently unable to rule them out.

#### Example: search for laptops under 80,000₽, sorted by price

```json
{
  "mode": "search",
  "searchQuery": "ноутбук",
  "priceMax": 80000,
  "sortBy": "priceAsc",
  "maxItems": 30
}
````

#### Example: browse the Smartphones category, in stock only, min 4.5 rating

```json
{
  "mode": "byCategory",
  "category": "17a8a01d16404e77|smartfony",
  "inStockOnly": true,
  "minRating": 4.5,
  "maxItems": 50
}
```

#### Example: single product lookup

```json
{
  "mode": "productDetails",
  "productUrl": "https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/"
}
```

### Use cases

- **Price monitoring** — track competitor pricing on electronics across categories
- **Market research** — analyze rating/review distribution for a product category
- **Assortment tracking** — monitor stock availability for specific SKUs
- **Deal discovery** — filter by price range and rating to surface the best-value products
- **Catalog enrichment** — pull the full spec sheet and images for a known product URL
- **Price-drop / promo detection** — compare `priceHistoryMin`/`priceHistoryMax` against the current `price` to spot real discounts vs. list-price theater
- **Review-quality signals** — use `ratingBreakdown` and `subRatings` to gauge review distribution and per-aspect sentiment before trusting the headline `rating`

### Other Russian marketplace actors by CrawlerBros

| Actor | URL |
|---|---|
| Citilink Scraper - Russian Electronics Store Products | <https://apify.com/crawlerbros/citilink-scraper> |
| DNS-Shop Scraper (this actor) | <https://apify.com/crawlerbros/dns-shop-scraper> |
| Eldorado Scraper | <https://apify.com/crawlerbros/eldorado-scraper> |
| ETM Electrical Equipment Scraper | <https://apify.com/crawlerbros/etm-scraper> |
| Holodilnik.ru Scraper | <https://apify.com/crawlerbros/holodilnik-scraper> |
| Lemanapro Scraper | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Is this affiliated with DNS?** No — this is an independent third-party actor that reads dns-shop.ru's publicly visible product pages. It is not affiliated with or endorsed by DNS.

**Do I need a proxy?** No. The actor passes dns-shop.ru's Qrator anti-bot challenge automatically via a warm-up browser session — `proxyConfiguration` is optional and off by default. Only turn it on if your specific runs start getting consistently blocked (which would indicate your egress IP has been independently reputation-flagged).

**What currency are prices in?** Russian rubles (`RUB`), as shown on the site.

**Why is `specs` a short list, not the full technical sheet?** `specs` reads the "key highlights" spec block shown directly on the product/listing page — populated for every record in every mode. The full technical sheet (`fullSpecs`) lives on a separate sub-page per product, so it's only fetched for `mode=productDetails` (a single item); fetching it for every row of a search/category listing would multiply the number of page loads needed per run.

**Why do some products lack `installmentPrice`, `reviewCount`, `ratingBreakdown`, or `priceHistory`?** Not every product offers installment financing, not every product has reviews yet (so there's nothing to break down), and brand-new listings may not have accumulated any price history yet — these fields are only included when the site actually shows them.

**What's in `variants`?** DNS-shop sells each color/memory/model combination of a product as its own separate SKU with its own URL and stock status. `variants` (mode=`productDetails` only) lists all of them — so you can see, from one lookup, that (for example) the black 256GB configuration is out of stock while the blue 128GB one is available, without running a separate lookup per configuration. Omitted entirely for products that don't offer any configuration choice.

**How fresh is the pricing data?** Live — every run fetches current pages; prices reflect what's shown to a live visitor at scrape time.

**Can I get products from a category not in the curated dropdown?** Yes — use `categoryUrl` with the full dns-shop.ru category (or filtered category) URL instead of the `category` dropdown.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text query (mode=search), e.g. `iphone`, `ноутбук`, `телевизор`.

## `category` (type: `string`):

A curated top-level dns-shop.ru category. For a sub-category not listed here, use `categoryUrl` instead.

## `categoryUrl` (type: `string`):

Full dns-shop.ru category URL for a sub-category not in the curated list above, e.g. `https://www.dns-shop.ru/catalog/17a8a01d16404e77/smartfony/?brand=apple`. Takes priority over `category` if both are set.

## `productUrl` (type: `string`):

Full dns-shop.ru product URL, e.g. `https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/`.

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

Result order for search/byCategory listings. Ignored by mode=productDetails (a single explicit product lookup is never reordered).

## `priceMin` (type: `integer`):

Drop products cheaper than this (rubles). Applies to search/byCategory listings only; ignored by mode=productDetails.

## `priceMax` (type: `integer`):

Drop products more expensive than this (rubles). Applies to search/byCategory listings only; ignored by mode=productDetails.

## `minRating` (type: `number`):

Drop products rated below this (0–5 scale). Applies to search/byCategory listings only; ignored by mode=productDetails.

## `inStockOnly` (type: `boolean`):

Only emit products currently available for purchase. Applies to search/byCategory listings only; ignored by mode=productDetails.

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

Hard cap on emitted records.

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

Optional. dns-shop.ru's Qrator WAF returns HTTP 401 with a JS challenge on the first request of any session, from any IP — this actor solves it automatically by warming up a real (Camoufox) browser session before scraping, so no proxy is required in normal use. Only set this if your runs start getting consistently blocked, which would indicate the egress IP itself has been reputation-flagged.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "category": "17a8a01d16404e77|smartfony",
  "productUrl": "https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/",
  "sortBy": "popularity",
  "inStockOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing all scraped dns-shop.ru products.

# 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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "category": "17a8a01d16404e77|smartfony",
    "productUrl": "https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/",
    "sortBy": "popularity",
    "inStockOnly": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/dns-shop-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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "category": "17a8a01d16404e77|smartfony",
    "productUrl": "https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/",
    "sortBy": "popularity",
    "inStockOnly": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/dns-shop-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 '{
  "mode": "search",
  "searchQuery": "iphone",
  "category": "17a8a01d16404e77|smartfony",
  "productUrl": "https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/",
  "sortBy": "popularity",
  "inStockOnly": false,
  "maxItems": 10
}' |
apify call crawlerbros/dns-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DNS-Shop Scraper",
        "description": "Scrape dns-shop.ru, a major Russian electronics retailer. Search products, browse categories, or fetch a single product's price, rating, images, and specs.",
        "version": "1.0",
        "x-build-id": "pNm6xVQ9vczGaBBUQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~dns-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-dns-shop-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/crawlerbros~dns-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-dns-shop-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/crawlerbros~dns-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-dns-shop-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query (mode=search), e.g. `iphone`, `ноутбук`, `телевизор`.",
                        "default": "iphone"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "",
                            "17a8a01d16404e77|smartfony",
                            "af47fe7c3bae7fd7|smartfony-i-gadzety",
                            "17a892f816404e77|noutbuki",
                            "17a8943716404e77|monitory",
                            "17a89aab16404e77|videokarty",
                            "17aa522a16404e77|komplektuusie-dla-pk",
                            "e33ed1823ba77fd7|komputery-i-po",
                            "17a8921e16404e77|periferia-i-aksessuary",
                            "17a9ef1716404e77|nausniki-i-garnitury",
                            "17aa72de16404e77|audiotehnika",
                            "17a8bfb516404e77|tv-konsoli-i-audio",
                            "17a8ae1316404e77|televizory-i-aksessuary",
                            "00f7d5bb3ba87fd7|konsoli-i-videoigry",
                            "151328a13ba87fd7|plansety-elektronnye-knigi",
                            "17a8e9b716404e77|bytovaa-tehnika",
                            "e258ce9b690b26d7|vstraivaemaa-tehnika",
                            "17a9e9c316404e77|videonabludenie",
                            "03d800b1b7df14a9|setevoe-oborudovanie",
                            "17a892c016404e77|wi-fi-routery-i-oborudovanie-dla-malyh-setej",
                            "17a9c2a316404e77|instrument-i-strojka",
                            "17a88a6b16404e77|avtozvuk",
                            "17a88ba616404e77|avtotovary",
                            "17a8ea5816404e77|krasota-i-zdorove",
                            "17a8addb16404e77|ofis-i-mebel",
                            "21600c8ef34aec24|osvesenie-i-aksessuary",
                            "17a8e3a816404e77|posuda-i-kuhonnye-predmety",
                            "dbb4f637c37f0606|sadovaa-tehnika",
                            "d5ee7d4f1f208a19|portativnyj-transport",
                            "3d6d8700cb3f50ff|igry-i-tvorcestvo"
                        ],
                        "type": "string",
                        "description": "A curated top-level dns-shop.ru category. For a sub-category not listed here, use `categoryUrl` instead.",
                        "default": ""
                    },
                    "categoryUrl": {
                        "title": "Category URL override (mode=byCategory)",
                        "type": "string",
                        "description": "Full dns-shop.ru category URL for a sub-category not in the curated list above, e.g. `https://www.dns-shop.ru/catalog/17a8a01d16404e77/smartfony/?brand=apple`. Takes priority over `category` if both are set."
                    },
                    "productUrl": {
                        "title": "Product URL (mode=productDetails)",
                        "type": "string",
                        "description": "Full dns-shop.ru product URL, e.g. `https://www.dns-shop.ru/product/00eb38374882ed20/61-smartfon-apple-iphone-15-128-gb-cernyj/`."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "popularity",
                            "priceAsc",
                            "priceDesc",
                            "rating",
                            "new"
                        ],
                        "type": "string",
                        "description": "Result order for search/byCategory listings. Ignored by mode=productDetails (a single explicit product lookup is never reordered).",
                        "default": "popularity"
                    },
                    "priceMin": {
                        "title": "Min price (RUB)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (rubles). Applies to search/byCategory listings only; ignored by mode=productDetails."
                    },
                    "priceMax": {
                        "title": "Max price (RUB)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (rubles). Applies to search/byCategory listings only; ignored by mode=productDetails."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop products rated below this (0–5 scale). Applies to search/byCategory listings only; ignored by mode=productDetails."
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently available for purchase. Applies to search/byCategory listings only; ignored by mode=productDetails.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. dns-shop.ru's Qrator WAF returns HTTP 401 with a JS challenge on the first request of any session, from any IP — this actor solves it automatically by warming up a real (Camoufox) browser session before scraping, so no proxy is required in normal use. Only set this if your runs start getting consistently blocked, which would indicate the egress IP itself has been reputation-flagged.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
