# Autovit Scraper (`rastriq/autovit-scraper`) Actor

Scrapes car listings from Autovit.ro (Romania). Extracts price, mileage, year, fuel type, location and more.

- **URL**: https://apify.com/rastriq/autovit-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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 — Romania Used Car Listings, Prices & Mileage

**Autovit Scraper** extracts used car listings from Autovit.ro, a large car marketplace in Romania, and returns structured data: make, model, version, year, mileage, power, price, fuel type, gearbox, origin, city, county and seller type. Filter by make, model, fuel, price range and year range, set how many listings you want, and export JSON, CSV or Excel. Try it first with a small `maxItems` such as 10.

### Why scrape Autovit?

Romania is an active used-car market, and Autovit Scraper gives you structured access to its listings:

- **Dealers and importers:** compare Romanian asking prices with Poland, Portugal or Spain.
- **Price analysts:** benchmark by make, model, fuel type or county.
- **Marketplaces and lead teams:** segment professional dealers versus private sellers.
- **Data teams:** feed dashboards and valuation models with Romanian listings.

### What input does Autovit Scraper accept?

All inputs are optional. Filters narrow the search before the run starts, which reduces cost and time.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `make` | string | none | Car make, for example `BMW`, `Audi`, `Mercedes-Benz`. |
| `model` | string | none | Car model, in the site's slug format, for example `Seria-3` or `A4`. |
| `fuel` | string | none | Fuel type: `benzina`, `motorina`, `electric`, `hybrid`, `gpl`. |
| `minPrice` | integer | none | Minimum price. |
| `maxPrice` | integer | none | Maximum price. |
| `minYear` | integer | none | Minimum first registration year. |
| `maxYear` | integer | none | Maximum first registration year. |
| `maxPages` | integer | `3` | Maximum search result pages to scrape. |
| `maxItems` | integer | `50` | Maximum listings to return. |
| `proxyConfiguration` | object | none | Apify proxy configuration. |

Example: BMW 3 Series diesel, 2018 to 2024, 5,000 to 30,000.

```json
{
  "make": "BMW",
  "model": "Seria-3",
  "fuel": "motorina",
  "minPrice": 5000,
  "maxPrice": 30000,
  "minYear": 2018,
  "maxYear": 2024,
  "maxItems": 500,
  "maxPages": 25
}
```

Example: quick test with defaults and a small limit.

```json
{
  "maxItems": 10,
  "maxPages": 1
}
```

Both `maxPages` and `maxItems` apply, so the run stops at whichever limit is reached first. If you need many listings, raise both.

### What data does Autovit Scraper return?

| Field | Type | Description |
|---|---|---|
| `title` | string | Full listing title, for example "BMW Seria 3 2.0d xDrive" |
| `make` | string | Brand |
| `model` | string | Model name |
| `version` | string | Trim level or engine variant |
| `year` | integer | First registration year |
| `km` | integer | Mileage in kilometres |
| `hp` | integer | Engine power in horsepower |
| `price` | number | Asking price in EUR |
| `currency` | string | Documented as always `EUR` |
| `fuel_type` | string | Diesel, Benzina, Electric, Hybrid, GPL and so on |
| `gearbox` | string | Manuala or Automata |
| `origin` | string | National or imported |
| `city` | string | Seller city |
| `region` | string | Romanian county (Judet) |
| `is_professional` | boolean | `true` for dealers, `false` for private sellers |
| `img_url` | string | Primary listing image |
| `url` | string | Direct link to the listing |
| `scraped_at` | datetime | Timestamp of extraction |

Some fields may be empty when a listing does not show them. Illustrative example of one item (values are made up to show the format, not real data):

```json
{
  "title": "BMW Seria 3 2.0d xDrive",
  "make": "BMW",
  "model": "Seria 3",
  "version": "320d xDrive",
  "year": 2019,
  "km": 112000,
  "hp": 190,
  "price": 21900,
  "currency": "EUR",
  "fuel_type": "Diesel",
  "gearbox": "Automata",
  "origin": "Imported",
  "city": "Cluj-Napoca",
  "region": "Cluj",
  "is_professional": true,
  "img_url": "https://www.autovit.ro/example-image.jpg",
  "url": "https://www.autovit.ro/example-listing",
  "scraped_at": "2026-10-13T10:00:00+00:00"
}
```

### Tips for cleaner Autovit data

- Combine `make` and `model` with a year range to keep each run focused and cheap.
- Use `is_professional` to separate dealer stock from private sellers, and `origin` to compare national versus imported cars.
- Group by `region` (county) to compare asking prices across Romania.
- Run the same filters on a schedule and compare `url` and `price` between runs to detect new listings and price changes.

### How much does it cost to scrape Autovit?

Autovit Scraper uses pay-per-event pricing:

| Event | Price |
|---|---|
| Actor Start (one event per GB of memory, minimum one) | $0.005 |
| Result (each item in the dataset) | $0.0015 |

Worked example with the default 1,024 MB memory (one start event): 1,000 results = 1,000 × $0.0015 + $0.005 = **$1.505**. A default run of 50 results costs 50 × $0.0015 + $0.005 = $0.08, and 500 results cost $0.755. Earlier documentation quoted $1.00 per 1,000 results; the figures above follow the current pricing configuration. Check the Pricing tab for discounts on your plan.

### How to run Autovit Scraper via API

```bash
curl -X POST "https://api.apify.com/v2/acts/rastriq~autovit-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"make":"Dacia","fuel":"benzina","maxItems":100,"maxPages":5}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("rastriq/autovit-scraper").call(run_input={
    "make": "BMW",
    "model": "Seria-3",
    "minYear": 2018,
    "maxItems": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["km"])
```

You can also schedule runs, use webhooks, connect Make, Zapier or n8n, send data to Google Sheets, or call the Actor from AI agents through the Apify MCP server.

### FAQ

**Does a default run return the whole catalogue?** No. The defaults are `maxPages` 3 and `maxItems` 50. Raise both and add filters to get more.

**How do I limit cost?** Use `maxItems` and filters. You pay per result plus the start event.

**What are the right values for `fuel`?** The input description lists `benzina`, `motorina`, `electric`, `hybrid` and `gpl`.

**How do I write the model?** Use the slug style shown in the input description, such as `Seria-3`.

**Are prices always in euros?** The previous documentation states that `price` is in EUR and `currency` is always `EUR`.

**Is it legal?** The Actor reads public listing pages. You are responsible for following the site's terms and data-protection rules for any personal data.

**Where do I get help?** Open an issue on the Actor's Issues tab with the run ID.

### Related Rastriq actors

- [OtoMoto Scraper](https://apify.com/rastriq/otomoto-scraper): Poland
- [Nettiauto Scraper](https://apify.com/rastriq/nettiauto-scraper): Finland
- [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper): European car listings
- [Polovni Automobili Scraper](https://apify.com/rastriq/polovniautomobili-scraper): Serbia vehicle listings

# Actor input Schema

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

Car make to filter (e.g. BMW, Audi, Mercedes-Benz)

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

Car model to filter (e.g. Seria-3, A4)

## `fuel` (type: `string`):

Fuel type: benzina, motorina, electric, hybrid, gpl

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

Minimum price filter

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

Maximum price filter

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

Minimum first registration year

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

Maximum first registration year

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

Maximum number of search result pages to scrape

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

Maximum number of listings to return

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

Apify proxy configuration

## Actor input object example

```json
{
  "maxPages": 3,
  "maxItems": 50
}
```

# Actor output Schema

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

All scraped car listings. Each item contains make, model, year, mileage, price (EUR), fuel type, gearbox, city, region, seller type and image URL.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/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 '{}' |
apify call rastriq/autovit-scraper --silent --output-dataset

```

## MCP server setup

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