# Auto24.ee Scraper - Estonian Car Listings & Prices (`studio-amba/auto24-ee-scraper`) Actor

Scrape car listings from Auto24.ee, Estonia's largest car marketplace. Extract prices, specs, mileage, fuel type, transmission, power, seller info, and images. Filter by make, model, year, price range, and fuel type. No login or cookies required.

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

## Pricing

from $1.20 / 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.
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

## Auto24.ee Scraper

Scrape car listings from [Auto24.ee](https://www.auto24.ee), Estonia's largest car marketplace. Extract prices, specs, mileage, fuel type, transmission, power, seller info, and images from used car listings.

No login or cookies required.

### How to scrape Auto24.ee data

1. Go to the [Auto24.ee Scraper](https://apify.com/studio-amba/auto24-ee-scraper) page on Apify Store.
2. Click **Try for free**.
3. Set your search filters (make, model, year range, price range, fuel type).
4. Click **Start** and wait for the run to finish.
5. Download your data in JSON, CSV, Excel, or connect via API.

### Features

- Search by car make (Volkswagen, BMW, Toyota, Audi, Mercedes-Benz, Skoda, Volvo, and more)
- Filter by model, year range, price range, fuel type, and transmission
- Search passenger cars, SUVs, or commercial vehicles (vans)
- Extract detailed specs: engine size, power (kW), mileage, fuel type, transmission
- Full EUR price as advertised, plus auto24.ee's own VAT wording ("inc. VAT", "includes VAT 24%", "VAT 0% (no VAT accrue)")
- Optional listing-page mode (`fetchDetails`): VAT rate, regular price next to a bargain price, seller type and name, vehicle location, vehicle type, first registration, CO2 (g/km, WLTP or NEDC), seats, doors, displacement, weights, payload, country bought from, and the visible part of the VIN and registration number
- Read specific listings by URL (`detailUrls`) without running a search
- Primary image URL for each listing
- Direct link to the original listing on Auto24.ee
- Pagination support for large result sets
- No login, cookies, or account needed

### Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `searchQuery` | string | Free-text search (e.g., "volkswagen", "SUV"). Used when make is not set. |
| `make` | string | Car manufacturer (e.g., Volkswagen, BMW, Toyota) |
| `model` | string | Car model (e.g., Golf, Passat). Requires make. |
| `vehicleCategory` | string | `passenger-and-suv` (default, the site's Cars tab), `passenger`, `suv`, or `commercial` for vans |
| `yearFrom` | integer | Minimum first registration year |
| `yearTo` | integer | Maximum first registration year |
| `priceFrom` | integer | Minimum price in EUR |
| `priceTo` | integer | Maximum price in EUR |
| `fuelType` | string | Fuel type: petrol, diesel, lpg, electric, hybrid, cng |
| `transmission` | string | Transmission: manual, automatic |
| `maxResults` | integer | Maximum listings to return (default: 100) |
| `fetchDetails` | boolean | Off by default. Opens each listing's own page for the fields in [Listing page fields](#listing-page-fields-fetchdetails). One extra page per listing. While off, those fields are null. |
| `detailUrls` | array | Optional. auto24.ee listing links (e.g. `https://eng.auto24.ee/vehicles/4262149`) to read directly. Skips the search, always returns the listing page fields. Capped by `maxResults`. |
| `proxyConfiguration` | object | Proxy settings (RESIDENTIAL recommended) |

#### Example input

```json
{
    "make": "Volkswagen",
    "model": "Golf",
    "yearFrom": 2018,
    "priceTo": 20000,
    "fuelType": "diesel",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "EE"
    }
}
```

### Output format

Each scraped listing contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `listingTitle` | string | Full listing title |
| `make` | string | Car manufacturer |
| `model` | string | Car model |
| `year` | integer | First registration year |
| `price` | number | Current asking price in EUR (the bargain price when one is advertised) |
| `priceRawText` | string | The price exactly as auto24.ee shows it, e.g. `€45,990` |
| `currency` | string | Price currency (EUR) |
| `vatRawText` | string or null | auto24.ee's VAT wording, verbatim. Search results only show `inc. VAT` or nothing; the listing page (fetchDetails) shows `includes VAT 24%` or `VAT 0% (no VAT accrue)` |
| `vatRate` | number or null | VAT rate stated on the listing (24, 0), null when none is shown |
| `vatStatus` | string or null | `includes-vat`, `vat-0`, `excludes-vat`, `unrecognised`, or null when the listing says nothing. Never inferred from a missing badge; a margin scheme is never assumed |
| `priceIncludesVat` | boolean or null | true only when the listing says VAT above 0% is in the price, false for VAT 0% or VAT excluded, null when the listing says nothing |
| `priceBeforeDiscount` | number or null | Regular price when a lower bargain price is advertised (fetchDetails) |
| `bodyType` | string or null | Body type, e.g. Pickup, Touring |
| `drive` | string or null | Drive type, e.g. Four-wheel drive |
| `mileage` | integer | Mileage in kilometers |
| `fuelType` | string | Fuel type (Petrol, Diesel, Electric, etc.) |
| `transmission` | string | Transmission type (Automatic, Manual) |
| `engineSize` | string | Engine displacement (e.g., 2.0 L) |
| `power` | string | Engine power (e.g., 110 kW) |
| `location` | string or null | Vehicle location from the listing page, e.g. `Tallinn, Estonia` (fetchDetails, otherwise null) |
| `sellerType` | string or null | `Professional` (dealer) or `Private` (fetchDetails, otherwise null) |
| `sellerName` | string or null | Dealer or seller name (fetchDetails) |
| `vehicleType` | string or null | auto24.ee's own vehicle type, e.g. `passenger car` (fetchDetails). Not an EU vehicle category |
| `firstRegistration` | string or null | Month and year of first registration, e.g. `12/2024` (fetchDetails) |
| `color` | string or null | Colour (fetchDetails) |
| `registrationStatus` | string or null | e.g. `Registered in Estonia` (fetchDetails) |
| `detailStatus` | string | `not-requested`, `fetched`, `unavailable` (sold, no data on the page) or `failed` (the listing page could not be loaded; results-page fields kept, listing-page fields null) |
| `co2GramsPerKm` … `registrationNumberStatus` | | See [Listing page fields](#listing-page-fields-fetchdetails) |
| `imageUrl` | string | Primary car image URL |
| `url` | string | Direct link to listing on Auto24.ee |
| `scrapedAt` | string | ISO 8601 scraping timestamp |

### Listing page fields (fetchDetails)

These come from each listing's own page. They are null when `fetchDetails` is off, and null when the listing does not show the value. A missing value is never written as 0.

| Field | Type | Description |
|-------|------|-------------|
| `co2GramsPerKm` | number or null | CO2 emissions in g/km |
| `co2RawLabel` | string or null | The label auto24.ee shows, verbatim, e.g. `CO2` or `CO2 (WLTP)` |
| `co2Method` | string or null | `WLTP` or `NEDC` only when the label says so, `unknown` when the CO2 value has no method, null when there is no CO2 value |
| `seats` | integer or null | Number of seats |
| `doors` | integer or null | Number of doors |
| `engineDisplacementCm3` | integer or null | Displacement in cm3 (null when the listing gives litres only) |
| `powerKw` | integer or null | Power in kW |
| `curbWeightKg` | integer or null | Base curb weight in kg |
| `grossWeightKg` | integer or null | Gross vehicle weight in kg (mostly vans and pickups) |
| `payloadKg` | integer or null | Load carrying capacity in kg (mostly vans and pickups) |
| `boughtFromCountry` | string or null | Country from the "Bought from" line, e.g. `Estonia` |
| `firstRegistration` | string or null | Month and year, e.g. `05/2025` |
| `priceBeforeDiscount` | number or null | Regular price when a bargain price is advertised. `price` is then the bargain (current asking) price |
| `vinVisibleText` | string or null | The VIN exactly as the page shows it, e.g. `JTEARD...` |
| `vinStatus` | string or null | See below |
| `registrationVisibleText` | string or null | The registration plate exactly as the page shows it, e.g. `854...` |
| `registrationNumberStatus` | string or null | See below. Separate from `registrationStatus`, which is the registration and inspection note |

#### VIN and registration number status

auto24.ee hides the full VIN and plate behind a "show VIN" button that needs a CAPTCHA or a login. The actor does not click it, solve CAPTCHAs or log in. It returns what the page shows and says how complete that is:

- `full`: the whole value is on the page
- `partial`: only a masked prefix is shown, e.g. `JTEARD...`. This is not a complete VIN or plate
- `gated`: the row is there but no characters are visible
- `absent`: the listing has no VIN or registration number row

On most listings both are `partial`.

#### Example output

With `fetchDetails` on, from a Toyota Hilux search on 29 September 2026:

```json
{
    "listingTitle": "Toyota Hilux 2.4 110kW",
    "make": "Toyota",
    "model": "Hilux",
    "year": 2023,
    "price": 42995,
    "priceRawText": "EUR 42,995",
    "currency": "EUR",
    "vatRawText": "VAT 0% (no VAT accrue)",
    "vatRate": 0,
    "vatStatus": "vat-0",
    "priceIncludesVat": false,
    "priceBeforeDiscount": null,
    "mileage": 37110,
    "fuelType": "Diesel",
    "transmission": "Automatic",
    "bodyType": "Pickup",
    "drive": "Four-wheel drive",
    "vehicleType": "passenger car",
    "firstRegistration": "05/2023",
    "location": "Tallinn, Estonia",
    "sellerType": "Professional",
    "sellerName": "Elke Mustamäe",
    "url": "https://eng.auto24.ee/vehicles/4337210",
    "detailStatus": "fetched"
}
```

A Renault Master read through `detailUrls` on 30 September 2026 (listing-page fields only):

```json
{
    "price": 28400,
    "priceBeforeDiscount": 29900,
    "vatRawText": "includes VAT 24%",
    "firstRegistration": "04/2025",
    "co2GramsPerKm": 206,
    "co2RawLabel": "CO2 (WLTP)",
    "co2Method": "WLTP",
    "seats": 3,
    "doors": 5,
    "engineDisplacementCm3": 1997,
    "powerKw": 96,
    "curbWeightKg": 2323,
    "grossWeightKg": 3500,
    "payloadKg": 1177,
    "boughtFromCountry": "Estonia",
    "vinVisibleText": "VF1RDA...",
    "vinStatus": "partial",
    "registrationVisibleText": "729...",
    "registrationNumberStatus": "partial",
    "detailStatus": "fetched"
}
```

### Proxy configuration

Auto24.ee may block datacenter IP addresses. For best results, use **RESIDENTIAL** proxies with an Estonian IP:

```json
{
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "EE"
    }
}
```

### Cost estimate

This actor is billed $0.02 per run plus $0.002 per result, so **1,000 results cost about $2.02**. `fetchDetails` does not change the price per result, but it adds one page load per listing, so a run takes longer. Usage cost only settles once a run reports **SUCCEEDED** — reading a dataset mid-run will show a cost far below the real total.

### Tips for best results

- **Start with a specific make** to get focused results. If no make is set, the scraper defaults to "volkswagen".
- **Use year and price filters** to narrow down results and reduce scraping time.
- **Set maxResults** to control how many listings you need. Higher values take longer but give more data.
- **Need VAT, seller, CO2 or weight data?** Turn on `fetchDetails`. The search results only show "inc. VAT" on some prices; the exact rate and "VAT 0%" are on each listing's own page.
- **RESIDENTIAL proxies** are recommended. The site may return 403 errors with datacenter proxies.
- The scraper uses the English version of Auto24.ee (`eng.auto24.ee`) for consistent field extraction.

### About Auto24.ee

Auto24.ee is Estonia's largest online car marketplace, operating since 2001. It features thousands of used and new car listings from both private sellers and professional dealers across Estonia. The platform covers passenger cars, commercial vehicles, motorcycles, and more.

### Use cases

- **Car price comparison** -- Compare prices across makes and models in the Estonian market
- **Market research** -- Track pricing trends for specific vehicle types
- **Inventory monitoring** -- Keep tabs on dealer inventory and new listings
- **Data analysis** -- Build datasets for automotive market analysis in the Baltics
- **Price alerts** -- Monitor price changes for specific car models

### Integrations

Connect Auto24.ee Scraper with other tools using the Apify API:

- Export data to Google Sheets, Excel, or CSV
- Send results to Slack, email, or webhooks
- Store data in databases (PostgreSQL, MongoDB)
- Schedule regular runs for continuous monitoring
- Use with Make, Zapier, or n8n for automation workflows

### Legal notice

This scraper collects only publicly available data from Auto24.ee. No login, authentication, or cookies are required. Always review and comply with the website's terms of service before using scraped data commercially.

# Actor input Schema

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

Free-text search for make or keyword (e.g., 'volkswagen', 'audi', 'SUV'). Used when make is not set.

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

Car manufacturer (e.g., Volkswagen, BMW, Toyota, Audi, Mercedes-Benz, Skoda, Volvo, Ford, Opel, Hyundai).

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

Car model (e.g., Golf, Passat, 3 Series, A4). Requires make to be set.

## `vehicleCategory` (type: `string`):

Which auto24.ee category to search. 'Passenger cars and SUVs' is the site's own Cars tab. Pick 'Commercial vehicles' for vans and light commercials (Toyota ProAce, VW Transporter, Ford Transit). Before version 0.1.15 the actor searched passenger cars only, so SUVs and vans were missing.

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

Minimum first registration year (e.g., 2018).

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

Maximum first registration year (e.g., 2024).

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

Minimum price in EUR.

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

Maximum price in EUR.

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

Filter by fuel type.

## `transmission` (type: `string`):

Filter by transmission type.

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

Maximum number of car listings to return.

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

Off by default. When off, the output holds only what the search results show, and every field listed here is null with detailStatus 'not-requested'. When on, the actor opens every listing's own page on auto24.ee and adds: the exact VAT wording and rate ('includes VAT 24%' or 'VAT 0% (no VAT accrue)'), the regular price when a bargain price is advertised (priceBeforeDiscount; price stays the current asking price), seller type and name, vehicle location, vehicle type, body type, first registration month and year, colour, registration status, CO2 in g/km with the source label and method (WLTP or NEDC only when the label says so), seats, doors, engine displacement in cm3, power in kW, curb weight, gross weight, payload, the 'Bought from' country, and the VIN and registration number exactly as visible (auto24.ee masks both behind a CAPTCHA, so these are usually a prefix with status 'partial'). One extra page load per listing through the unblocking service, run 4 at a time, so a run takes roughly 2 to 5 seconds longer per listing.

## `detailUrls` (type: `array`):

Read these auto24.ee listing pages directly instead of running a search, e.g. https://eng.auto24.ee/vehicles/4262149 (www.auto24.ee/soidukid/<id> links work too). Always returns the full listing-page fields, as with fetchDetails. Search filters are ignored when this is set. Capped by maxResults, at most 2000 URLs.

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

Proxy settings. RESIDENTIAL proxies recommended for Auto24.ee.

## Actor input object example

```json
{
  "searchQuery": "volkswagen",
  "vehicleCategory": "passenger-and-suv",
  "maxResults": 5,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "EE"
  }
}
```

# 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": "EE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/auto24-ee-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": "EE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/auto24-ee-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": "EE"
  }
}' |
apify call studio-amba/auto24-ee-scraper --silent --output-dataset

```

## MCP server setup

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