# Avito Russia Property Listings Scraper (`jungle_synthesizer/avito-russia-property-listings-scraper`) Actor

Scrape live real estate listings from Avito, Russia's largest classifieds site. Returns apartments, houses, rooms, land plots, garages, and commercial property for sale or rent, with room count, floor, area, price per m², metro walk time, and seller class.

- **URL**: https://apify.com/jungle\_synthesizer/avito-russia-property-listings-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 record scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Avito Russia Property Listings Scraper

Scrape live real estate listings from [Avito](https://www.avito.ru), Russia's largest classifieds site. Returns apartments, houses, rooms, land plots, garages, and commercial property — for sale or for rent — with room count, floor, total/living/kitchen area, price per square meter, metro walk time, seller class, and the full listing description.

***

### Avito Property Scraper Features

- Covers all six Avito real estate categories: apartments, houses/dachas/cottages, rooms, land plots, garages, and commercial property — for sale (`prodam`) or rent (`sdam`)
- Derives room count, total area, and floor-of-floors directly from Avito's own listing title convention, so those fields are populated even when the source omits them elsewhere on the page
- Returns living-area and kitchen-area breakdowns, land area (for houses/land), and building year when disclosed
- Resolves price per square meter automatically from the listing's own price and area
- Classifies each seller as private, agency, or developer, and flags new-construction (novostroyka) offers
- Returns the full listing description as clean text, plus every attached photo URL
- Filter by property category, deal type, and region — or leave them unset to cover the broadest default slice

***

### Who Uses Avito Property Data?

- **Relocation and valuation desks** — build comparable-sales and rental-rate datasets across Russian cities without manually browsing listings
- **Proptech platforms** — feed structured Russian real estate data into search, alerting, or valuation products
- **Market researchers** — track pricing trends, inventory levels, and new-construction activity by region and property type
- **CIS-market analysts** — monitor a specific city or property segment's live inventory and pricing

***

### How Avito Property Scraper Works

1. Give it a `maxItems` limit and, optionally, which property categories, deal types, and regions to cover.
2. The scraper walks each selected region/category/deal-type combination's listing pages, saving every unique property it finds.
3. Each listing comes back as one structured record with pricing, layout, location, and seller details — no manual HTML cleanup.
4. The run stops once it hits your `maxItems` limit or runs out of listings, whichever comes first.

Real estate sites update constantly — for a large, ongoing collection, run this actor on a schedule and use `maxItems` to bound each run's cost.

***

### Input

```json
{
  "maxItems": 100,
  "propertyTypes": ["kvartiry"],
  "dealTypes": ["prodam"]
}
```

| Field           | Type                 | Default                      | Description |
|-----------------|----------------------|------------------------------|-------------|
| `maxItems`      | integer              | — (required)                 | Maximum number of property listings to scrape. |
| `regions`       | array of strings     | largest federal-subject hubs | Avito region/city URL slugs to crawl (e.g. `moskva`, `sankt-peterburg`). Leave empty for the default set. |
| `propertyTypes` | array (multi-select) | all categories               | Property categories to include: `kvartiry` (apartments), `doma-dachi-kottedzhi` (houses/dachas/cottages), `komnaty` (rooms), `zemelnye-uchastki` (land plots), `garazhi-i-mashinomesta` (garages/parking), `kommercheskaya-nedvizhimost` (commercial). Leave empty for all. |
| `dealTypes`     | array (multi-select) | both                         | `prodam` (for sale) and/or `sdam` (for rent). Leave empty for both. |

#### Example: Apartments for rent in Moscow and St. Petersburg

```json
{
  "maxItems": 200,
  "regions": ["moskva", "sankt-peterburg"],
  "propertyTypes": ["kvartiry"],
  "dealTypes": ["sdam"]
}
```

***

### Avito Property Scraper Output Fields

```json
{
  "listing_id": "8060826600",
  "listing_url": "https://www.avito.ru/moskva/kvartiry/...",
  "title": "6-к. квартира, 693,7 м², 66/67 эт.",
  "price_rub": 1734250000,
  "price_raw": "1 734 250 000 ₽",
  "price_period": "sale",
  "price_per_sqm_rub": 2500000,
  "deal_type": "prodam",
  "property_type": "kvartira",
  "rooms": 6,
  "area_total_sqm": 693.7,
  "area_living_sqm": 577.6,
  "area_kitchen_sqm": 68.1,
  "floor": 66,
  "floors_total": 67,
  "land_area_sotka": null,
  "address": "...",
  "district": null,
  "metro_station": null,
  "metro_distance_min": null,
  "region": null,
  "city": null,
  "seller_name": "Capital Group",
  "seller_url": "https://www.avito.ru/brands/...",
  "seller_type": "developer",
  "seller_rating": null,
  "seller_reviews_count": null,
  "is_developer_offer": true,
  "building_year": null,
  "description": "...",
  "image_urls": [],
  "images_count": 0,
  "published_at": null,
  "views_total": null,
  "views_today": null,
  "listing_status": "active",
  "scraped_at": "2026-09-20T16:23:32.911Z"
}
```

| Field                                                           | Description |
|-----------------------------------------------------------------|-------------|
| `listing_id`                                                    | Avito's internal item id, stable across listing edits |
| `listing_url`                                                   | Canonical URL of the listing |
| `title`                                                         | Listing title as shown on Avito |
| `price_rub`                                                     | Price in rubles (sale price or rent amount) |
| `price_raw`                                                     | Original price string as displayed |
| `price_period`                                                  | `sale`, `month`, or `day` |
| `price_per_sqm_rub`                                             | Price per square meter, computed when price and area are both known |
| `deal_type`                                                     | `prodam` (sale) or `sdam` (rent) |
| `property_type`                                                 | `kvartira`, `dom`, `komnata`, `uchastok`, `garazh`, or `kommercheskaya` |
| `rooms`                                                         | Room count; studios are `0` |
| `area_total_sqm` / `area_living_sqm` / `area_kitchen_sqm`       | Area breakdown in square meters, when disclosed |
| `floor` / `floors_total`                                        | Floor and building height |
| `land_area_sotka`                                               | Land plot area in sotka (houses/land only) |
| `address` / `district` / `metro_station` / `metro_distance_min` | Location details, when disclosed in that form |
| `region` / `city`                                               | Federal subject and city, when the address cleanly separates into them |
| `seller_name` / `seller_url` / `seller_type`                    | Seller identity and class (`private`, `agency`, `developer`) |
| `seller_rating` / `seller_reviews_count`                        | Seller reputation, when Avito discloses it |
| `is_developer_offer`                                            | `true` for new-construction/developer offers |
| `building_year`                                                 | Year built, when disclosed |
| `description`                                                   | Full listing description |
| `image_urls` / `images_count`                                   | Photo URLs and count |
| `published_at`                                                  | ISO-8601 publish timestamp |
| `views_total` / `views_today`                                   | View counters, when disclosed |
| `listing_status`                                                | `active` or `closed` |
| `scraped_at`                                                    | ISO-8601 timestamp this record was scraped |

Some fields depend on what a given listing discloses — a compact studio ad and a full-page developer listing don't expose the same detail, and fields the source doesn't provide come back `null` rather than a guess.

***

### FAQ

#### How do I scrape Avito property listings?

Create a task from this Actor, set `maxItems` and any category/region/deal-type filters you want, and run it. Results land in the run's dataset in structured JSON, ready to export as CSV, Excel, or JSON.

#### What property types are covered?

Apartments, houses/dachas/cottages, rooms, land plots, garages/parking, and commercial property — for sale or for rent.

#### Can I limit the crawl to specific regions?

Yes — set `regions` to the Avito region/city URL slugs you want (e.g. `moskva`). Leave it unset to cover the default set of the largest federal subjects.

#### Does this include closed or expired listings?

No — every run scrapes what's live on Avito at the time it runs.

***

### Need More Features?

Message us with your use case — custom fields, additional regions, or a different output shape can usually be added quickly.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

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

Maximum number of property listings to scrape

## `regions` (type: `array`):

Avito region/city URL slugs to crawl (e.g. 'moskva', 'sankt-peterburg', 'novosibirskaya\_oblast'). Leave empty to use a default set of the largest federal subjects.

## `propertyTypes` (type: `array`):

Property categories to include. Leave empty to crawl every category (apartments, houses, rooms, land, garages, commercial).

## `dealTypes` (type: `array`):

Sale and/or rent listings to include. Leave empty to crawl both.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/avito-russia-property-listings-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/avito-russia-property-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}' |
apify call jungle_synthesizer/avito-russia-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/avito-russia-property-listings-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Caqf8aVxPw8e7IQKE/builds/QHpZweXAGjeDO5rfH/openapi.json