# Avito Real Estate Scraper — Russia Property Data & API (`sian.agency/avito-property-scraper`) Actor

Avito real estate scraper & property data API for Russia's largest marketplace. Apartments, rooms, houses, commercial & land for sale and rent: price (RUB), price/m², rooms, area, floor, city, district & photos — clean JSON/CSV.

- **URL**: https://apify.com/sian.agency/avito-property-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, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 overview 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

## Avito Real Estate 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-1AE392)](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 Avito real-estate data API — apartments, houses, commercial & land across Russia, with price-per-m² on every row and no Avito API key required
##### Built for property investors, brokers, proptech teams and market researchers who need clean Russian real-estate data — for sale and for rent — across Moscow, Saint Petersburg and every region Avito covers.

### 📋 Overview

**Pull listings from Avito — Russia's largest marketplace — as clean JSON, CSV or Excel.** Apartments, rooms, houses & dachas, commercial property and land plots, for sale and for rent, across Moscow, Saint Petersburg and any region you target. Every row arrives analysis-ready: numeric price in rubles, computed **price-per-m²**, rooms, area, floor, city, district and the full photo gallery.

**Why investors and brokers choose us:**
- ⚡ **Whole-market sweeps, fast**: paginate a region's real-estate feed and pull thousands of clean listings in minutes
- 💰 **Price on every row**: the numeric ruble price is recovered for ~100% of listings — plus a computed **price-per-m²** for instant comparison
- 🎯 **Accurate deal typing**: every listing is tagged `sale` or `rent` per-row, so a "rent" search returns only true rentals
- 📐 **Analysis-ready specs**: rooms, total area, floor / floors, city and district parsed onto every row
- 🗺️ **Two ways to search**: pick a city or location ID with filters, or paste an Avito search URL with your filters already applied
- 💎 **No API key, no code**: no Avito account or API access needed — point, click, export a real-estate data feed
- 🆓 **Free to try**: scrape listings with no credit card

### ✨ Features

- 🏙️ **Search by city or location ID**: target Moscow, Saint Petersburg or any Russian region by its numeric location ID
- 🔗 **Search by URL**: paste one or more Avito search URLs and the filters baked into them are honored
- 🏷️ **Six real-estate verticals**: apartments, rooms, houses & dachas, commercial, land plots, garages & parking
- 🤝 **Sale or rent**: choose a deal type, matched per-listing for accuracy, or return both
- 🛏️ **Rich filters**: rooms, price range (RUB) and sort order (newest, price low→high, price high→low)
- 📊 **Price-per-m² + thumbnail** computed on every row for instant comparison and mapping
- 🗺️ **City + district on every listing** for neighborhood-level territory analysis
- 🔖 **New-build aware**: from-price (`от …`) and price-lowered flags surfaced on every row
- 📤 **Clean exports**: JSON, CSV, Excel, or the full REST API

### 🎬 Quick Start

Choose a city (or location ID), pick a category 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~avito-property-scraper/runs?token=[YOUR_TOKEN]" \
-H 'Content-Type: application/json' \
-d '{"city":"Москва","category":"apartments","dealType":"sale","maxResults":50}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose where to search

Enter a **city** (Москва / Moscow and Санкт-Петербург / SPB resolve automatically) or paste a numeric **Location ID** for any other region. Prefer your own filters? Paste Avito **search URLs** in `searchUrls`.

#### Step 2: Pick category & deal type

Set the **category** (apartments, rooms, houses, commercial, land, garages) and **deal type** (Sale / Rent / Any).

#### Step 3: Set filters & run

Rooms, price range (RUB), sort order, Max results — then hit **Start**.

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

- A clean dataset of Russian property listings (JSON / CSV / Excel)
- Price (RUB), price-per-m², rooms, area, floor, city, district and photos on every row
- A repeatable, no-code real-estate data feed across Russia

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| city | string | No | City to search. `Москва` / `Moscow` and `Санкт-Петербург` / `SPB` resolve automatically. |
| locationId | integer | No | Numeric Avito location ID — overrides City; required for non-cached regions (Moscow = 637640, SPB = 653240). |
| category | string | No | `apartments`, `rooms`, `houses`, `commercial`, `land`, `garages`. Default `apartments`. |
| dealType | string | No | `sale`, `rent`, or empty for both. Default `sale`. |
| searchUrls | array | No | Avito search URLs — on-page filters honored. |
| rooms | array | No | Room filter, e.g. `["2","3"]`. Use `studio` and `5+`. |
| minPrice / maxPrice | integer | No | Price range filter in RUB. |
| sort | string | No | `default`, `date`, `price`, `-price`. |
| maxResults | integer | No | Max listings this run. Default 100. |

**Example — by city & filters:**

```json
{
  "city": "Москва",
  "category": "apartments",
  "dealType": "sale",
  "rooms": ["2", "3"],
  "minPrice": 5000000,
  "maxPrice": 25000000,
  "sort": "-price",
  "maxResults": 200
}
```

**Example — by location ID (rent):**

```json
{
  "locationId": 653240,
  "category": "apartments",
  "dealType": "rent",
  "maxResults": 100
}
```

**Example — by search URL:**

```json
{
  "searchUrls": ["https://www.avito.ru/web/1/main/items?locationId=637640&categoryId=24&page=1&display=list"],
  "maxResults": 100
}
```

### 📤 Output

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

| Field | Type | Description |
|-------|------|-------------|
| id | integer | Avito listing ID |
| propertyTitle | string | Listing headline (e.g. "2-к. квартира, 50,2 м², 18/33 эт.") |
| url | string | Canonical Avito listing URL |
| deal\_type | string | `sale` or `rent` (derived per-listing) |
| object\_type | string | apartment, studio, room, house, commercial, land, garage |
| price | integer | Numeric price in rubles |
| price\_string | string | Full formatted price (e.g. "15 000 000 ₽") |
| price\_per\_sqm | integer | Computed price per square metre |
| price\_is\_from | bool | True for starting / "от …" new-build prices |
| was\_lowered | bool | True if the price was recently lowered |
| rooms | integer | Room count (0 = studio) |
| area\_total | number | Total area in m² |
| floor / floors\_total | integer | Floor and total floors |
| city / district | string | City and district |
| location\_id | integer | Avito numeric location ID |
| images / image\_count / thumbnail | array / integer / string | Photo gallery |

**Example:**

```json
{
  "id": 8124783900,
  "propertyTitle": "Квартира-студия, 28,2 м², 16/18 эт.",
  "url": "https://www.avito.ru/moskva/kvartiry/kvartira-studiya_282_m_1618_et._8124783900",
  "deal_type": "sale",
  "object_type": "studio",
  "price": 15000000,
  "price_string": "15 000 000 ₽",
  "price_per_sqm": 531915,
  "price_is_from": false,
  "rooms": 0,
  "area_total": 28.2,
  "floor": 16,
  "floors_total": 18,
  "city": "Москва",
  "district": "Люблино",
  "location_id": 637640,
  "thumbnail": "https://80.img.avito.st/image/1/...",
  "image_count": 6
}
```

### 💼 Use Cases & Examples

#### 1. Market research & price benchmarking

**Analysts sizing a Russian city or district market.**
**Input:** city + apartments + sale. **Output:** thousands of listings with price-per-m². **Use:** build a live price index per district.

#### 2. Investment sourcing

**Investors hunting undervalued or high-yield stock.**
**Input:** filters + `minPrice` / `maxPrice` + `rooms`. **Output:** filtered listings with price-per-m². **Use:** rank deals by price-per-m² vs district median.

#### 3. Rental-yield research

**Investors comparing buy vs rent economics.**
**Input:** two runs — one `sale`, one `rent` — for the same area. **Output:** matched sale and rent rows. **Use:** estimate gross rental yield per district.

#### 4. Portfolio & competitor monitoring

**Brokerages tracking active stock and pricing.**
**Input:** scheduled `searchUrls` runs per region. **Output:** a clean, repeatable Russian property data feed. **Use:** watch new supply, price cuts and competitor inventory.

#### 5. New-build (off-plan) tracking

**Analysts monitoring developer launches.**
**Input:** apartments + sale, scanning for from-price listings. **Output:** rows flagged `price_is_from` with starting prices. **Use:** track new-build entry pricing.

#### 6. Regional price comparison

**Researchers comparing markets across Russia.**
**Input:** the same category across multiple location IDs. **Output:** per-region listings with price-per-m². **Use:** compare affordability across cities.

### 🔗 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/avito-property-scraper').call({
  city: 'Москва', category: 'apartments', dealType: 'sale', 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/avito-property-scraper').call(
    run_input={'city': 'Москва', 'category': 'apartments', 'dealType': 'sale', '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~avito-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"city":"Москва","category":"apartments","dealType":"sale","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 listings per run — full feature access, same quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- **Unlimited** listings per run
- Pay-per-result: only charged for listings actually extracted

💰 **Pay only for what you extract** — clean Russian property data at a per-listing price built for whole-market sweeps.

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

### ❓ Frequently Asked Questions

**Q: Which areas are covered?**
A: All of Russia. Moscow (`637640`) and Saint Petersburg (`653240`) resolve by name; for any other region, pass its numeric `locationId`.

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

**Q: How do I find a location ID for my city?**
A: Open the area you want on Avito and read the `locationId` from the listing-feed request in your browser's network tab, then paste it into the `locationId` field.

**Q: Does it return both sale and rent?**
A: Yes — set `dealType` to `sale`, `rent`, or leave it on Any to return both. Each listing is tagged per-row, so the filter is accurate.

**Q: Is the price included?**
A: Yes — the numeric ruble price is recovered for ~100% of listings, plus a computed price-per-m² and the original formatted price string.

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

### 🐛 Troubleshooting

**No results returned**

- Check the `city` / `locationId` and `category` combination, or paste a working Avito search URL in `searchUrls` instead.
- Loosen filters — an overly tight price/rooms combination can return zero listings.

**Unknown city error**

- Only Moscow and Saint Petersburg resolve by name. For any other region, provide a numeric `locationId`.

**Fewer results than expected**

- The FREE tier caps listings per run. Upgrade to PAID for unlimited, or raise `maxResults`.

**A "rent" search shows fewer rows than the page count suggests**

- Each listing is filtered to the deal type you chose, so off-deal items are dropped for accuracy. Set `dealType` to Any to keep everything.

### ⚖️ 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 Avito or its parent company. "Avito" / "Авито" is a trademark of its respective owner. You are responsible for complying with Avito'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

## `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 city / location** — choose a city (or paste a numeric location ID) and narrow with the filters below.
- **By search URL** — paste one or more Avito search URLs you built on the site.

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

🏙️ City to search. Cached cities resolve automatically: **Москва / Moscow** and **Санкт-Петербург / SPB**. For any other city, leave this blank and set a **Location ID** below.

## `locationId` (type: `integer`):

📍 Numeric Avito location ID — overrides City, and required for cities not in the cached list (e.g. Moscow = 637640, Saint Petersburg = 653240).

**HOW TO FIND IT:** open the area you want on Avito and read the `locationId` value off the listing-feed request in your browser's network tab.

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

🏷️ Which real-estate vertical to search.

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

🤝 Sale or rent. Results are filtered to the deal type you choose (matched per listing for accuracy). Leave on **Any** to return both.

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

🔗 Avito search URLs to scrape. Used when **Search by = By search URL**. Each URL must point to an Avito listing feed and carry a location.

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

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

🔢 Maximum listings to extract this run.

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

## `rooms` (type: `array`):

🛏️ Optional. Room counts to filter by — add one or more. Use **"studio"** for studios and **"5+"** for five-or-more. Example: `["2", "3"]` returns 2- and 3-room listings.

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

↕️ How Avito orders the results before they are scraped.

## `minPrice` (type: `integer`):

💸 Optional. Minimum price filter in Russian rubles.

## `maxPrice` (type: `integer`):

💰 Optional. Maximum price filter in Russian rubles.

## Actor input object example

```json
{
  "searchMode": "byCity",
  "city": "Москва",
  "locationId": 637640,
  "category": "apartments",
  "dealType": "sale",
  "searchUrls": [
    "https://www.avito.ru/web/1/main/items?locationId=637640&categoryId=24&page=1&display=list"
  ],
  "maxResults": 100,
  "rooms": [
    "2",
    "3"
  ]
}
```

# Actor output Schema

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

Scraped Avito listings (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 = {
    "city": "Москва"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/avito-property-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 = { "city": "Москва" }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/avito-property-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 '{
  "city": "Москва"
}' |
apify call sian.agency/avito-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Avito Real Estate Scraper — Russia Property Data & API",
        "description": "Avito real estate scraper & property data API for Russia's largest marketplace. Apartments, rooms, houses, commercial & land for sale and rent: price (RUB), price/m², rooms, area, floor, city, district & photos — clean JSON/CSV.",
        "version": "1.0",
        "x-build-id": "bHqA27m7TD5ffgzTc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~avito-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-avito-property-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~avito-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-avito-property-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~avito-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-avito-property-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": {
                    "searchMode": {
                        "title": "🧭 Search by (auto-detected)",
                        "enum": [
                            "byCity",
                            "bySearchUrl"
                        ],
                        "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 city / location** — choose a city (or paste a numeric location ID) and narrow with the filters below.\n- **By search URL** — paste one or more Avito search URLs you built on the site.",
                        "default": "byCity"
                    },
                    "city": {
                        "title": "🏙️ City",
                        "type": "string",
                        "description": "🏙️ City to search. Cached cities resolve automatically: **Москва / Moscow** and **Санкт-Петербург / SPB**. For any other city, leave this blank and set a **Location ID** below.",
                        "default": "Москва"
                    },
                    "locationId": {
                        "title": "📍 Location ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "📍 Numeric Avito location ID — overrides City, and required for cities not in the cached list (e.g. Moscow = 637640, Saint Petersburg = 653240).\n\n**HOW TO FIND IT:** open the area you want on Avito and read the `locationId` value off the listing-feed request in your browser's network tab."
                    },
                    "category": {
                        "title": "🏷️ Category",
                        "enum": [
                            "apartments",
                            "rooms",
                            "houses",
                            "commercial",
                            "land",
                            "garages"
                        ],
                        "type": "string",
                        "description": "🏷️ Which real-estate vertical to search.",
                        "default": "apartments"
                    },
                    "dealType": {
                        "title": "🤝 Deal type",
                        "enum": [
                            "sale",
                            "rent",
                            ""
                        ],
                        "type": "string",
                        "description": "🤝 Sale or rent. Results are filtered to the deal type you choose (matched per listing for accuracy). Leave on **Any** to return both.",
                        "default": "sale"
                    },
                    "searchUrls": {
                        "title": "🔗 Search URLs",
                        "type": "array",
                        "description": "🔗 Avito search URLs to scrape. Used when **Search by = By search URL**. Each URL must point to an Avito listing feed and carry a location.\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 listings to extract this run.\n\n- **FREE tier:** capped at 25 listings per run.\n- **PAID tier:** unlimited — set as high as you need.",
                        "default": 100
                    },
                    "rooms": {
                        "title": "🛏️ Rooms",
                        "type": "array",
                        "description": "🛏️ Optional. Room counts to filter by — add one or more. Use **\"studio\"** for studios and **\"5+\"** for five-or-more. Example: `[\"2\", \"3\"]` returns 2- and 3-room listings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "↕️ Sort by",
                        "enum": [
                            "default",
                            "date",
                            "price",
                            "-price"
                        ],
                        "type": "string",
                        "description": "↕️ How Avito orders the results before they are scraped."
                    },
                    "minPrice": {
                        "title": "💸 Min price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💸 Optional. Minimum price filter in Russian rubles."
                    },
                    "maxPrice": {
                        "title": "💰 Max price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💰 Optional. Maximum price filter in Russian rubles."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
