# Avito Scraper: Avito.ru Listings, Prices & Sellers (`amitaviv/avito-scraper`) Actor

Scrape Avito.ru listings in any category from a search URL or a keyword, city, category and price range: price, price per m², address, coordinates, date, parameters, photos, seller type and company name. Only-new mode for monitoring. No browser; private sellers' names withheld by default.

- **URL**: https://apify.com/amitaviv/avito-scraper.md
- **Developed by:** [Amit Aviv](https://apify.com/amitaviv) (community)
- **Categories:** Real estate, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 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/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 Scraper (avito.ru listings)

Returns listings from Avito.ru, Russia's largest classifieds site, in any category (flats, houses, cars, phones, furniture, services ...) from search URLs you copy out of the browser or from a keyword, region, category and price range. Plain HTTP with no browser, so 500 listings take under a minute; apart from the start fee you pay only for delivered listings, and a run that delivers nothing because of an error ends as Failed, never as a green empty run.

**Private sellers are not named by default.** For Avito shops and for companies whose details Avito has verified you get the company name, its Avito page and its badges; for everyone else (private persons, and accounts Avito calls companies that show neither, which can be individual agents) those fields are empty unless you switch on the opt-in described under "Legal and responsible use". Phone numbers are never collected.

### What you get

- Title, price in roubles, the price as Avito prints it, price per m² for real estate, whether the price was lowered, whether the listing is in an Avito sale, and the sale or dealer-discount price
- Category, location, short and full address, latitude and longitude, nearby metro stations and districts with distances
- Date and time the listing was published or last lifted to the top (`listedAt`)
- Description, photo URLs (largest size), photo count, whether there is a video; whether the listing can be bought with Avito Delivery, Avito's delivery time ("Доставка от 1 дня") and its "Только доставка" badge
- Parsed from the title / parameter line: rooms, area m², floor, floors in the building (real estate); year and mileage (vehicles); and the vehicle parameter line as text
- With **details** on: every parameter of the listing page (`parameters`: rooms, kitchen area, ceiling height, renovation, house type, year built, lift, parking; engine, gearbox, drive, colour, condition, VIN as masked by Avito ...), all photos, the exact seller type and whether the seller is an Avito shop
- Seller type (`private`, `company` or `null` when Avito does not say, see below); for shops and verified companies the name, Avito page, number of completed listings, verification badges and since-when
- One record per listing, as JSON, CSV or Excel, or through the API
- A run summary (`OUTPUT_SUMMARY` in the run's key-value store): what was requested, delivered and charged, how many listings Avito reports per search, which inputs failed or were ignored and why, whether a proxy was used, and why the run stopped

What it does not return: phone numbers (Avito shows them only to logged-in users), private sellers' names or profile links (unless you opt in), names of company employees, reviews, anything behind a login, view counts.

### How to use

1. Open avito.ru, make the search you want (city, category, filters, sort) and copy the URL from the browser. Or type keywords and a city.
2. Paste the URL into **Avito search or listing URLs**, or fill in **Search keywords** / **Category** and **Region**. Several entries are fine.
3. Set **Maximum listings per search**, and **Open each listing page** if you need all parameters. Press Start.
4. Download the results from the Output tab, or read them from the API.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `startUrls` | list of text | none | Avito search or category pages (all filters you set on the site are kept) or listing pages (`…_1234567890`, returned with full details). `m.avito.ru` and URLs without `https://` are accepted. Ignored and listed in the summary with the reason: duplicates, other sites, a city's start page without a category (`avito.ru/moskva`: add one, e.g. `avito.ru/moskva/kvartiry`), and Avito pages that are not searches (`avito.ru/business`, help pages, seller profiles). |
| `searchQueries` | list of text | none | Keywords, as typed in Avito's search box. Each one is a search in `region` (and `category`). |
| `region` | text | Россия | A city or region by name (`Москва`, `Санкт-Петербург`, `Екатеринбург`, `Московская область`; about 50 names known), `Россия` for the whole country, or Avito's slug from its URLs (`kazan`, `nizhniy_novgorod`). |
| `category` | text | none | Avito's category path, the part of its URL after the city: `kvartiry/prodam`, `kvartiry/sdam/na_dlitelnyy_srok`, `avtomobili`, `telefony`, `predlozheniya_uslug` ... A category alone reads the whole category. A whole Avito URL typed into `region` or `category` is accepted: its city and category are used where the other field is empty (if the two disagree, the field meant for it wins and the summary warns). |
| `priceMin`, `priceMax` | number | none | Price range in roubles, for searches built from the fields above. |
| `cityOnly` | yes/no | yes | Keep a city search to the city itself. The actor asks Avito not to widen the search (`radius=0`) and then leaves out every listing Avito shows that is located outside the city: listings from other cities that Avito mixes into a city search because they are sold with delivery, and, in keyword searches (where Avito drops the radius), listings from nearby and other towns. Parts of a city that Avito lists under the city (Peterhof in St Petersburg, Zelenograd in Moscow) count as the city. Left-out listings are not delivered or charged; the status message and the summary (`outsideCity`, `cityOnly`) give their number on the pages read. Off: everything Avito shows, as on the website, which for cars and some other categories includes towns up to about 200 km around the city. Not applied to regions such as `Московская область` or to `Россия` (the summary says so), and pasted search URLs are returned as Avito shows them. |
| `sellerType` | choice | all | `private` or `company` uses Avito's own seller filter, so every listing carries a definite `sellerType`. |
| `sort` | choice | Avito's default | `date` (newest first), `price_asc`, `price_desc`. |
| `maxItems` | number | 50 | Stop each search after this many listings (up to 5,000). |
| `includeDetails` | yes/no | no | Open each listing's own page for all parameters and photos. Charged as an add-on per listing whose page was read; slower (see Limits). |
| `onlyNew` | yes/no | no | Monitoring: return and charge only listings that earlier runs have not delivered. See "Monitoring". |
| `monitorKey` | text | empty | Name of the monitor memory, to keep two schedules apart. |
| `includePrivateSellerData` | yes/no | no | Also return private persons' display names and profile links. Requires a lawful basis, see below. |
| `proxyConfiguration` | proxy | off | Not needed: the actor switches to Apify Proxy by itself when Avito refuses its address. |

```json
{
  "region": "Краснодар",
  "category": "kvartiry/prodam",
  "maxItems": 30,
  "includeDetails": true
}
```

### Example result

From run `C5BTLsWfmgnFus55w` (the input above) on 2026-10-20; only the description and the photo list are shortened here (`priceWithDiscounts`, `onSale`, `deliveryOnly` and `deliveryText` were added later, in builds 0.1.13, 0.1.15 and 0.1.19, and are shown with the values this listing has):

```json
{
  "id": 8417769121,
  "url": "https://www.avito.ru/krasnodar/kvartiry/1-k._kvartira_316_m_49_et._8417769121",
  "title": "1-к. квартира, 31,6 м², 4/9 эт.",
  "price": 2950000,
  "currency": "RUB",
  "priceWithDiscounts": null,
  "priceText": "2 950 000 ₽",
  "pricePerM2": 93354,
  "priceWasLowered": true,
  "onSale": false,
  "category": "Квартиры",
  "categorySlug": "kvartiry",
  "categoryId": 24,
  "location": "Краснодар",
  "address": "Ул. имени 40-летия Победы, 41",
  "fullAddress": "Краснодарский край, Краснодар, ул. имени 40-летия Победы, 41",
  "latitude": 45.056804,
  "longitude": 39.015234,
  "nearby": [{ "name": "р-н Прикубанский", "distance": null }],
  "listedAt": "2026-10-20T14:21:21.000Z",
  "description": "Пpодажa квартиpы в Kраснодaрe Прeдлaгаетcя к пoкупке уютная квapтиpa в Пpикубанском paйoне Кpаснoдaрa, на улицe имени 40-лeтия Победы. …",
  "paramsText": null,
  "rooms": 1,
  "areaM2": 31.6,
  "floor": 4,
  "floorsTotal": 9,
  "year": null,
  "mileageKm": null,
  "parameters": {
    "Количество комнат": "1",
    "Общая площадь": "31.6 м²",
    "Площадь кухни": "6 м²",
    "Жилая площадь": "18 м²",
    "Этаж": "4 из 9",
    "Балкон или лоджия": "лоджия",
    "Высота потолков": "2.6 м",
    "Окна": "во двор",
    "Ремонт": "дизайнерский",
    "Мебель": "кухня, хранение одежды, спальные места",
    "Техника": "кондиционер, холодильник, стиральная машина, водонагреватель",
    "Способ продажи": "свободная",
    "Условия продажи": "возможна ипотека",
    "Тип дома": "панельный",
    "Год постройки": "2010",
    "Этажей в доме": "9",
    "Пассажирский лифт": "1",
    "В доме": "мусоропровод, газ",
    "Двор": "детская площадка, спортивная площадка"
  },
  "images": [
    "https://c80.img.avito.st/image/1/1._VmzF7a4UbCFoNO9xUCoFK-3U7YNttOmhbtTsgO-WboF.kzki2uZRpzfZh_-VZ_uFBPPVRDXcJj6ldOWrc965W0o",
    "https://60.img.avito.st/image/1/1.gbD3wra4LVnBda9U-Zzw_OtiL19JY69PwW4vW0drJVNB.fS5q-F8ggY9crwjUIepUJoywmep2Xo4yBe45GZT8zys"
  ],
  "imagesCount": 14,
  "hasVideo": false,
  "hasDelivery": false,
  "deliveryOnly": false,
  "deliveryText": null,
  "sellerType": "company",
  "isShop": true,
  "sellerName": "Данис Девелопмент",
  "sellerUrl": "https://www.avito.ru/brands/9b3d003c4ba56257a7cf3e9289984f94",
  "sellerClosedListings": 2717,
  "sellerBadges": ["Реквизиты проверены"],
  "sellerSince": null,
  "privateDataRedacted": false,
  "detailsFetched": true,
  "searchUrl": "https://www.avito.ru/krasnodar/kvartiry/prodam",
  "scrapedAt": "2026-10-20T14:46:21.217Z"
}
```

| Field | Meaning |
|---|---|
| `id` | Avito's listing number; stable between runs. |
| `price`, `currency`, `priceText` | Price in roubles as a number (`null` for "price on request"), `RUB`, and the text Avito shows (it can say "за месяц", "за сутки" ...). |
| `priceWithDiscounts` | A lower price Avito shows besides the asking price, which stays in `price`. Dealer offers (mostly new cars) show "от 4 069 000 ₽", the minimum with all dealer discounts (asking price 4 649 000). Listings in an Avito sale ("Хватамба") show a sale price on their own page, e.g. 35 625 instead of 37 500: it is filled in when details are read, as search cards do not show it. `null` otherwise. |
| `onSale` | `true` when the listing is in an Avito sale (the "Хватамба" badge on the card, or a sale price on the listing page); turn on details to get the sale price. |
| `pricePerM2` | Price per m² as Avito computes it; real estate only. |
| `location` | The city or town of the listing. Cards of listings sold with delivery show a delivery time instead of a place: `location` is then the searched city when the listing is in it, else `null` (filled in when details are read). |
| `address`, `fullAddress` | The short address of the search card and the full one; as precise as the seller published it. Some cards (phones, and listings sold with delivery) have no address: then `address` is `null`, or the full address when details are read. |
| `listedAt` | When the listing was published or last lifted to the top by its seller (Avito sorts "newest" by this time). |
| `paramsText` | The parameter line of vehicle cards, e.g. `363 945 км, 1.5 AMT (143 л.с.), внедорожник, передний, бензин`. |
| `rooms` ... `mileageKm` | Read from the title and the parameter line; `rooms` is `0` for a studio; `null` where the title does not say. |
| `parameters` | All parameters of the listing page, in Avito's Russian labels (only with details). |
| `sellerType` | `company` or `private` when known: always with the `sellerType` filter or details; without them, `company` when the card shows Avito's verified-company badge, otherwise `null`. |
| `sellerName`, `sellerUrl` | Given for Avito shops and for sellers whose card shows Avito's "Реквизиты проверены" (company details verified) badge. Everyone else, including accounts Avito marks as companies without either (these can be individual agents named like a person), only with `includePrivateSellerData`. |
| `privateDataRedacted` | `true` when a seller name was shown on Avito and left out under the rule above. |
| `hasDelivery`, `deliveryOnly`, `deliveryText` | `hasDelivery`: the listing can be bought with Avito Delivery (the card shows "Доставка от N дней" or "Только доставка"; with details, also the listing page's "Купить с доставкой"). `deliveryOnly`: the card carries Avito's "Только доставка" badge, which Avito shows on listings from far-away cities: for a buyer in the searched place they come by delivery only. So with `cityOnly` on it is practically always `false` (in run `osbc9302PbEKqfHQJ`, 37 of 50 Moscow phone listings had delivery and none the badge); it is `true` on the other cities' listings that `cityOnly` off lets through (20 of 30 in run `wnNevlgs4fDPOTeLy`). `deliveryText`: the delivery time as the card shows it, e.g. `Доставка от 1 дня`. For listing URLs in the input only `hasDelivery` is known. |
| `detailsFetched` | `true` when the listing's own page was read (and the details add-on charged). |

Fields Avito does not provide for a given listing are `null` (lists are empty), never missing. Text uses ordinary spaces where Avito uses non-breaking ones.

### Pricing

Pay per event. You pay for what is delivered, not for time, memory or proxies.

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Actor start (once per run) | $0.003 | $0.003 | $0.003 | $0.003 |
| Listing delivered | $0.0024 | $0.002 | $0.0018 | $0.0016 |
| Listing details (add-on, per listing whose page was read) | $0.0024 | $0.002 | $0.0018 | $0.0016 |

Worked example on Bronze: one search, 200 listings = 200 × $0.002 + $0.003 = **$0.403**. With details: + 200 × $0.002 = **$0.803**. A scheduled "only new" run that finds 5 new listings costs 5 × $0.002 + $0.003 = $0.013; a run that finds nothing new costs $0.003.

- A listing that appears twice in one run (on two pages, or in two of your searches) is delivered and charged once.
- The details add-on is charged only for listings whose page was actually read (`detailsFetched: true`).
- The maximum total charge you set for a run is respected: the actor stops before it would go over, keeps what was delivered, and says so (run `fBWm0wKRFwEhWnBDN`: limit $0.017 → exactly 7 listings, Succeeded).

### Reliability and failure behaviour

| What happened | Run status | Status message |
|---|---|---|
| Listings delivered | Succeeded | `Scraped 500 listings from 1 query` |
| Avito has no listings for your search | Succeeded | `0 results: avito.ru has no listings for this query` |
| A category Avito shows only as a landing page (services) with an explicit price sort | **Failed** | `No listings delivered: Avito shows this page as a category landing page that lists none of its … listings: add a keyword …` (with the default order the actor reads such a category newest first instead, see Limits) |
| A URL that is not an Avito search page | **Failed**, or ignored when other inputs work | `… this URL is not an Avito search page …` / `… a city page without a category; add one …` |
| Some searches worked, some failed | Succeeded | `Scraped 120 listings from 2 queries — 1 of 2 queries failed ("…": …)` |
| Nothing delivered because Avito refused every attempt | **Failed** | `No listings delivered: avito.ru blocked every attempt; try again later. No listings were charged (the start fee applies).` |
| Input the actor cannot use (other site, unknown region, bad category path) | **Failed**, within seconds | One sentence naming the problem and the fix, e.g. `Nothing to do: … Paste an avito.ru search URL into "startUrls", or set "searchQueries" and/or "category" with a "region". …` or `"Атлантида" is not a region Avito knows by that name: use a city such as "Москва" … No listings were charged (the start fee applies).` An unusable URL next to a usable keyword search is ignored and listed in the summary's `ignoredInputs`; when the region itself is unknown the run stops on that before the URLs are listed. |
| City search with listings from elsewhere (`cityOnly`) | Succeeded | `Scraped 30 listings from 1 query — 55 listings outside the city skipped on the pages read (cityOnly; not charged)` (the count covers every page read, including the rest of the last page after the maximum was reached) |
| Maximum charge reached | Succeeded | `… — stopped at the maximum charge set for this run` |
| Run timeout close | Succeeded | `… — stopped just before the run timeout; raise the timeout to get the rest` (with a note when Avito refused requests on the way) |

How it gets through: Avito shows new visitors an automatic security check ("Доступ ограничен: проверка безопасности"): a small computation that every browser opening the page performs on its own, without any user action. The actor performs the same computation. When Avito refuses an address outright (HTTP 403 / 429, or its "Подождите, идет загрузка" script page, which the actor does not run), the run continues on a fresh address through Apify Proxy, datacenter first and residential after repeated refusals; you need no proxy settings for this. Measured on 2026-10-20: all 16 test runs that should have delivered listings did (19 runs in all; the other 3 were a bad input, an empty search and a second "only new" run, which ended as they should); the 1,000-listing run `GNVXJ4OhdLcz4ATRZ` moved to the datacenter proxy once and finished in 172 s.

- Results are saved page by page. A run that is aborted or times out keeps what was delivered and never charges the same listing twice. With details, a timeout in the middle of a page still delivers (and charges) the listings whose pages were already read; the rest of that page is not delivered or charged.
- A run that the platform restarts (migration, resurrect) continues where it was and counts what it delivered before the restart against the maximum.
- Requests are retried on network errors, HTTP 429 and 5xx; page requests start at most once a second, and a run moves to a fresh proxy address every 10 pages once it uses the proxy.

### Limits

- Avito shows at most 100 pages per search (about 5,000 listings; cars 32 per page, so 3,200). Split bigger searches by price range or district; the summary says when a search was cut by this.
- Speed: about 500 listings in 45 s and 1,000 in 3 minutes without details (runs `OPinsy337YGXYpYP9`, `GNVXJ4OhdLcz4ATRZ`). With details each listing page is one more request, and Avito limits those per address, so expect roughly 20 to 35 listings per minute: 30 took 103 s (`C5BTLsWfmgnFus55w`), 60 took 172 s (`evhOMzU9Ux05wzDj0`), 100 took 382 s (`sUDrJklKNcnTS0NJC`).
- Without the seller-type filter or details, `sellerType` is `null` for sellers without Avito's verified-company badge: Avito's search cards do not say.
- Searches sorted newest first shift while you read them (new listings push older ones down a page); a listing met twice is delivered once.
- Avito answers keyword searches by moving to the matching category; the result is what Avito itself shows for that search (minus the listings outside the city with `cityOnly`).
- `cityOnly` reads more pages for the same number of listings when Avito mixes in many listings from elsewhere; after 2 pages in a row with no listing in the city it stops that search and says so.
- Services (`predlozheniya_uslug` and its sub-categories) are shown by Avito as a landing page without a list in its default order, and as an ordinary list newest first. Such a search is therefore read newest first (the summary says `sortedByDate`). With an explicit price sort it fails with advice, as Avito does not list it. A keyword (`searchQueries`) works in any order.
- Wholesale price ranges that some shops show on the listing page (`17 631 — 17 990`) are not returned; `price` is the single retail price.
- Avito's "newest first" order is close to, but not strictly, the order of `listedAt`, and for some categories it places dealer offers near the top.
- Russia only (avito.ru), Russian-language data as Avito publishes it.

### Monitoring: only new listings

1. Turn on **Only new listings** and save the input as a task.
2. Schedule the task (hourly or daily).
3. The first run delivers the newest listings up to the maximum. Every later run delivers and charges only listings it has not delivered before for the same search, and stops reading once a page is mostly known; a run with nothing new ends as Succeeded with `0 new listings…` and charges only the start event (runs `UX6KlR3cgWDixoQ69` → 20 new, `7gA6mbbcbghqO24K2` → 0 new).

A listing that its seller pays to lift back to the top is not delivered again. The memory is a key-value store named `avito-scraper-monitor` in your own account (one record per search and monitor name); delete it or change **Monitor name** to start over. Set the maximum above the number of new listings you expect between two runs. To be notified, add an integration (email, Slack, webhook) to the task.

### FAQ

**Do I need a proxy?** No. Leave the proxy off; the run moves to Apify Proxy by itself if Avito refuses its address, at no extra charge to you.

**Why is `sellerType` empty for some listings?** Avito's search cards do not say whether a seller is a person or a company. Use the **Seller type** filter (Avito's own) or turn on details.

**Why are there fewer listings than Avito's counter shows?** Avito lists at most 100 pages per search; split the search by price range or district. The summary gives Avito's count per search (`totalOnSite`).

**Can I get phone numbers?** No. Avito shows them only to logged-in users, and this actor never logs in.

**Can I run it from code?** Yes: the API, the Apify clients for JavaScript and Python, Make, Zapier, n8n. The Output tab shows the URLs.

**What happens when Avito changes its pages?** Runs fail loudly instead of returning empty data; report the run id under Issues.

### Legal and responsible use

This actor collects listing data that Avito shows publicly to any visitor without a login. Avito's user agreement restricts automated collection and re-use of its content; check it and your purpose before you build on the output. Do not re-publish listings or photos (they belong to their authors) and do not use the output to build a competing classifieds site.

Personal data: listings come from both companies and private persons. By default the actor leaves out private persons' names and profile links (`privateDataRedacted: true`), never returns phone numbers or names of company employees, and returns descriptions as the seller wrote them (a seller may have typed contact details into the text). Turn on `includePrivateSellerData` only if you have a lawful basis to process personal data of private individuals (for example under Russia's Federal Law 152-FZ "On Personal Data" or the GDPR) and use it accordingly. Do not use the output for unsolicited marketing to individuals.

You are responsible for complying with the laws that apply to you and to the data. If you are unsure, ask a lawyer.

### Related actors

- [Yandex Maps Scraper](https://apify.com/amitaviv/yandex-maps-scraper): businesses and places in Russia from Yandex Maps.

### Changelog

- 2026-10-24 0.1.19: `hasDelivery` works (it was always `false`): it is read from the card's "Доставка от N дней" block and "Только доставка" badge, and from the listing page's delivery button with details; new fields `deliveryOnly` and `deliveryText`. `cityOnly` now really keeps a city search to the city: listings Avito shows from other cities (delivery listings, and other towns in keyword searches) are skipped, not charged, and counted in the status message; it stops reading after 2 pages with nothing in the city. Delivery listings in the searched city get the city as `location`.
- 2026-10-24 0.1.16: services categories are read (newest first) instead of returning "0 results"; a city start page (`avito.ru/moskva`) or another non-search page is reported as unusable input instead of as a block; with details, a timeout no longer discards the listing pages already read; `onSale` and the sale price in `priceWithDiscounts`; seller names only for shops and verified companies; `address` is `null` rather than empty; descriptions use plain spaces; a whole Avito URL in `region` / `category` is understood; a restarted run keeps to the maximum; a timeout message no longer says "try again later" when a longer timeout is the cure.
- 2026-10-24 0.1.13: `cityOnly` (on by default: a city search no longer includes towns up to 200 km away for cars); dealer offers report the price without discounts in `price` and the discounted one in `priceWithDiscounts`.
- 2026-10-20 0.1: first version.

### Support

Open an issue on the actor's **Issues** tab with the run id.

# Actor input Schema

## `startUrls` (type: `array`):

Avito.ru pages copied from the browser's address bar. A search or category page, e.g. https://www.avito.ru/moskva/kvartiry/prodam?pmax=15000000 (every filter you set on the site is kept), returns its listings page by page. A listing page (…\_1234567890) returns that one listing with its full details. m.avito.ru and URLs without https:// are accepted. A city's start page (avito.ru/moskva) needs a category added (avito.ru/moskva/kvartiry); seller profiles and Avito's service pages are not searches and are ignored with a reason. Default: empty. Leave empty to build the search from the fields below; both can be used in one run.

## `searchQueries` (type: `array`):

Words to search for, as typed in Avito's search box, e.g. "iphone 15" or "велосипед". Each keyword is one search in the region (and category) below. Default: empty. Leave empty and set a category to read a whole category.

## `region` (type: `string`):

Where to search: a large city or region by name ("Москва", "Санкт-Петербург", "Екатеринбург", "Московская область"; about 50 names are known), "Россия" for the whole country, or the slug Avito uses in its URLs (avito.ru/<slug>/…, e.g. "kazan", "nizhniy_novgorod"). A whole Avito URL is accepted too. Used with searchQueries or category. Default: Россия (whole country).

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

Avito category path: the part of an Avito URL after the city, e.g. "kvartiry/prodam" (flats for sale), "kvartiry/sdam/na_dlitelnyy_srok" (long-term rentals), "avtomobili" (cars), "telefony" (phones), "noutbuki" (laptops), "predlozheniya_uslug" (services; Avito lists services only newest first, so they are read in that order). A whole Avito URL is accepted: its city is used when "region" is empty. Default: empty (all categories; a keyword search then lets Avito pick the category).

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

Only listings priced at or above this, in roubles. Applies to searches built from searchQueries / category (a pasted URL keeps its own filters). Default: no minimum.

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

Only listings priced at or below this, in roubles. Applies to searches built from searchQueries / category. Default: no maximum.

## `cityOnly` (type: `boolean`):

On (default): for a search built from a city in "region", the actor asks Avito not to widen it and then leaves out every listing located outside the city that Avito still shows (listings from other cities sold with delivery, and other towns in keyword searches). Parts of the city that Avito lists under it (Peterhof, Zelenograd) count as the city. Left-out listings are not delivered or charged, and the status message gives their number. Off: everything Avito shows, as on the website; for cars and some other categories that includes towns up to about 200 km around the city. Not applied to regions such as "Московская область" or "Россия"; pasted search URLs are returned as Avito shows them.

## `sellerType` (type: `string`):

Uses Avito's own seller filter, so every listing of a filtered search carries a definite sellerType. With "All sellers" a card shows a seller as a company only when it carries Avito's verified-company badge (otherwise sellerType is null); includeDetails reads the exact type from each listing page. Also applied to pasted search URLs that have no seller filter of their own. Default: all.

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

Order in which Avito lists the results (and so which listings a maximum keeps). A pasted URL keeps its own order unless it has none. "Only new" mode always reads newest first. Default: Avito's default.

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

Stop each search after this many listings. Avito shows at most 100 pages per search (about 5,000 listings; 3,200 for cars): split bigger searches by price range or district. Default: 50.

## `includeDetails` (type: `boolean`):

Off (default): one record per search card, which already has title, price, address, coordinates, date, description, photos and the parameter line. On: also open each listing's page and add all its parameters (rooms, areas, floor, house, mileage, engine, condition …), all photos, the exact seller type, a sale price where Avito shows one, and for Avito shops the shop name and since-when. Charged as an extra event per listing whose page was read; slower.

## `onlyNew` (type: `boolean`):

Off (default): every run delivers the listings it finds. On: return and charge only listings that earlier runs of this actor in your account have not delivered for the same search, for scheduled monitoring of new ads. Searches are then read newest first and stop at the first page that is mostly known. A listing its seller paid to lift back to the top is not delivered again. The memory is a key-value store named avito-scraper-monitor in your account; delete it to start over. The first run delivers the newest listings up to the maximum.

## `monitorKey` (type: `string`):

Only with onlyNew. A free name for the monitor memory, e.g. moscow-flats-hourly. Runs with the same search and the same monitor name share one memory; give two schedules different names to keep their memories apart. Default: empty.

## `includePrivateSellerData` (type: `boolean`):

Off (default): a seller's name and profile link are given only for Avito shops and for sellers with Avito's verified-company badge ("Реквизиты проверены"); for everyone else, including accounts Avito marks as companies without either (these can be individual agents), they are left empty (privateDataRedacted: true). On: those names and profile links are included too. Turn this on only if you have a lawful basis to process personal data of private individuals (e.g. under Russia's Federal Law 152-FZ or the GDPR) and will use it accordingly. Phone numbers are never collected: Avito shows them only to logged-in users.

## `proxyConfiguration` (type: `object`):

Default and recommended: no proxy. The actor passes Avito's automatic security check itself; if Avito still refuses the run's address, the run switches by itself to Apify Proxy (datacenter, then residential). Set a proxy here only to force one, e.g. residential with country RU.

## Actor input object example

```json
{
  "startUrls": [],
  "region": "moskva",
  "category": "kvartiry/prodam",
  "cityOnly": true,
  "sellerType": "all",
  "sort": "default",
  "maxItems": 10,
  "includeDetails": false,
  "onlyNew": false,
  "includePrivateSellerData": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All delivered listings as JSON, one object per listing. Main fields: id, url, title, price (RUB, the asking price), currency, priceWithDiscounts (dealer-discount or sale price, else null), priceText, pricePerM2, priceWasLowered, onSale, category, categorySlug, categoryId, location, address, fullAddress, latitude, longitude, nearby (metro and landmarks with distance), listedAt, description, paramsText, rooms, areaM2, floor, floorsTotal, year, mileageKm, parameters (with includeDetails), images, imagesCount, hasVideo, hasDelivery (can be bought with Avito Delivery), deliveryOnly ("Только доставка"), deliveryText (e.g. "Доставка от 1 дня"), sellerType (private, company or null), isShop, sellerName and sellerUrl (Avito shops and verified companies; others only with includePrivateSellerData), sellerClosedListings, sellerBadges, sellerSince, privateDataRedacted, detailsFetched, searchUrl, scrapedAt. A value the source does not give is null.

## `resultsCsv` (type: `string`):

All delivered listings as a CSV file, one row per listing, with the same fields as the JSON output.

## `summary` (type: `string`):

JSON record OUTPUT_SUMMARY: what was requested, delivered and charged; per search the number of listings Avito reports and how the search ended; which inputs failed or were ignored and why; warnings; whether a proxy was used; why the run stopped.

# 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 = {
    "startUrls": [],
    "region": "moskva",
    "category": "kvartiry/prodam",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("amitaviv/avito-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 = {
    "startUrls": [],
    "region": "moskva",
    "category": "kvartiry/prodam",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("amitaviv/avito-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 '{
  "startUrls": [],
  "region": "moskva",
  "category": "kvartiry/prodam",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call amitaviv/avito-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,amitaviv/avito-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/XN3MF2ifgjfsvuacD/builds/feapmezcfZ4afin0x/openapi.json