# Avito Real Estate Scraper | Парсер Авито Недвижимость (`actorforgehq/avito-real-estate-scraper`) Actor

Avito real estate scraper: every property listing on avito.ru — flats, houses, rooms, land, commercial — as clean JSON with URLs and lastmod stamps. Monitor new listings, deltas; no prices/photos in v1. Russia property data from Avito's sitemaps, no proxies. Авито недвижимость: парсер объявлений.

- **URL**: https://apify.com/actorforgehq/avito-real-estate-scraper.md
- **Developed by:** [ActorForge](https://apify.com/actorforgehq) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 listing discovereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 | Парсер Авито Недвижимость

Discover **every property listing on Avito** (avito.ru) — Russia's #1 real estate marketplace —
as clean JSON. Full-section crawl of flats, houses, rooms, land, commercial and more via Avito's
own published sitemaps: canonical listing URLs, freshness timestamps and URL-derived fields.
Russia property data for new-listing monitoring — fast, API-level, no browser automation.
*Авито недвижимость: парсер объявлений, мониторинг новых объявлений.*

### What this actor is (and honestly is not)

This is a **discovery and freshness** actor, not a card scraper:

- **It gives you the full inventory** of a property section — every listing URL Avito publishes
  in its sitemaps (~550,000 live flat listings, updated by Avito continuously), with `lastmod`
  freshness stamps. Perfect for spotting **new listings**, computing **deltas between runs**, and
  building a **comps universe per city**.
- **It does not open listing pages**, so there are **no prices, photos, addresses or seller
  info** in the output — only what Avito publishes in the sitemap URL itself. Card enrichment
  is a planned v2 (it requires Russian residential IPs; discovery does not).
- **It is not a filtered search.** Avito's `robots.txt` disallows parameterized search and its
  API for crawlers; sitemap crawling is the route Avito itself sanctions. Filter by city and
  freshness here, do finer filtering downstream.

### What you get

One row per discovered listing:

```json
{
  "url": "https://www.avito.ru/moskva/kvartiry/3-k._kvartira_75_m_29_et._8112834772",
  "itemId": "8112834772",
  "city": "moskva",
  "category": "kvartiry",
  "title": "3-k. kvartira 75 m 29 et.",
  "rooms": 3,
  "lastmod": "2026-07-16T07:31:50Z"
}
```

- `itemId` — Avito's listing id (string), extracted from the URL tail. Stable join key.
- `city` — city slug exactly as in the URL (`moskva`, `sankt-peterburg`, `rostov-na-donu`).
- `category` — section slug from the URL (`kvartiry`, `komnaty`, `doma_dachi_kottedzhi`, …).
- `title` — the URL slug made human-readable (underscores → spaces). Transliterated Latin, as
  published by Avito.
- `rooms` — number of rooms (`3`) or `"studio"`, present **only when the slug states it
  unambiguously** (`3-k._kvartira…`, `kvartira-studiya…`). Auction lots, wanted ads and
  `apartamenty` variants get no `rooms` field rather than a guess.
- `lastmod` — ISO timestamp from Avito's sitemap; absent for the rare entries Avito publishes
  without one. **Numbers like area and floor are deliberately NOT parsed from the slug**: Avito
  strips the decimal comma there (`556_m` can mean 55.6 m² or 556 m²), so any parsed number
  would be a guess. Numeric card fields arrive with v2 enrichment.

### Use cases

- **New-listing alerts** — run on a schedule with `updatedAfter` and get only fresh listings.
- **Market inventory & deltas** — track how many listings each city/section has, what appeared
  and disappeared between runs (diff by `itemId`).
- **Comps universe** — the complete set of listing URLs per city, ready for your own enrichment
  or valuation pipeline.
- **Feed for card scraping** — clean, deduplicated URL + freshness input for any downstream
  detail scraper.

### Input

| Field | Type | Description |
|---|---|---|
| `sections` | string\[] | Property sections to crawl. Default `["kvartiry"]`. Full list: `kvartiry`, `komnaty`, `doma_dachi_kottedzhi`, `zemelnye_uchastki`, `kommercheskaya_nedvizhimost`, `garazhi_i_mashinomesta`, `nedvizhimost_za_rubezhom`, `realty_rent` (short-term rent). |
| `cities` | string\[] | City slugs as they appear in Avito URLs (`moskva`, `sankt-peterburg`). Empty = all cities. |
| `updatedAfter` | string | ISO date; keep only listings with sitemap `lastmod` on or after it. Entries without `lastmod` are dropped when this filter is set. |
| `maxItems` | integer | Hard cap on output rows. Default 50 000 (≈ one sitemap file). Raise for a full-section crawl (flats ≈ 550k). |

### How to use it

1. Click **Try for free** / **Start** on this page.
2. Choose one or more **Property sections**. The default is `kvartiry` (flats).
3. Optionally list **Cities** using the slugs Avito puts in its URLs — `moskva`,
   `sankt-peterburg`, `rostov-na-donu`. Leave it empty to keep every city.
4. For new-listing alerts, set **Updated after** to an ISO date; only listings whose sitemap
   `lastmod` is on or after it survive. (Entries without a `lastmod` are dropped when this
   filter is on.)
5. Set **Max items**. The default 50 000 is about one sitemap file; raise it for a full-section
   crawl.
6. Run it, then export the **Listings** view as JSON, CSV or Excel, or read it over the API.

**The usual pattern is a schedule plus a diff.** Run it daily with `updatedAfter` set to
yesterday and you get exactly the listings that appeared or were refreshed; diff consecutive
runs by `itemId` to see what came and went. Every output field carries typed metadata in the
Actor's dataset schema, so agents calling this through the Apify MCP server know what they are
getting.

### Why this scraper

- **It uses the door Avito left open.** Listing pages and the mobile API sit behind Avito's
  Qrator firewall and are disallowed for crawlers by `robots.txt`; the sitemaps are published
  *by Avito itself* in that same `robots.txt`. This actor reads only those — which is why it
  needs **no expensive Russian residential proxies** and keeps a predictable success rate.
- **Honest failures.** A firewall page instead of a sitemap, a truncated gzip, a drifted format
  — each fails the task loudly with a clear reason instead of masquerading as an empty result.
- **Schema-validated output** — every row is checked against a schema before it reaches your
  dataset; a format change on Avito's side surfaces as a failure, not as `undefined` in your
  pipeline.
- **Polite by design** — a handful of requests per run (one index + one gzip file per ~50 000
  listings), spaced out. A full flats crawl is ~12 HTTP requests total.

### Limits (honest)

- **No card fields.** Prices, areas, floors, photos, addresses, seller names are not in
  sitemaps and therefore not in v1 output. `rooms` appears only when unambiguous.
- **No search filters.** You can slice by section, city and freshness — not by price or rooms
  range (Avito forbids parameterized search for crawlers; we don't circumvent that).
- **Freshness is Avito's.** `lastmod` comes from Avito's sitemap generator; entries without it
  are passed through as-is (unless `updatedAfter` is set, which drops them).
- **Sections are a fixed list** taken from Avito's live sitemap index; if Avito adds a section
  it appears here with an actor update.
- Public data only; no login, no captcha solving, no access-control bypassing. Requests are
  paced ≥500 ms apart.

### Pricing

Pay-per-event: a platform charge per run start plus one `listing-discovered` event per output
row. No hidden compute or proxy surcharges — discovery runs without residential proxies. See
the Store page for current rates.

### FAQ

**Do I need Russian proxies for this?**
No — and that is the point. Avito's sitemaps are served without the Qrator firewall that guards
listing pages, so discovery runs on plain infrastructure. Card enrichment (v2) will need
Russian residential IPs; discovery does not.

**Where are the prices, photos and addresses?**
Not in the output, because they are not in the sitemaps. This Actor deliberately stops at what
Avito publishes for crawlers. Anything else would mean opening listing pages, which Avito's
`robots.txt` disallows.

**Why is `rooms` missing on some rows?**
Because the slug did not state it unambiguously. Auction lots, wanted ads and `apartamenty`
variants get no `rooms` field rather than a guessed number.

**Why aren't area and floor parsed out of the URL slug?**
Avito strips the decimal comma in slugs, so `556_m` is both 55.6 m² and 556 m². A parsed number
would be a coin flip, so the field is left out until v2 reads it from the card.

**Can I filter by price or room count?**
Not here. Avito forbids parameterized search for crawlers, so the Actor slices by section, city
and freshness only. Filter finer downstream on the rows it returns.

**How fresh is `lastmod`?**
It comes straight from Avito's own sitemap generator, unmodified. Avito refreshes those files
continuously; the Actor reports what it read.

**How many requests does a full crawl make?**
Very few — one sitemap index plus one gzip file per ~50 000 listings. A complete flats crawl is
roughly 12 HTTP requests, spaced at least 500 ms apart.

### Other Actors by ActorForge

- [Wildberries Scraper](https://apify.com/actorforgehq/wildberries-scraper) — products, prices
  and reviews from Wildberries as clean, schema-validated JSON.
- [Lazada Reviews Scraper](https://apify.com/actorforgehq/lazada-reviews-scraper) — ratings,
  review text and buyer media from Lazada across the SEA marketplaces.

Need card-level enrichment, another Avito vertical, or a different marketplace? Open an issue
from the Actor's page and tell us what you need.

### Disclaimer

This is an **unofficial** actor. It is not affiliated with, endorsed by, or connected to Avito
in any way. It collects only data that Avito publishes publicly in its sitemap files, without
logging in and without circumventing access controls. You are responsible for ensuring your use
of the collected data complies with applicable law and with Avito's terms.

### Changelog

See the repository `CHANGELOG.md`.

# Actor input Schema

## `sections` (type: `array`):

Avito real estate sections to crawl. Slugs match the avito.ru URL path (live sitemap index, 2026-07-19).

## `cities` (type: `array`):

Avito city slugs exactly as they appear in listing URLs, e.g. `moskva`, `sankt-peterburg`, `rostov-na-donu`. Leave empty to keep all cities.

## `updatedAfter` (type: `string`):

Keep only listings whose sitemap `lastmod` is on or after this ISO date (e.g. 2026-07-01). Listings without `lastmod` are dropped when this filter is set. This is the field to set for scheduled new-listing alerts.

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

Hard cap on discovered listings. Defaults to 1 000 — a fast, cheap sample across dozens of cities. Raise it for a full-section crawl: one Avito sitemap file holds up to 50 000 listings, and flats run to ~550k in total. Runtime barely changes with the cap (the actor downloads a whole sitemap file either way and slices), so the cap controls how much you are billed, not how long you wait.

## Actor input object example

```json
{
  "sections": [
    "kvartiry",
    "doma_dachi_kottedzhi"
  ],
  "cities": [
    "moskva",
    "sankt-peterburg"
  ],
  "updatedAfter": "2026-07-01",
  "maxItems": 1000
}
```

# Actor output Schema

## `listings` (type: `string`):

Discovered Avito property listings with canonical URL, itemId, city, category, title, rooms (when unambiguous) and lastmod.

# 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 = {
    "sections": [
        "kvartiry"
    ],
    "maxItems": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorforgehq/avito-real-estate-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 = {
    "sections": ["kvartiry"],
    "maxItems": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("actorforgehq/avito-real-estate-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 '{
  "sections": [
    "kvartiry"
  ],
  "maxItems": 1000
}' |
apify call actorforgehq/avito-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/U3Un4EePAIqubA8wK/builds/AUfd2NP7ge2PWScYF/openapi.json