# Yandex Market Scraper: Парсер Яндекс Маркет (`getascraper/yandex-market-scraper`) Actor

Scrape Yandex Market (market.yandex.ru) products by keyword: price, rating, reviews, seller, specs, and verified images. Batch many searches. Парсер товаров Яндекс Маркета.

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

## Pricing

from $2.54 / 1,000 product records

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Yandex Market Scraper: Парсер Яндекс Маркет

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FDF2EF;border:1px solid #F6CDC2;border-top:4px solid #D6300B;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Turn Yandex Market searches into ready-to-use product data, one run at a time.</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">Search Яндекс Маркет by keyword, batch as many keywords as you want in a single run, and get price, stock, seller, rating, and a verified working photo for every product.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🎯 Batch keyword search</span><br>
<span style="font-size:12px;color:#57534E">Search dozens of keywords in one run instead of starting a new run for every term</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🖼️ Working photos only</span><br>
<span style="font-size:12px;color:#57534E">Every image link is checked before it ships, so you never get a broken thumbnail</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🏷️ Full pricing picture</span><br>
<span style="font-size:12px;color:#57534E">Current price, old price, discount percent, and stock status on every row</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #F6CDC2;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#D6300B">🏬 Seller and brand details</span><br>
<span style="font-size:12px;color:#57534E">See who is selling it, what brand it is, and how it is rated, not just the price</span>
</td>
</tr>
</table>

Get structured data from **Яндекс Маркет** (market.yandex.ru), Russia's largest online marketplace. Give this Actor a list of keywords and it returns one clean row per product: name, brand, price, old price, discount, stock status, rating, seller, category, a short spec summary, an estimated delivery time, and a verified working image. Built for price monitoring, sourcing research, and any tool that needs clean, structured marketplace data without babysitting one search at a time.

### 🔍 What does Yandex Market Scraper do?

This Actor searches **Яндекс Маркет**, Russia's largest online marketplace, by keyword and returns structured data for every matching product.

Give it one or more search terms and it returns price, stock status, rating, seller, brand, a short spec summary, an estimated delivery time, and a verified working image for each result. Add as many keywords as you want, they all run in the same batch, and every row is tagged with the keyword that found it. It runs on the Apify platform with scheduling, integrations (Make, Zapier, Google Sheets), and run monitoring built in.

<table width="100%"><tr>
<td style="padding:12px 18px;background:#FDF2EF;border-left:4px solid #D6300B">
<span style="font-size:15px;color:#1C1917">⚡ <b>Batch keywords, not one at a time.</b> Search dozens of terms in a single run and get back only listings with a working photo, or none at all if Yandex Market doesn't have one.</span>
</td>
</tr></table>

### 💡 Why use Yandex Market Scraper?

- **Price and stock monitoring** - track price, stock, and discount across dozens of keywords in one run instead of checking each search by hand.
- **Sourcing and resale research** - compare brand, seller, and rating side by side before deciding what's worth listing elsewhere.
- **Market research** - measure how a category is priced and stocked across many search terms without opening a single product page by hand.
- **Building your own tools** - feed clean pricing and verified product images straight into a price comparison, catalog, or monitoring tool.

### 🚀 How to use Yandex Market Scraper

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Add your keywords</span><br>
<span style="font-size:12px;color:#57534E">Type in one or more search terms, in Russian or English.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Set your filters</span><br>
<span style="font-size:12px;color:#57534E">Narrow by price range, sort order, category, or region.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FDF2EF;border:1px solid #F6CDC2;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#D6300B;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Start and export</span><br>
<span style="font-size:12px;color:#57534E">Download results as a spreadsheet or table, or pull them into your own tools.</span>
</td>
</tr>
</table>

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchQueries` | array of keywords | No | One or more keywords to search on Yandex Market (e.g. `iphone`, `кроссовки`). Every result row is tagged with the keyword that found it, so you can batch many searches in one run. |
| `maxItems` | integer | No | Maximum number of product rows to return across all keywords combined (0 = no limit, default 100). Keep this modest while testing. |
| `enrichProducts` | boolean | No | Adds brand, seller name, rating, discount, delivery estimate, and a verified image to each row. Turn off for a faster, leaner run with just the core fields. |
| `sortBy` | enum | No | Order results by popularity, cheapest first, most expensive first, or highest rated. |
| `priceFrom` | integer | No | Only return products priced at or above this value, in Russian rubles. |
| `priceTo` | integer | No | Only return products priced at or below this value, in Russian rubles. |
| `categoryId` | string | No | Optional Yandex Market category ID to limit the search to a single category. Leave blank to search all categories. |
| `region` | string | No | Yandex region ID used for pricing, availability, and delivery estimates. Defaults to Moscow. |
| `proxyConfiguration` | proxy configuration | No | Russian residential proxy (default) is required. Yandex Market blocks datacenter and non-Russian traffic. |

### 📦 Output

Download the results as a spreadsheet, a table, or structured data ready for your own systems. Each row is one product:

````

{
"productId": 123456789,
"modelId": "1789234561",
"sku": "100987654321",
"name": "Смартфон Apple iPhone 15 128GB",
"brand": "Apple",
"price": 64990,
"oldPrice": 71990,
"discountPercent": 10,
"currency": "RUB",
"inStock": true,
"availability": "В наличии",
"rating": 4.8,
"ratingCount": 236,
"sellerName": "DNS",
"sellerId": 4215678,
"businessId": "10321456",
"vendorId": 152,
"categoryId": 91491,
"specSummary": "128 ГБ, экран 6.1 дюйма, основная камера 48 Мп, аккумулятор 3349 мА·ч",
"delivery": "Завтра, бесплатно",
"image": "https://avatars.mds.yandex.net/get-mpic/1234567/img\_id890/orig",
"productUrl": "https://market.yandex.ru/card/apple-iphone-15/1789234561",
"offerId": "abc123XYZ",
"searchPosition": 1,
"sourceQuery": "iphone 15",
"scrapedAt": "2026-07-09T10:15:00Z"
}

````

### 📊 Output data fields

| Field | Type | Description |
|---|---|---|
| `productId` | number | Yandex Market's internal product identifier |
| `modelId` | string | Yandex Market's model identifier for this product |
| `sku` | string | The specific SKU (variant) identifier for this listing |
| `name` | string | Product title |
| `brand` | string | Brand name, when Yandex Market provides one |
| `price` | number | Current price |
| `oldPrice` | number | Price before a markdown, when Yandex Market shows one |
| `discountPercent` | number | Discount percentage, when a markdown is active |
| `currency` | string | Currency code |
| `inStock` | boolean | Whether the product currently shows as available |
| `availability` | string | Yandex Market's stated availability status |
| `rating` | number | Average product rating, when Yandex Market provides one |
| `ratingCount` | number | Number of ratings behind the score. Newer or unrated listings omit this field rather than show a fake zero |
| `sellerName` | string | Name of the seller offering this product |
| `sellerId` | number | Seller's identifier on Yandex Market |
| `businessId` | string | Yandex Market's business identifier for the seller |
| `vendorId` | number | Brand identifier |
| `categoryId` | number | Yandex Market category identifier |
| `specSummary` | string | A short spec summary in Yandex Market's own words, not a complete specification table |
| `delivery` | string | Estimated delivery text as shown on Yandex Market |
| `image` | string | A verified, working image link. Omitted rather than shown broken when the photo doesn't load |
| `productUrl` | string | Link to the product page on Yandex Market |
| `offerId` | string | Identifier for this specific offer |
| `searchPosition` | number | The product's position in the search results it was found in |
| `sourceQuery` | string | Which of your input keywords produced this row |
| `scrapedAt` | string | When the row was collected |

### 💰 Pricing

This Actor uses pay-per-result pricing: you pay for the products you actually get back, and nothing for an empty run. There is no subscription and no minimum spend. Use `maxItems` and the price filters to control how many results a run returns.

### ⭐ Enjoying Yandex Market Scraper: Парсер Яндекс Маркет?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FDF2EF;border:1px solid #F6CDC2;border-left:5px solid #D6300B;border-radius:10px 10px 0 0">
<span style="font-size:20px;letter-spacing:4px">⭐ ⭐ ⭐ ⭐ ⭐</span><br>
<span style="font-size:17px;font-weight:800;color:#1C1917">Turning Yandex Market searches into structured product data, batch keywords included, in one run?</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other sellers, sourcers, and researchers watching Yandex Market find it. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#D6300B;border:1px solid #F6CDC2;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/yandex-market-scraper/reviews" style="display:block;padding:13px 16px;color:#FFFFFF;text-decoration:none;font-weight:800;font-size:15px;letter-spacing:0.3px">★&nbsp;&nbsp;Rate this Actor on Apify</a>
</td>
</tr>
</table>

### ✨ Tips

- Batch related keywords in one `searchQueries` list instead of running the Actor multiple times.
- Turn off `enrichProducts` when you only need core fields like name, price, and stock, it returns faster.
- Use `priceFrom` and `priceTo` to narrow a broad category search instead of scrolling through every result.
- Keep `maxItems` low while testing a new keyword list, then raise it once you know what it returns.

### ❓ FAQ, disclaimers, and support

**Что такое парсер Яндекс Маркета?** This Actor is a parser (парсер) for Yandex Market. Give it search keywords and it returns structured product data: price, stock, seller, rating, brand, and a verified image for each matching product.

**Как собрать данные о товарах с Яндекс Маркета?** Add your search terms to `searchQueries` and run the Actor. It returns every matching product with price, availability, seller, and a working image, batched across all your keywords in one run.

**Does this include every technical detail for each product?** No. Each row includes a short spec summary pulled from the listing itself, not a detailed breakdown of every technical attribute.

**Why does the image field sometimes stay empty?** Every image link is checked before it ships. When a photo doesn't load, the field is left out rather than shown broken.

**Why do I need a proxy?** Yandex Market blocks datacenter and non-Russian traffic. A Russian residential proxy is required, and the default configuration works reliably out of the box.

**Is scraping Yandex Market data legal?** This Actor collects publicly available product data. You are responsible for complying with Yandex Market's Terms of Service and applicable laws in your use of the data.

**Found a bug or need a field added?** Open an issue on the Actor's **Issues** tab. Custom solutions are available on request.

# Actor input Schema

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

One or more keywords to search on Yandex Market. Each query is scraped and every result row is tagged with the query it came from, so you can batch many searches in a single run.
## `maxItems` (type: `integer`):

Maximum number of product rows to return across all queries combined (0 = no limit). Keep this modest during testing.
## `enrichProducts` (type: `boolean`):

When on, each product row is enriched with brand, seller name and rating, delivery estimate, discount, and a verified image. Turn off for a leaner, faster run with core fields only.
## `sortBy` (type: `string`):

Result ordering on Yandex Market.
## `priceFrom` (type: `integer`):

Only return products priced at or above this value, in Russian rubles.
## `priceTo` (type: `integer`):

Only return products priced at or below this value, in Russian rubles.
## `categoryId` (type: `string`):

Optional Yandex Market category id (hid) to constrain the search to a single category. Leave blank to search all categories.
## `region` (type: `string`):

Yandex region id used for pricing, availability and delivery. Default 213 = Moscow (e.g. 2 = Saint Petersburg, 65 = Novosibirsk).
## `proxyConfiguration` (type: `object`):

Yandex Market blocks datacenter and non-Russian IPs with a captcha. Russian residential proxies are required and set by default. Do not weaken this unless you know what you are doing.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone"
  ],
  "maxItems": 100,
  "enrichProducts": true,
  "sortBy": "popular",
  "region": "213",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
````

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "iphone"
    ],
    "region": "213",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/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"],
    "region": "213",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/yandex-market-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 '{
  "searchQueries": [
    "iphone"
  ],
  "region": "213",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call getascraper/yandex-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Market Scraper: Парсер Яндекс Маркет",
        "description": "Scrape Yandex Market (market.yandex.ru) products by keyword: price, rating, reviews, seller, specs, and verified images. Batch many searches. Парсер товаров Яндекс Маркета.",
        "version": "1.0",
        "x-build-id": "jeCnCj7y7g81A2zDq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~yandex-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-yandex-market-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/getascraper~yandex-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-yandex-market-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/getascraper~yandex-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-yandex-market-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more keywords to search on Yandex Market. Each query is scraped and every result row is tagged with the query it came from, so you can batch many searches in a single run.",
                        "default": [
                            "iphone"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of product rows to return across all queries combined (0 = no limit). Keep this modest during testing.",
                        "default": 100
                    },
                    "enrichProducts": {
                        "title": "Enrich products",
                        "type": "boolean",
                        "description": "When on, each product row is enriched with brand, seller name and rating, delivery estimate, discount, and a verified image. Turn off for a leaner, faster run with core fields only.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popular",
                            "cheapest",
                            "expensive",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Result ordering on Yandex Market.",
                        "default": "popular"
                    },
                    "priceFrom": {
                        "title": "Minimum price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products priced at or above this value, in Russian rubles."
                    },
                    "priceTo": {
                        "title": "Maximum price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products priced at or below this value, in Russian rubles."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Optional Yandex Market category id (hid) to constrain the search to a single category. Leave blank to search all categories."
                    },
                    "region": {
                        "title": "Region ID",
                        "type": "string",
                        "description": "Yandex region id used for pricing, availability and delivery. Default 213 = Moscow (e.g. 2 = Saint Petersburg, 65 = Novosibirsk).",
                        "default": "213"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Yandex Market blocks datacenter and non-Russian IPs with a captcha. Russian residential proxies are required and set by default. Do not weaken this unless you know what you are doing.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
