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:

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

A keyword search example:

{
  "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

{
  "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.

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

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

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:

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:

{
  "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 for UK classified inventory.
• OLX Poland Classifieds Scraper for Polish classified inventory.
• Bazoš 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.