# Yandex Realty Scraper: Яндекс Недвижимость (`getascraper/yandex-realty-scraper`) Actor

Search Yandex Realty (Яндекс Недвижимость) listings across Russian cities. Filter by price, area, rooms, floor, build year, owner-only, and new buildings. Get renovation state, amenity tags, mortgage estimate, and GPS coordinates per listing.

- **URL**: https://apify.com/getascraper/yandex-realty-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.32 / 1,000 property listings

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 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 Realty Scraper: Яндекс Недвижимость

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FFEEEA;border:1px solid #FBD0C6;border-top:4px solid #FC3F1D;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Yandex Realty listings with the owner-vs-agency filter Yandex itself buries</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">Search Яндекс Недвижимость by price, area, rooms, and build year, and pull renovation state, amenity tags, and GPS coordinates on every listing.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C22C12">👤 Owner-only filter</span><br>
<span style="font-size:12px;color:#57534E">Skip agency markups and reach the seller directly</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C22C12">🏗️ New-buildings toggle</span><br>
<span style="font-size:12px;color:#57534E">Isolate primary-market listings from resale</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C22C12">🎨 Renovation state</span><br>
<span style="font-size:12px;color:#57534E">Know the condition before you schedule a viewing</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FBD0C6;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C22C12">📍 GPS coordinates</span><br>
<span style="font-size:12px;color:#57534E">Map every result without a separate geocoding step</span>
</td>
</tr>
</table>

Get real estate listings from Yandex Realty across major Russian cities, with prices, square meter costs, coordinates, nearest metro stations, building construction types, and image grids.

---

### 🔍 What does Yandex Realty Scraper do?

This tool helps you extract complete real estate data from Yandex Realty. It retrieves listings for buying or renting apartments, houses, rooms, land plots, garages, and commercial properties across all major Russian regions.

The scraper extracts deep listings including exact property sizes, prices per square meter, building build years, materials, nearest metro stations with transit times, coordinates, and full image galleries. It runs fast and securely with automated connection handling, helping you build databases for market analysis or lead generation.

---

### 💼 Why use Yandex Realty Scraper?

Real estate agents, property developers, and market analysts can leverage this data in several ways:

- **Market analysis:** Track real estate prices, square meter costs, and price trends across different districts.
- **Lead generation:** Locate properties for sale or rent to connect with real estate agencies or independent sellers.
- **Location analysis:** Check property distances to metro stations, public transport access, and neighborhood amenities.
- **Investment research:** Analyze construction state, building materials, and property attributes to assess valuation.

---

### 🚶 How to use Yandex Realty Scraper

To begin extracting real estate listings, follow these simple steps:

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FFEEEA;border:1px solid #FBD0C6;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Set your filters</span><br>
<span style="font-size:12px;color:#57534E">Price, area, rooms, floor, build year, owner or agency.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFEEEA;border:1px solid #FBD0C6;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Run the search</span><br>
<span style="font-size:12px;color:#57534E">Results turn into structured rows in seconds.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFEEEA;border:1px solid #FBD0C6;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#FC3F1D;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Get the full picture</span><br>
<span style="font-size:12px;color:#57534E">Renovation state, amenity tags, and coordinates per listing.</span>
</td>
</tr>
</table>

---

### 📥 Input

The tool accepts the following parameters to customize your search:

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URLs | No | Direct Yandex Realty search page links. These override the structured dropdown configurations. |
| `dealType` | enum | No | Scrape properties for sale or rent. Choose between "sell" or "rent". |
| `propertyType` | enum | No | Select target property types like apartments, houses, land, or garages. |
| `region` | text | No | URL city slug. Examples include "moskva" for Moscow and "sankt-peterburg" for St. Petersburg. |
| `maxItems` | integer | No | Maximum number of property listings to save. |
| `priceMin` | integer | No | Only return listings priced at or above this amount. |
| `priceMax` | integer | No | Only return listings priced at or below this amount. |
| `areaMin` | integer | No | Only return listings with total area at or above this value, in square meters. |
| `areaMax` | integer | No | Only return listings with total area at or below this value, in square meters. |
| `roomsTotal` | enum | No | Filter by room count. Leave blank for all room counts. |
| `floorMin` | integer | No | Only return listings on or above this floor. |
| `floorMax` | integer | No | Only return listings on or below this floor. |
| `builtYearMin` | integer | No | Only return listings in buildings completed in or after this year. |
| `builtYearMax` | integer | No | Only return listings in buildings completed in or before this year. |
| `ownerOnly` | boolean | No | Exclude listings posted by agents or agencies, keeping only direct owner listings. |
| `newBuildingOnly` | boolean | No | Restrict results to primary market new construction listings. |
| `sortBy` | enum | No | Sort results by price, price per square meter, area, or newest first. |
| `proxyConfiguration` | object | No | Custom proxy settings to ensure seamless connection routing. |

---

### 📤 Output

The dataset items are saved to your storage in real time. You can download the extracted listings in formats such as JSON, Excel, CSV, or HTML.

Here is a simplified JSON sample of the extracted real estate listings:

```json
{
  "offerId": "6088059653392968263",
  "offerCategory": "SELL",
  "offerType": "APARTMENT",
  "creationDate": "2026-07-01T12:00:00Z",
  "updateDate": "2026-07-09T01:30:00Z",
  "price": 27999920,
  "currency": "RUB",
  "pricePerSquareMeter": 494000,
  "priceTrend": "INCREASED",
  "previousPrice": 27433120,
  "hasPriceHistory": true,
  "minMonthlyMortgagePayment": 134131,
  "address": "Москва, Волоколамское шоссе",
  "latitude": 55.8126,
  "longitude": 37.427425,
  "nearestMetroName": "Спартак",
  "nearestMetroTransport": "ON_FOOT",
  "nearestMetroTime": 15,
  "builtYear": 2028,
  "builtQuarter": 4,
  "buildingState": "UNFINISHED",
  "buildingType": "MONOLIT",
  "improvements": ["ELITE", "PARKING", "LIFT", "GUARDED"],
  "parkingType": "OPEN",
  "siteName": "Клубный город на реке Примавера",
  "flatType": "FLATS",
  "floor": 4,
  "floorsTotal": 12,
  "area": 102.2,
  "livingSpace": 60.5,
  "kitchenSpace": 15.2,
  "roomsTotal": 3,
  "ceilingHeight": 3.1,
  "authorCategory": "DEVELOPER",
  "authorName": "ООО Специализированный застройщик Стадион Спартак",
  "description": "Квартира свободной планировки в премиальном жилом комплексе.",
  "image": "https://avatars.mds.yandex.net/get-realty/12345/portrait.jpg",
  "propertyUrl": "https://realty.yandex.ru/offer/6088059653392968263/",
  "scrapedAt": "2026-07-09T04:25:42.000Z"
}
````

***

### 📋 Data table

Here are the main fields included in each extracted real estate listing:

| Field | Type | Description |
|---|---|---|
| `offerId` | string | Unique property identifier assigned by the platform. |
| `offerCategory` | string | The category of the deal, such as SELL or RENT. |
| `offerType` | string | The classification of property, like APARTMENT or HOUSE. |
| `price` | number | Absolute listing price in RUB. |
| `currency` | string | The price currency denomination. |
| `pricePerSquareMeter` | number | Price per square meter calculated from price and total area. |
| `nearestMetroName` | string | Name of the nearest subway or metro station. |
| `nearestMetroTime` | number | Walking or driving time to the nearest station in minutes. |
| `builtYear` | number | Construction completion year of the building. |
| `area` | number | Total property area measured in square meters. |
| `roomsTotal` | number | Total number of rooms in the listing. |
| `propertyUrl` | string | Direct web link to the property card page. |

***

### 💰 Pricing

Our pricing model is completely transparent and operates on a pay per event basis. There are no subscription fees or monthly charges. You only pay for the real estate listings successfully extracted and added to your dataset. If a search query yields no results, the run costs nothing.

***

### ⭐ Enjoying Yandex Realty Scraper?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FFEEEA;border:1px solid #FBD0C6;border-left:5px solid #FC3F1D;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">If this saved you from browsing Yandex Realty listings by hand, a rating helps a lot.</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other real estate researchers and investors find it. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#FC3F1D;border:1px solid #FBD0C6;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/yandex-realty-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>

***

### ❓ FAQ, disclaimers, and support

- **Is Yandex Realty scraping legal?**
  Yes. This tool extracts publicly accessible listings. We advise checking regional data localization and privacy regulations if you process personal names or agent details downstream.
- **Can I filter by specific price ranges?**
  Yes. You can use direct search links in the start URLs parameter to filter by custom boundaries like price, area, building materials, or floor level.
- **How can I get support or report issues?**
  If you have feedback, questions, or custom extraction requirements, open a ticket in the Issues tab of this page and our support team will assist you quickly.

### 🔗 Other actors

- [Yandex Maps Review Monitor](https://apify.com/getascraper/yandex-maps-review-monitor) ↗ - tracks new reviews and ratings on Yandex Maps business listings.
- [Yandex Market Scraper](https://apify.com/getascraper/yandex-market-scraper) ↗ - searches Yandex Market by keyword for pricing and seller data.
- [Yandex Reverse Image Scraper](https://apify.com/getascraper/yandex-reverse-image-scraper) ↗ - runs batch reverse image search on Yandex Images.
- [Etagi Real Estate Scraper](https://apify.com/getascraper/etagi-property-scraper) ↗ - extracts property listings from the Etagi real estate network.
- [Avito Auto Scraper](https://apify.com/getascraper/avito-auto-scraper) ↗ - collects used car listings from Avito Auto.

# Actor input Schema

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

Provide direct Yandex Realty search URLs (e.g., https://realty.yandex.ru/moskva/kupit/kvartira/). These override the structured category dropdowns below.

## `dealType` (type: `string`):

Select whether to scrape property sale or rental listings.

## `propertyType` (type: `string`):

Select the target property classification.

## `region` (type: `string`):

The URL city slug. Examples: 'moskva' (Moscow), 'sankt-peterburg' (St. Petersburg), 'ekaterinburg' (Yekaterinburg). Leave empty if Start URLs are supplied.

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

Maximum number of property listing records to extract.

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

Only return listings priced at or above this amount (in the listing's own currency, usually RUB).

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

Only return listings priced at or below this amount (in the listing's own currency, usually RUB).

## `areaMin` (type: `integer`):

Only return listings with total area at or above this value.

## `areaMax` (type: `integer`):

Only return listings with total area at or below this value.

## `roomsTotal` (type: `string`):

Filter by room count. Leave blank for all room counts.

## `floorMin` (type: `integer`):

Only return listings on or above this floor.

## `floorMax` (type: `integer`):

Only return listings on or below this floor.

## `builtYearMin` (type: `integer`):

Only return listings in buildings completed in or after this year.

## `builtYearMax` (type: `integer`):

Only return listings in buildings completed in or before this year.

## `ownerOnly` (type: `boolean`):

When enabled, excludes listings posted by real estate agents/agencies, keeping only direct owner listings.

## `newBuildingOnly` (type: `boolean`):

When enabled, restricts results to primary-market new-construction listings.

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

Result ordering, matching Yandex Realty's own sort options.

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

Proxy settings. Russian residential proxies are highly recommended to bypass edge-level geo-blocking on realty.yandex.ru.

## Actor input object example

```json
{
  "dealType": "sell",
  "propertyType": "kvartira",
  "region": "moskva",
  "maxItems": 100,
  "roomsTotal": "",
  "ownerOnly": false,
  "newBuildingOnly": false,
  "sortBy": "RELEVANCE",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "dealType": "sell",
    "propertyType": "kvartira",
    "region": "moskva",
    "maxItems": 100,
    "roomsTotal": "",
    "ownerOnly": false,
    "newBuildingOnly": false,
    "sortBy": "RELEVANCE",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/yandex-realty-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 = {
    "dealType": "sell",
    "propertyType": "kvartira",
    "region": "moskva",
    "maxItems": 100,
    "roomsTotal": "",
    "ownerOnly": False,
    "newBuildingOnly": False,
    "sortBy": "RELEVANCE",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/yandex-realty-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 '{
  "dealType": "sell",
  "propertyType": "kvartira",
  "region": "moskva",
  "maxItems": 100,
  "roomsTotal": "",
  "ownerOnly": false,
  "newBuildingOnly": false,
  "sortBy": "RELEVANCE",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call getascraper/yandex-realty-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Realty Scraper: Яндекс Недвижимость",
        "description": "Search Yandex Realty (Яндекс Недвижимость) listings across Russian cities. Filter by price, area, rooms, floor, build year, owner-only, and new buildings. Get renovation state, amenity tags, mortgage estimate, and GPS coordinates per listing.",
        "version": "0.1",
        "x-build-id": "5gHGquPUfYqUNfksU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~yandex-realty-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-yandex-realty-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-realty-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-yandex-realty-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-realty-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-yandex-realty-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Provide direct Yandex Realty search URLs (e.g., https://realty.yandex.ru/moskva/kupit/kvartira/). These override the structured category dropdowns below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "sell",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Select whether to scrape property sale or rental listings.",
                        "default": "sell"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "kvartira",
                            "dom",
                            "komnata",
                            "uchastok",
                            "garazh",
                            "kommercheskaya-nedvizhimost"
                        ],
                        "type": "string",
                        "description": "Select the target property classification.",
                        "default": "kvartira"
                    },
                    "region": {
                        "title": "Region Slug",
                        "type": "string",
                        "description": "The URL city slug. Examples: 'moskva' (Moscow), 'sankt-peterburg' (St. Petersburg), 'ekaterinburg' (Yekaterinburg). Leave empty if Start URLs are supplied.",
                        "default": "moskva"
                    },
                    "maxItems": {
                        "title": "Max Property Listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of property listing records to extract.",
                        "default": 100
                    },
                    "priceMin": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount (in the listing's own currency, usually RUB)."
                    },
                    "priceMax": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount (in the listing's own currency, usually RUB)."
                    },
                    "areaMin": {
                        "title": "Min Total Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with total area at or above this value."
                    },
                    "areaMax": {
                        "title": "Max Total Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with total area at or below this value."
                    },
                    "roomsTotal": {
                        "title": "Rooms",
                        "enum": [
                            "",
                            "0",
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "Filter by room count. Leave blank for all room counts.",
                        "default": ""
                    },
                    "floorMin": {
                        "title": "Min Floor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings on or above this floor."
                    },
                    "floorMax": {
                        "title": "Max Floor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings on or below this floor."
                    },
                    "builtYearMin": {
                        "title": "Min Build Year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Only return listings in buildings completed in or after this year."
                    },
                    "builtYearMax": {
                        "title": "Max Build Year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Only return listings in buildings completed in or before this year."
                    },
                    "ownerOnly": {
                        "title": "Owner Listings Only",
                        "type": "boolean",
                        "description": "When enabled, excludes listings posted by real estate agents/agencies, keeping only direct owner listings.",
                        "default": false
                    },
                    "newBuildingOnly": {
                        "title": "New Buildings Only",
                        "type": "boolean",
                        "description": "When enabled, restricts results to primary-market new-construction listings.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "RELEVANCE",
                            "PRICE",
                            "PRICE_DESC",
                            "PRICE_PER_SQUARE",
                            "PRICE_PER_SQUARE_DESC",
                            "AREA",
                            "AREA_DESC",
                            "DATE_DESC"
                        ],
                        "type": "string",
                        "description": "Result ordering, matching Yandex Realty's own sort options.",
                        "default": "RELEVANCE"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Russian residential proxies are highly recommended to bypass edge-level geo-blocking on realty.yandex.ru.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
