# Avito Auto Scraper: Парсер Авито Авто (`getascraper/avito-auto-scraper`) Actor

Scrape vehicle listings from Avito Auto (avito.ru) - price, mileage, generation, dealer identity, and Avito's own market-price valuation for any city.

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

## Pricing

from $3.29 / 1,000 vehicle listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Auto Scraper: Парсер Авито Авто

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#EDF9F9;border:1px solid #CCEEED;border-top:4px solid #00AAA6;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Get live Avito Auto listings, prices, mileage, and dealer data ready for your spreadsheet in under 60 seconds.</span><br>
<span style="font-size:15px;color:#57534E;line-height:1.6">Pull structured vehicle data, including Avito's own fair-price verdict, from Авито Авто by city or region. No browser and no login required.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #CCEEED;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#00807D">⚖️ Built-in fair-price verdict</span><br>
<span style="font-size:12px;color:#57534E">Avito's own market-price judgment ships on listings it has enough data for, not a third-party guess</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #CCEEED;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#00807D">🔧 Full vehicle spec sheet</span><br>
<span style="font-size:12px;color:#57534E">Price, mileage, year, generation, transmission, drivetrain, fuel, and body type in one row</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #CCEEED;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#00807D">🏬 Dealer or private seller</span><br>
<span style="font-size:12px;color:#57534E">Every listing tagged with dealer name, ID, storefront link, and seller rating</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #CCEEED;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#00807D">🔓 No browser, no login</span><br>
<span style="font-size:12px;color:#57534E">Runs reliably against Russia's largest classifieds site without any sign-in wall</span>
</td>
</tr>
</table>

Get structured data from **Авито Авто** (avito.ru), the automotive section of Russia's largest classifieds site. Give this Actor a city and it returns one clean row per vehicle listing: price, mileage, year, generation, transmission, drivetrain, fuel type, body type, dealer or private-seller identity, seller rating, photos, and Avito's own market-price verdict for that vehicle. Built for dealer inventory monitoring, used-car market research, and price-per-mileage sourcing, without opening a single listing by hand.

<table width="100%"><tr>
<td style="padding:12px 18px;background:#EDF9F9;border-left:4px solid #00AAA6">
<span style="font-size:15px;color:#1C1917">📍 <b>Pick a city first.</b> A nationwide search returns zero listings on Avito. Always set <code>citySlug</code> to a specific city or region, such as <code>moskva</code> or <code>krasnodar</code>.</span>
</td>
</tr></table>

### 🔍 What does Avito Auto Scraper do?

This Actor pulls vehicle listings from **Авито Авто**, the car and dealer section of avito.ru, by city or region.

Give it a city slug and it returns every vehicle listing it finds there: title, price, year, generation, mileage, transmission, drivetrain, fuel type, and body type, plus the exact GPS coordinates of the listing. It also tells you whether the seller is a registered dealership or a private individual, including the dealer's name, ID, storefront link, and seller rating, and it carries Avito's own market-price verdict for the vehicle when Avito has enough comparable sales to compute one. It runs on the Apify platform with scheduling, integrations (Make, Zapier, Google Sheets), and run monitoring built in.

### 💡 Why use Avito Auto Scraper?

- **I am a car importer** comparing prices for the same model across Russian cities, using mileage and generation data to spot underpriced inventory before a competitor does.
- **I am a used-car market analyst** tracking pricing trends across regions and vehicle segments, pairing Avito's own fair-price verdicts with my own valuation models.
- **I am a reseller** building a price-per-mileage sourcing list, filtering private-seller listings priced below what Avito itself considers fair market value.
- **I am a competitive intelligence lead** monitoring dealer inventory and pricing across storefronts, tracking which dealers list what, at what price, and how often it changes.

### 🚀 How to use Avito Auto Scraper

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#EDF9F9;border:1px solid #CCEEED;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#00AAA6;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Pick a city</span><br>
<span style="font-size:12px;color:#57534E">Set a specific Avito city or region slug like moskva or krasnodar. Nationwide searches return nothing.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#EDF9F9;border:1px solid #CCEEED;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#00AAA6;letter-spacing:1px">STEP 2</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Set your limits</span><br>
<span style="font-size:12px;color:#57534E">Cap how many listings and search pages to pull in a single run.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#EDF9F9;border:1px solid #CCEEED;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#00AAA6;letter-spacing:1px">STEP 3</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Start and export</span><br>
<span style="font-size:12px;color:#57534E">Download results as a spreadsheet or table, or pull them straight into your own tools.</span>
</td>
</tr>
</table>

### ⚙️ Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `citySlug` | string | Yes | Avito city or region slug to search, such as `moskva`, `sankt-peterburg`, or `krasnodar`. A nationwide slug returns zero listings, so always pick a specific city or region. |
| `maxItems` | integer | No | Maximum number of vehicle listings to scrape. Set to `0` for unlimited, bounded only by `maxPages`. Defaults to `100`. |
| `maxPages` | integer | No | Maximum number of search-result pages to page through, at roughly 50 listings per page. Avito caps results around page 100. Defaults to `5`. |
| `proxyConfiguration` | object | No | Proxy routing settings. Defaults to Apify's Russian proxy network, already tuned for reliable access to Avito. |

### 📦 Output

Download the results as a spreadsheet, a table, or structured data ready for your own systems. Each row is one vehicle listing:

````

{
"citySlug": "moskva",
"scrapedAt": "2026-07-10T05:16:45.174Z",
"itemId": "7882768227",
"title": "Audi Q5L 2.0 AMT, 2025",
"url": "https://www.avito.ru/moskva/avtomobili/audi\_q5l\_2.0\_amt\_2025\_7882768227",
"price": 6000000,
"formattedPrice": "от 5 100 000 ₽",
"locationAddress": "Москва, МКАД, 44-й километр, 1Вс2",
"locationLat": 55.755814,
"locationLng": 37.617635,
"isShop": true,
"dealerName": "PELETON ИМПОРТ",
"dealerId": 8834049,
"dealerDomain": "72a2c8f20c582f97119da2323ad07edf",
"dealerStorefrontUrl": "https://www.avito.ru/brands/72a2c8f20c582f97119da2323ad07edf?gdlkerfdnwq=101\&page\_from=from\_item\_header\&iid=7882768227",
"sellerRating": 4.9,
"sellerReviewCount": 222,
"photos": \[
"https://20.img.avito.st/image/1/1.VvfR3ra4-h7naXgT8ZdSgvR--Bhvf3gI53L4HGF38hRn.FkJfASt47rSUvuxfDUZFbjhHwIQF-RwqobSyRslqWFw",
"https://40.img.avito.st/image/1/1.US8J2La4\_cY\_b3\_LJ6kKZCx4\_8C3eX\_QP3T\_xLlx9cy\_.X5oz1pKuYQGhqilxfArHx-4X\_B0Mx4wH0GE7PjdOFPU"
],
"isNew": true,
"isUsed": false,
"vehicleType": "new",
"year": 2025,
"generation": "GU (2024—2026)",
"engineVolume": "2 л",
"fuelType": "Бензин",
"transmission": "Робот",
"drivetrain": "Полный",
"bodyType": "Внедорожник 5-дверный",
"vinPartial": "LFV3\*\*\*\*\*\*\*\*\*\*\*\*\*",
"specifications": \[
{ "title": "Год выпуска", "description": "2025" },
{ "title": "Модификация", "description": "40 TFSI 2.0 quattro S tronic (204 л.с.)" },
{ "title": "Комплектация", "description": "Exclusive" },
{ "title": "Цвет", "description": "Зелёный" }
],
"enginePower": "204 л.с."
}

````

### 📊 Output data fields

| Field | Type | Description |
| --- | --- | --- |
| `citySlug` | string | The city or region slug this listing was scraped from. |
| `itemId` | string | Avito's internal listing ID. |
| `title` | string | Listing headline as shown on Avito, usually model, engine, and year. |
| `url` | string | Direct link to the listing on Avito. |
| `price` | number | Listed price in Russian rubles. |
| `formattedPrice` | string | Avito's own formatted price string, including "from" price ranges when Avito shows one. |
| `year` | number | Model year. |
| `generation` | string | Vehicle generation or platform, when Avito lists one. |
| `mileageKm` | number | Odometer reading in kilometers. Omitted for new, unregistered vehicles. |
| `transmission` | string | Transmission type, such as automatic, manual, or robotic. |
| `drivetrain` | string | Drivetrain layout, such as front, rear, or all-wheel drive. |
| `fuelType` | string | Fuel or engine type, such as petrol, diesel, electric, or hybrid. |
| `bodyType` | string | Body style, such as SUV, sedan, or hatchback. |
| `engineVolume` | string | Engine displacement, as shown on the listing. |
| `enginePower` | string | Engine power, as shown on the listing. |
| `specifications` | array of objects | Full title and description spec pairs straight from Avito's own spec sheet for this listing. |
| `locationAddress` | string | Seller or dealer address as shown on the listing. |
| `locationLat` | number | Listing latitude, for mapping. |
| `locationLng` | number | Listing longitude, for mapping. |
| `sellerRating` | number | Seller's rating on Avito, when Avito shows one. |
| `sellerReviewCount` | number | Number of reviews behind that rating. |
| `isShop` | boolean | True when the listing comes from a registered dealer storefront rather than a private seller. |
| `dealerName` | string | Dealer's storefront name, when the listing is from a shop. |
| `dealerId` | number | Avito's internal dealer ID. |
| `dealerDomain` | string | Dealer's storefront URL slug on Avito. |
| `dealerStorefrontUrl` | string | Direct link to the dealer's full inventory on Avito. |
| `marketPriceEstimate` | object | Avito's own fair-price verdict for this listing, comparing it against similar vehicles. Only present when Avito has enough comparable data to compute one. |
| `vinPartial` | string | The first characters of the VIN Avito exposes publicly. The rest is masked by Avito itself. |
| `photos` | array of URLs | All photo URLs attached to the listing. |
| `videoUrl` | string | Listing video URL, when the seller added one. |
| `isNew` | boolean | True when Avito lists the vehicle as new. |
| `isUsed` | boolean | True when Avito lists the vehicle as used. |
| `vehicleType` | string | Avito's own new or used classification label for this listing. |
| `scrapedAt` | string | Timestamp when this row was collected. |

### 💰 Pricing

This Actor uses pay-per-result pricing: you pay for the vehicle listings you actually get back, and nothing for an empty run. There is no subscription and no minimum spend. Use `maxItems` to control how many results a run returns.

### ⭐ Enjoying Avito Auto Scraper: Парсер Авито Авто?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#EDF9F9;border:1px solid #CCEEED;border-left:5px solid #00AAA6;border-radius:10px 10px 0 0">
<span style="font-size:20px;letter-spacing:4px">⭐ ⭐ ⭐ ⭐ ⭐</span><br>
<span style="font-size:17px;font-weight:800;color:#1C1917">Turning Авито Авто listings into structured spreadsheet data, fair-price verdict included?</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other importers, dealers, and analysts watching the Russian used-car market find it. Your feedback also tells us what to build next.</span>
</td>
</tr>
<tr>
<td style="padding:0;background:#00AAA6;border:1px solid #CCEEED;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/avito-auto-scraper/reviews" style="display:block;padding:13px 16px;color:#FFFFFF;text-decoration:none;font-weight:800;font-size:15px;letter-spacing:0.3px">★&nbsp;&nbsp;Rate this Actor on Apify</a>
</td>
</tr>
</table>

### ✨ Tips

- `citySlug` is required. Always set it to a specific city or region slug, never a nationwide one.
- Keep `maxItems` low while testing a new city, then raise it once you know what it returns.
- Raise `maxPages` for a wider sweep of a large city, or keep it low for a quick daily check.
- Use `dealerStorefrontUrl` to pull a specific dealer's full inventory, then re-run against their other city listings.
- Filter on `marketPriceEstimate` when it is present to shortlist listings priced below Avito's own fair-value range.

### ❓ FAQ, disclaimers, and support

**Что такое парсер Авито Авто?** This Actor is a parser (парсер) for Avito Auto. Give it a city, and it returns structured vehicle listing data: price, mileage, year, spec, dealer identity, and Avito's own fair-price verdict for each matching car.

**Как собрать данные об автомобилях с Авито?** Set `citySlug` to the city you want, adjust `maxItems` and `maxPages` if needed, and run the Actor. It returns one row per vehicle listing found in that city.

**Does this scraper get blocked by Avito?** It is built specifically to run reliably against Avito's automotive section, city after city, without manual intervention.

**Does it extract private phone numbers?** No. Avito masks seller phone numbers in its own public listing data, and this Actor does not attempt to reveal them. Phone numbers are out of scope by design.

**Does it return the full VIN or a vehicle history report?** No. Avito itself only exposes the first few characters of a VIN publicly. A full VIN and vehicle history report is Avito's own paid upsell product, not something obtainable by scraping.

**How fresh is the data?** Every run fetches current listings directly from Avito at run time. There is no cached or stale data.

**Are all vehicle categories on Avito Auto supported?** Yes, this Actor covers the general car listings within the city or region you set in `citySlug`.

**Is scraping Avito data legal?** This Actor collects publicly available listing data. You are responsible for complying with Avito's Terms of Service and applicable laws in your use of the data.

**Found a bug or need a field added?** Open an issue on the Actor's **Issues** tab. Custom solutions are available on request.

# Actor input Schema

## `citySlug` (type: `string`):

Avito city or region URL slug to search within, e.g. 'moskva', 'sankt-peterburg', 'krasnodar'. A nationwide slug like 'rossiya' returns zero listings (confirmed) - always pick a specific city or region.
## `maxItems` (type: `integer`):

Maximum number of vehicle detail pages to scrape. 0 = unlimited (bounded only by Max search pages).
## `maxPages` (type: `integer`):

Maximum number of search-result pages to paginate through (~50 listings/page). Avito caps search results around page 100.
## `proxyConfiguration` (type: `object`):

Avito is fronted by QRATOR, a TLS/JA3-fingerprint + IP-reputation gate (not a JS challenge or CAPTCHA). Residential Russian proxy is the validated safe production default; datacenter proxy passed in light testing but is untested at production volume.

## Actor input object example

```json
{
  "citySlug": "moskva",
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
````

# Actor output Schema

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

No description

# 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 = {
    "citySlug": "moskva",
    "maxItems": 100,
    "maxPages": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/avito-auto-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 = {
    "citySlug": "moskva",
    "maxItems": 100,
    "maxPages": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/avito-auto-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 '{
  "citySlug": "moskva",
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call getascraper/avito-auto-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Avito Auto Scraper: Парсер Авито Авто",
        "description": "Scrape vehicle listings from Avito Auto (avito.ru) - price, mileage, generation, dealer identity, and Avito's own market-price valuation for any city.",
        "version": "0.1",
        "x-build-id": "8ULTb86am7I33oIBf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~avito-auto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-avito-auto-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/getascraper~avito-auto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-avito-auto-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/getascraper~avito-auto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-avito-auto-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",
                "required": [
                    "citySlug"
                ],
                "properties": {
                    "citySlug": {
                        "title": "City / region slug",
                        "type": "string",
                        "description": "Avito city or region URL slug to search within, e.g. 'moskva', 'sankt-peterburg', 'krasnodar'. A nationwide slug like 'rossiya' returns zero listings (confirmed) - always pick a specific city or region."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 0,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of vehicle detail pages to scrape. 0 = unlimited (bounded only by Max search pages).",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of search-result pages to paginate through (~50 listings/page). Avito caps search results around page 100.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Avito is fronted by QRATOR, a TLS/JA3-fingerprint + IP-reputation gate (not a JS challenge or CAPTCHA). Residential Russian proxy is the validated safe production default; datacenter proxy passed in light testing but is untested at production volume.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
