# Avito API (`automation-lab/avito-russia-classified-listings`) Actor

Extract public Avito classified listing IDs, titles, ruble prices, attributes, seller context, locations, images, availability, and canonical URLs for inventory and price monitoring.

- **URL**: https://apify.com/automation-lab/avito-russia-classified-listings.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 78.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.92 / 1,000 item extracteds

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?

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 API

Extract public Avito classified listings for recurring inventory and price monitoring.
This Actor turns Avito category, location, and search result URLs into normalized dataset rows with listing identity, ruble price, seller context, location, images, availability, and canonical URLs.
It provides an **Avito API** workflow without requiring an Avito account or browser cookies.

### What does Avito API extract?

The Actor reads public result pages on `www.avito.ru`.
It supports:

- location pages such as Moscow listings;
- category pages such as phones or laptops;
- keyword search result URLs;
- multiple start URLs in one run;
- result pagination;
- stable-ID deduplication across URLs and pages;
- typed JSON, CSV, Excel, XML, and RSS exports through Apify datasets.

It does not open individual listing detail pages.
It does not reveal phone numbers, messages, or private account data.

### Who is it for?

#### Price intelligence teams

Collect comparable asking prices from a repeatable source URL.
Load successive datasets into a warehouse and compare prices by `listingId`.

#### Marketplace and retail analysts

Measure visible inventory by category, location, seller type, and price band.
Use canonical URLs to review unusual records manually.

#### Resellers and sourcing teams

Export current public listings from narrowly targeted category or search pages.
Use scheduled runs to identify additions and removals in downstream systems.

#### Data engineers

Replace fragile copy-and-paste workflows with a stable dataset contract and API-triggered runs.
Connect results to Google Sheets, webhooks, cloud storage, or an ETL pipeline.

### Why use this Actor?

- **Search URL support:** supply the public Avito URL that defines the scope.
- **Normalized records:** use consistent field names instead of parsing page markup.
- **Stable identity:** deduplicate and compare rows using `listingId`.
- **Bounded pagination:** control both page count and total saved records.
- **Seller context:** capture the public seller name, rating, review summary, and business signal when exposed.
- **Image coverage:** receive the largest visible image variant for each result image.
- **Safe public scope:** no login, contact reveal, CAPTCHA-solving service, or private messages.

### Input parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `startUrls` | array | Yes | Moscow phones | Public Avito category, location, or search result URLs |
| `maxItems` | integer | No | `50` | Maximum unique listings saved across all URLs; range 1–1,000 |
| `maxPages` | integer | No | `5` | Maximum result pages requested per URL; range 1–20 |

Only HTTPS URLs on `avito.ru` are accepted.
Listing detail URLs are rejected because this Actor is designed for result-list monitoring.

### Getting started

1. Open an Avito category, location, or search results page.
2. Copy the complete URL from the browser.
3. Add it to **Avito search and category URLs**.
4. Choose a small `maxItems` value for the first run.
5. Run the Actor.
6. Open the default dataset to inspect the normalized listings.
7. Export the dataset or connect it to your destination.

A small category example:

```json
{
  "startUrls": [
    { "url": "https://www.avito.ru/moskva/telefony" }
  ],
  "maxItems": 10,
  "maxPages": 1
}
```

A keyword search example:

```json
{
  "startUrls": [
    { "url": "https://www.avito.ru/moskva/telefony?q=iphone" }
  ],
  "maxItems": 25,
  "maxPages": 1
}
```

### Output fields

| Field | Meaning |
| --- | --- |
| `listingId` | Stable numeric Avito listing ID represented as a string |
| `title` | Public listing title |
| `description` | Description excerpt exposed in results |
| `price` | Numeric asking price in rubles |
| `priceText` | Price exactly as Avito displays it |
| `currency` | `RUB` |
| `category`, `categoryId` | Public category name and ID |
| `location`, `address` | Public result-card location text when exposed |
| `attributes` | Visible structured result attributes |
| `availability` | `active` because the row appeared in current results |
| `sellerName` | Public seller or shop name when exposed |
| `sellerType` | `business` or `private` inferred from public result signals |
| `sellerRating` | Public rating score when exposed |
| `sellerReviewSummary` | Public review summary when exposed |
| `sellerUrl` | Public seller or brand URL when exposed |
| `imageUrl` | Largest primary result image |
| `imageUrls` | Largest available URL for each result image |
| `imageCount` | Image count reported by Avito |
| `publishedAt` | Result sort timestamp converted to ISO 8601 when exposed |
| `canonicalUrl` | Absolute listing URL |
| `sourceUrl` | Input URL that produced the row |
| `scrapedAt` | Collection timestamp in ISO 8601 |

Fields that Avito does not expose on a particular card are returned as `null` or an empty array.

### Example output

```json
{
  "listingId": "1234567890",
  "title": "Smartphone, 256 GB",
  "description": "Device in excellent condition with original box.",
  "price": 45000,
  "priceText": "45 000 ₽",
  "currency": "RUB",
  "category": "Телефоны",
  "categoryId": 84,
  "location": "Москва",
  "address": "Москва",
  "attributes": [
    { "name": "AutoParams", "value": "Новый" }
  ],
  "availability": "active",
  "sellerName": "Example Electronics Shop",
  "sellerType": "business",
  "sellerRating": 4.9,
  "sellerReviewSummary": "125 отзывов",
  "sellerUrl": "https://www.avito.ru/brands/example",
  "imageUrl": "https://00.img.avito.st/image/1/example",
  "imageUrls": ["https://00.img.avito.st/image/1/example"],
  "imageCount": 5,
  "publishedAt": "2026-01-15T12:00:00.000Z",
  "canonicalUrl": "https://www.avito.ru/moskva/telefony/example_1234567890",
  "sourceUrl": "https://www.avito.ru/moskva/telefony",
  "scrapedAt": "2026-01-15T12:05:00.000Z"
}
```

The example is anonymized.
Actual records contain current public Avito values.

### How much does it cost to extract Avito listings?

This Actor uses pay-per-event pricing.
Each run emits one `start` event and one `item` event for every unique listing saved.
Duplicates, rejected records, and blocked requests do not create item charges.

The one-time start event costs **$0.003**.
The per-listing event uses this six-tier curve:

| Apify tier | Price per saved listing |
| --- | ---: |
| FREE | $0.0036708 |
| BRONZE | $0.003192 |
| SILVER | $0.0024898 |
| GOLD | $0.0019152 |
| PLATINUM | $0.0012768 |
| DIAMOND | $0.00089376 |

The current Console pricing table is the source of truth.
Estimate a run with:

`estimated price = $0.003 + (unique listings × your tier's item price)`

At BRONZE rates, a 10-listing test costs about **$0.03492** and a 100-listing inventory export costs about **$0.32220**.
A recurring workflow pays independently for each scheduled run and its saved items.
Infrastructure and residential proxy costs are included in Actor operation and are not separate customer events.

### Pagination and limits

Avito usually exposes up to 50 result cards per page.
`maxItems` is the global saved-row limit across all inputs.
`maxPages` is applied separately to every input URL.

The Actor stops when any of these occurs:

- `maxItems` is reached;
- `maxPages` is reached;
- Avito returns no result cards;
- a page contains no new listing IDs.

Use narrow URLs and modest page limits for recurring monitoring.
This reduces runtime and makes comparisons easier to interpret.

### Recurring inventory and price monitoring

Apify schedules can run the same Task hourly, daily, or weekly.
A practical workflow is:

1. Save the Actor input as an Apify Task.
2. Schedule the Task at the required interval.
3. Send each finished dataset to your database or spreadsheet.
4. Match rows by `listingId`.
5. Compare `price`, `availability`, and seller fields with the previous snapshot.
6. Treat IDs missing from later snapshots as candidates for manual availability review.

The Actor emits current snapshots.
It does not maintain historical state or send alerts itself.

### Export and integration options

Every run writes primary records to the default Apify dataset.
You can:

- download JSON, JSONL, CSV, Excel, XML, or RSS;
- send results to Google Sheets;
- trigger a webhook when a run finishes;
- read rows with the Apify API client;
- load datasets into BigQuery, Snowflake, PostgreSQL, or another warehouse;
- orchestrate downstream steps with Make, Zapier, n8n, or custom code.

For price monitoring, preserve `listingId`, `price`, `sourceUrl`, and `scrapedAt`.

### Run with the Apify API using cURL

Replace `YOUR_TOKEN` with an Apify API token.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~avito-russia-classified-listings/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.avito.ru/moskva/telefony"}],
    "maxItems": 25,
    "maxPages": 1
  }'
```

Read the run's `defaultDatasetId` from the response and fetch its items with the dataset API.

### Run with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/avito-russia-classified-listings').call({
  startUrls: [{ url: 'https://www.avito.ru/moskva/telefony?q=iphone' }],
  maxItems: 25,
  maxPages: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/avito-russia-classified-listings").call(
    run_input={
        "startUrls": [{"url": "https://www.avito.ru/moskva/telefony"}],
        "maxItems": 25,
        "maxPages": 1,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Avito API through MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/avito-russia-classified-listings"
```

#### Claude Desktop

Add this HTTP MCP server in Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/avito-russia-classified-listings"
    }
  }
}
```

#### Cursor

Add the same `apify` HTTP server URL in Cursor's MCP settings and enable the Actor tool for your workspace.

#### VS Code

Add the same `apify` HTTP server URL through your VS Code MCP extension or workspace MCP configuration.

Example prompts:

- “Run the Avito listings Actor for this Moscow phone category and return 20 rows.”
- “Export the latest listing IDs, titles, prices, sellers, and URLs as a table.”
- “Compare this dataset with yesterday's file by listing ID and flag price changes.”

MCP clients still use your Apify account and the Actor's active pricing.

### Reliability and anti-bot handling

Avito protects public result pages and can reject individual network sessions.
The Actor uses browser-grade TLS impersonation and bounded residential-session rotation.
It retries a page with a fresh identity after a recognized challenge.

A run fails rather than returning a misleading empty dataset when every bounded session is blocked.
Retry the Task later if Avito temporarily rejects all sessions.
Do not add your own proxy URLs; the required proxy strategy is managed by the Actor.

### Limitations

- Only public `avito.ru` category, location, and search result URLs are supported.
- Listing detail URLs are rejected.
- Phone numbers, private messages, account-only data, and contact reveal are not collected.
- Result-card fields vary by category and seller, so nullable fields are expected.
- A listing appearing in results is labeled `active`; absence from one snapshot is not proof of deletion.
- Avito may reorder results between pages, so cross-page IDs are deduplicated.
- Anti-bot changes can temporarily block all bounded sessions and fail a run.
- The maximum is 1,000 saved listings and 20 pages per input URL.
- Output reflects the public page at collection time; it is not a historical database.

### Responsible use and legality

Use this Actor only for public data you are permitted to collect.
Review Avito's terms, robots guidance, and applicable laws before running it.
Choose reasonable schedules and limits.
Do not use output for harassment, unlawful profiling, discrimination, spam, or attempts to bypass access controls.

Seller names and ratings can be personal data in some contexts.
Apply purpose limitation, access controls, retention limits, and deletion processes appropriate to your jurisdiction.
This documentation is not legal advice.

### Troubleshooting

#### The run says every residential session was blocked

Avito rejected all bounded identities for that page.
Wait and retry once later.
Confirm the URL opens as a public results page and reduce broad pagination.

#### My input URL is rejected

Use an HTTPS URL on `www.avito.ru` that displays a category, location, or search result list.
Do not provide an individual listing URL or another Avito country site.

#### Some fields are null

Avito does not expose every field on every result card.
For example, private sellers may not expose a shop URL or rating summary.
Null values preserve a stable output schema without inventing data.

#### I received fewer rows than `maxItems`

The source may have fewer results, `maxPages` may be reached, or duplicate listings may appear across pages and inputs.
`maxItems` is a ceiling, not a guaranteed count.

#### Prices contain text and numbers

Use numeric `price` for calculations and `priceText` for display.
All numeric prices are denominated in rubles and `currency` is `RUB`.

### Related Automation Lab Actors

- [Gumtree UK Classified Listings Scraper](https://apify.com/automation-lab/gumtree-uk-classified-listings-scraper) for UK classified inventory.
- [OLX Poland Classifieds Scraper](https://apify.com/automation-lab/olx-poland-classifieds-scraper) for Polish classified inventory.
- [Bazoš Czech Classifieds Scraper](https://apify.com/automation-lab/bazos-czech-classifieds-scraper) for Czech classified inventory.

Choose the Actor matching the marketplace where the public listings are hosted.
Each Actor has a source-specific schema and access strategy.

### Frequently asked questions

#### Is this an official Avito API?

No.
This is an independent Apify Actor that converts public Avito result pages into an API-friendly dataset.
It is not affiliated with or endorsed by Avito.

#### Does it need my Avito account?

No.
The supported workflow uses public result pages and does not accept login credentials.

#### Can it monitor new and changed listings?

Schedule repeated runs and compare datasets by `listingId` in your own destination.
The Actor produces current snapshots; historical comparison and alerts are downstream responsibilities.

#### Can I scrape more than one category?

Yes.
Add multiple category or search URLs to `startUrls`.
The Actor deduplicates listing IDs across them and respects the global `maxItems` limit.

#### Does it charge for failed requests or duplicates?

The per-item event is emitted only for unique normalized listings saved to the dataset.
The one-time start event still applies once a run begins.

#### Can I request listing descriptions?

The Actor returns the description excerpt exposed on the result card when available.
It does not open detail pages, so it does not promise the full listing description.

# Actor input Schema

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

Public https://www.avito.ru category, location, or search result URLs. Listing detail URLs are not supported.

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

Maximum number of unique listings to save across all supplied URLs.

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

Maximum number of result pages to request from each supplied URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.avito.ru/moskva/telefony"
    }
  ],
  "maxItems": 20,
  "maxPages": 5
}
```

# Actor output Schema

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

Default dataset containing all unique Avito listing records saved by the run.

# 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": [
        {
            "url": "https://www.avito.ru/moskva/telefony"
        }
    ],
    "maxItems": 20,
    "maxPages": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/avito-russia-classified-listings").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": [{ "url": "https://www.avito.ru/moskva/telefony" }],
    "maxItems": 20,
    "maxPages": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/avito-russia-classified-listings").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": [
    {
      "url": "https://www.avito.ru/moskva/telefony"
    }
  ],
  "maxItems": 20,
  "maxPages": 5
}' |
apify call automation-lab/avito-russia-classified-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/avito-russia-classified-listings"
        }
    }
}

```

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/tZj9XRlDjhOflZTRO/builds/ez37jEPSecbKCPVBf/openapi.json