# Sauto Scraper - Czech Car Marketplace Data (`studio-amba/sauto-scraper`) Actor

Scrape car listings from Sauto.cz, Czech Republic's largest online car marketplace (Seznam.cz group). Extract prices, specs, mileage, fuel type, transmission, seller info, and images. No login or cookies required.

- **URL**: https://apify.com/studio-amba/sauto-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 14 total users, 1 monthly users, 96.8% 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

## Sauto.cz Scraper

Scrape car listings from [Sauto.cz](https://www.sauto.cz), Czech Republic's largest online car marketplace. Part of the Seznam.cz group, Sauto hosts over 100,000 vehicle listings from dealers and private sellers across Czechia.

### How to scrape Sauto data

1. Go to the [Sauto Scraper](https://apify.com/studio-amba/sauto-scraper) page on Apify Store.
2. Click "Try for free" to open the actor in Apify Console.
3. Enter your search criteria — manufacturer name, price range, fuel type, or year range.
4. Click "Start" and wait for the run to finish.
5. Download your data as JSON, CSV, Excel, or connect via API.

No login, cookies, or Sauto.cz account required.

### Why use this actor?

- **Czech car market research** — Track pricing trends, compare dealer vs. private seller prices, analyze inventory by region.
- **Dealer inventory monitoring** — Watch competitor stock levels and pricing across the Czech Republic.
- **Price comparison** — Cross-reference Sauto.cz listings with other European marketplaces (AutoScout24, Mobile.de) for import/export arbitrage.
- **Data journalism & analytics** — Build datasets on Czech automotive market trends, popular models, fuel type shifts, and pricing by region.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Manufacturer name to search (e.g., "volkswagen", "skoda"). Default: "volkswagen" |
| `make` | String | No | Car manufacturer. Overrides searchQuery when set. |
| `model` | String | No | Car model (e.g., "golf", "octavia"). Use with make. |
| `yearFrom` | Integer | No | Minimum first registration year (e.g., 2018) |
| `yearTo` | Integer | No | Maximum first registration year (e.g., 2024) |
| `priceFrom` | Integer | No | Minimum price in CZK |
| `priceTo` | Integer | No | Maximum price in CZK |
| `mileageMin` | Integer | No | Minimum mileage in km (Sauto's own filter) |
| `mileageMax` | Integer | No | Maximum mileage in km (Sauto's own filter) |
| `condition` | String | No | ojete (used), nove (new), predvadeci (demo), havarovane (damaged), veteran |
| `fuelType` | String | No | Fuel type: benzin, nafta, elektro, hybrid, lpg, cng |
| `maxResults` | Integer | No | Maximum listings to return (default: 50). Not used in whole-market mode |
| `wholeMarket` | Boolean | No | Off by default. Reads every passenger-car listing on Sauto.cz |
| `trackListings` | Boolean | No | Off by default. Remembers listings between runs: new, removed, price changes, market days supply |
| `trackingKey` | String | No | Name of the tracked segment (default: derived from the filters) |
| `salesWindowDays` | Integer | No | Days counted as potential sales for market days supply (default: 45) |
| `priceBands` | Array | No | Price band edges in CZK for the segment summary |
| `proxyConfiguration` | Object | No | Proxy settings (RESIDENTIAL + CZ recommended) |

#### Empty input behavior

Running with empty input `{}` will scrape Volkswagen listings (the default search). This ensures the actor always returns data even without explicit configuration.

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `listingTitle` | String | `"Skoda Octavia, 1.6 TDI, Style, Automat"` |
| `make` | String | `"Skoda"` |
| `model` | String | `"Octavia"` |
| `year` | Integer | `2017` |
| `price` | Number | `230000` |
| `currency` | String | `"CZK"` |
| `mileage` | Integer | `215186` |
| `fuelType` | String | `"Nafta"` |
| `transmission` | String | `"Automaticka"` |
| `engineSize` | String | `"1.6 TDI, Style, Automat"` |
| `power` | String | `""` |
| `location` | String | `"Hlavni mesto Praha"` |
| `sellerType` | String | `"Dealer"` |
| `sellerName` | String | `"AAA AUTO"` |
| `dealerId` | String | `"12973177"` (null for private sellers) |
| `listedAt` | String | `"2026-10-14T07:50:48.000Z"` (ad created) |
| `imageUrl` | String | Primary car image URL |
| `imageUrls` | Array | All car image URLs |
| `url` | String | Full listing URL on Sauto.cz |
| `listingId` | String | `"210414413"` |
| `scrapedAt` | String | `"2026-06-09T12:00:00.000Z"` |

### Example output

```json
{
    "listingTitle": "Skoda Octavia, 1.6 TDI, Style, Automat",
    "make": "Skoda",
    "model": "Octavia",
    "year": 2017,
    "price": 230000,
    "currency": "CZK",
    "mileage": 215186,
    "fuelType": "Nafta",
    "transmission": "Automaticka",
    "engineSize": "1.6 TDI, Style, Automat",
    "power": "",
    "location": "Hlavni mesto Praha",
    "sellerType": "Dealer",
    "sellerName": "AAA AUTO",
    "imageUrl": "https://d19-a.sdn.cz/d_19/c_img_qC_A/kQMlcCt5zmC5zFHCpoGx7ZZm/c237.jpeg",
    "imageUrls": [
        "https://d19-a.sdn.cz/d_19/c_img_qC_A/kQMlcCt5zmC5zFHCpoGx7ZZm/c237.jpeg"
    ],
    "url": "https://www.sauto.cz/inzerce/osobni/skoda/octavia/210414413",
    "listingId": "210414413",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
```

### Whole-market mode

Set `wholeMarket` to `true` to read every passenger-car listing on Sauto.cz (about 111,000 on 28 October 2026). Sauto returns at most 10,000 listings per search, so the actor splits the market by make and splits the largest makes (Škoda, Volkswagen) into price bands. It checks that the parts add up to the site's own total and saves the check in the run's key-value store as `MARKET_READ_SUMMARY`.

Price, mileage, year, condition and fuel filters still apply in this mode, so `condition: "ojete"` reads the whole used-car market. Make, model, search query and start URLs are ignored. Every row has `sellerName` and `dealerId`, so you can filter one dealer's own stock out of the market read.

A whole-market run pushes one row per listing, so you pay for about 111,000 results.

### Listing tracking and market days supply

With `trackListings` on, the actor remembers every listing of the search in a key-value store in your account named `sauto-tracking`. Run the same input on a schedule (daily or weekly). Each run then adds:

- `status` on every row: `new` or `active`, with `firstSeenAt`, `previousPrice`, `priceChanged` and `daysListed`.
- One row per listing that disappeared since the last run (`status: removed`). The actor asks Sauto for the ad's own status, so `removalClass` is `potential_sold` (deleted or switched off by the seller), `reposted` (the same car under a new id), `expired`, or `deactivated_by_site` (unpaid, too few photos, duplicate VIN). `siteStatus` and `deactivationReason` hold Sauto's raw values.
- One `__SEGMENT_SUMMARY__` row with active listings, potential sales in the window, `mdsDays` (market days supply = active listings / average daily potential sales), and p25, median and p75 prices.

Sauto never says that a car was sold, so a removal is a potential sale. Listings are only marked removed when the run read every listing of the search; set `maxResults` above the size of the search, or use whole-market mode. The first complete run starts the history; removals are counted from the second run on.

### Filtering tips

#### By fuel type

Use Czech fuel names: `benzin` (petrol), `nafta` (diesel), `elektro` (electric), `hybrid`, `lpg`, `cng`.

#### By price range

Prices are in CZK (Czech Koruna). As a rough guide: 100,000 CZK ~ 4,000 EUR. Set `priceFrom` and `priceTo` to narrow results.

#### By year

Set `yearFrom` and `yearTo` to filter by first registration year. In a normal search, year filtering is done client-side, so the actor fetches more data and filters locally. For large result sets with year filters, increase `maxResults` to ensure enough matches. In whole-market mode the site's own year filter is used.

#### By mileage

Set `mileageMin` and `mileageMax` (km). This uses Sauto's own filter, so no data is fetched and thrown away.

#### Popular manufacturers on Sauto.cz

`skoda`, `volkswagen`, `ford`, `bmw`, `audi`, `mercedes-benz`, `opel`, `peugeot`, `renault`, `toyota`, `hyundai`, `kia`, `citroen`, `seat`, `dacia`, `fiat`, `mazda`, `nissan`, `honda`, `volvo`

### Cost estimate

This actor uses the Sauto.cz public API and is lightweight to run. It charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result scraped. 100 results costs about $0.22; 1,000 results about $2.02. A run's usage cost only settles after it reports SUCCEEDED.

### Limitations

- **Year filtering is client-side in normal searches** — The actor fetches results and filters locally, which may require fetching more data than the final output. Whole-market mode uses the site's own year filter.
- **Engine power not in API** — The search API does not return engine power (kW/HP) data. The `power` field will be empty. Engine variant info (e.g., "1.6 TDI") is available in the `engineSize` field.
- **Personal cars only** — This actor scrapes the "Osobni" (personal/passenger) car category. Commercial vehicles, trucks, and motorcycles are not included.
- **API result limit** — The Sauto.cz API returns at most 10,000 results per search query. Use whole-market mode to read more than that.
- Data is scraped from the public Sauto.cz API and may change without notice.

### About Sauto.cz

Sauto.cz is operated by Seznam.cz, the Czech Republic's largest internet company. It is the country's dedicated car marketplace, distinct from general classifieds sites. With over 100,000 active listings, it covers the full spectrum of the Czech used and new car market, from budget vehicles to premium imports.

# Actor input Schema

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

Optional: paste a Sauto.cz car-search URL (e.g. from your browser's address bar after filtering on the site) instead of setting the fields below. Make/model (from the URL path) and price/year/fuel filters (from the query string) are read from the URL. When set, this replaces the filters below.

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

Manufacturer name to search for (e.g., 'volkswagen', 'skoda', 'bmw', 'audi'). Uses manufacturer SEO slug on Sauto.cz.

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

Car manufacturer (e.g., volkswagen, skoda, bmw). Overrides searchQuery when set.

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

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

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

Minimum first registration year (e.g., 2018). Filtered client-side.

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

Maximum first registration year (e.g., 2024). Filtered client-side.

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

Minimum price in CZK (e.g., 100000 for 100,000 CZK).

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

Maximum price in CZK (e.g., 500000 for 500,000 CZK).

## `mileageMin` (type: `integer`):

Minimum odometer reading in km. Uses Sauto's own mileage filter (km-od on the site).

## `mileageMax` (type: `integer`):

Maximum odometer reading in km. Uses Sauto's own mileage filter (km-do on the site).

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

Vehicle condition, using Sauto's own filter. Leave empty for all.

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

Filter by fuel type.

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

Maximum number of car listings to return. Not used in whole-market mode, which reads every listing.

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

Off by default. When on, the actor reads every passenger-car listing on Sauto.cz (about 111,000 on 28 Oct 2026; you pay for every row), ignoring make, model, search query and start URLs. Price, mileage, year, condition and fuel filters still apply. Sauto returns at most 10,000 listings per search, so the actor splits the market by make and, for the largest makes, by price band, and checks that the parts add up to the site total. Every row carries sellerName and dealerId, so a dealer's own stock can be compared with the market. Year filters use the site's own filter here (manufacturing date first).

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

Off by default. When on, the actor remembers every listing of this search in a key-value store in your account ("sauto-tracking") and adds firstSeenAt, lastSeenAt, status (new, active), price changes, one row per listing that disappeared since the last run (status removed, with removalClass potential_sold, reposted, expired or deactivated_by_site, from Sauto's own ad status), and one **SEGMENT_SUMMARY** row with market days supply and p25/median/p75 prices. A removal is a potential sale, never a confirmed one. Set maxResults above the number of listings in the search (or use whole-market mode): listings are only marked removed when the run read every listing. Schedule the same input daily or weekly.

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

Name of the tracked segment in the store. Leave empty to derive it from the search filters, so the same filters always continue 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 CZK. Default \[100000, 200000, 300000, 500000, 750000, 1000000, 1500000] gives 0-99999, 100000-199999, ... and 1500000+.

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

Proxy settings. Recommended: RESIDENTIAL proxies with CZ country for best results.

## Actor input object example

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

# 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 = {
    "startUrls": [],
    "searchQuery": "volkswagen",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CZ"
    }
};

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

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

```

## MCP server setup

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