# Drom.ru Scraper - Cars, Prices, Specs & Sellers (`abotapi/drom-auto-listings-scraper`) Actor

Scrape drom.ru vehicle listings: make/model/year/mileage, price, engine and transmission specs, public masked VIN, seller type and the full specifications table. Make+region search with filters or paste links. Resume, incremental updates and MCP export included.

- **URL**: https://apify.com/abotapi/drom-auto-listings-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 listing records

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Drom.ru Vehicle Listings Scraper

Collect structured vehicle listings from Drom.ru by make, region, price, year and drivetrain, or provide listing and search URLs. A statistics mode returns sold Japan-auction lots with their actual yen prices. Choose whether to read each listing page for its available specifications and seller details. Results are written as JSON records to the Apify dataset.

### Why This Scraper?

- **Search, URLs or sold-lot statistics.** Build searches from filters, provide Drom search and listing links, or read Japan-auction sale prices per make and model.
- **Listing context.** Keep the source URL, region, collection mode and discovery position with each record.
- **Optional details.** Read the listing page for its specification table, description, seller type and public masked VIN when present.
- **Recurring updates.** Resume interrupted runs and classify changes across scheduled runs.
- **Bounded collection.** Set one global item cap; page traversal is unlimited unless you enter an optional page limit.
- **App delivery.** Keep the dataset as the primary output and optionally forward a capped set of records to configured MCP connectors.

### Use Cases

- **Who:** vehicle marketplaces and dealers who need a regional inventory snapshot.
- **Who:** automotive analysts comparing asking prices, model years and mileage across regions.
- **Who:** data teams monitoring selected makes for newly listed or changed vehicles.
- **Who:** importers and valuation analysts who need real Japan-auction sale prices (not asking prices) by make, model, year and grade.
- **Who:** vehicle researchers who need listing-page specifications and public seller signals alongside search-card prices.

### Data You Get

> Sample shape: fields vary by listing and detail availability.

| Field | Example |
|---|---|
| `id` | `712672086` |
| `url` | `https://auto.drom.ru/moscow/audi/a4/712672086.html` |
| `title` | `Audi A4, 2011` |
| `make` | `Audi` |
| `model` | `A4` |
| `year` | `2011` |
| `price` | `830000` |
| `currency` | `RUB` |
| `mileageKm` | `162653` |
| `engine` | `1.8 л (160 л.с.)` |
| `powerHp` | `160` |
| `city` | `Москва` |
| `vinPartial` | masked value when shown publicly |
| `specs` | specification name/value map |
| `description` | seller description when details are fetched |
| `imageUrl` | main listing image URL |
| `photos` | full available image gallery |
| `photoCount` | source photo count |
| `subtitle` | trim or variant |
| `bodyType` | body style |
| `generation` | model generation |
| `complectation` | trim configuration |
| `sellerType` | seller type shown on the page |
| `changeType` | `NEW` |

### How to Use

1. Choose **Search** to build a query from filters, **URLs** to process supplied Drom links, or **Statistics** for sold Japan-auction lots.
2. Add make slugs such as `audi`, `toyota` or `lada`; optionally set a region such as `vladivostok` or `moscow`.
3. Set `maxItems` to cap returned listings. Leave `maxPages` empty to continue until the source ends or the item cap is reached.
4. Enable detail pages when you need the listing specification table and other detail-page fields.
5. For recurring monitoring, enable incremental mode and keep the same state key and search scope.

**Search Audi listings:**

```json
{"mode":"search","makes":["audi"],"maxItems":20}
```

**Filter Toyota listings in Vladivostok:**

```json
{"mode":"search","makes":["toyota"],"region":"vladivostok","maxPrice":2000000,"maxItems":20}
```

**Process a Drom search URL:**

```json
{"mode":"urls","listingUrls":[{"url":"https://auto.drom.ru/audi/"}],"maxItems":20,"fetchDetails":false}
```

**Sold Japan-auction lots for an Audi A4, cheapest first (prices in yen):**

```json
{"mode":"statistics","makes":["audi"],"models":["a4"],"minYear":2012,"maxYear":2016,"statisticsSort":"price_asc","maxItems":50}
```

Statistics records have `recordType` `auction_sale` and `currency` `JPY`. `price` is the actual lot price in yen; `priceInRussiaRub` is Drom's separate estimate for the car in Russia, so no averages are computed for you. With details on, each lot page adds the full photo gallery, description and colour. You can also paste statistics pages (`drom.ru/world/japan/audi/`) or a single sold-lot link in **URLs** mode. Open the **Auction sales** output tab for these records.

#### Run it from your code

**Run it from Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("abotapi/drom-auto-listings-scraper").call(run_input={
    "mode": "search", "makes": ["audi"], "maxItems": 5,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**Run it from JavaScript:**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('abotapi/drom-auto-listings-scraper').call({
  mode: 'search', makes: ['audi'], maxItems: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Proxy and regions

The default input requests Apify Residential with the RU country code. Confirm proxy access and regional response quality for your account before scaling. The region field narrows the Drom path; it does not change the proxy exit country.

### Send results into your apps (MCP connectors)

Optionally send a capped set of returned records to configured MCP connectors. Dataset output remains the primary record store. For Notion, provide the parent page URL or ID.

| Field | What it does |
|---|---|
| `mcpConnectors` | Connector IDs to use; empty disables connector export. |
| `notionParentPageUrl` | Parent page URL or ID for the Notion connector. |
| `maxNotifyListings` | Maximum records sent to each connector during a run. |

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (filters), `urls` (supplied links) or `statistics` (sold Japan-auction lots). |
| `makes` | array | `audi` | Make slugs; an empty list searches all makes (statistics mode needs at least one). |
| `region` | string | empty | Optional Drom region slug. |
| `models` | array | empty | Statistics mode: model slugs such as `a4`; empty reads every model of the make. |
| `minPrice` | integer | empty | Minimum price in RUB (search mode). |
| `maxPrice` | integer | empty | Maximum price in RUB (search mode). |
| `minPriceYen` | integer | empty | Statistics mode: lowest sale price in JPY. |
| `maxPriceYen` | integer | empty | Statistics mode: highest sale price in JPY. |
| `statisticsSort` | string | `newest` | Statistics mode: `newest`, `price_asc`, `price_desc`, `year_asc` or `year_desc`. |
| `minYear` | integer | empty | Earliest model year. |
| `maxYear` | integer | empty | Latest model year. |
| `transmission` | integer | `0` | `0` any, `1` manual, `2` automatic types (including CVT and robotized), `3` CVT, `4` robotized. |
| `drivetrain` | integer | `0` | `0` any, `1` FWD, `2` RWD, `3` 4WD. |
| `listingUrls` | array | Audi examples | Drom search/listing URLs in `{ "url": "..." }` items. |
| `maxItems` | integer | `20` | Global returned-record cap; `0` is unlimited. |
| `maxPages` | integer | unset | Optional page cap; unset or `0` means unlimited. |
| `fetchDetails` | boolean | `true` | Fetch the listing (or sold-lot) page for available detail fields. |
| `proxy` | object | Apify Residential, RU | Apify proxy settings. |
| `resumeFromRunId` | string | empty | Run or dataset ID whose previously collected listings should be skipped. |
| `incrementalMode` | boolean | `false` | Track NEW, UPDATED, UNCHANGED and EXPIRED records between runs. |
| `stateKey` | string | derived | Name for a reusable incremental baseline. |
| `emitUnchanged` | boolean | `false` | Include unchanged listings in the output. |
| `emitExpired` | boolean | `false` | Include disappeared listings as tombstones. |
| `ignoreFieldsForChanges` | array | empty | Additional top-level fields to omit from change detection. |
| `mcpConnectors` | array | empty | MCP connector IDs for optional export. |
| `notionParentPageUrl` | string | empty | Notion parent page URL or ID. |
| `maxNotifyListings` | integer | `50` | Per-connector record limit. |

### Output Example

> Sample shape: illustrative listing output; optional values depend on what the source publishes.

**Audi listing record:**

```json
{
  "id": "712672086",
  "url": "https://auto.drom.ru/moscow/audi/a4/712672086.html",
  "title": "Audi A4, 2011",
  "make": "Audi",
  "model": "A4",
  "year": 2011,
  "price": 830000,
  "currency": "RUB",
  "mileageKm": 162653,
  "gearbox": "вариатор",
  "region": "moscow",
  "recordType": "listing",
  "changeType": "NEW"
}
```

> Sample shape: a sold-lot record carries `recordType` `auction_sale`, `price` in `JPY`, `auctionName`, `auctionDate`, `lotNumber`, `auctionGrade`, `mileageKm` and `engineDisplacementCc`, alongside the shared make, model and year fields.

### Plan Requirement

The actor uses pay-per-event pricing. A run start, each returned listing or sold lot and each detail read may incur the corresponding event charge. The detail event applies only after an extra detail read from search results and a successful record write. An individual pasted listing URL is the primary source and does not incur an extra detail event. Current event prices are shown on the actor's Pricing tab.

### FAQ

#### How much does it cost?

Charges depend on the run, returned listings and detail pages fetched. Set `maxItems` to bound the number of records; consult the Pricing tab for current event prices.

#### Is it legal to scrape Drom.ru?

This actor reads publicly viewable listing pages. You are responsible for following Drom's terms and applicable privacy and data-protection laws, and for having a lawful basis before processing personal data.

#### Can I schedule recurring checks?

Yes. Enable incremental mode and keep the same search scope and state key across scheduled runs. The first run establishes a baseline; later runs classify records against it.

#### Why did a run fail instead of returning an empty dataset?

If every attempted page is refused or unreadable, the actor reports a connection failure instead of presenting that as an empty market. Check the run log and proxy access, then retry with a valid RU connection.

#### Can an AI agent use the output?

Yes. Records are available through the Apify dataset API. Optional MCP connector export can send a capped set of records to supported apps.

### 🔗 Want more car data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🚗 <a href="https://apify.com/abotapi/autotrader-com-scraper"><b>Autotrader US</b></a><br>Scrape US car listings from Autotrader by make, model, ZIP, price, year, body style...</td><td>🏷️ <a href="https://apify.com/abotapi/avito-ru-scraper"><b>Avito.ru Scraper</b></a><br>Scrape structured listings from Avito.ru by region, category, filters, or direct URL...</td></tr>
<tr><td>🚗 <a href="https://apify.com/abotapi/easyauto123-cars-scraper"><b>EasyAuto123 Scraper</b></a><br>Scrape EasyAuto123 vehicle listings into clean structured data. Extract prices, VINs...</td><td>🚗 <a href="https://apify.com/abotapi/cars-com-scraper"><b>Cars.com Scraper</b></a><br>Scrape cars.com listings by make, ZIP and radius. 90+ fields per car: price, MSRP...</td></tr>
<tr><td>🚗 <a href="https://apify.com/abotapi/mobile-de-scraper"><b>mobile.de Scraper</b></a><br>Scrape mobile.de vehicle listings with 30+ fields including price, mileage, registration...</td><td>🚗 <a href="https://apify.com/abotapi/autoscout24-scraper"><b>AutoScout24 Scraper</b></a><br>A lean, production-grade scraper for autoscout24.com. Point it at a search, get back...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/drom-auto-listings-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

search builds drom searches from your filters (makes, region, price, year). urls scrapes exactly the drom search, listing or Japan-auction statistics links you paste. statistics returns sold Japan-auction lots with actual yen prices for the makes (and optional models) you list.

## `makes` (type: `array`):

Make slugs from drom URLs (audi, bmw, toyota, kamaz...). In search mode an empty list searches all makes; statistics mode needs at least one make.

## `minYear` (type: `integer`):

Earliest model year (search and statistics mode).

## `maxYear` (type: `integer`):

Latest model year (search and statistics mode).

## `region` (type: `string`):

Region slug from drom URLs (moscow, vladivostok, krasnoyarsk...). Leave empty for all Russia.

## `minPrice` (type: `integer`):

Minimum listing price in rubles.

## `maxPrice` (type: `integer`):

Maximum listing price in rubles.

## `transmission` (type: `integer`):

0 = any, 1 = manual, 2 = all automatic types (including CVT and robotized), 3 = CVT, 4 = robotized.

## `drivetrain` (type: `integer`):

0 = any, 1 = FWD, 2 = RWD, 3 = 4WD.

## `models` (type: `array`):

Optional model slugs from the drom statistics pages (a4, corolla, land_cruiser). Each model is read for every make; leave empty for all models of the make.

## `minPriceYen` (type: `integer`):

Lowest auction sale price in Japanese yen. Statistics mode only; the RUB price filters apply to search mode.

## `maxPriceYen` (type: `integer`):

Highest auction sale price in Japanese yen. Statistics mode only.

## `statisticsSort` (type: `string`):

Order of sold lots. Statistics mode only.

## `listingUrls` (type: `array`):

Drom search pages, regional search pages, forward pages (/audi/all/page2/), or individual listings (.../<id>.html). Pasted filters and the starting page are preserved. Statistics pages (https://www.drom.ru/world/japan/audi/) and sold lot links are accepted too.

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

Maximum number of listings returned per run. This is the only finite default run cap.

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

Maximum pages walked per search. 0 means no page cap, so Max items is the only cap that stops a run early.

## `fetchDetails` (type: `boolean`):

Read each discovered listing page (or sold-lot page in statistics mode) for full specifications, gallery and public details. Pasted individual listing URLs are always read as their primary source; this option controls extra detail reads from search results.

## `proxy` (type: `object`):

Residential proxies are recommended for reliability. Russian exits match the listing market. If the selected connection is unavailable, a backup connection is tried.

## `resumeFromRunId` (type: `string`):

Run or dataset ID whose collected listings should be skipped (for continuing after an interrupted run).

## `incrementalMode` (type: `boolean`):

Track state between runs and classify every listing as NEW, UPDATED, UNCHANGED or EXPIRED instead of always NEW. Rows already known and unchanged are suppressed.

## `stateKey` (type: `string`):

Named baseline for incremental runs. Leave empty to derive the key from the run scope.

## `emitUnchanged` (type: `boolean`):

In incremental mode, also push rows that did not change (changeType UNCHANGED).

## `emitExpired` (type: `boolean`):

In incremental mode, emit EXPIRED tombstone rows for listings that disappeared from the walked scope.

## `ignoreFieldsForChanges` (type: `array`):

Extra field names that must never mark a row UPDATED.

## `mcpConnectors` (type: `array`):

Apify MCP connector IDs that receive pushed records while the run executes.

## `notionParentPageUrl` (type: `string`):

Notion parent page for the Notion MCP connector.

## `maxNotifyListings` (type: `integer`):

Cap on records sent to MCP connectors per run.

## Actor input object example

```json
{
  "mode": "search",
  "makes": [
    "audi"
  ],
  "region": "",
  "transmission": 0,
  "drivetrain": 0,
  "models": [],
  "statisticsSort": "newest",
  "listingUrls": [
    {
      "url": "https://auto.drom.ru/audi/"
    },
    {
      "url": "https://auto.drom.ru/moscow/audi/"
    },
    {
      "url": "https://auto.drom.ru/audi/all/page2/"
    },
    {
      "url": "https://auto.drom.ru/moscow/audi/a4/712672086.html"
    }
  ],
  "maxItems": 20,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  },
  "resumeFromRunId": "",
  "incrementalMode": false,
  "stateKey": "",
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "mcpConnectors": [],
  "notionParentPageUrl": "",
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `detail` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `auctionSales` (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 = {
    "makes": [
        "audi"
    ],
    "listingUrls": [
        {
            "url": "https://auto.drom.ru/audi/"
        },
        {
            "url": "https://auto.drom.ru/moscow/audi/"
        },
        {
            "url": "https://auto.drom.ru/audi/all/page2/"
        },
        {
            "url": "https://auto.drom.ru/moscow/audi/a4/712672086.html"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/drom-auto-listings-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 = {
    "makes": ["audi"],
    "listingUrls": [
        { "url": "https://auto.drom.ru/audi/" },
        { "url": "https://auto.drom.ru/moscow/audi/" },
        { "url": "https://auto.drom.ru/audi/all/page2/" },
        { "url": "https://auto.drom.ru/moscow/audi/a4/712672086.html" },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/drom-auto-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "makes": [
    "audi"
  ],
  "listingUrls": [
    {
      "url": "https://auto.drom.ru/audi/"
    },
    {
      "url": "https://auto.drom.ru/moscow/audi/"
    },
    {
      "url": "https://auto.drom.ru/audi/all/page2/"
    },
    {
      "url": "https://auto.drom.ru/moscow/audi/a4/712672086.html"
    }
  ]
}' |
apify call abotapi/drom-auto-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/drom-auto-listings-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0ufbuFpP5dAcxeFF3/builds/BB37jiq4xGi9ycOCE/openapi.json