DEV Community

Cover image for How to Scrape Autovit Car Listings in Python with Autovit Scraper
ReventaData
ReventaData

Posted on Originally published at apify.com

How to Scrape Autovit Car Listings in Python with Autovit Scraper

By the end of this tutorial you will have a Python script that pulls passenger-car listings from autovit.ro, the Romanian car marketplace, into structured rows: asking price in EUR, make, model, version, year, mileage, fuel, engine power, city and seller type.

Autovit Scraper (reventadata/autovit-scraper) is the Apify Actor built for this site. You send it a search term, and it returns one row per listing. This guide runs it from Python with the Apify API client. The sample rows come from a real run on 16 November 2026 that returned ten listings, not from an invented example. Each row is one car, so you can compare cars without opening each page.


Prerequisites

You need three things:

  1. Python 3, with pip available.
  2. A free Apify account, which you can create with an email address or a GitHub login.
  3. Your API token, from Settings > API & Integrations in Apify Console.

Install the client and export the token:

pip install -U "apify-client~=3.0"
export APIFY_API_TOKEN="your_apify_token_here"
Enter fullscreen mode Exit fullscreen mode

No scraping code is needed on your side. The Actor fetches the public pages for you.


What you'll achieve

You will search Autovit for "golf", read the rows in Python and print a summary for each car: title, price in EUR, year, mileage, city and seller type.

Autovit lists passenger cars only. Each row describes one car, and the rows carry the specification as separate fields, so you can sort or filter them without reading the description text.

The same script works for a buyer comparing asking prices, or for someone tracking new listings of one model. Only the input changes. The script in this guide is the same one you will run, with no extra setup on the Autovit side.


Step 1: Open Autovit Scraper

Open the Autovit Scraper page on Apify Store to see the Actor's description. This tutorial calls it from Python, so you only need its name, reventadata/autovit-scraper.


Step 2: Choose the search

The search is described by these input fields:

  • searchQueries: a list of search terms, one search per term. Leave it empty to browse all passenger cars with the other filters.
  • make and model: the make and model as Autovit writes them, lower case with hyphens, for example volkswagen and seria-3. With a search term they are applied to the results.
  • minPrice and maxPrice: whole numbers in EUR.
  • minYear and maxYear: production year, for example 2018.
  • fuelType: any or electric.
  • sellerType: any, private or professional (dealers).
  • sortBy: relevance, newest (the default when unset), priceAsc or priceDesc.
  • requireKeywordMatch: true keeps only listings where every word of the search term appears in the title, make, model or version. The default is false.
  • maxItems: the cap on rows across all searches.
  • maxPages: the cap on pages per search, 32 listings per page plus one pinned listing.

A value outside the list for fuelType, sellerType or sortBy is refused before the run starts.

The run in this guide used this input:

{
    "searchQueries": ["golf"],
    "maxItems": 10,
    "maxPages": 1
}
Enter fullscreen mode Exit fullscreen mode

Step 3: Run it from Python

This script starts the Actor, waits for it, reads the dataset and prints two lines per listing:

import os
from apify_client import ApifyClient

# 1. Initialise the client with your token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Describe the search: passenger cars matching "golf", up to 10 rows
run_input = {
    "searchQueries": ["golf"],
    "maxItems": 10,
    "maxPages": 1,
}

# 3. Start the Actor and wait for it to finish
run = client.actor("reventadata/autovit-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Read the rows from the run's default dataset
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")

# 5. Print two lines per listing
for item in items:
    title = item.get("title")
    price, year, mileage = item.get("price"), item.get("year"), item.get("mileageKm")
    print(f"{title} | {price} EUR | {year} | {mileage} km")
    print(f"  {item.get('city')}, {item.get('region')} | fuel: {item.get('fuelType')} | seller: {item.get('sellerType')}")
Enter fullscreen mode Exit fullscreen mode

Step 4: Read the output

The loop prints one block per listing. These are the first three blocks of the run, printed by the script above from the run's rows:

Retrieved 10 listings.

Volkswagen Golf | 5000 EUR | 2014 | 198610 km
  Timisoara, Timis | fuel: Diesel | seller: crosslisted
Volkswagen Golf 1.6 Comfortline | 3000 EUR | 2008 | 284449 km
  Bucuresti, Bucuresti | fuel: Benzina | seller: private
Volkswagen Golf 1.6 TDI DPF Style | 4499 EUR | 2012 | 184650 km
  Cluj-Napoca, Cluj | fuel: Diesel | seller: private
Enter fullscreen mode Exit fullscreen mode

In this run all ten rows are Volkswagen Golf cars. Six rows carry the seller type crosslisted, four carry private, and none carries professional.

Each row has the same fields in the same order, and a field the listing does not carry is null.

One complete row from this run, the Volkswagen Golf 1.6 Comfortline in Bucuresti, copied as the Actor returned it:

{
    "id": "7060958415",
    "url": "https://www.autovit.ro/autoturisme/anunt/volkswagen-golf-ver-1-6-comfortline-ID7HR3Q3.html",
    "title": "Volkswagen Golf 1.6 Comfortline",
    "description": "Golf V 2008, 1.6 natural aspirat, benzina, 102 cp, manuala",
    "price": 3000,
    "currency": "EUR",
    "priceIsGross": true,
    "priceBadges": null,
    "priceEvaluation": "NONE",
    "priceDropPercent": null,
    "priceDropLowestPrice": null,
    "make": "Volkswagen",
    "model": "Golf",
    "version": "1.6 Comfortline",
    "year": 2008,
    "mileageKm": 284449,
    "fuelType": "Benzina",
    "gearbox": null,
    "enginePowerHp": 102,
    "countryOrigin": null,
    "city": "Bucuresti",
    "region": "Bucuresti",
    "postedAt": "2026-11-16T19:17:19Z",
    "imageUrl": "https://ireland.apollo.olxcdn.com/v1/files/fzm3wp2gkz242-AUTOVITRO/image;s=640x480",
    "sellerType": "private",
    "dealerName": null,
    "dealerUrl": null,
    "badges": null,
    "originAdId": null,
    "cepikVerified": false,
    "isPromotedTopAd": false,
    "categoryId": "29",
    "matchedKeyword": "golf"
}
Enter fullscreen mode Exit fullscreen mode

The copy above leaves out the engine-capacity field.


Understanding your results

Every row carries 34 fields. The ones you will use most:

  • price and currency: the asking price, EUR in every row of this run.
  • title, make, model, version: the listing title, and the make, model and trim as displayed. version is empty on 7 of the 10 rows.
  • year, mileageKm, fuelType: production year, mileage in km, and fuel as displayed in Romanian (Diesel, Benzina).
  • enginePowerHp (CP) and the engine capacity in cm3: power and engine size as numbers.
  • city, region: the city and county.
  • sellerType: private for a private seller, professional for a dealer, and crosslisted for the seller type the site marks that way. This run has six crosslisted rows.
  • dealerName and dealerUrl: filled only for dealer listings. Empty on all ten rows of this run.
  • priceEvaluation: the site's own price indicator. In this run it is NONE on 8 rows, ABOVE on 1 and IN on 1.
  • description: the short text the seller wrote. Empty on one row.

gearbox, countryOrigin, badges, priceBadges, priceDropPercent and priceDropLowestPrice are null on all ten rows of this run.


Pro tips

  1. Keep sortBy on newest for monitoring. It is the default, and it lists the newest cars first, so a scheduled search shows the latest cars first.
  2. Use requireKeywordMatch for model names. With it on, a search term must appear in the title, make, model or version, so a broad term does not pull in unrelated cars.
  3. Pick the seller type you need. private is applied on Autovit's side. professional is applied to the rows after they are read, so a dealers-only search reads the same pages as an any-seller search.
  4. Start small. Set maxItems to the rows you need and maxPages to 1 while you test. maxItems and maxPages cap the run. The run in this guide returned ten rows from one page in 4.1 seconds.
  5. Compute your own ratios. There is no price-per-kilometre field. Divide price by mileageKm yourself, and skip rows where either is null.

Troubleshooting

  • Zero rows, status SUCCEEDED. Autovit answered and nothing matched. The run's status message says so. Try a broader term or looser filters.
  • Zero rows, status FAILED. Either the input is wrong (the status message says what to fix), or a page could not be read, so matches may have been missed. The status message says which.
  • Fewer rows than expected. Price and year limits are checked on every row, and a listing with no price cannot pass a price limit. Read the run log for the reason.

Autovit's terms of use (Help Center, "Regulament persoane fizice", sections 3.13 and 3.14, Romanian text) restrict downloading and reusing listing data systematically or for disclosure to third parties. Check your use against them before you collect at scale.


Next steps

For current pricing and details, see the Store page.

To repeat a search, save it as an Apify task and attach a schedule, which runs an Actor or task on a cron expression. Datasets export as JSON, CSV, Excel and other formats (dataset docs).

Which model would you track on Autovit? Drop a comment below.

About the author: reventadata builds and publishes data extraction Actors on the Apify Store.

Top comments (0)