# Avito Listings Scraper API (`dami_studio/avito-listings-scraper`) Actor

Scrape Avito.ru classified ads by search term, category, city, or a pasted Avito URL. Each row: listing id, title, price, category, city, address, coordinates, seller name and type, publish date, photos and link. $0.30 per 1,000 listings - the lowest per-listing price of any Avito scraper on Apify.

- **URL**: https://apify.com/dami\_studio/avito-listings-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Listings Scraper API

Scrape classified listings from **Avito.ru**, Russia's largest classifieds site. Give it a search
term, a category, a city, or just paste an Avito search URL, and it returns structured rows: listing
id, title, description, price, category, city and street address, coordinates, seller name and
seller type, publish date, every photo URL, and the listing link.

**$0.30 per 1,000 listings.** That is the lowest per-listing price of any Avito scraper on the Apify
Store — checked against all 29 of them, at their cheapest tier, not just their headline price. The
next cheapest is $0.40/1,000 and it also charges $0.10 to start every run. The widely-used ones are
$3.00–$4.99 per 1,000.

### What you get

One row per listing:

| field | example |
|---|---|
| `listingId` | `8016198496` |
| `title` | `Land Rover Range Rover 4.4 AT, 2026` |
| `description` | first ~250 characters of the seller's text |
| `price` / `priceText` | `38250000` / `38 250 000 ₽` |
| `currency` | `RUB` |
| `priceWithoutDiscount`, `discountPercent` | set when Avito shows a markdown |
| `categoryId` / `categoryName` / `categorySlug` | `9` / `Автомобили` / `avtomobili` |
| `microCategoryId` | `23887` |
| `locationId` / `location` | `637640` / `Москва` |
| `address` / `addressLocality` | `Москва, Крылатское` / `Москва` |
| `latitude` / `longitude` | `55.765888` / `37.403989` |
| `sellerName` | `А1 АВТО` |
| `sellerType` | `private` or `company` |
| `sellerTypeText` | Avito's own words: `Автодилер`, `Компания`, `Агентство` |
| `sellerUrl` | `https://www.avito.ru/brands/a1auto` |
| `sellerRating`, `sellerReviewsText` | `4.5`, `60 отзывов` — when Avito shows them |
| `publishedAt` | `2026-07-31T10:49:16.000Z` |
| `images` / `imageCount` | array of full-size photo URLs / `21` |
| `isNew`, `isVerified`, `isReserved`, `hasVideo` | booleans |
| `params` | `4.4 AT (615 л.с.), внедорожник, полный, бензин` |
| `url` | link to the listing |

Not every field is set on every listing, because Avito does not show every field on every ad.
Measured on the runs below: `publishedAt`, `images` and `url` were present on 100% of rows;
`latitude`/`longitude` on 100% of property rows but 57% of phone rows; `sellerName` on 41% of
property rows, because Avito shows no name for most private sellers. Missing values are `null`,
never invented.

### Input

Fill in the form, or paste URLs — both end up in the same place.

```json
{
  "query": "iphone 15",
  "region": ["Moscow"],
  "category": ["phones"],
  "maxItems": 500,
  "sort": "newest",
  "sellerType": "private",
  "minPrice": 20000,
  "maxPrice": 60000
}
```

```json
{
  "searchUrls": ["https://www.avito.ru/sankt-peterburg/kvartiry/sdam?pmin=30000&pmax=60000"],
  "maxItems": 120
}
```

`region` and `category` accept English names (`Moscow`, `Saint Petersburg`, `cars`, `flats`,
`jobs`), Russian names (`Москва`, `автомобили`), or the raw slug out of any Avito URL
(`moskva`, `kvartiry/prodam`). Anything not in the built-in alias table is passed through as a slug,
so every one of Avito's thousands of sub-categories works.

Run it with **empty input** and you get one clearly-labelled sample row, free. Nothing is charged
until you ask for a real search.

### Real numbers from real runs

Measured on the Apify platform, 2026-08-09:

| run | listings | wall time | platform cost |
|---|---|---|---|
| empty input (sample) | 0 charged | 2.2 s | $0.00018 |
| `iphone 15`, Moscow | 5 | 5.7 s | $0.00040 |
| flats to rent, St Petersburg, from a pasted URL | 120 | 16.2 s | $0.00158 |
| cars, Moscow | 250 | 26.6 s | $0.00284 |
| cars, Moscow | 1000 | 90.7 s | $0.01033 |

About **11 listings per second**. Every run above returned exactly the number of rows requested,
with zero pages refused.

### Two things about Avito worth knowing before you run it

**1. A region is a suggestion, not a filter.** Search Moscow and read page 1 and you get Moscow.
Read page 50 of the same search and most of it is Kaluga, Tver, Smolensk and Bryansk — Avito pads a
region search with neighbouring ones and does not tell you. This actor sends Avito's own
`localPriority` flag so you only get the region you asked for. It is on by default; the
**Stay inside the chosen region** checkbox turns it off if you want Avito's mixed behaviour.

**2. Any single search stops at 5,000 listings.** Avito's pager always ends at page 100 and 50
listings a page, no matter that it reports 81,801 matches. Ask for page 101 and it answers HTTP 200
with a redirect back to page 1 — which is how a naive scraper ends up billing you for the same first
50 rows over and over. This one detects that and stops. To go past 5,000, split the search: by city,
by price band (`minPrice`/`maxPrice`), or into sub-categories.

### What this does not do

- **No phone numbers.** Avito hides seller phone numbers behind a logged-in click. They are not in
  the search results and this actor does not try to get them.
- **No full ad text.** The description is the preview Avito puts in search results, roughly the
  first 250 characters. Opening each ad for the complete text would be a separate request per
  listing and would cost you many times more.
- **Seller type comes from Avito's own labelling.** Avito prints a business line ("Компания",
  "Автодилер", "Агентство") on business accounts and nothing on private ones, and that is what
  `sellerType` reflects. It is also why the actor re-checks every row when you filter by seller
  type — Avito silently ignores its own `user=` parameter in some categories, notably cars, so
  rows that do not match are dropped and never charged.
- **No listing history, no price history, no sold-date.**
- **Not a seller-profile scraper.** You get the seller's name and profile URL, not their full
  catalogue.

### Reliability

Avito sits behind Qrator and rate-limits by IP address. The actor handles this itself: it retries,
and falls back from the plain Apify container address to rotating Apify datacentre sessions when an
address has been throttled. Not one page was refused across the 29 pages the runs above read. If a run
does get refused, it writes uncharged diagnostic rows explaining what happened rather than returning
an empty dataset silently — and it stops early instead of spending your money retrying.

You can supply your own proxy in `proxyConfiguration` if you have Russian exit addresses, but you do
not need one.

### Pricing

| event | price |
|---|---|
| Actor start | $0.0025 per run |
| Listing scraped | $0.0003 each — **$0.30 per 1,000** |

Sample rows, diagnostic rows, duplicates and rows dropped by the seller-type filter are **not
charged**. A 1,000-listing run costs $0.3025.

### FAQ

**How do I scrape Avito.ru?**
Run this actor with a search term, a category, or a pasted Avito search URL. It reads Avito's own
server-rendered search results and returns structured JSON, CSV or Excel. No account, no API key and
no proxy of your own is needed.

**Is there an official Avito API?**
Yes, but not for this. `api.avito.ru` is an OAuth API for sellers and advertisers to manage their
own ads and read their own stats. It does not let you search the public catalogue. This actor reads
the public site instead.

**How many Avito listings can I get in one run?**
Up to 5,000 per individual search, which is Avito's own pagination ceiling, and up to 50,000 per run
across several searches. Add regions, categories or price bands to widen it: ten cities is ten
searches and up to 50,000 listings.

**Can I filter by price, city or seller type?**
Yes — `minPrice`, `maxPrice`, `region` and `sellerType`. Price and region are applied by Avito;
seller type is applied by Avito where it works and re-checked here where it does not.

**Can I get sellers' phone numbers?**
No. Avito requires a logged-in session and a click to reveal a phone number. This actor does not log
in and does not collect phone numbers.

**Does it work for cars, flats and jobs, or only goods?**
All of them. `avtomobili`, `kvartiry`, `vakansii`, `nedvizhimost`, `rabota` and every other Avito
category work, because the actor uses Avito's own URL structure. Cars and property listings also
come back with coordinates.

**What does it cost to scrape 10,000 Avito listings?**
$3.00 in listing charges plus $0.0025 for the run — $3.0025 total.

**How current is the data?**
Live. Every run reads Avito at that moment; `publishedAt` is the listing's own timestamp and
`scrapedAt` is when the row was read.

**What if Avito blocks the run?**
You get uncharged diagnostic rows saying which pages were refused, not an empty dataset. Re-running
usually lands on a different address and works. You are never charged for a listing you did not get.

# Actor input Schema

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

What to search for, in Russian — for example "iphone 15", "диван", "велосипед". Leave empty to browse a whole category.

## `region` (type: `array`):

Avito region, by English name ("Moscow", "Saint Petersburg", "Kazan"), Russian name ("Москва"), or the slug from an Avito URL ("moskva", "sankt-peterburg", "moskovskaya\_oblast"). Leave empty for the whole of Russia. Add several to run one search per region.

## `category` (type: `array`):

Avito category by English name ("cars", "phones", "flats", "jobs", "furniture"), Russian name ("автомобили"), or the slug from an Avito URL ("avtomobili", "kvartiry/prodam"). Leave empty to search every category.

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

Optional. Paste Avito search or category URLs instead of filling in the fields above, e.g. https://www.avito.ru/moskva/avtomobili?cd=1\&pmin=500000. The region, category, search text, price range, seller type and sort order in the URL are all read.

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

How many listings to return in total across all searches. Each returned listing is one charged result. Avito caps any single search at 5,000 listings (100 pages of 50) — add regions, price bands or sub-categories to go past that.

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

Avito's own ordering. "Default" is its relevance ranking, which puts promoted listings first.

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

Return only private sellers or only businesses (shops, dealers, agencies). Avito ignores its own seller filter in some categories, so the actor also checks every row and drops the ones that do not match — dropped rows are never charged.

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

Optional lower price bound, in roubles.

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

Optional upper price bound, in roubles.

## `localOnly` (type: `boolean`):

On by default. Avito treats a region as a relevance boost rather than a filter: on page 50 of a Moscow search, most listings are actually from Kaluga, Tver and Smolensk. This sends Avito's own localPriority flag so only the chosen region comes back. Turn it off to get Avito's default mixed results.

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

Optional. The actor works without a proxy — it uses the Apify container address and falls back to Apify datacentre sessions on its own. Supply your own proxy URLs here only if you have Russian addresses you would rather use.

## Actor input object example

```json
{
  "query": "iphone 15",
  "region": [],
  "category": [],
  "searchUrls": [],
  "maxItems": 100,
  "sort": "default",
  "sellerType": "any",
  "localOnly": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "query": "iphone 15",
    "region": [],
    "category": [],
    "searchUrls": [],
    "maxItems": 100,
    "sort": "default",
    "sellerType": "any",
    "localOnly": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/avito-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 = {
    "query": "iphone 15",
    "region": [],
    "category": [],
    "searchUrls": [],
    "maxItems": 100,
    "sort": "default",
    "sellerType": "any",
    "localOnly": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/avito-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 '{
  "query": "iphone 15",
  "region": [],
  "category": [],
  "searchUrls": [],
  "maxItems": 100,
  "sort": "default",
  "sellerType": "any",
  "localOnly": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dami_studio/avito-listings-scraper --silent --output-dataset

```

## MCP server setup

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