# OLX.ro Car Scraper: Romanian Used Car Ads & Prices (`extractify-labs/olx-ro-cars`) Actor

Scrape olx.ro car ads (Autoturisme) with the site's own filters: 134 brands, models, county, year, price, km, fuel, gearbox. Seller, VIN, fair-price check, alerts. No proxy, $1 per 1,000 ads.

- **URL**: https://apify.com/extractify-labs/olx-ro-cars.md
- **Developed by:** [Extractify Labs](https://apify.com/extractify-labs) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 car ads

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

## 🚗 OLX.ro Car Scraper: Romanian Used Car Ads & Prices

Collect car ads from **olx.ro** (the **Autoturisme** section) using the same filters you use on the website: brand, model, county, year, price, mileage, fuel, gearbox, body type and more. Each ad comes back as one clean row with the price in EUR and RON, full car details, the seller, the location, photos, the VIN when the seller shows it, and a **fair-price check** against similar cars. You pay only for the ads you get, **$1 per 1,000 ads**. No subscription, no start fee, no proxy to buy.

Already have a search open on olx.ro? **Paste the link** and the Actor collects exactly that search.

> 🔑 Romanian keywords: *anunțuri auto olx, mașini second hand, autoturisme olx, mașini de vânzare, mașini la mâna a doua, persoană fizică, preț mașini, anunțuri mașini România, scraper olx.*

***

### 📌 Pe scurt (în română)

Acest Actor extrage anunțurile de **autoturisme** de pe **olx.ro**, câte un rând pentru fiecare anunț: marca, modelul, anul, rulajul, prețul (EUR și RON), combustibilul, cutia de viteze, caroseria, puterea, capacitatea motorului, culoarea, VIN-ul (când vânzătorul îl afișează), fotografiile, județul și orașul, plus datele vânzătorului (persoană fizică sau firmă).

- **Filtre ca pe site:** 134 de mărci, modele (de ex. „Logan”, „Seria 3”), toate cele 41 de județe, stare (nou / utilizat), combustibil, cutie de viteze, caroserie, culoare, volan, interval de an, preț, rulaj, putere și capacitate motor, tip vânzător, sortare.
- **Lipești un link de căutare** de pe olx.ro și primești exact acele anunțuri.
- **Anunțurile preluate de pe Autovit** sunt marcate (`isAutovitCrossPost`) și le poți exclude, ca să rămâi doar cu anunțurile publicate direct pe OLX (în mare parte persoane fizice).
- **Verificare de preț:** fiecare anunț este comparat cu mașini similare (aceeași marcă, model, an și rulaj apropiat) din aceeași rulare.
- **Monitorizare:** rulat periodic, îți arată doar anunțurile noi, scumpite / ieftinite sau dispărute și poate trimite un rezumat pe Slack, Discord, Make, n8n sau Zapier.

Plătești doar pentru anunțurile extrase: **1 USD la 1.000 de anunțuri**, fără abonament și fără proxy. olx.ro afișează maximum 1.000 de anunțuri pe căutare; pentru mai multe, Actorul împarte automat căutarea pe mărci, ani și intervale de preț.

> Instrument independent, neoficial. Nu are nicio legătură cu OLX, olx.ro sau Autovit.

***

### 👤 Who it's for

- **🏷️ Dealers and car flippers** looking for private-seller cars priced under the market, by make, model and county, every morning.
- **🔎 Car buyers** tracking a specific car (say, a 2016+ diesel Golf in Cluj) and wanting to know the moment a new one appears or a price drops.
- **📈 Market analysts and data teams** who need Romanian used-car prices, supply and seller mix. Pair it with our **Autovit.ro Used Car Listings Scraper** for the dealer side, and use the Autovit flag here to avoid counting the same car twice.
- **🤖 AI and automation builders** who want a compact, predictable car feed for an agent, a spreadsheet or a Make / n8n / Zapier flow.

***

### ✅ What you get

- **⚙️ Real car filters, applied by olx.ro itself.** 134 brands, models by the name shown on olx.ro, 41 counties, condition, fuel (including plug-in hybrid), gearbox, body, colour, steering side, and year / price / mileage / power / engine-size ranges. No URL building, no numeric ids to look up.
- **🔗 Paste-a-search.** Any olx.ro car search link from your browser works as input.
- **💶 Prices in both currencies.** Each ad keeps the seller's own price and currency, plus olx.ro's conversion into the currency you pick (EUR or RON). Price filters work across both.
- **💸 Fair-price check.** `priceVsMedianPct` and `priceRating` (very\_good … very\_high) compare each ad with similar cars in the same run. `pricePrevious` shows the price before the last price cut.
- **🔁 Autovit-aware.** Roughly a third of olx.ro car ads are dealer ads mirrored from autovit.ro. Every row says whether it is one (`isAutovitCrossPost`, with the `autovitUrl`), and one switch removes them.
- **🧹 No duplicates, no strays.** Promoted "top ads" that olx.ro repeats on every results page are returned only once, and ads olx.ro still files under a brand they don't belong to are skipped, so a brand search returns only that brand.
- **🔑 VIN on about half of the ads**, whenever the seller shows it in the ad, in a clean `vin` field (no extra requests).
- **👤 Seller details.** Name, company name, private or dealer, member since, last online, and whether phone and chat contact are offered.
- **📍 Location.** City, district, county and map coordinates (olx.ro marks when the pin is only approximate).
- **🔔 Monitoring and alerts.** Incremental mode returns only what changed since the last run, with a price history, and can post a summary of new ads and price drops to your webhook.
- **⚡ Fast and cheap by default.** No proxy needed: 100 ads in a few seconds, and the prefilled test run finishes in well under a minute.
- **📦 Full or compact output.** Every field, or 18 key fields for spreadsheets and AI tools.

***

### 📦 What's in scope

This Actor covers the **Autoturisme** (passenger cars) section of **olx.ro**, Romania only.

| Section on olx.ro | Covered? |
|---|---|
| Autoturisme (passenger cars), new and used, private and dealer | ✅ Yes |
| Autoutilitare (vans), Camioane (trucks), Motociclete, Rulote, Remorci | ❌ No |
| Piese auto (parts), Închirieri (rentals) | ❌ No |
| Other OLX countries (Poland, Bulgaria, Portugal…) | ❌ No |

**About the 1,000-ad limit.** olx.ro shows at most **1,000 ads for any one search**. When you ask for more (via **Max ads**), the Actor splits your search: brand by brand (if you didn't choose a brand), then by year band, then by price band, and merges the results without duplicates. A very broad search can still leave some ads out if a single slice holds more than 1,000. The log tells you when that happens, and narrowing the filters picks up the rest. **Pasted search links** are collected as they are, so each link returns up to 1,000 ads.

***

### ⌨️ How to use it

1. **Pick your search.** Either fill in the filters (brand, model, county, year, price…), or paste one or more olx.ro search links under **olx.ro search URLs**. If links are set, the filters are ignored.
2. **Set Max ads.** The default is 100. Raise it for bigger pulls; you pay only for ads actually returned.
3. **Run.** Export the results to Excel, CSV or JSON, or pull them over the API.
4. **Optional: schedule it** with **Incremental mode** on to get only new and changed ads each time.

#### Input fields

| Field | What it does |
|---|---|
| `startUrls` | olx.ro car search links to collect as they are. Overrides the filters. |
| `brands` | Brands as shown on olx.ro, e.g. `Dacia`, `Volkswagen`, `BMW`, `Land Rover`. All 134 olx.ro brands. Empty = all. |
| `models` | Models as shown on olx.ro, e.g. `Logan`, `Golf`, `Seria 3`. A model alone is enough: `Logan` searches Dacia Logan. |
| `query` | Free-text keyword, like the olx.ro search box (e.g. `4x4`, `carte service`). |
| `county` | One of the 41 counties (județe), incl. Bucharest-Ilfov. Empty = all of Romania. |
| `condition` | `any`, `used` or `new`. |
| `fuelTypes` | Any of `petrol`, `diesel`, `lpg`, `hybrid`, `plugin-hybrid`, `electric`. |
| `gearbox` | `any`, `manual` or `automatic`. |
| `bodyTypes` | Any of `sedan`, `hatchback`, `estate-car`, `suv`, `off-road-vehicle`, `coupe`, `cabriolet`, `mvp`, `minibus`, `pickup`. |
| `colors` | Any of `black`, `white`, `gray`, `silver`, `blue`, `red`, `green`, `gold`, `beige`, `other`. |
| `steeringWheel` | `any`, `lhd` (left-hand drive) or `rhd` (right-hand drive). |
| `yearFrom` / `yearTo` | Manufacturing year range. |
| `priceFrom` / `priceTo` | Price range in the price currency. |
| `priceCurrency` | `EUR` (default) or `RON`. olx.ro converts, so a RON range also finds ads listed in EUR. |
| `filterByCurrency` | Keep only ads the seller priced in the price currency. |
| `mileageFrom` / `mileageTo` | Mileage range in km. |
| `powerFrom` / `powerTo` | Engine power range in HP. |
| `engineSizeFrom` / `engineSizeTo` | Engine size range in cm³. |
| `sellerType` | `any`, `private` (persoană fizică) or `business` (firmă / dealer). |
| `excludeAutovitAds` | Drop dealer ads mirrored from autovit.ro and keep only ads posted directly on olx.ro. |
| `sortBy` | Newest first (default), cheapest first, most expensive first, or most relevant. |
| `maxItems` | Stop after this many ads (default 100). |
| `outputMode` | `full` (every field) or `compact` (18 key fields). |
| `descriptionMaxLength` | Cut descriptions to this many characters; `0` removes them. |
| `proxyConfiguration` | Not needed. Leave it off unless your runs get blocked. |
| `incrementalMode`, `stateKey`, `emitUnchanged`, `emitMissing` | Monitoring; see below. |
| `notifyOn`, `notifyMinPriceDropPct`, `notifyTopN`, `notifyWebhookUrl` | Run-end summary of new ads and price drops; see below. |

#### Example 1: the prefilled test run

The 100 newest Dacia ads, done in seconds.

```json
{
  "brands": ["Dacia"],
  "maxItems": 100
}
```

#### Example 2: Dacia Logan from private sellers in Cluj, 2016 or newer, up to €8,000

```json
{
  "models": ["Logan"],
  "county": "2",
  "yearFrom": 2016,
  "priceTo": 8000,
  "priceCurrency": "EUR",
  "sellerType": "private",
  "sortBy": "filter_float_price:asc",
  "maxItems": 200
}
```

`county` takes the olx.ro county id; in the Console you just pick the name from the list (Cluj = `2`, Bucharest-Ilfov = `46`, Timiș = `13`, Iași = `10`, Brașov = `4`).

#### Example 3: paste a search from your browser

```json
{
  "startUrls": [
    { "url": "https://www.olx.ro/auto-masini-moto-ambarcatiuni/autoturisme/?search%5Bfilter_float_price%3Afrom%5D=5000&search%5Bfilter_float_price%3Ato%5D=15000" }
  ],
  "maxItems": 500
}
```

#### Example 4: only ads posted directly on olx.ro (no Autovit mirrors), automatic SUVs

```json
{
  "bodyTypes": ["suv"],
  "gearbox": "automatic",
  "excludeAutovitAds": true,
  "maxItems": 300
}
```

#### Example 5: a daily monitor with a Slack alert on price drops

```json
{
  "brands": ["Volkswagen"],
  "models": ["Golf"],
  "yearFrom": 2016,
  "fuelTypes": ["diesel"],
  "maxItems": 1000,
  "incrementalMode": true,
  "stateKey": "golf-diesel-2016",
  "notifyOn": "both",
  "notifyMinPriceDropPct": 5,
  "notifyWebhookUrl": "https://hooks.slack.com/services/..."
}
```

***

### 📊 Output

One row per ad in the run's dataset, ready to export to JSON, CSV or Excel or to read over the API. Empty values are left out of the row instead of being sent as `null`.

#### Headline fields

| Field | Type | Description |
|---|---|---|
| `offerId` | integer | olx.ro ad id. Stable across runs; use it to de-duplicate. |
| `url` | string | Link to the ad on olx.ro. |
| `title` | string | Ad title. |
| `price` / `currency` | integer / string | Price as listed, in the seller's currency (`EUR` or `RON`). |
| `priceConverted` / `priceCurrencyConverted` | integer / string | The price converted by olx.ro into your price currency. |
| `priceNegotiable` | boolean | The ad shows "Negociabil". |
| `pricePrevious` | integer | Price before the seller's last price cut. |
| `make` / `model` | string | e.g. `Dacia` / `Logan`. |
| `year` | integer | Manufacturing year. |
| `mileageKm` | integer | Mileage in km. |
| `fuelType`, `transmission`, `bodyType`, `condition` | string | Normalised values (e.g. `diesel`, `manual`, `suv`, `used`). |
| `engineCapacityCm3` / `powerHp` | integer | Engine size and power. |
| `color`, `doorCount`, `steeringWheelSide`, `registrationStatus` | | Colour, doors, `lhd`/`rhd`, registered or not. |
| `vin` | string | VIN, when the seller shows it. |
| `images` / `thumbnail` | array / string | Photo URLs (800x600). |
| `seller` | object | `id`, `uuid`, `name`, `companyName`, `about`, `type` (`private` / `dealer`), `memberSince`, `lastSeenAt`, `hasPhone`, `hasChat`. |
| `location` | object | `city`, `district`, `county`, `latitude`, `longitude`, `gpsObfuscated`. |
| `isAutovitCrossPost` / `autovitUrl` | boolean / string | Whether the ad is mirrored from autovit.ro, and its autovit.ro link. |
| `priceVsMedianPct` / `priceRating` | number / string | Fair-price check (see below). |
| `promotionFlags` | object | Paid promotion: `highlighted`, `topAd`, `urgent`. |
| `postedAt`, `refreshedAt`, `validTo`, `scrapedAt` | string | Posted, last bumped, expiry and collection times (ISO 8601). |
| `extraAttributes` / `paramsRaw` | object / array | Every ad attribute, as a simple map and exactly as olx.ro returns it. Nothing is thrown away. |
| `changeType`, `firstSeenAt`, `lastSeenAt`, `priceHistory`, `isRepost` | | Monitoring fields, when **Incremental mode** is on. |

#### Sample row (full mode, shortened)

```json
{
  "offerId": 299700001,
  "url": "https://www.olx.ro/d/oferta/dacia-logan-1-0-sce-2019-IDabc123.html",
  "country": "ro",
  "title": "Dacia Logan 1.0 SCe 2019, carte service, proprietar",
  "description": "Masina este in stare foarte buna, revizii la zi...",
  "price": 6900,
  "currency": "EUR",
  "priceNegotiable": true,
  "priceConverted": 34300,
  "priceCurrencyConverted": "RON",
  "make": "Dacia",
  "model": "Logan",
  "year": 2019,
  "mileageKm": 87000,
  "fuelType": "petrol",
  "transmission": "manual",
  "bodyType": "sedan",
  "condition": "used",
  "engineCapacityCm3": 999,
  "powerHp": 73,
  "color": "white",
  "vin": "UU1XXXXXXXX000000",
  "steeringWheelSide": "lhd",
  "doorCount": 4,
  "registrationStatus": "registered",
  "thumbnail": "https://frankfurt.apollo.olxcdn.com:443/v1/files/<photo-1>/image;s=800x600",
  "images": ["https://frankfurt.apollo.olxcdn.com:443/v1/files/<photo-1>/image;s=800x600"],
  "extraAttributes": { "model": "Logan", "petrol": "Benzina", "rulaj_pana": "87 000 km", "state": "Utilizat" },
  "promotionFlags": { "highlighted": false, "topAd": false, "urgent": false },
  "isAutovitCrossPost": false,
  "postedAt": "2026-09-25T10:14:02+03:00",
  "refreshedAt": "2026-09-26T08:00:11+03:00",
  "validTo": "2026-10-25T10:14:02+03:00",
  "scrapedAt": "2026-09-27T18:31:37+00:00",
  "seller": {
    "id": 10000001,
    "name": "Andrei",
    "type": "private",
    "memberSince": "2018-04-11T09:05:08+03:00",
    "lastSeenAt": "2026-09-27T16:03:51+03:00",
    "hasPhone": true,
    "hasChat": true
  },
  "location": {
    "city": "Cluj-Napoca",
    "county": "Cluj",
    "latitude": 46.77,
    "longitude": 23.59,
    "gpsObfuscated": true
  },
  "priceVsMedianPct": -8.4,
  "priceRating": "good"
}
```

*Values above are illustrative, not a real ad.*

#### Ready-made dataset views

- **Car ads**: photo, title, make, model, year, km, fuel, gearbox, body, power, price, city, county, seller.
- **Price check**: price, converted price, price before cut, % vs similar cars, price rating.
- **Sellers**: seller, company, private or dealer, on olx.ro since, last online, phone / chat, Autovit mirror flag.
- **Vehicle details**: engine, power, gearbox, body, doors, colour, condition, registration, steering, VIN.
- **Changes since last run**: NEW / UPDATED / MISSING / REAPPEARED with first and last seen (monitoring).

#### Compact mode

`outputMode: "compact"` keeps 18 fields: `offerId`, `url`, `country`, `title`, `price`, `currency`, `make`, `model`, `year`, `mileageKm`, `fuelType`, `transmission`, `bodyType`, `condition`, `description`, `engineCapacityCm3`, `powerHp`, `color`. Seller, location, photos, fair-price and monitoring fields are left out. Combine it with `descriptionMaxLength` for small, token-friendly rows.

***

### 💸 Fair-price check

For every ad, the Actor looks at **similar cars in the same run**: same make and model, same 5-year band (e.g. 2015–2019) and same 50,000 km band. When at least **5** such cars are in the run, it compares the ad with their median price (in your price currency):

| `priceRating` | `priceVsMedianPct` |
|---|---|
| `very_good` | 15% or more below the median |
| `good` | 5–15% below |
| `fair` | within ±5% |
| `high` | 5–15% above |
| `very_high` | 15% or more above |

The check is only as good as the sample. It works best on a **single make and model** with a few hundred ads. On small or very mixed runs, many ads won't have 5 comparable cars and will come back without a rating. Condition, equipment and damage aren't part of the comparison, so read the ad before you call it a bargain.

***

### 🔁 Autovit mirrors

Dealers on autovit.ro can have their ads mirrored on olx.ro, so about **30–37% of olx.ro car ads** are the same cars you would find on autovit.ro. Every row tells you which ones:

- `isAutovitCrossPost: true` and `autovitUrl` for mirrored ads.
- **Skip ads mirrored from Autovit** (`excludeAutovitAds`) keeps only ads posted directly on olx.ro. What's left is mostly **private sellers**, the part of the market you won't find on autovit.ro.

Need the dealer side too? Our **Autovit.ro Used Car Listings Scraper** covers autovit.ro in depth. Run both and use `isAutovitCrossPost` here to avoid counting a car twice.

***

### 🔑 VIN

About half of olx.ro car ads show a VIN, and the Actor returns it in `vin` whenever the seller shows it: no extra requests, no extra cost. Use it to check the car's history with a VIN report service of your choice, or to spot the same car listed twice.

***

### 🔔 Monitoring and alerts

Turn on **Incremental mode** and run the Actor on a schedule (hourly, daily…). Each run compares olx.ro with what it saw last time and returns only the changes:

| `changeType` | Meaning |
|---|---|
| `NEW` | Ad seen for the first time. |
| `UPDATED` | Price or details changed. `priceHistory` lists the price seen on each run. |
| `REAPPEARED` | An ad that had disappeared is back (`isRepost: true`). |
| `MISSING` | Gone since last time, usually sold or expired (only with **Also return disappeared ads**). |
| `UNCHANGED` | Only with **Also return unchanged ads**. |

- **The first run builds the baseline**: it remembers the current ads and returns no rows, so it costs nothing. Changes start from the second run.
- Use a different **Monitor name** (`stateKey`) for each search you track.
- If a run stops at **Max ads**, disappeared ads are not reported that time, to avoid false alarms. Give monitors a Max ads above the number of matching ads.
- **Notify on** builds a short summary of new ads and/or price drops (at least **Minimum price drop (%)**) at the end of each run. It is saved in the `olx-ro-cars-notifications` key-value store (`digest-latest`) and, if you set a **Webhook URL**, posted there as JSON. That works with Slack and Discord webhooks, Make, n8n, Zapier or your own endpoint. The webhook URL is stored as a secret input.

***

### 💰 Pricing

**Pay per result: $1.00 per 1,000 ads** ($0.001 per ad), with lower prices on higher Apify plans. Nothing else is charged.

- **No start fee, no subscription, no proxy cost.** A 100-ad run costs $0.10.
- **You control the spend.** **Max ads** caps each run, and the Actor respects your run's spending limit. It stops cleanly when the limit is reached, keeps what it collected, and doesn't crash.
- **Monitoring is cheap.** In incremental mode you pay only for rows returned (new and changed ads), and the baseline run is free.

***

### ❓ FAQ

**How many ads can I get?**
As many as match your search. olx.ro shows up to 1,000 ads per search; above that, the Actor splits the search by brand, year and price band to go further. Pasted links return up to 1,000 ads each.

**How fast is it?**
Very. It reads olx.ro's listing data 50 ads at a time: 100 ads take a few seconds, and a few thousand take a couple of minutes.

**Do I need a proxy?**
No. olx.ro works without one, and the default is no proxy. Switch on Apify Proxy only if your runs ever start getting blocked.

**Can I use my own olx.ro search?**
Yes. Set it up on olx.ro, copy the link from the address bar and paste it into **olx.ro search URLs**.

**Why do some ads have no `priceRating`?**
The fair-price check needs at least 5 similar cars (same make, model, 5-year band and 50,000 km band) in the same run. Run a single make and model with a bigger Max ads to get more ratings.

**Can I get only private sellers?**
Yes: set **Seller** to *Private seller (Persoana fizica)*. Add **Skip ads mirrored from Autovit** to remove dealer mirrors too.

**Does it return phone numbers?**
No. olx.ro shows the phone number only after a click on the ad, and the Actor doesn't do that. You get `seller.hasPhone` and `seller.hasChat`, which say whether the seller offers phone or chat contact, plus the seller's name, type and location.

**What currency are prices in?**
`price` / `currency` are exactly what the seller listed (EUR or RON). `priceConverted` / `priceCurrencyConverted` give olx.ro's conversion into the currency you pick under **Price currency**.

**Does it cover vans, motorcycles or other countries?**
No. It covers olx.ro passenger cars (Autoturisme) only.

**Is collecting seller data allowed?**
The Actor collects only what olx.ro shows publicly. Seller names, locations and similar details can be personal data under the GDPR, so make sure you have a valid legal basis for how you use them.

**Is it legal?**
It reads publicly available ads, without logging in and without getting past any access control, at a polite pace. You're responsible for using the data in line with applicable laws and olx.ro's terms.

***

### ⚖️ Disclaimer

This is an **independent, unofficial tool**. It is **not affiliated with, endorsed by or connected to OLX, olx.ro, Autovit, OLX Group or any of their subsidiaries**. "OLX", "olx.ro" and "Autovit" are trademarks of their respective owners and are used here only to describe what the Actor works with. The Actor collects only publicly available information. Making sure your use of the data complies with applicable law and the website's terms is up to you.

# Changelog

This Actor's version history is a separate document: https://apify.com/extractify-labs/olx-ro-cars/changelog.md

# Actor input Schema

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

Optional. Paste any olx.ro car search you set up in your browser (brand, county, price, fuel, sorting, anything) and the actor collects exactly those results, up to 1,000 ads per link (olx.ro's own limit). When set, the search filters below are ignored.

## `brands` (type: `array`):

Car brands as shown on olx.ro, e.g. Dacia, Volkswagen, BMW, Land Rover (not case-sensitive). All 134 olx.ro brands are supported. Leave empty for all brands.

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

Model names as shown on olx.ro, e.g. Logan, Duster, Golf, Seria 3 (not case-sensitive). Each model only narrows its own brand, and a model on its own is enough: "Logan" searches Dacia Logan.

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

Free-text search, like the olx.ro search box, e.g. "4x4" or "carte service".

## `county` (type: `string`):

Only ads from this county. Leave empty for the whole of Romania.

## `condition` (type: `string`):

New or used cars.

## `fuelTypes` (type: `array`):

One or more fuel types. Leave empty for all.

## `gearbox` (type: `string`):

Manual or automatic.

## `bodyTypes` (type: `array`):

One or more body types. Leave empty for all.

## `colors` (type: `array`):

One or more colours. Leave empty for all.

## `steeringWheel` (type: `string`):

Left-hand drive (standard in Romania) or right-hand drive.

## `yearFrom` (type: `integer`):

Oldest manufacturing year, inclusive.

## `yearTo` (type: `integer`):

Newest manufacturing year, inclusive.

## `priceFrom` (type: `integer`):

Lowest price, in the price currency below.

## `priceTo` (type: `integer`):

Highest price, in the price currency below.

## `priceCurrency` (type: `string`):

Currency for the price filters. olx.ro converts every ad, so a RON price filter also finds ads listed in EUR (and the other way round). Each ad also gets its price converted to this currency.

## `filterByCurrency` (type: `boolean`):

Keep only ads whose seller set the price in the price currency above.

## `mileageFrom` (type: `integer`):

Lowest mileage.

## `mileageTo` (type: `integer`):

Highest mileage.

## `powerFrom` (type: `integer`):

Lowest engine power.

## `powerTo` (type: `integer`):

Highest engine power.

## `engineSizeFrom` (type: `integer`):

Smallest engine displacement.

## `engineSizeTo` (type: `integer`):

Largest engine displacement.

## `sellerType` (type: `string`):

Private sellers or dealers.

## `excludeAutovitAds` (type: `boolean`):

About a third of olx.ro car ads are dealer ads mirrored from autovit.ro. Turn this on to keep only ads posted directly on olx.ro, which are mostly private sellers. Mirrored ads are always marked in the output (isAutovitCrossPost).

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

Order in which olx.ro returns the ads.

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

Stop after this many ads. olx.ro shows at most 1,000 ads per search. Above 1,000, the actor splits the search by brand (if you chose none), then by year band, then by price band to reach more. Pasted search links return up to 1,000 ads each.

## `outputMode` (type: `string`):

Full returns every field. Compact keeps the 18 fields most buyers compare on: id, link, country, title, price, currency, make, model, year, mileage, fuel, gearbox, body, condition, engine size, power, colour and description. Seller, location, photos and price-check fields are left out.

## `descriptionMaxLength` (type: `integer`):

Cut ad descriptions to this many characters. 0 removes the description. Empty keeps it in full.

## `proxyConfiguration` (type: `object`):

Not needed: olx.ro works without a proxy. Only switch on Apify Proxy if your runs start getting blocked.

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

Remember ads between runs and return only what changed: new ads, price or detail changes, and (optionally) ads that disappeared. The first run only builds the baseline, so it returns no ads and costs nothing.

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

Name for this monitor's memory. Use a different name per search you track, e.g. "dacia-logan-cluj". Changing it starts over.

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

Return ads that did not change since the last run too (marked UNCHANGED).

## `emitMissing` (type: `boolean`):

Return ads that were there last time but are gone now (marked MISSING), usually sold or expired. Skipped when the run stops at Max ads, to avoid false alarms.

## `notifyOn` (type: `string`):

Build a short summary of new ads and/or price drops at the end of each run. Needs Incremental mode.

## `notifyMinPriceDropPct` (type: `integer`):

Only report price drops of at least this percentage.

## `notifyTopN` (type: `integer`):

Maximum new ads and price drops listed in each summary.

## `notifyWebhookUrl` (type: `string`):

Optional. POST the summary as JSON to this address, e.g. a Slack or Discord webhook, Make, n8n or Zapier. The summary is always saved in the olx-ro-cars-notifications store too.

## Actor input object example

```json
{
  "brands": [
    "Dacia"
  ],
  "condition": "any",
  "gearbox": "any",
  "steeringWheel": "any",
  "priceCurrency": "EUR",
  "filterByCurrency": false,
  "sellerType": "any",
  "excludeAutovitAds": false,
  "sortBy": "created_at:desc",
  "maxItems": 100,
  "outputMode": "full",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "incrementalMode": false,
  "stateKey": "olx-ro-cars-state",
  "emitUnchanged": false,
  "emitMissing": false,
  "notifyOn": "none",
  "notifyMinPriceDropPct": 5,
  "notifyTopN": 20
}
```

# Actor output Schema

## `results` (type: `string`):

All car ads collected in this run.

# 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 = {
    "brands": [
        "Dacia"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractify-labs/olx-ro-cars").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 = {
    "brands": ["Dacia"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("extractify-labs/olx-ro-cars").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 '{
  "brands": [
    "Dacia"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call extractify-labs/olx-ro-cars --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,extractify-labs/olx-ro-cars"
        }
    }
}
```

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/YEwcICSxWGYIr368r/builds/1EZxqMcJeMMF8S7No/openapi.json