# Autovit Scraper - Romanian Car Marketplace Data (`studio-amba/autovit-scraper`) Actor

Scrape car listings from Autovit.ro, Romania's #1 car marketplace. Extract prices in EUR, specs, mileage, fuel type, seller info, and photos. No login or cookies required.

- **URL**: https://apify.com/studio-amba/autovit-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 11 total users, 0 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Autovit Scraper

Scrape car listings from [Autovit.ro](https://www.autovit.ro), Romania's largest and most popular dedicated car marketplace with millions of monthly visitors. Part of the OLX Auto group.

### Why use this scraper?

- **Market research** -- Analyze the Romanian used car market: prices, demand patterns, and inventory levels across makes and models.
- **Price monitoring** -- Track price changes for specific vehicles over time to spot deals or understand depreciation curves.
- **Dealer intelligence** -- Identify active dealers, their inventory size, pricing strategies, and geographic coverage across Romania.
- **Competitive analysis** -- Compare pricing between private sellers (Privat) and professional dealers (Profesionist) across Romanian regions.
- **Import/export analysis** -- Understand price gaps between Romania and other EU markets for arbitrage opportunities. Romanian car prices in EUR make cross-border comparison straightforward.
- **Fleet management** -- Source vehicles for fleet purchases by monitoring bulk availability and price drops.
- **Data journalism** -- Build datasets on Romanian automotive market trends, popular models, fuel type transitions, and regional price differences.
- **Academic research** -- Study consumer behavior, pricing dynamics, and market efficiency in Romania's car market.

### How to scrape Autovit data

1. **Create an Apify account** -- Sign up at [apify.com](https://apify.com) (free tier available).
2. **Open the Autovit Scraper** -- Navigate to this actor's page in the Apify Store.
3. **Configure your search** -- Enter a search query (e.g., "volkswagen golf"), or use the Make and Model fields for precise filtering. Set year range, price range, and fuel type as needed.
4. **Set result limits** -- Choose how many listings you want (default: 100). More results take longer but give a more complete picture.
5. **Run the actor** -- Click "Start" and wait for the run to complete. Most searches finish within 1-5 minutes.
6. **Download your data** -- Export results as JSON, CSV, or Excel from the Dataset tab. Integrate via API for automated workflows.

### Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `searchQuery` | string | Free text search (e.g., "volkswagen golf", "dacia logan", "bmw 320d") | `volkswagen` |
| `make` | string | Car manufacturer (e.g., volkswagen, bmw, dacia, audi, mercedes-benz) | -- |
| `model` | string | Car model (e.g., golf, logan, 320, a4, octavia). Use with Make. | -- |
| `yearFrom` | integer | Minimum year of manufacture | -- |
| `yearTo` | integer | Maximum year of manufacture | -- |
| `priceFrom` | integer | Minimum price in EUR | -- |
| `priceTo` | integer | Maximum price in EUR | -- |
| `fuelType` | string | Fuel type: benzina, diesel, electric, hibrid, gpl | All |
| `maxResults` | integer | Maximum listings to return (1-2000) | 100 |
| `proxyConfiguration` | object | Proxy settings (RO residential recommended) | Apify Residential RO |

### Output example

Each listing produces a JSON object like this:

```json
{
    "listingTitle": "Volkswagen Golf VII 1.6 TDI Comfortline",
    "make": "Volkswagen",
    "model": "Golf VII 1.6 TDI Comfortline",
    "year": 2018,
    "price": 14900,
    "currency": "EUR",
    "mileage": 142000,
    "fuelType": "Diesel",
    "transmission": "Manuala",
    "engineSize": "1598 cm3",
    "power": "115 CP",
    "location": "Bucuresti",
    "sellerType": "Profesionist",
    "imageUrl": "https://ireland.apollo.olxcdn.com/...",
    "url": "https://www.autovit.ro/autoturisme/anunt/volkswagen-golf-...",
    "scrapedAt": "2026-06-09T14:30:00.000Z"
}
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `listingTitle` | string | Full title as shown on the listing |
| `make` | string | Car manufacturer |
| `model` | string | Car model name and variant |
| `year` | integer | Year of manufacture |
| `price` | number | Price in EUR (Romanian car marketplace uses EUR) |
| `currency` | string | Always "EUR" |
| `mileage` | integer | Odometer reading in kilometers |
| `fuelType` | string | Benzina, Diesel, Electric, Hibrid, or GPL |
| `transmission` | string | Automata (automatic) or Manuala (manual) |
| `engineSize` | string | Engine displacement (e.g., "1968 cm3") |
| `power` | string | Engine power (e.g., "150 CP" or "110 kW") |
| `location` | string | Seller location in Romania (city or county) |
| `sellerType` | string | "Privat" (private) or "Profesionist" (dealer) |
| `imageUrl` | string | Main listing photo URL |
| `url` | string | Direct link to the listing on Autovit.ro |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

### Cost estimate

The scraper uses Playwright to render pages. Typical costs on the Apify platform:

- **50 listings** -- ~$0.10-0.15 (under 1 minute)
- **200 listings** -- ~$0.30-0.50 (2-4 minutes)
- **1000 listings** -- ~$1.00-2.00 (10-20 minutes)

Costs depend on proxy usage and the number of pages loaded. Romanian residential proxies are recommended for reliable access.

### Tips and advanced options

- **Empty input works** -- Running the actor with no input will search for "volkswagen" by default and return up to 100 listings.
- **Make + Model is more precise** -- Using the Make and Model fields produces more targeted results than a free text search query.
- **Combine filters** -- Use year range + fuel type + price range together for highly specific searches.
- **EUR pricing** -- Autovit.ro lists car prices in EUR, making it easy to compare with other EU car marketplaces.
- **Popular makes in Romania** -- Dacia, Volkswagen, BMW, Audi, Mercedes-Benz, Skoda, Opel, Ford, Toyota, and Renault are the most listed brands.
- **Proxy selection** -- Romanian residential proxies (RO) give the best results. The default configuration is pre-set for this.
- **Large datasets** -- For scraping the full market (10,000+ listings), run multiple searches by make to stay within rate limits.
- **API integration** -- Use the Apify API to schedule regular runs and feed data into your database, Google Sheets, or BI tools.

### Whole market and listing tracking

Two inputs turn the actor from a search into a market read. Both are off by default, and both read the search pages without a browser, which is faster and cheaper than the normal search.

- **Read the whole market** (`wholeMarket`) reads every passenger-car listing on Autovit.ro, about 45,000 in October 2026. The actor reads each make as its own search, sorted by ad id so pages stay stable while it reads, and checks that the make totals add up to the site total. The result is in the run's `MARKET_READ_SUMMARY` record. The search fields, Max Results, Start URLs and Dealer URLs do not apply in this mode.
- **Track listings between runs** (`trackListings`) remembers every listing of the search, or of the whole market, in a key-value store in your account (`autovit-tracking`). Each run then marks listings as `new` or `active`, notes price changes, adds one row per listing that disappeared since the last run (`status: removed`, `removalClass: potential_sold` or `reposted`) and one `__SEGMENT_SUMMARY__` row with market days supply (`mdsDays`), p25/median/p75 asking price and price bands. A whole-market summary also has a `makes` list with the same numbers per make.

Market days supply is active listings divided by the daily rate of potential sales over the sales window (45 days by default). Autovit.ro does not say why an ad disappeared, so a removal is a potential sale, never a confirmed one. The first complete run only records the listings; removals are counted from the second run on. Listings are only marked removed when a run read every result page. A listing missing from the results is checked on its own ad page first: an ad that is still online stays active, and only the site's "ad no longer available" answer (HTTP 410) counts as a removal.

Every row in these modes carries `listingId`, `sellerType`, `sellerId` and, for dealers, `sellerName`, `dealerId` and `dealerUrl`, so you can group one dealer's own stock and compare it with the market. The result cards do not show the gearbox, so `transmission` is only filled when the title or short description names it. `refreshedAt` is the date on the result card, which moves when a seller refreshes the ad; it is not the creation date, so `listedAt` stays empty and `daysListed` counts from the first run that saw a new listing.

Cost: each row is a dataset item, so a whole-market read is billed per listing like any other run. Schedule the same input weekly to build the history.

### FAQ

**Is web scraping Autovit.ro legal?**
This actor scrapes publicly available data that anyone can see without logging in. It respects robots.txt and does not bypass authentication. Ensure your use case complies with applicable laws and the site's terms of service.

**Do I need an Autovit account?**
No. This scraper accesses only public listing data. No login, cookies, or account credentials are required.

**How does the scraper handle anti-bot protection?**
The actor uses Playwright with anti-detection measures including realistic browser fingerprinting, Romanian Accept-Language headers, and residential proxies. It navigates the site like a real user.

**Can I scrape specific car brands?**
Yes. Use the Make input field (e.g., "dacia", "bmw", "audi") optionally combined with Model for precise filtering.

**What if I get zero results?**
Check that your search terms match cars available on Autovit.ro. Ensure proxy configuration is set to RO residential proxies. Try broader search terms or use common Romanian market makes like Dacia, Volkswagen, or BMW.

**How often is the data updated?**
Autovit.ro listings change constantly as new cars are listed and sold ones are removed. Run the scraper as often as needed -- daily runs are common for price monitoring.

**Can I export to CSV or Excel?**
Yes. After the run completes, go to the Dataset tab and click Export. Choose JSON, CSV, Excel, XML, or other formats.

### About Autovit.ro

Autovit.ro is Romania's largest dedicated online car marketplace, part of the OLX Auto group. With millions of monthly visits, it is the go-to platform for both private sellers and professional car dealers across Romania. The site lists hundreds of thousands of vehicles at any given time, from budget daily drivers to luxury and performance cars.

The platform offers detailed filtering by make, model, year, mileage, fuel type, price range, location, and many other parameters. Listings include photos, detailed technical specifications, seller contact information, and pricing in EUR. Autovit.ro is the primary price reference for the Romanian car market and a key resource for anyone involved in buying, selling, or analyzing vehicles in Romania.

Romania's car market is notable for its use of EUR pricing (unlike most EU countries that use local currency), making Autovit data particularly useful for cross-border price comparison and import/export analysis within the European Union.

# Actor input Schema

## `searchQuery` (type: `string`):

Free text search for cars (e.g., 'volkswagen golf', 'bmw 320', 'dacia logan'). Used when Make is not specified.

## `make` (type: `string`):

Car manufacturer (e.g., volkswagen, bmw, audi, dacia, mercedes-benz, toyota, skoda). Overrides search query for precise filtering.

## `model` (type: `string`):

Car model (e.g., golf, 320, logan, a4, octavia). Must be used together with Make.

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

Minimum year of manufacture (e.g., 2015).

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

Maximum year of manufacture (e.g., 2024).

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

Minimum price in EUR.

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

Maximum price in EUR.

## `fuelType` (type: `string`):

Filter by fuel type.

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

Scrape specific Autovit.ro pages directly instead of running a search. Paste search result URLs (e.g. https://www.autovit.ro/autoturisme/volkswagen?search%5Bfilter_float_year%3Afrom%5D=2020), category/listing URLs, or dealer shop URLs (https://<dealer>.autovit.ro/inventory), one per line (up to 50). When this field is filled, the search fields above are not used.

## `dealerUrls` (type: `array`):

Scrape the full stock of specific dealers instead of running a search. Paste dealer shop URLs, one per line (up to 50), for example https://apantopselection.autovit.ro/inventory. Every car the dealer has published is returned. When this field is filled, the search fields above are not used.

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

Maximum number of car listings to scrape.

## `wholeMarket` (type: `boolean`):

Off by default. When on, the actor reads every passenger-car listing on autovit.ro, splitting the search wherever the site limits how many results one search shows, and ignores the search fields and Max Results. A full read is tens of thousands of rows: check the per-result cost in the README before running it. Every row carries the seller, so each dealer's own stock can be grouped by dealerId.

## `trackListings` (type: `boolean`):

Off by default. When on, the actor reads every result page of the search (or of the whole market) and remembers each listing in a key-value store in your account ("autovit-tracking"). It adds firstSeenAt, lastSeenAt, status (new, active), price changes, one row per listing that disappeared since the last run (status removed, with removalClass potential_sold or reposted), and one **SEGMENT_SUMMARY** row with market days supply (mdsDays) and p25/median/p75 price. autovit.ro does not say why an ad disappeared, so a removal is a potential sale, never a confirmed one. Listings are only marked removed when the run read every result page. Max Results does not apply. Schedule the same input weekly or daily.

## `trackingKey` (type: `string`):

Name of the tracked segment in the store. Leave empty to derive it from the search, so the same search always continues the same history. Set your own for a readable name (letters, digits, - \_ . only). A new key starts a new history.

## `salesWindowDays` (type: `integer`):

Number of past days counted as potential sales for the market days supply: MDS = active listings / (potential sales in the window / window days).

## `priceBands` (type: `array`):

Band edges for the price breakdown in the segment summary, in EUR. Default \[5000, 10000, 15000, 20000, 30000, 50000] gives 0-4999, 5000-9999, ... and 50000+.

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

Proxy settings. Romanian residential proxies recommended for best results.

## Actor input object example

```json
{
  "searchQuery": "volkswagen",
  "maxResults": 5,
  "wholeMarket": false,
  "trackListings": false,
  "salesWindowDays": 45,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RO"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "volkswagen",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RO"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/autovit-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 = {
    "searchQuery": "volkswagen",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RO",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/autovit-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 '{
  "searchQuery": "volkswagen",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RO"
  }
}' |
apify call studio-amba/autovit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/autovit-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/qzIArE9X898XCELNz/builds/XXSAXL1oXKHPkltFv/openapi.json