# Avito Scraper — Listings, Prices & Seller Details (`khadinakbar/avito-scraper`) Actor

Scrape Avito.ru by keyword or URL (search, category, item): title, price, location, images, seller, posted date; optional detail enrichment with description, seller profile, and phone number. HTTP-only over Russian residential proxy. MCP-ready.

- **URL**: https://apify.com/khadinakbar/avito-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 avito item enricheds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Scraper — Listings, Prices & Seller Details

Scrape **Avito.ru** — Russia's largest classifieds marketplace — by keyword or by URL. Get clean, structured JSON for every listing: title, price, location, images, seller, and posted date, plus (with detail enrichment) the full description, item parameters, seller profile, and view count. No login, MCP-ready.

### What it does

Give it a **search keyword** (e.g. `iPhone 15`, `диван угловой`) or one or more **Avito URLs** (search results, a category, or individual item pages). The actor paginates the results, normalizes every listing into a stable schema, and optionally opens each item to enrich it with the full description, specs, and seller details.

Avito renders its catalog with JavaScript and hard-blocks every non-Russian IP at the edge, so the actor drives an **anti-detect browser (Camoufox / Firefox)** over **Russian residential proxies** — both built in. You don't supply a proxy.

### When to use it

- **Price & market research** across a category or city.
- **Competitor / inventory monitoring** — track new listings for a keyword on a schedule.
- **Seller sourcing** — collect seller name, type (private vs company), and profile URL per listing.
- Feeding an **AI agent / MCP client** that needs structured Avito data from a single query.

Do **not** use it for Avito *account* actions (messaging, posting) — it is a public, read-only scraper.

### Output

One record per listing/item. Core fields:

| Field | Description |
|---|---|
| `id` | Avito item id |
| `url` | Canonical listing URL |
| `title` | Listing title |
| `price` | Numeric price (RUB) |
| `priceLabel` | Price as shown (e.g. "27 290 ₽") |
| `location` | City / region |
| `images` | Array of image URLs |
| `sellerName` | Seller display name |
| `sellerType` | `Частное лицо` (private) / `Компания` (company) |
| `postedText` | Posted date as shown on Avito |
| `description` | Short snippet |
| `source` | Extraction source |

With **detail enrichment** (`enrichDetails`, on by default) each record also gets:

| Field | Description |
|---|---|
| `fullDescription` | Complete item description |
| `params` | Item parameters (brand, condition, specs…) as a key/value object |
| `address` | Full street address (real estate / auto), metro proximity stripped |
| `sellerProfileUrl` | Link to the seller's Avito profile |
| `viewCount` | Listing views |

> **Note on phone numbers:** Avito gates seller phone reveal behind login / its mobile app, so phone numbers are **not** reliably scrapable and are not included. Seller name, type, and profile URL are provided instead.

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Listing scraped (enrichment off) | $0.004 / listing |
| Item enriched (default) | $0.009 / item |

You're billed **only for results actually returned**, capped by your `Max results`. The run logs the maximum possible cost before it starts.

### Input

| Field | Type | Notes |
|---|---|---|
| `query` | string | Search keyword. Cyrillic or Latin. |
| `startUrls` | array | Avito search / category / item URLs (auto-detected). |
| `maxResults` | integer | Hard cap (1–1000, default 50). |
| `enrichDetails` | boolean | Add full detail + seller (default `true`). |
| `sortBy` | enum | `relevance`, `newest`, `price_asc`, `price_desc`. |
| `locationPath` | string | Avito city slug (e.g. `moskva`) to scope a keyword search. |
| `proxyUrls` | array | Your own RU residential proxies (optional override). |

#### Example input

```json
{
  "query": "iPhone 15",
  "maxResults": 20,
  "enrichDetails": true,
  "sortBy": "newest",
  "locationPath": "moskva"
}
````

### Run it via API

**JavaScript (Apify client):**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/avito-scraper').call({
    query: 'iPhone 15',
    maxResults: 20,
    enrichDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (Apify client):**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/avito-scraper").call(run_input={
    "query": "iPhone 15",
    "maxResults": 20,
    "enrichDetails": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### MCP / AI agents

Exposed in the Apify MCP server as `apify--avito-scraper`. The tool takes a single keyword or URL and returns structured listings — a natural one-call tool for Claude, ChatGPT, or any MCP client doing Russian-market research.

### FAQ

**Do I need a proxy?** No. Russian residential proxy is built in. Avito blocks all non-RU IPs, so the actor will not work without one — which is why it's included.

**Why can runs take a while?** Avito's Russian-residential IP pool is inconsistent; the actor relaunches the browser on a fresh IP whenever it hits Avito's "access restricted" block page. Most runs succeed, but the occasional retry adds time. Keep `maxResults` sized to what you actually need.

**Does it support city/category filters?** Yes, via `locationPath` (a city slug like `moskva`) or by passing an Avito URL that already encodes the filters.

**Can it get seller phone numbers?** No — Avito requires login or its app to reveal phones, so they are not reliably scrapable. The actor returns seller name, type, and profile URL instead.

**What if a search returns nothing?** You get an empty dataset and a clear status message — no charge for results that don't exist.

### Legal

This actor collects only **publicly available** data from Avito.ru and performs no login or account actions. You are responsible for using the output in compliance with Avito's Terms of Service, applicable data-protection laws, and any export/sanctions regulations relevant to your jurisdiction. Use it for legitimate research and market analysis where permitted.

# Actor input Schema

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

Free-text keyword searched across all of Avito.ru, e.g. 'iPhone 15' or 'диван угловой'. Cyrillic and Latin both work. Leave empty if you supply Start URLs instead. NOT a URL — for a specific Avito search/category/item page use the Start URLs field.

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

Avito.ru page URLs to scrape: search results, category pages, or individual item pages (auto-detected). Example: 'https://www.avito.ru/moskva/telefony?q=iphone'. Item URLs return full detail; search/category URLs are paginated. Use this OR the keyword field.

## `maxResults` (type: `integer`):

Maximum number of result records to return and bill for (hard cap). Defaults to 50; range 1–1000. With detail enrichment on, each result is one enriched record; with it off, each is one listing. Pagination stops automatically when this many are collected.

## `enrichDetails` (type: `boolean`):

When true (default), each listing is opened to add full description, item parameters, seller name/type, seller profile URL, and view count. When false, only the lighter search-card fields are returned (faster, cheaper). Item Start URLs are always enriched regardless of this flag.

## `sortBy` (type: `string`):

Order of search results: 'relevance' (default), 'newest' (most recently posted first), 'price\_asc' (cheapest first), or 'price\_desc' (most expensive first). Applies to keyword and search/category URL modes. Ignored for direct item URLs.

## `locationPath` (type: `string`):

Avito region/city URL slug to scope a keyword search, e.g. 'moskva' for Moscow, 'sankt-peterburg' for Saint Petersburg, or 'all' for all of Russia (default). Take it from the first path segment of an Avito city URL. NOT a numeric id and NOT a full URL. Ignored when Start URLs already encode a location.

## `proxyUrls` (type: `array`):

Optional list of your own Russian residential proxy URLs (e.g. 'http://user:pass@host:port') to use instead of the built-in proxy. Avito blocks non-Russian and datacenter IPs, so only RU residential/mobile proxies work here. Leave empty to use the actor's managed proxy.

## Actor input object example

```json
{
  "query": "велосипед горный",
  "startUrls": [
    "https://www.avito.ru/all/telefony?q=iphone+15"
  ],
  "maxResults": 20,
  "enrichDetails": true,
  "sortBy": "relevance",
  "locationPath": "moskva",
  "proxyUrls": [
    "http://user:pass@ru-residential.example.com:8000"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

All Avito listing/item records collected across the search, category, and item pages. Download as JSON, CSV, Excel, HTML, or RSS.

# 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",
    "startUrls": [],
    "maxResults": 20,
    "proxyUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 15",
    "startUrls": [],
    "maxResults": 20,
    "proxyUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/avito-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
  "startUrls": [],
  "maxResults": 20,
  "proxyUrls": []
}' |
apify call khadinakbar/avito-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/avito-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Avito Scraper — Listings, Prices & Seller Details",
        "description": "Scrape Avito.ru by keyword or URL (search, category, item): title, price, location, images, seller, posted date; optional detail enrichment with description, seller profile, and phone number. HTTP-only over Russian residential proxy. MCP-ready.",
        "version": "1.0",
        "x-build-id": "BEazScx8Gewqmr20I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~avito-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-avito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~avito-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-avito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~avito-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-avito-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword searched across all of Avito.ru, e.g. 'iPhone 15' or 'диван угловой'. Cyrillic and Latin both work. Leave empty if you supply Start URLs instead. NOT a URL — for a specific Avito search/category/item page use the Start URLs field."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Avito.ru page URLs to scrape: search results, category pages, or individual item pages (auto-detected). Example: 'https://www.avito.ru/moskva/telefony?q=iphone'. Item URLs return full detail; search/category URLs are paginated. Use this OR the keyword field.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of result records to return and bill for (hard cap). Defaults to 50; range 1–1000. With detail enrichment on, each result is one enriched record; with it off, each is one listing. Pagination stops automatically when this many are collected.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Enrich with item details",
                        "type": "boolean",
                        "description": "When true (default), each listing is opened to add full description, item parameters, seller name/type, seller profile URL, and view count. When false, only the lighter search-card fields are returned (faster, cheaper). Item Start URLs are always enriched regardless of this flag.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Order of search results: 'relevance' (default), 'newest' (most recently posted first), 'price_asc' (cheapest first), or 'price_desc' (most expensive first). Applies to keyword and search/category URL modes. Ignored for direct item URLs.",
                        "default": "relevance"
                    },
                    "locationPath": {
                        "title": "Location (optional)",
                        "type": "string",
                        "description": "Avito region/city URL slug to scope a keyword search, e.g. 'moskva' for Moscow, 'sankt-peterburg' for Saint Petersburg, or 'all' for all of Russia (default). Take it from the first path segment of an Avito city URL. NOT a numeric id and NOT a full URL. Ignored when Start URLs already encode a location."
                    },
                    "proxyUrls": {
                        "title": "Custom Russian proxy URLs (optional override)",
                        "type": "array",
                        "description": "Optional list of your own Russian residential proxy URLs (e.g. 'http://user:pass@host:port') to use instead of the built-in proxy. Avito blocks non-Russian and datacenter IPs, so only RU residential/mobile proxies work here. Leave empty to use the actor's managed proxy.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```