# Avito Real Estate Scraper - Properties, Prices & Rentals (`abotapi/avito-real-estate-listings-scraper`) Actor

Scrape Avito real estate: apartments and rooms for sale or rent with rooms, area, floor, price per square metre, mortgage chips and the owner-vs-agent seller signal. City search with the site's own facet filters or paste links. Resume, incremental updates and MCP export included.

- **URL**: https://apify.com/abotapi/avito-real-estate-listings-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 listing records

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 Real Estate Scraper - Apartments for Sale & Rent

Avito Real Estate Scraper turns Avito's real-estate section into a clean data API. Search apartments and rooms for sale or rent by city with the site's own facet filters (room count, resale vs new-build, price range, owner-only), or paste search links - and get structured records with rooms, area, floor, price per square metre, mortgage chips, the full attribute table and the owner-vs-agent seller signal - then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Two ways in.** Search by city and property filters, or paste Avito search and category links.
- **Sale and rental listings.** Search apartments and rooms for sale or long-stay rent, with short-stay apartment rentals also available.
- **Property filters.** Narrow searches with room count, property features, price range, keywords and private-owner filters.
- **Listing details.** Enable detail reads for seller type, descriptions, property attributes, coordinates and available price history.
- **Built for schedules.** Resume interrupted runs or use incremental mode to return new and changed listings.
- **App exports.** Download JSON, CSV or Excel, use the dataset API, or send records to connected apps through MCP.

### Use Cases

- **Who:** property researchers - compare asking prices, floor areas and price per square metre across city searches.
- **Who:** rental analysts - collect rental listings by city, price range and keyword.
- **Who:** listing-monitoring teams - track new and changed properties with recurring runs.

### Data You Get

> Sample shape: one property listing; values illustrate the record format.

| Field | Example |
|---|---|
| `id` | 8062141126 |
| `title` | 4-к. квартира, 305,9 м², 11/11 эт. |
| `price` | 590968210 |
| `pricePerSqm` | 1931888 |
| `rooms` | 4 |
| `areaSqm` | 305.9 |
| `floor` | 11 |
| `totalFloors` | 11 |
| `realtyBenefit` | Ипотека 12,39% |
| `category` | kvartiry |
| `subcategory` | prodam |
| `region` | moskva |
| `sellerType` | private |
| `sellerName` | (detail read) |
| `url` | https://www.avito.ru/moskva/kvartiry/4-k.\_kvartira_3059_m_1111_et.\_8062141126 |
| `changeType` | NEW |

### How to Use

1. Pick a mode: **Search** builds tokenized real-estate searches from your filters; **URL** scrapes exactly the avito search links you paste (the site's own filter links work as-is).
2. Pick the category (apartments or rooms) and the deal type (sale, long-stay rent, short-stay rent), then narrow with rooms, feature, price and owner filters.
3. Set **Max items** for the run cap (20 by default) and keep **Fetch detail pages** on for the seller signal and the full attribute table.
4. Run the actor and export the dataset, or select an MCP connector to send records into your apps.

**Apartments for sale in Moscow:**

```json
{"mode": "search", "regions": ["Moscow"], "category": "kvartiry", "dealType": "prodam", "maxListings": 30}
```

**Two-room resale with owner-only:**

```json
{"mode": "search", "regions": ["Moscow"], "rooms": 2, "features": "vtorichka", "ownerOnly": true, "maxListings": 20}
```

**Cheap long-stay rentals, cheapest first:**

```json
{"mode": "search", "regions": ["Moscow"], "dealType": "sdam", "maxPrice": 60000, "sortBy": "price_asc", "maxListings": 20}
```

**Watch a search on a schedule:**

```json
{"mode": "search", "regions": ["Moscow"], "rooms": 2, "incrementalMode": true, "stateKey": "are-watch", "maxListings": 0}
```

#### Run it from your code

**Run it from Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("abotapi/avito-real-estate-listings-scraper").call(run_input={
    "mode": "search",
    "regions": ["Moscow"],
    "maxListings": 5,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**Run it from JavaScript:**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('abotapi/avito-real-estate-listings-scraper').call({
  mode: 'search', regions: ['Moscow'], maxListings: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Tips

- Residential proxies are required: the listing routes refuse datacenter IPs. The exit country rotates per session for maximum reliability.
- Room, feature facets are the site's own sale-scoped filters; rent listings filter by price and keyword.
- Other real-estate categories (houses, commercial, land, garages) work in URL mode: paste a tokenized link from the site.

### Send results into your apps (MCP connectors)

Optionally send records into the apps you already use through MCP connectors: set **MCP connectors** (for example a Notion database) and cap the export with **Max records to connectors**. The export is a gated side channel: it never changes the dataset.

| Field | What it does |
|---|---|
| `mcpConnectors` | Connector ids to export to (empty = no export). |
| `notionParentPageUrl` | URL or id of the Notion parent page (required for the Notion connector). |
| `maxNotifyListings` | Cap on records written to each connector per run. |

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | Filter-driven search, or paste your own avito links. |
| `regions` | array | \["Moscow"] | City names (Москва / Moscow) or avito slugs. |
| `category` | string | `kvartiry` | Apartments or rooms. Houses/commercial/land/garages work in URL mode. |
| `dealType` | string | `prodam` | Sale, long-stay rent, or short-stay rent. |
| `rooms` | integer | - | Room facet 1-5 (site's own values; sale listings only). |
| `features` | string | - | Resale / new-build / free plan / renovated / courtyard windows / mortgage / market price. |
| `minPrice` | integer | - | Price range floor in rubles. |
| `maxPrice` | integer | - | Price range ceiling in rubles. |
| `query` | string | - | Free-text keyword. |
| `sortBy` | string | `default` | Relevance, newest, price up, price down. |
| `ownerOnly` | boolean | false | Exclude agencies and professional sellers. |
| `urls` | array | \[{"url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ"}, {"url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ?p=2"}, {"url": "https://www.avito.ru/moskva/kvartiry/sdam-ASgBAgICAkSSA8gQ8AeQUg"}] | Tokenized avito search links (url mode). |
| `maxListings` | integer | 20 | Hard global cap on records per run (0 = billing cap only). |
| `maxPages` | integer | 0 | Cap on pages per search (0 = no page cap). |
| `fetchDetails` | boolean | true | Read each listing's page for seller type, attributes, coordinates, price history. |
| `proxy` | object | {"useApifyProxy": true, "apifyProxyGroups": \["RESIDENTIAL"]} | Residential required - datacenter is refused on listing routes. |
| `resumeFromRunId` | string | - | Paste a previous run ID to continue without re-collecting or re-charging. |
| `incrementalMode` | boolean | false | Track changes across scheduled runs; suppress and never bill unchanged records. |
| `stateKey` | string | - | Optional name for the incremental baseline. |
| `emitUnchanged` | boolean | false | Also return unchanged records, marked and billed. |
| `emitExpired` | boolean | false | Also return disappeared records, marked and billed. |
| `ignoreFieldsForChanges` | array | - | Extra top-level fields excluded from change detection. |
| `mcpConnectors` | array | - | Connector ids to export to (empty = no export). |
| `notionParentPageUrl` | string | - | URL or id of the Notion parent page (required for the Notion connector). |
| `maxNotifyListings` | integer | 50 | Cap on records written to each connector per run. |

### Output Example

> Sample shape: one listing record, from a live record.

**Live record: 4-к. квартира, 305,9 м², 11/11 эт.**

```json
{
  "id": "8062141126",
  "title": "4-к. квартира, 305,9 м², 11/11 эт.",
  "price": 590968210,
  "pricePerSqm": 1931888,
  "rooms": 4,
  "areaSqm": 305.9,
  "floor": 11,
  "totalFloors": 11,
  "realtyBenefit": "Ипотека 12,39%",
  "category": "kvartiry",
  "subcategory": "prodam",
  "region": "moskva",
  "url": "https://www.avito.ru/moskva/kvartiry/4-k._kvartira_3059_m_1111_et._8062141126"
}
```

### Plan Requirement

Charges include a start fee per run, a per-record fee for every listing returned, and a detail surcharge for each listing whose page was read for full enrichment. Listings returned as search cards without the detail read carry no detail surcharge. Exact prices are on the actor's Pricing tab.

### FAQ

#### How much does it cost?

Charges include a start fee per run, a per-record fee for every listing returned, and a detail surcharge per enriched listing. `Max items` caps the records a run returns, so it also caps the bill. Exact prices are on the actor's Pricing tab.

#### Is it legal to scrape Avito?

The actor reads publicly accessible Avito property listings and listing details. It does not access private accounts or checkout. You are responsible for using the data in line with the site's terms of use, privacy law such as GDPR or CCPA, and applicable regulations; personal data of identifiable individuals requires a lawful basis.

#### Does it scrape comments or reviews?

No. This actor returns property listings and optional listing details; it does not collect comments or reviews.

#### Can I get only new or changed listings on a schedule?

Yes. Turn on **Incremental mode** and schedule the actor. The first run returns everything matching as NEW; later runs return only NEW and UPDATED records. Listing content changes are tracked; rotating photo URLs and view counters are excluded as noise by default. Use **State key** to keep a monitoring campaign stable, and **Emit unchanged** or **Emit expired** only if you also want those rows (they return and bill extra rows).

#### Why did my run fail instead of returning an empty dataset?

A run that never got a single readable answer fails loudly with a connection message instead of reporting an empty dataset. Check the city, property filters, links and proxy settings before retrying.

#### Can I use it with AI agents or MCP?

Yes. Every record is plain JSON over the dataset API, and the MCP connector export sends rows straight into tools like Notion. Point an agent at the dataset items endpoint with the input above.

### 🔗 Want more Avito data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🚗 <a href="https://apify.com/abotapi/avito-auto-listings-scraper"><b>Avito Cars Scraper</b></a><br>Scrape Avito transport: used and new car listings with year, mileage, price, the site's...</td><td>🏷️ <a href="https://apify.com/abotapi/avito-ru-scraper"><b>Avito.ru Scraper</b></a><br>Scrape structured listings from Avito.ru by region, category, filters, or direct URL...</td></tr>
<tr><td>🏨 <a href="https://apify.com/abotapi/hostelworld-scraper"><b>Hostelworld Scraper</b></a><br>Scrape Hostelworld hostels, hotels, guesthouses, B&amp;Bs, apartments and campsites by city...</td><td>🏨 <a href="https://apify.com/abotapi/hipflat-scraper"><b>Hipflat Scraper Thailand Property &amp; Projects</b></a><br>Scrape hipflat.co.th property listings and new-project data across Thailand: price, price...</td></tr>
<tr><td>🏨 <a href="https://apify.com/abotapi/booking-com-scraper"><b>Booking.com Scraper</b></a><br>Scrape booking.com hotels, apartments, villas and hostels. Search any destination with...</td><td>🏨 <a href="https://apify.com/abotapi/klook-activities-scraper"><b>Klook Scraper</b></a><br>Scrape Klook activities, tours, attractions and travel experiences from search pages or...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/avito-real-estate-listings-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

search builds tokenized real-estate searches from your filters. url scrapes exactly the avito search/category links you paste (tokenized links from the site work as-is).

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

City names (Москва / Moscow) or avito slugs (moskva). Every search is city-scoped on avito.

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

kvartiry = apartments (flats, studios, penthouses); komnaty = rooms. Other real-estate categories (houses, commercial, land, garages) work in url mode - paste a link from the site.

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

prodam = for sale, sdam = long-stay rent, posutochno = short-stay rent (kvartiry only).

## `rooms` (type: `integer`):

Room facet 1-5 (the site's own values; 5 means 5+). Sale listings only - the site scopes this facet to resale apartments. Leave empty for any.

## `features` (type: `string`):

Resale, new-build, free plan, renovated, courtyard windows, mortgage-friendly, market price - the site's own facet tokens.

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

Minimum listing price in rubles.

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

Maximum listing price in rubles.

## `query` (type: `string`):

Free-text search keyword (e.g. a residential complex name).

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

default = relevance, date_desc = newest, price_asc / price_desc.

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

Exclude agencies and professional sellers (the site's own owner filter).

## `urls` (type: `array`):

Paste Avito property search or category links copied from the site, including their filter tokens. Use the example links as a guide.

## `maxListings` (type: `integer`):

Maximum number of listings per run (a hard global cap across all searches). 0 means the per-result billing cap applies.

## `maxPages` (type: `integer`):

Maximum pages walked per search. 0 means no page cap, so Max items is the only cap that stops a run early.

## `fetchDetails` (type: `boolean`):

Read each listing's page for the seller type (owner vs agent), full attributes (building, house params), description, coordinates and price history signals.

## `proxy` (type: `object`):

Residential proxies are required - the site refuses datacenter IPs for the listing routes. Keep the residential default; the exit country rotates per session for maximum reliability.

## `resumeFromRunId` (type: `string`):

Run or dataset ID whose collected listings should be skipped (for continuing after an interrupted run).

## `incrementalMode` (type: `boolean`):

Track state between runs and classify every listing as NEW, UPDATED, UNCHANGED or EXPIRED instead of always NEW. Rows already known and unchanged are suppressed.

## `stateKey` (type: `string`):

Named baseline for incremental runs. Leave empty to derive the key from the run scope.

## `emitUnchanged` (type: `boolean`):

In incremental mode, also push rows that did not change (changeType UNCHANGED).

## `emitExpired` (type: `boolean`):

In incremental mode, emit EXPIRED tombstone rows for listings that disappeared from the walked scope.

## `ignoreFieldsForChanges` (type: `array`):

Extra field names that must never mark a row UPDATED (photo URL churn and view counters are already excluded by default).

## `mcpConnectors` (type: `array`):

Apify MCP connector IDs that receive pushed records while the run executes.

## `notionParentPageUrl` (type: `string`):

Notion parent page for the Notion MCP connector.

## `maxNotifyListings` (type: `integer`):

Cap on records sent to MCP connectors per run.

## Actor input object example

```json
{
  "mode": "search",
  "regions": [
    "Moscow"
  ],
  "category": "kvartiry",
  "dealType": "prodam",
  "query": "",
  "sortBy": "default",
  "ownerOnly": false,
  "urls": [
    {
      "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ"
    },
    {
      "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ?p=2"
    },
    {
      "url": "https://www.avito.ru/moskva/kvartiry/sdam-ASgBAgICAkSSA8gQ8AeQUg"
    }
  ],
  "maxListings": 20,
  "maxPages": 0,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "resumeFromRunId": "",
  "incrementalMode": false,
  "stateKey": "",
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "mcpConnectors": [],
  "notionParentPageUrl": "",
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `changes` (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 = {
    "regions": [
        "Moscow"
    ],
    "urls": [
        {
            "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ"
        },
        {
            "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ?p=2"
        },
        {
            "url": "https://www.avito.ru/moskva/kvartiry/sdam-ASgBAgICAkSSA8gQ8AeQUg"
        }
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/avito-real-estate-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 = {
    "regions": ["Moscow"],
    "urls": [
        { "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ" },
        { "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ?p=2" },
        { "url": "https://www.avito.ru/moskva/kvartiry/sdam-ASgBAgICAkSSA8gQ8AeQUg" },
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/avito-real-estate-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 '{
  "regions": [
    "Moscow"
  ],
  "urls": [
    {
      "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ"
    },
    {
      "url": "https://www.avito.ru/moskva/kvartiry/prodam-ASgBAgICAUSSA8YQ?p=2"
    },
    {
      "url": "https://www.avito.ru/moskva/kvartiry/sdam-ASgBAgICAkSSA8gQ8AeQUg"
    }
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/avito-real-estate-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/avito-real-estate-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/2QqCeGODfMhi93BVD/builds/R0COs1Rk8L4WIa77W/openapi.json