# Drom.ru Cars Scraper: Парсер Дром Авто (`getascraper/drom-ru-cars-scraper`) Actor

Scrape used-car listings from Drom.ru by city and make/model - price, year, mileage, engine, transmission, drivetrain, fuel type, body type, seller type (dealer vs private), photos, and description.

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

## Pricing

from $2.17 / 1,000 vehicle listings

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/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

## 🚗 Drom.ru Cars Scraper: Парсер Дром Авто

<table width="100%">
<tr>
<td style="padding:24px 28px;background:#FFF7ED;border:1px solid #FED7AA;border-top:4px solid #EA580C;border-radius:12px">
<span style="font-size:23px;font-weight:800;color:#1C1917;line-height:1.3">Get live Drom.ru used-car listings, prices, 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 from Drom.ru by city and make/model. No browser, no residential-proxy markup, no login required.</span>
</td>
</tr>
</table>

<table width="100%">
<tr>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FED7AA;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C2410C">🔓 No proxy tax</span><br>
<span style="font-size:12px;color:#57534E">Drom.ru has no bot defenses to clear, so this Actor runs on cheap datacenter routing instead of the residential markup other scrapers charge you for</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FED7AA;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C2410C">🏷️ Honest dealer vs. private tags</span><br>
<span style="font-size:12px;color:#57534E">Every listing marked dealer or private seller, with dealer verification status and total listing count on request</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FED7AA;border-left:none;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C2410C">🔧 Full spec sheet</span><br>
<span style="font-size:12px;color:#57534E">Price, year, engine volume and power, transmission, drivetrain, fuel type, body type, and mileage in one row</span>
</td>
<td style="padding:14px 12px;width:25%;background:#FFFFFF;border:1px solid #FED7AA;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:15px;font-weight:800;color:#C2410C">🔍 Optional deep enrichment</span><br>
<span style="font-size:12px;color:#57534E">Add generation, trim, partial VIN, accident/paperwork flags, and owner count with one checkbox</span>
</td>
</tr>
</table>

Get structured data from **Дром** (drom.ru), one of Russia's longest-running used-car classifieds sites. Give this Actor a city, and optionally a make and model, and it returns one clean row per listing: price, year, engine volume and power, transmission, drivetrain, fuel type, body type, mileage, seller type, dealer identity, photos, and description. Built for import/export price comparison, used-car market research, sourcing lists, and dealer-inventory monitoring, without opening a single listing by hand.

### 🔍 What does Drom.ru Cars Scraper do?

This Actor pulls used-car listings from **Дром** (drom.ru), by city and, optionally, make and model.

Give it a city slug and it returns every matching listing: title, price, year, engine volume and power, transmission, drivetrain, fuel type, body type, and mileage, straight from the exact text drom.ru itself shows on each listing card. It also tags every listing as a dealer or a private seller, with the dealer's name attached. Turn on detail-page enrichment to add the full description, vehicle generation, trim/complectation, partial VIN, steering-wheel side, accident and paperwork flags, owner count, and dealer verification status. It runs on the Apify platform with scheduling, integrations (Make, Zapier, Google Sheets), and run monitoring built in.

<table width="100%"><tr>
<td style="padding:12px 18px;background:#FFF7ED;border-left:4px solid #EA580C">
<span style="font-size:15px;color:#1C1917">💸 <b>Cheaper to run than it looks.</b> Drom.ru has no anti-bot layer, so this Actor ships on standard datacenter proxy instead of the pricier residential routing most Russia-market scrapers need.</span>
</td>
</tr></table>

### 💡 Why use Drom.ru Cars Scraper?

- **I am a car importer** comparing domestic Russian prices against landed import cost, to spot arbitrage before a competitor does.
- **I am a used-car market analyst** tracking price trends across cities and models, without waiting on a slow, proxy-taxed scraper to finish.
- **I am a reseller** building a sourcing list of underpriced private-seller cars, filtered by mileage, year, and price range.
- **I am a competitive intelligence lead** monitoring which dealers list what inventory, at what price, across Russian cities.

### 🚀 How to use Drom.ru Cars Scraper

<table width="100%">
<tr>
<td style="padding:16px 14px;width:33%;background:#FFF7ED;border:1px solid #FED7AA;border-radius:10px 0 0 10px;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#EA580C;letter-spacing:1px">STEP 1</span><br>
<span style="font-size:14px;font-weight:700;color:#1C1917">Pick a city, make, and model</span><br>
<span style="font-size:12px;color:#57534E">Set a city like moscow, and optionally a make and model to narrow the search.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFF7ED;border:1px solid #FED7AA;border-left:none;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#EA580C;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, and turn on detail-page enrichment if you want it.</span>
</td>
<td style="padding:16px 14px;width:33%;background:#FFF7ED;border:1px solid #FED7AA;border-left:none;border-radius:0 10px 10px 0;vertical-align:top">
<span style="font-size:12px;font-weight:800;color:#EA580C;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 | Drom.ru city slug to search, such as `moscow`, `novosibirsk`, or `spb`. Must match the exact slug drom.ru uses in its own URLs. |
| `makeSlug` | string | No | Drom.ru make slug, such as `toyota`, `bmw`, or `mercedes-benz`. Leave empty to scrape all makes for the city. |
| `modelSlug` | string | No | Drom.ru model slug, such as `camry`. Only applied when `makeSlug` is also set. |
| `minPrice` / `maxPrice` | integer | No | Lower/upper bound on listing price in Russian rubles. |
| `minYear` / `maxYear` | integer | No | Lower/upper bound on manufacture year. |
| `startUrls` | array of URLs | No | Paste your own auto.drom.ru search-result URLs instead of using the fields above. Overrides city/make/model/price/year filters entirely. |
| `scrapeDetails` | boolean | No | Visit each listing's detail page to add description, generation, trim, partial VIN, owner count, steering-wheel side, accident/paperwork flags, and dealer verification. Defaults to `false`. |
| `maxItems` | integer | No | Maximum number of listings to return. Defaults to `100`. |
| `maxPages` | integer | No | Maximum number of search-result pages to page through, at roughly 20 listings per page. Capped at `10`. Defaults to `5`. |
| `proxyConfiguration` | object | No | Proxy routing settings. Defaults to standard datacenter routing, which is all Drom.ru needs. |

### 📦 Output

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

````

{
"bullId": 296772177,
"url": "https://auto.drom.ru/moscow/toyota/camry/296772177.html",
"citySlug": "moscow",
"title": "Toyota Camry, 2022",
"subtitle": "2.0G CVT Luxury",
"make": "toyota",
"model": "camry",
"year": 2022,
"price": 2750000,
"engineVolume": "2.0 л",
"enginePower": "174 л.с.",
"fuelType": "бензин",
"transmission": "вариатор",
"drivetrain": "передний",
"mileageKm": 51000,
"bodyType": "Седан",
"sellerType": "private",
"location": "Москва",
"datePosted": "сегодня",
"photos": \[
"https://s31.auto.drom.ru/photo/v2/example1/gen544wb.jpg",
"https://s31.auto.drom.ru/photo/v2/example2/gen544wb.jpg"
],
"photoCount": 7,
"scrapedAt": "2026-07-16T02:26:04.455Z"
}

````

### 📊 Output data fields

| Field | Type | Description |
| --- | --- | --- |
| `bullId` | number | Drom.ru's internal listing ID. |
| `url` | string | Direct link to the listing on Drom.ru. |
| `title` | string | Listing headline, usually make, model, and year. |
| `subtitle` | string | Trim or complectation, when Drom.ru shows one on the card. |
| `citySlug` | string | The city slug this listing was scraped from. |
| `make` | string | Make slug used for the search, when set. |
| `model` | string | Model slug used for the search, when set. |
| `year` | number | Manufacture year. |
| `price` | number | Listed price in Russian rubles. |
| `engineVolume` | string | Engine displacement, as shown on the listing. |
| `enginePower` | string | Engine power, as shown on the listing. |
| `fuelType` | string | Fuel or engine type, such as petrol, diesel, hybrid, or electric. |
| `transmission` | string | Transmission type, such as manual, automatic, or CVT. |
| `drivetrain` | string | Drivetrain layout, such as front, rear, or all-wheel drive. |
| `mileageKm` | number | Odometer reading in kilometers. Omitted for new, unregistered vehicles. |
| `bodyType` | string | Body style, such as sedan, SUV, or hatchback. |
| `sellerType` | string | `dealer` or `private`, based on Drom.ru's own listing data. |
| `dealerName` | string | Dealer's storefront name, when the listing is from a dealer. |
| `location` | string | City shown on the listing. |
| `datePosted` | string | Drom.ru's own relative posting time, such as "today" or "3 hours ago". |
| `photos` | array of URLs | Photo URLs attached to the listing. |
| `photoCount` | number | Total photo count on the listing, including any not returned above. |
| `sold` | boolean | True when Drom.ru already marks the listing as sold. |
| `description` | string | Full seller description. Only present with detail-page enrichment on. |
| `generation` | string | Vehicle generation, when Drom.ru lists one. Detail-page enrichment only. |
| `complectation` | string | Trim/complectation name. Detail-page enrichment only. |
| `vinPartial` | string | The first characters of the VIN Drom.ru exposes publicly, when present. Detail-page enrichment only. |
| `numberOfOwners` | string | Owner count, as reported by the seller. Detail-page enrichment only. |
| `wheelSide` | string | `left` or `right`, steering-wheel side. Detail-page enrichment only. |
| `hasDamage` | boolean | True when the seller discloses prior damage. Detail-page enrichment only. |
| `hasDocs` | boolean | True when the seller confirms complete paperwork. Detail-page enrichment only. |
| `dealerCardUrl` | string | Link to the dealer's storefront page. Detail-page enrichment only. |
| `dealerOfficial` | boolean | True when Drom.ru marks the dealer as an official/authorized dealer. Detail-page enrichment only. |
| `dealerBulletinCount` | number | Dealer's total active listing count on Drom.ru. Detail-page enrichment only. |
| `conditionNote` | string | Drom.ru's own condition text, such as marking zero-mileage dealer stock as new. Detail-page enrichment only. |
| `scrapedAt` | string | Timestamp when this row was collected. |

### 💰 Pricing

This Actor uses pay-per-result pricing: you pay for the 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 Drom.ru Cars Scraper: Парсер Дром Авто?

<table width="100%">
<tr>
<td style="padding:20px 24px 14px;background:#FFF7ED;border:1px solid #FED7AA;border-left:5px solid #EA580C;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, dealer tags included?</span><br>
<span style="font-size:14px;color:#57534E">A 5-star rating takes 10 seconds and helps other importers, resellers, 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:#EA580C;border:1px solid #FED7AA;border-top:none;border-radius:0 0 10px 10px;text-align:center">
<a href="https://apify.com/getascraper/drom-ru-cars-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

- Leave `makeSlug`/`modelSlug` empty for a citywide sweep, or set both for a tightly scoped search.
- Keep `maxItems` low while testing a new city or model, then raise it once you know what it returns.
- Turn on `scrapeDetails` only when you need description, generation, trim, VIN, or dealer verification. It roughly doubles run time.
- `maxPages` is capped at `10` (about 200 listings per filtered search) to stay within Drom.ru's own crawl rules.
- Use `dealerName` and `sellerType` to build a dealer-only or private-only sourcing list in one filter.

### ❓ FAQ, disclaimers, and support

**Что такое парсер Дром Авто?** This Actor is a parser (парсер) for Drom.ru's used-car section. Give it a city, and it returns structured listing data: price, year, spec, mileage, and seller identity for each matching car.

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

**Does this scraper get blocked by Drom.ru?** No. Drom.ru has no bot-detection layer on its listing pages, so this Actor runs reliably without a browser or a residential proxy.

**Does it extract private phone numbers?** No. Contact reveal is out of scope by design.

**Does it return the full VIN?** No. Drom.ru itself only exposes the first characters of a VIN publicly, and only on some listings. This Actor never guesses or fabricates the rest.

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

**Is scraping Drom.ru data legal?** This Actor collects publicly available listing data. You are responsible for complying with Drom.ru'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.

### 🔗 Other actors

- [Avito Auto Scraper: Парсер Авито Авто](https://apify.com/getascraper/avito-auto-scraper) ↗ - scrapes vehicle listings from Avito Auto, Russia's largest classifieds site.
- [HH.ru Jobs Scraper: Парсер вакансий HH.ru](https://apify.com/getascraper/hh-ru-jobs-scraper) ↗ - extracts job vacancies and salary data from Russia's largest job site.
- [CIAN Real Estate Scraper: Недвижимость ЦИАН](https://apify.com/getascraper/cian-real-estate-scraper) ↗ - pulls apartment listings for sale or rent from Russia's largest real estate portal.
- [2GIS Reviews Scraper: Отзывы 2ГИС](https://apify.com/getascraper/2gis-reviews-scraper) ↗ - collects business reviews and replies from 2GIS.
- [Avito Seller Profile Scraper: Профили продавцов Авито](https://apify.com/getascraper/avito-seller-profile-scraper) ↗ - pulls seller profiles, verification status, and active listings from Avito.

# Actor input Schema

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

Drom.ru city URL slug to search within, e.g. 'moscow', 'novosibirsk', 'spb', 'ekaterinburg'. Must match the exact slug drom.ru itself uses in its URLs, not a free-text city name. Required unless Start URLs (Advanced) is set.
## `makeSlug` (type: `string`):

Drom.ru make URL slug, e.g. 'toyota', 'bmw', 'mercedes-benz', 'lada'. Leave empty to scrape all makes for the city. Must match the exact slug drom.ru uses (some brands use special slugs, e.g. 'land_rover', 'cheryexeed' for Exeed) - see AGENTS.md for verified examples.
## `modelSlug` (type: `string`):

Drom.ru model URL slug, e.g. 'camry'. Only applied when Make is also set; ignored otherwise.
## `minPrice` (type: `integer`):

Lower bound on listing price in Russian rubles. Verified working query filter.
## `maxPrice` (type: `integer`):

Upper bound on listing price in Russian rubles. Verified working query filter.
## `minYear` (type: `integer`):

Lower bound on manufacture year. Verified working query filter (note: 'yearFrom'/'yearTo' were tested and confirmed non-functional on drom.ru - this Actor uses the correct 'minyear'/'maxyear' params).
## `maxYear` (type: `integer`):

Upper bound on manufacture year. Verified working query filter.
## `startUrls` (type: `array`):

Optional: paste your own auto.drom.ru search-result URLs instead of using the fields above (e.g. to use verified-but-not-exposed filters like transmission, engine volume, or drivetrain - see AGENTS.md for the full list). When set, this overrides City/Make/Model/Price/Year filters entirely.
## `scrapeDetails` (type: `boolean`):

Visit each listing's detail page to add full description, generation, trim/complectation, partial VIN, owner count, steering-wheel side, accident/documents flags, and dealer-card detail. Roughly doubles requests and run time.
## `maxItems` (type: `integer`):

Maximum number of listings to return.
## `maxPages` (type: `integer`):

Maximum number of search-result pages to paginate through (~20 listings/page). Hard-capped at 10: drom.ru's robots.txt only Allow's crawling through page10 (a blanket Disallow covers pagination beyond that) - see AGENTS.md.
## `proxyConfiguration` (type: `object`):

Recon this session found no anti-bot layer on drom.ru at all (plain unproxied requests, including 12 rapid back-to-back, all returned real 200 responses). Datacenter proxy ships as the default for IP diversity at scale; it is not a confirmed technical requirement the way residential is for avito-auto-scraper or cian-real-estate-scraper.

## Actor input object example

```json
{
  "citySlug": "moscow",
  "makeSlug": "toyota",
  "modelSlug": "camry",
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

# 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": "moscow",
    "makeSlug": "toyota",
    "modelSlug": "camry",
    "startUrls": [],
    "scrapeDetails": false,
    "maxItems": 100,
    "maxPages": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/drom-ru-cars-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": "moscow",
    "makeSlug": "toyota",
    "modelSlug": "camry",
    "startUrls": [],
    "scrapeDetails": False,
    "maxItems": 100,
    "maxPages": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/drom-ru-cars-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": "moscow",
  "makeSlug": "toyota",
  "modelSlug": "camry",
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/drom-ru-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drom.ru Cars Scraper: Парсер Дром Авто",
        "description": "Scrape used-car listings from Drom.ru by city and make/model - price, year, mileage, engine, transmission, drivetrain, fuel type, body type, seller type (dealer vs private), photos, and description.",
        "version": "0.1",
        "x-build-id": "20zNp7lmESudO3U44"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~drom-ru-cars-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-drom-ru-cars-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~drom-ru-cars-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-drom-ru-cars-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~drom-ru-cars-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-drom-ru-cars-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": "Drom.ru city URL slug to search within, e.g. 'moscow', 'novosibirsk', 'spb', 'ekaterinburg'. Must match the exact slug drom.ru itself uses in its URLs, not a free-text city name. Required unless Start URLs (Advanced) is set."
                    },
                    "makeSlug": {
                        "title": "Make (brand) slug",
                        "type": "string",
                        "description": "Drom.ru make URL slug, e.g. 'toyota', 'bmw', 'mercedes-benz', 'lada'. Leave empty to scrape all makes for the city. Must match the exact slug drom.ru uses (some brands use special slugs, e.g. 'land_rover', 'cheryexeed' for Exeed) - see AGENTS.md for verified examples.",
                        "default": ""
                    },
                    "modelSlug": {
                        "title": "Model slug",
                        "type": "string",
                        "description": "Drom.ru model URL slug, e.g. 'camry'. Only applied when Make is also set; ignored otherwise.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound on listing price in Russian rubles. Verified working query filter."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (RUB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound on listing price in Russian rubles. Verified working query filter."
                    },
                    "minYear": {
                        "title": "Minimum Year",
                        "minimum": 1940,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Lower bound on manufacture year. Verified working query filter (note: 'yearFrom'/'yearTo' were tested and confirmed non-functional on drom.ru - this Actor uses the correct 'minyear'/'maxyear' params)."
                    },
                    "maxYear": {
                        "title": "Maximum Year",
                        "minimum": 1940,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Upper bound on manufacture year. Verified working query filter."
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Optional: paste your own auto.drom.ru search-result URLs instead of using the fields above (e.g. to use verified-but-not-exposed filters like transmission, engine volume, or drivetrain - see AGENTS.md for the full list). When set, this overrides City/Make/Model/Price/Year filters entirely.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to add full description, generation, trim/complectation, partial VIN, owner count, steering-wheel side, accident/documents flags, and dealer-card detail. Roughly doubles requests and run time.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of search-result pages to paginate through (~20 listings/page). Hard-capped at 10: drom.ru's robots.txt only Allow's crawling through page10 (a blanket Disallow covers pagination beyond that) - see AGENTS.md.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Recon this session found no anti-bot layer on drom.ru at all (plain unproxied requests, including 12 rapid back-to-back, all returned real 200 responses). Datacenter proxy ships as the default for IP diversity at scale; it is not a confirmed technical requirement the way residential is for avito-auto-scraper or cian-real-estate-scraper.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
