# Avito Scraper - Listings, Prices, Sellers, Russia (`s-r/avito-scraper`) Actor

Scrape Avito listings by search term, category, city or URL and get title, price in roubles, seller type, location, coordinates and photos as clean rows. Covers classifieds and rentals across the whole of Russia.

- **URL**: https://apify.com/s-r/avito-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.50 / 1,000 avito listings

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/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 - listings, prices and sellers from Russia's biggest classifieds site

Scrape Avito listings by search term, category, city or URL and get the title,
the asking price in roubles, the seller type, the location with coordinates and
the full photo set as clean rows. This Avito scraper reads the same result pages
a shopper sees, so an Avito price tracker built on it sees what buyers see rather
than what an API decides to publish.

### What you get

- Up to 50 listings per search page, paged automatically until your row limit
- Listing id, title and canonical URL with Avito's tracking query stripped off
- Asking price as a number in roubles plus the price exactly as printed, the
  struck-through price and the discount percentage when a seller is cutting
- City or region, the finer address line Avito prints, and latitude and
  longitude for every advert that carries them
- Private-seller versus business flag, verified flag and reserved flag
- Every photo at the widest size Avito serves, plus the photo count
- Category name and category slug, so a result row feeds straight back in as the
  input of a narrower run
- On rows read from a listing URL: the full advert text, the seller name,
  availability, new-or-used condition and the category breadcrumb path
- A run summary that separates "this search found nothing" from "the site did
  not serve us", because in a dataset those two look identical and mean
  completely different things

### Why scrape Avito

Avito is the default second-hand and small-business marketplace in Russia, and
for most categories it is the only price signal that exists at scale. There is
no public Avito API for listing data. The official developer programme is aimed
at sellers managing their own adverts, not at anyone who wants to see the market,
so pricing research, competitor monitoring and supply tracking all come down to
reading the site.

That matters more on classifieds than on a retail catalogue. A retailer publishes
one price per product. Avito publishes a distribution: the same phone model is
listed forty times at forty prices, by private sellers and by shops, in cities
with very different price levels. The useful number is not any single advert, it
is the spread and how it moves, and you only get that by collecting the whole
result page and paging through it.

The rental side works the same way. Avito carries a very large share of Russian
long-term and short-term rental supply, and category and city slugs let you pull
one neighbourhood's flats the same way you would pull one model of phone. Because
every row carries coordinates when the advert has them, rental and vehicle data
map directly without a geocoding step.

### Input

| Field | Type | Required | What it does |
|---|---|---|---|
| `query` | string | yes | What to search for, Russian or Latin script |
| `location` | string | no | City or region slug from an Avito URL, `all` for the whole country |
| `category` | string | no | Category slug, for example `telefony`, `kvartiry`, `avtomobili` |
| `searchUrls` | array | no | Full Avito search URLs, used instead of the fields above |
| `listingUrls` | array | no | Individual advert URLs to read one at a time |
| `priceMin` | integer | no | Lowest price in roubles |
| `priceMax` | integer | no | Highest price in roubles |
| `sort` | select | no | Relevance, newest first, cheapest first, most expensive first |
| `sellerType` | select | no | Any seller, private only, or companies only |
| `onlyWithPhoto` | boolean | no | Skip adverts with no photograph |
| `maxItems` | integer | no | Stop after this many listings, default 50 |

The slugs are the ones in Avito's own URLs. If a browser shows you
`avito.ru/moskva/telefony`, then `moskva` is the location and `telefony` is the
category. If you would rather not think about slugs at all, paste the whole
search URL into `searchUrls` and every filter you set in the browser is kept.

### Output

```json
{
  "id": "8143951259",
  "title": "iPhone 17, 256 ГБ, SIM + eSIM",
  "url": "https://www.avito.ru/saratov/telefony/iphone_17_256_gb_sim_esim_8143951259",
  "price": 83490,
  "price_text": "83 490 ₽",
  "price_without_discount": null,
  "discount_percent": null,
  "currency": "RUB",
  "category": "Телефоны",
  "category_slug": "telefony",
  "region": "Саратов",
  "address": "Саратов",
  "latitude": "51.528497",
  "longitude": "46.037371",
  "is_company": null,
  "is_verified": true,
  "is_reserved": null,
  "images": ["https://00.img.avito.st/image/1/..."],
  "image_count": 5,
  "attributes": [],
  "listed_at_ms": 1789240600000,
  "found": true,
  "blocked": false
}
```

Rows read from `listingUrls` carry `description`, `seller`, `availability`,
`condition` and `breadcrumbs` on top of the fields above.

### Use cases

**Price research before you buy or list.** If you are pricing stock to sell on
Avito, the question is never "what is this worth" but "what is the tenth-cheapest
comparable advert asking today". Pull one category in one city sorted by price,
take the distribution, and you have a listing price that will actually move.
Run it weekly and you have the trend, which is the part a single lookup on the
site can never give you.

**Competitor and dealer monitoring.** The seller-type filter splits genuine
second-hand supply from business inventory in one input. Electronics resellers,
car dealers and furniture shops all list on Avito under business accounts, so
restricting a category to companies gives you a clean view of who is stocking
what, at what price, in which cities, without the noise of private adverts.

**Rental and property tracking.** Property analysts use Avito the way their
western counterparts use portals that publish an API. Category and city slugs
narrow a run to one neighbourhood, newest-first sorting turns it into a feed of
new supply, and the coordinates on each row drop straight onto a map. Because
listings disappear when they let, tracking the same search over time also tells
you how fast stock is moving.

**Sourcing and arbitrage.** Regional price gaps on Avito are real and large. The
same item is routinely cheaper several time zones away from Moscow. Running one
query across several city slugs and comparing the medians is a spread report you
can act on, and the rows carry everything you need to contact the seller.

### How it compares

| | This actor | `zen-studio/avito-listings-scraper` | `abotapi/avito-ru-scraper` |
|---|---|---|---|
| Price per listing | $0.0035 | $0.00499 | $0.002 plus $0.10 per run |
| Cost of a 200-row run | $0.70 | $1.00 | $0.50 |
| Cost of a 20-row run | $0.07 | $0.10 | $0.14 |
| Coordinates on every row | yes | not published | not published |
| Says when it was refused | yes | no | no |
| Listing URLs as input | yes | yes | yes |

`abotapi` is cheaper per row and dearer per run, which flips the ranking below
about seventy rows: their run fee costs more than the entire result set on a
small job. `zen-studio` has the larger installed base and a separate seller
profile actor that this one does not try to replace. What neither of them
publishes is the thing this actor treats as a headline field: whether a run that
returned nothing returned nothing because the search was empty.

### Pricing

Billing is pay-per-event at $0.0035 per listing delivered. A refused read costs
nothing: if the site does not serve us, you get a row saying so and no charge for
it. All pricing is pay-per-event — you only pay for results you receive. No
actor-start fee, no per-compute-unit charges.

### Limits and gotchas

- Avito serves Russia. Prices are in roubles and there is no other currency.
- One search page holds 50 listings. A `maxItems` of 500 is ten pages, and each
  page is a separate request, so a large run takes minutes rather than seconds.
- Avito's result ordering is not stable between requests. Two runs of the same
  search minutes apart can return the same listings in a different order, and a
  small number of adverts may appear on the boundary between two pages. Rows are
  de-duplicated by listing id within a run.
- `priceMin`, `priceMax`, `sort`, `sellerType` and `onlyWithPhoto` apply to the
  search-term path. If you paste a URL into `searchUrls`, whatever is in that URL
  wins, which is the point of pasting it.
- Advert text, seller name and condition are only on the listing page, so they
  appear on rows produced from `listingUrls`, not on search rows.
- Some adverts name no price at all. Those rows arrive with `price` empty rather
  than zero, so that a missing price is never mistaken for a free item.
- The site refuses some requests. The actor retries, and if every attempt is
  refused you get a row with `blocked` set and the run summary says
  `siteRefusedUs`. Treat that as "come back later", not as "no such listings".
- Avito decides who it serves by client, and it changes its mind: the set of
  accepted clients moved twice inside one hour on 16 September 2026. The actor
  therefore tries several and the run summary records which one worked, under
  `servedBy`, alongside `refusedBy` and `anyIdentityServed`. If
  `anyIdentityServed` is false, nothing the actor knows about was accepted on
  that run, which is a different problem from an empty search and is worth
  reporting rather than re-running.

### FAQ

**Can I scrape Avito without an API key?**
Yes. There is no public Avito API for listing data, and this actor needs no key,
no account and no cookies from you. You give it a search and it returns rows.

**How do I get Avito listings for a specific city?**
Put the city slug from an Avito URL into `location`, for example `moskva`,
`sankt-peterburg` or `novosibirsk`. Use `all` to search the whole country, which
is the default.

**Can I scrape Avito rental and property listings?**
Yes. Use the property category slug, for example `kvartiry`, together with a city
slug. Every row carries coordinates when the advert has them, so rental data maps
without a separate geocoding step.

**How do I filter Avito results by price?**
Set `priceMin` and `priceMax` in roubles. They are applied by Avito itself as
part of the search rather than after the fact, so paging stays efficient.

**Why did my Avito run return no listings?**
Check the run summary. `emptySearch` true means the search genuinely matched
nothing, usually a typo in a slug. `siteRefusedUs` true means the site did not
serve the result set on that run and the same search is worth re-running.

### Related Actors

- [Kaufland Scraper](https://apify.com/s-r/kaufland-scraper)
- [eBay Scraper](https://apify.com/s-r/ebay-scraper)
- [Naver Map Scraper](https://apify.com/s-r/naver-map-scraper)

# Actor input Schema

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

What to search for on Avito, in Russian or in Latin letters. Combined with the city and category below into one search. Leave empty if you are pasting your own search URLs instead.

## `location` (type: `string`):

The city or region slug exactly as it appears in an Avito URL, for example 'moskva', 'sankt-peterburg' or 'kaliningrad'. Use 'all' to search the whole of Russia.

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

The category slug from an Avito URL, for example 'telefony' for phones, 'kvartiry' for flats or 'avtomobili' for cars. Leave empty to search every category.

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

Full Avito search or category URLs to read, pasted straight from the browser. Anything here is used instead of the search term, city and category above, so your own filters are kept exactly as you set them.

## `listingUrls` (type: `array`):

Individual Avito listing URLs to read one by one. Use this when you already know which adverts you want rather than searching for them.

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

Lowest price to include, in roubles. Applies to the search term path, not to search URLs you paste yourself.

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

Highest price to include, in roubles. Applies to the search term path, not to search URLs you paste yourself.

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

How Avito should order the results before we read them. Newest first is the one to use for monitoring a category over time.

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

Restrict the search to private adverts or to business adverts. Useful for separating genuine second-hand supply from dealer inventory.

## `onlyWithPhoto` (type: `boolean`):

Skip adverts that carry no photograph. Photoless adverts on classifieds sites are disproportionately stale or placeholder listings.

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

Stop after this many listings. Avito returns 50 per page, so 200 is four pages. Free-plan runs are capped at 10 rows regardless of this number.

## Actor input object example

```json
{
  "query": "iphone 15",
  "location": "moskva",
  "category": "telefony",
  "searchUrls": [
    "https://www.avito.ru/moskva/telefony?q=iphone+15"
  ],
  "listingUrls": [
    "https://www.avito.ru/moskva/telefony/iphone_15_128_gb_4171861963"
  ],
  "sort": "relevance",
  "sellerType": "any",
  "onlyWithPhoto": false,
  "maxItems": 50
}
```

# Actor output Schema

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

One row per listing.

## `output` (type: `string`):

Counts, whether the search was genuinely empty or we were refused, and whether a proxy was configured.

## `errors` (type: `string`):

Refused reads and input problems.

# 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",
    "location": "all",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "query": "iphone",
    "location": "all",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "query": "iphone",
  "location": "all",
  "maxItems": 50
}' |
apify call s-r/avito-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/8dHI2sD0absTwREAp/builds/xgkQM28RRLBbNNTe7/openapi.json