# Yandex Realty Scraper — Russia Property Data & API (`sian.agency/yandex-realty-scraper`) Actor

Yandex Realty scraper & real estate data API for Russia's leading property portal. Sale & rent apartments, rooms, houses & land: price (RUB), price/m², rooms, area, floor, building year, address, GPS, metro, seller & photos — clean JSON/CSV.

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

## Pricing

from $2.00 / 1,000 overview offers

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 — Russia Property Data & API 🇷🇺🏠

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Property Finder Scraper](https://img.shields.io/badge/Store-Property%20Finder%20Scraper-93D500)](https://apify.com/sian.agency/propertyfinder-property-scraper?fpr=sian) [![Immobiliare Italy Scraper](https://img.shields.io/badge/Store-Immobiliare%20Italy-1AE392)](https://apify.com/sian.agency/immobiliare-property-scraper?fpr=sian) [![Zillow Property Scraper](https://img.shields.io/badge/Store-Zillow%20Property%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-property-scraper?fpr=sian)

#### 🎉 The fast, no-code Yandex Realty data API — Russian property data with price/m², metro proximity and seller info, no Yandex Realty API key required
##### Built for property investors, agencies, proptech teams, and market researchers who need clean Russian real-estate data — for sale and for rent — across Moscow, St. Petersburg and every Russian city.

### 📋 Overview

**Pull offers from Yandex Realty — Russia's leading real-estate portal — as clean JSON, CSV or Excel.** Apartments, rooms, houses and land, for sale and for rent, across Moscow, St. Petersburg, Novosibirsk, Yekaterinburg, Kazan, Krasnodar and every market the portal covers. Each row carries price in rubles, price per square metre, rooms, area, floor, build year, address, GPS, the nearest metro station and the seller — ready for investment math.

**Why investors and agencies choose us:**
- ⚡ **Two depths, one actor**: a fast Overview scan for whole-market sweeps, or per-offer Detail records
- 🔁 **Detail = Overview + more**: every overview field is on a Detail row too — never less
- 🇷🇺 **Built for Russia**: native ruble pricing, Cyrillic addresses, federal-subject regions and metro data out of the box
- 📐 **Analysis-ready**: price, area, **price-per-m²** and **GPS coordinates** on every row for instant investment math
- 🚇 **Metro intelligence**: nearest station, minutes-to-metro and walk/transport mode on every offer
- 💎 **No API key, no code**: no Yandex account or API access needed — point, click, export a real-estate data feed
- 🆓 **Free to try**: scrape offers with no credit card

### ✨ Features

- 🧭 **Overview mode**: bulk offers from search pages — price, specs, location, metro, seller, photos — ideal for fast market sweeps
- 🔍 **Detail mode**: per-offer record fetched from each offer's own page — refresh a known set of offers by URL or ID
- 🗺️ **Two ways to search**: build a search from filters (city + deal + type + filters), or paste a Yandex Realty search URL with your filters already applied
- 🎯 **By offer URL**: drop specific Yandex Realty offer URLs (or IDs) straight into Detail mode
- 🎚️ **Rich filters**: city, deal (sale / rent), property type (apartment / room / house / land), rooms, price range, area range, build year, floor, sort
- 📐 **Price-per-m² + thumbnail** on every row for instant comparison
- 📍 **GPS + full address** on every offer for mapping and territory analysis
- 🚇 **Metro proximity** on every row: station name, minutes and walk/transport mode
- 🧑‍💼 **Seller on every row**: owner, agency, agent or developer name and type for instant lead lists
- 📤 **Clean exports**: JSON, CSV, Excel, or the full REST API

### 🎬 Quick Start

Pick a scrape depth, choose a city and deal type, set filters, and run. Results stream to the Apify dataset as clean JSON/CSV.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~yandex-realty-scraper/runs?token=[YOUR_TOKEN]" \
-H 'Content-Type: application/json' \
-d '{"scrapeMode":"overview","city":"moskva","deal":"sale","ptype":"apartment","maxResults":50}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick your scrape depth

**Overview** for a fast price + spec scan from search pages, or **Detail** to refresh specific offers from their own pages.

#### Step 2: Choose your market & how to search

Set the **city** (`moskva`, `sankt-peterburg`, `kazan`, …), **deal** (sale / rent) and **type** (apartment / room / house / land), or paste a Yandex Realty **search URL** in `searchUrls`. For Detail, you can also drop specific offers into `offerUrls`.

#### Step 3: Set filters & run

Rooms, price range, area range, build year, floor, sort, Max results — then hit **Start**.

**That's it! In under a minute, you'll have:**

- A clean dataset of Russian property offers (JSON / CSV / Excel)
- Price, area, rooms, floor, GPS, metro, seller and price-per-m² on every row
- A repeatable, no-code real-estate data feed across Russia

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| scrapeMode | string | No | `overview` (fast & cheap) or `detail` (per-offer pages). Default `overview`. |
| city | string | No | City slug, e.g. `moskva`, `sankt-peterburg`, `kazan`. Default `moskva`. |
| deal | string | No | `sale` or `rent`. Default `sale`. |
| ptype | string | No | `apartment`, `room`, `house`, `lot`. Default `apartment`. |
| searchUrls | array | No | Yandex Realty search URLs — on-page filters honored. |
| offerUrls | array | No | Specific offer URLs or IDs (Detail mode). |
| rooms | string | No | Room count: `0` (studio) – `4`. Blank = any. |
| priceMin / priceMax | integer | No | Price range filter (RUB). |
| areaMin / areaMax | integer | No | Total area range filter (m²). |
| builtYearMin / builtYearMax | integer | No | Build-year range filter. |
| floorMin / floorMax | integer | No | Floor range filter. |
| sort | string | No | Sort order (e.g. `PRICE`, `DATE_DESC`, `AREA`). |
| maxResults | integer | No | Max offers this run. Default 100. |

**Example — by city & filters:**

```json
{
  "scrapeMode": "overview",
  "city": "moskva",
  "deal": "sale",
  "ptype": "apartment",
  "rooms": "2",
  "priceMin": 8000000,
  "priceMax": 12000000,
  "sort": "PRICE",
  "maxResults": 200
}
```

**Example — by search URL:**

```json
{
  "scrapeMode": "overview",
  "searchUrls": ["https://realty.yandex.ru/sankt-peterburg/kupit/kvartira/"],
  "maxResults": 100
}
```

**Example — Detail by offer URL:**

```json
{
  "scrapeMode": "detail",
  "offerUrls": [
    "https://realty.yandex.ru/offer/7040924941834439839"
  ]
}
```

### 📤 Output

Results are saved to the Apify dataset with **35+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| id | string | Offer ID |
| url | string | Offer URL |
| deal\_type | string | `sale` or `rent` |
| property\_type | string | APARTMENT, ROOMS, HOUSE, LOT |
| flat\_type / is\_new\_building | string / bool | New vs secondary classification |
| price | number | Asking / rent price |
| currency | string | RUB |
| price\_period | string | `WHOLE_LIFE` (sale) or `PER_MONTH` (rent) |
| price\_per\_sqm | number | Price per square metre |
| rooms | number | Room count (0 = studio) |
| area\_total\_sqm / area\_living\_sqm / kitchen\_area\_sqm | number | Area breakdown (m²) |
| floor / floors\_total | number | Floor + building height |
| building\_year / building\_type | number / string | Build year + construction type |
| renovation | string | Decoration / renovation state |
| address / geocoder\_address / region | string | Address rollup + city/region |
| latitude / longitude | number | GPS coordinates |
| metro\_name / metro\_time\_min / metro\_transport | string / number / string | Nearest metro + commute |
| seller\_type / seller\_name | string | Owner / agency / agent / developer |
| site\_name | string | New-building complex name |
| description | string | Offer description |
| tags | array | Descriptive tags |
| images / photo\_count / thumbnail | array / number / string | Photo gallery |

**Example:**

```json
{
  "id": "7040924941834439839",
  "url": "https://realty.yandex.ru/offer/7040924941834439839",
  "deal_type": "sale",
  "property_type": "APARTMENT",
  "is_new_building": true,
  "price": 49462648,
  "currency": "RUB",
  "price_period": "WHOLE_LIFE",
  "price_per_sqm": 838350,
  "rooms": 1,
  "area_total_sqm": 59.0,
  "floor": 28,
  "floors_total": 33,
  "building_year": 2027,
  "building_type": "MONOLIT",
  "address": "Крылатская улица, 33к3",
  "region": "Москва",
  "latitude": 55.771103,
  "longitude": 37.40565,
  "metro_name": "Крылатское",
  "metro_time_min": 15,
  "metro_transport": "ON_FOOT",
  "seller_type": "DEVELOPER",
  "seller_name": "СЗ Сияние",
  "site_name": "Клубный квартал «Крылатская 33»",
  "images": ["https://avatars.mds.yandex.net/.../orig"],
  "photo_count": 14
}
```

### 💼 Use Cases & Examples

#### 1. Market research & price benchmarking

**Analysts sizing a city or district market.**
**Input:** `overview` Moscow, sale, apartments. **Output:** offers with price-per-m². **Use:** build a live price index per district.

#### 2. Investment sourcing

**Investors hunting undervalued or high-yield stock.**
**Input:** `overview` + `priceMin`/`priceMax` + `rooms`. **Output:** filtered offers with price-per-m² and GPS. **Use:** rank deals by price-per-m² vs district median.

#### 3. New-building tracking

**Investors and analysts monitoring primary supply.**
**Input:** `overview` with `is_new_building` offers. **Output:** complex name, developer, completion year and entry pricing. **Use:** track new supply and launch pricing.

#### 4. Rental-yield research

**Investors comparing buy vs rent economics.**
**Input:** two runs — sale and rent — for the same city/type. **Output:** sale price + monthly rent with area. **Use:** compute gross yield per district.

#### 5. Proptech & valuation data feeds

**Proptech teams powering AVMs and dashboards.**
**Input:** scheduled `searchUrls` runs per city. **Output:** a clean, repeatable Russian real-estate data feed. **Use:** feed models without a Yandex Realty API.

#### 6. Metro-proximity analytics

**Teams pricing the commute premium.**
**Input:** `overview` across a city. **Output:** nearest metro, minutes and walk/transport mode on every row. **Use:** quantify how metro distance moves price.

#### 7. Lead generation

**Agencies building seller contact lists.**
**Input:** Overview scan of a target city. **Output:** `seller_type` and `seller_name` on every row. **Use:** prospecting and competitive coverage.

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/yandex-realty-scraper').call({
  scrapeMode: 'overview', city: 'moskva', deal: 'sale', ptype: 'apartment', maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/yandex-realty-scraper').call(
    run_input={'scrapeMode': 'overview', 'city': 'moskva', 'deal': 'sale', 'ptype': 'apartment', 'maxResults': 50}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~yandex-realty-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"scrapeMode":"overview","city":"moskva","deal":"sale","ptype":"apartment","maxResults":50}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. daily) or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON results
4. **Action**: Save to a sheet/DB, notify, or transform

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- Scrape offers per run — full feature access, same quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- **Unlimited** offers per run
- Pay-per-result: only charged for offers actually extracted
- Overview and Detail priced separately so you only pay for the depth you use

💰 **Pay only for what you extract** — Overview for cheap whole-market sweeps, Detail for per-offer refreshes.

🔗 [View current pricing](https://apify.com/sian.agency/yandex-realty-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: Which cities are covered?**
A: Any city Yandex Realty knows — Moscow (`moskva`), St. Petersburg (`sankt-peterburg`), Novosibirsk, Yekaterinburg, Kazan, Krasnodar and more. Use the city slug from the site's own URL.

**Q: Do I need a Yandex Realty API key?**
A: No. There's no setup and no Yandex account or API key required.

**Q: What's the difference between Overview and Detail?**
A: Overview is a fast, low-cost scan that pulls bulk offers from search pages — it already carries the full field set for residential offers. Detail fetches each offer's own page individually, useful for refreshing a known set of offers by URL or ID.

**Q: Can I use my own Yandex Realty search filters?**
A: Yes — paste your search URL in `searchUrls` and the on-page filters (price, rooms, area, sort, etc.) are honored. Or set filters directly (`rooms`, `priceMin`, `priceMax`, `areaMin`, `areaMax`, `builtYearMin`, `builtYearMax`, `floorMin`, `floorMax`).

**Q: Is the price in rubles?**
A: Yes — all prices are in Russian rubles (RUB), with `price_period` marking sale (`WHOLE_LIFE`) vs monthly rent (`PER_MONTH`).

**Q: Does it include metro data?**
A: Yes — every row carries the nearest metro station, minutes-to-metro and whether that's on foot or by transport.

**Q: What output formats are available?**
A: JSON, CSV, Excel — export directly from the Apify dataset.

### 🐛 Troubleshooting

**No results returned**

- Check the `city` / `deal` / `ptype` combination, or paste a working Yandex Realty search URL in `searchUrls` instead.
- Loosen filters — an overly tight price/area/room combination can return zero offers.

**Fewer results than expected**

- A single search reaches roughly 500 offers max — narrow with price, area or room filters and run multiple slices to cover a city's full inventory.
- The FREE tier caps offers per run. Upgrade to PAID for unlimited, or raise `maxResults`.

**Detail mode returns nothing**

- Make sure `offerUrls` contain valid Yandex Realty offer URLs or IDs, or run `overview` first to discover them.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

*This is an independent tool and is not affiliated with, endorsed by, or sponsored by Yandex or Yandex Realty (Яндекс Недвижимость). "Yandex" and "Yandex Realty" are trademarks of their respective owners. You are responsible for complying with Yandex Realty's terms of service and all applicable laws when using this tool.*

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue from the actor page
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `scrapeMode` (type: `string`):

⚡ **OVERVIEW** — fast, cheap, ungated. Pulls every core field straight from Yandex Realty's search pages (price, price/m², rooms, area, floor, building, address, GPS, metro, seller, photos).

🔍 **DETAIL** — fetches each offer's own page individually. Use when you have specific offer URLs to refresh.

**TIP:** Start with Overview — it already carries the full field set for residential offers.

## `searchMode` (type: `string`):

🧭 How to tell the scraper what to fetch. **Usually leave this blank — it is auto-inferred** from which inputs you provide:

- **By search URL** — paste one or more Yandex Realty search-results URLs (or build a search with the city / deal / type / filters below). The default for Overview.
- **By offer URL** — Detail mode only: paste specific offer URLs (or offer IDs) to fetch those exact properties.

**NOTE:** *By offer URL* is valid only when Scrape mode = Detail.

## `city` (type: `string`):

🏙️ City slug to search, taken straight from a Yandex Realty URL (the first path segment). Examples: `moskva` (Moscow), `sankt-peterburg` (St. Petersburg), `novosibirsk`, `ekaterinburg`, `kazan`, `krasnodar`. Any city slug Yandex Realty knows works here.

**Ignored when you paste full search URLs below** (the URL's own city wins).

## `deal` (type: `string`):

🤝 Whether to search properties for **sale** or for **rent**.

## `ptype` (type: `string`):

🏠 Which property type to search.

## `searchUrls` (type: `array`):

🔗 Yandex Realty search-results URLs to scrape. Used when **Search by = By search URL**.

**TIP:** Build any search on Yandex Realty (set your city, deal, type, filters, sort order), then copy the URL from the address bar — every on-page filter is honored.

**BULK EDIT:** Click "Bulk edit" to paste many URLs, one per line.

## `offerUrls` (type: `array`):

🆔 **Detail mode only.** Specific Yandex Realty offer URLs (or bare offer IDs) to fetch as full property pages.

**BULK EDIT:** Click "Bulk edit" to paste many URLs, one per line.

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

🔢 Maximum offers to extract this run.

- **FREE tier:** capped at 25 offers per run.
- **PAID tier:** unlimited — set as high as you need.

**NOTE:** Yandex Realty paginates one search to ~500 offers max — narrow with price/area/room filters to reach a city's full inventory.

## `rooms` (type: `string`):

🛏️ Optional. Room count to filter by. Use **0** for studios, **1**–**4** for that many rooms. Leave blank for any.

## `sort` (type: `string`):

↕️ How Yandex Realty orders the search results before they are scraped.

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

💸 Optional. Minimum price filter in Russian rubles.

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

💰 Optional. Maximum price filter in Russian rubles.

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

📐 Optional. Minimum total area in square metres.

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

📐 Optional. Maximum total area in square metres.

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

🏗️ Optional. Earliest building/commissioning year.

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

🏗️ Optional. Latest building/commissioning year.

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

🛗 Optional. Minimum floor.

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

🛗 Optional. Maximum floor.

## Actor input object example

```json
{
  "scrapeMode": "overview",
  "searchMode": "bySearchUrl",
  "city": "moskva",
  "deal": "sale",
  "ptype": "apartment",
  "searchUrls": [
    "https://realty.yandex.ru/moskva/kupit/kvartira/"
  ],
  "offerUrls": [
    "https://realty.yandex.ru/offer/7040924941834439839"
  ],
  "maxResults": 100,
  "rooms": "",
  "sort": ""
}
```

# Actor output Schema

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

Scraped Yandex Realty offers (JSON/CSV/Excel).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/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 '{}' |
apify call sian.agency/yandex-realty-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yandex Realty Scraper — Russia Property Data & API",
        "description": "Yandex Realty scraper & real estate data API for Russia's leading property portal. Sale & rent apartments, rooms, houses & land: price (RUB), price/m², rooms, area, floor, building year, address, GPS, metro, seller & photos — clean JSON/CSV.",
        "version": "1.0",
        "x-build-id": "KJtEoa0z2sZ6Xzu8n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~yandex-realty-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-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/sian.agency~yandex-realty-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-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/sian.agency~yandex-realty-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-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": {
                    "scrapeMode": {
                        "title": "⚡ Scrape mode",
                        "enum": [
                            "overview",
                            "detail"
                        ],
                        "type": "string",
                        "description": "⚡ **OVERVIEW** — fast, cheap, ungated. Pulls every core field straight from Yandex Realty's search pages (price, price/m², rooms, area, floor, building, address, GPS, metro, seller, photos).\n\n🔍 **DETAIL** — fetches each offer's own page individually. Use when you have specific offer URLs to refresh.\n\n**TIP:** Start with Overview — it already carries the full field set for residential offers.",
                        "default": "overview"
                    },
                    "searchMode": {
                        "title": "🧭 Search by (auto-detected)",
                        "enum": [
                            "bySearchUrl",
                            "byOfferUrl"
                        ],
                        "type": "string",
                        "description": "🧭 How to tell the scraper what to fetch. **Usually leave this blank — it is auto-inferred** from which inputs you provide:\n\n- **By search URL** — paste one or more Yandex Realty search-results URLs (or build a search with the city / deal / type / filters below). The default for Overview.\n- **By offer URL** — Detail mode only: paste specific offer URLs (or offer IDs) to fetch those exact properties.\n\n**NOTE:** *By offer URL* is valid only when Scrape mode = Detail.",
                        "default": "bySearchUrl"
                    },
                    "city": {
                        "title": "🏙️ City",
                        "type": "string",
                        "description": "🏙️ City slug to search, taken straight from a Yandex Realty URL (the first path segment). Examples: `moskva` (Moscow), `sankt-peterburg` (St. Petersburg), `novosibirsk`, `ekaterinburg`, `kazan`, `krasnodar`. Any city slug Yandex Realty knows works here.\n\n**Ignored when you paste full search URLs below** (the URL's own city wins).",
                        "default": "moskva"
                    },
                    "deal": {
                        "title": "🤝 Deal type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "🤝 Whether to search properties for **sale** or for **rent**.",
                        "default": "sale"
                    },
                    "ptype": {
                        "title": "🏠 Property type",
                        "enum": [
                            "apartment",
                            "room",
                            "house",
                            "lot"
                        ],
                        "type": "string",
                        "description": "🏠 Which property type to search.",
                        "default": "apartment"
                    },
                    "searchUrls": {
                        "title": "🔗 Search URLs",
                        "type": "array",
                        "description": "🔗 Yandex Realty search-results URLs to scrape. Used when **Search by = By search URL**.\n\n**TIP:** Build any search on Yandex Realty (set your city, deal, type, filters, sort order), then copy the URL from the address bar — every on-page filter is honored.\n\n**BULK EDIT:** Click \"Bulk edit\" to paste many URLs, one per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "offerUrls": {
                        "title": "🆔 Offer URLs",
                        "type": "array",
                        "description": "🆔 **Detail mode only.** Specific Yandex Realty offer URLs (or bare offer IDs) to fetch as full property pages.\n\n**BULK EDIT:** Click \"Bulk edit\" to paste many URLs, one per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 Maximum offers to extract this run.\n\n- **FREE tier:** capped at 25 offers per run.\n- **PAID tier:** unlimited — set as high as you need.\n\n**NOTE:** Yandex Realty paginates one search to ~500 offers max — narrow with price/area/room filters to reach a city's full inventory.",
                        "default": 100
                    },
                    "rooms": {
                        "title": "🛏️ Rooms",
                        "enum": [
                            "",
                            "0",
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "🛏️ Optional. Room count to filter by. Use **0** for studios, **1**–**4** for that many rooms. Leave blank for any.",
                        "default": ""
                    },
                    "sort": {
                        "title": "↕️ Sort by",
                        "enum": [
                            "",
                            "RELEVANCE",
                            "PRICE",
                            "PRICE_DESC",
                            "DATE_DESC",
                            "AREA",
                            "AREA_DESC",
                            "PRICE_PER_SQUARE_METER"
                        ],
                        "type": "string",
                        "description": "↕️ How Yandex Realty orders the search results before they are scraped.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "💸 Min price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💸 Optional. Minimum price filter in Russian rubles."
                    },
                    "priceMax": {
                        "title": "💰 Max price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💰 Optional. Maximum price filter in Russian rubles."
                    },
                    "areaMin": {
                        "title": "📐 Min area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "📐 Optional. Minimum total area in square metres."
                    },
                    "areaMax": {
                        "title": "📐 Max area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "📐 Optional. Maximum total area in square metres."
                    },
                    "builtYearMin": {
                        "title": "🏗️ Min build year",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🏗️ Optional. Earliest building/commissioning year."
                    },
                    "builtYearMax": {
                        "title": "🏗️ Max build year",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🏗️ Optional. Latest building/commissioning year."
                    },
                    "floorMin": {
                        "title": "🛗 Min floor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🛗 Optional. Minimum floor."
                    },
                    "floorMax": {
                        "title": "🛗 Max floor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🛗 Optional. Maximum floor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
