# Sauto.cz Scraper — Czech Used Cars, VIN, Equipment & Dealers (`oswaldocarabano/sauto-scraper`) Actor

Scrape Sauto.cz, the largest Czech car marketplace: price, mileage, year, fuel, gearbox, make/model IDs and location for cars, vans, trucks, motorbikes and campers. Add-on: VIN, full equipment, engine, STK, GPS and dealer phones, emails and company ID. Dealer list mode. No login.

- **URL**: https://apify.com/oswaldocarabano/sauto-scraper.md
- **Developed by:** [Oswaldo Carabano](https://apify.com/oswaldocarabano) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 vehicle listings

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 & API — Czech used car listings, VIN and dealers

**Scrape vehicle listings from Sauto.cz, the largest Czech car marketplace.**
Cars, vans, trucks, motorcycles, quads, trailers, campers, work machinery and
buses, anywhere in the Czech Republic.

Every row carries the price, mileage, year, fuel, gearbox, make and model **with
Sauto.cz's numeric IDs**, the region / district / municipality, the photos, the
Cebia verification flag and the dealer. Turn on the details add-on and the same
row grows to **a median of 95 populated fields**: VIN, full equipment list,
engine, colour, service book, STK date, GPS and the dealer's phones, emails and
company ID (IČO).

Use it as a **Sauto.cz API**: call it over the Apify API and get structured JSON,
CSV or Excel back — Czech used car market data, used cars for sale across the
Czech Republic, and a list of Czech car dealers with their contacts.

**No login. No cookies. No browser.** $0.90 per 1,000 vehicles.

***

### What you can use this for

| If you are… | You want |
|---|---|
| Building a **Czech car price dataset** or valuation model | price, mileage, year, fuel, gearbox, power and make/model IDs on every row |
| A **dealer or importer** watching the market | a daily run filtered by make, model, region or price, sorted by newest |
| Doing **B2B lead generation** for the automotive trade | the dealer list: phones, emails, website, IČO, address, GPS, rating, opening hours |
| Checking a car before buying | VIN, service book, first owner, crash history flag, STK validity, Cebia report link |
| Tracking **EV and hybrid** supply | fuel filter plus battery capacity, range and electric consumption from the add-on |

***

### How much there is (measured 23 Sep 2026)

| Category | Listings |
|---|---:|
| Cars | 106,824 |
| Vans & light commercial | 7,323 |
| Trailers | 2,032 |
| Motorcycles | 1,629 |
| Campers & caravans | 1,391 |
| Trucks | 1,159 |
| Quads & ATVs | 462 |
| Work machinery | 123 |
| Buses | 26 |

Sauto.cz only lets anyone page through the first **10,000 results** of a search.
This actor goes past that automatically: when more than 10,000 listings match, it
splits your search into **price bands** that each fit the window (we verified the
bands add up to the parent total, 106,825 vs 106,824). A local test delivered
10,500 cars in 72 seconds.

***

### What arrives in a row

Every percentage below was measured against the live site on 23 Sep 2026 and
carries its sample size. A field that came back empty every time is not
promised.

#### Search results — every run (n = 987 listings, 10 search profiles)

A **median of 48 populated fields** per row.

| Field | Fill rate |
|---|---:|
| `price_czk`, `price_by_agreement`, `manufacturer`, `model` + IDs, `images`, `image_count`, `region`, `district`, `cebia_verified`, `promoted` | 100% |
| `variant` (trim / engine name) | 95.5% |
| `fuel` | 89.5% |
| `mileage_km` | 89.3% |
| `manufactured_year` | 88.9% |
| `gearbox` | 79.7% |
| `dealer_name`, `dealer_id` *(dealers)* | 100% of dealer rows |
| `first_registration_date` | 61.0% |
| `municipality` | 49.0% |

#### Details add-on — `includeDetails` (n = 300 listings: 193 dealer, 107 private)

A **median of 95 populated fields** per row (p10 70, p90 102).

| Field | Fill rate |
|---|---:|
| `body_type`, `condition`, `price_original_czk`, `listing_status`, `valid_until` | 100% |
| `country_of_origin` | 98.0% |
| `color` | 95.7% |
| `description` | 91.0% |
| `engine_volume_ccm` | 91.0% |
| **`vin`** | **88.7%** |
| `engine_power_kw` | 86.0% |
| `equipment` (full list, Czech labels) and `equipment_grouped` (by category: safety, assist, interior…) | 81.7% |
| `seats` | 73.7% |
| `doors` | 71.7% |
| `drive` | 63.3% |
| `price_without_vat_czk` | 58.0% |
| `service_book` | 58.0% |
| `first_owner` | 53.7% |
| `stk_valid_until` | 51.3% |
| `crashed_in_past` | 42.7% |
| `airbags` | 42.0% |
| `euro_emission_class` | 40.7% |
| `price_leasing_czk` | 33.0% |
| `fuel_consumption_l_100km` | 28.0% |
| `cebia_report_url` | 14.3% |

And for **dealer listings** (n = 193): `dealer_phones`, `dealer_emails`,
`dealer_ico`, GPS and opening hours 100%, `dealer_rating` 99.0%,
`dealer_website` 92.7%.

The add-on opens one extra page per vehicle (about 22× the bandwidth of a
search row), which is why it is **off by default** and billed as its own event.

#### About the VIN

Many dealers tick "hide VIN" on the web page, but the listing data still carries
it. This actor delivers the VIN for **every dealer listing** and adds
`vin_hidden_on_site` so you know which ones the seller chose not to display. For
a private seller who hid it, the VIN is treated like their contact data (see
below).

***

### Dealer mode — `outputType: dealers`

One row per dealer found by your filters: name, logo, **phones, emails, website,
IČO**, street address, city, ZIP, GPS, rating and number of reviews, opening
hours for each day, Facebook / Instagram / LinkedIn, home delivery, and the
dealer's **total number of listings on Sauto.cz**. Deduplicated within the run.

***

### Privacy: dealers vs private sellers

| | Dealer | Private seller |
|---|---:|---:|
| Share of car listings | 92.95% | **7.05%** (7,531 of 106,824) |
| Phone in the source (details) | 100% | 88.8% |
| What we deliver by default | everything | **phone, user ID and a hidden VIN withheld** |

Private sellers are natural persons protected by EU data-protection law (GDPR).
By default their phone number and user ID are withheld, phone numbers or emails
typed into their description are redacted, and the row says so with
`contact_redacted: true`. Turn on `includePrivateSellerContact` only if you have
a lawful basis to process this personal data. Dealers' business contact data is
always delivered.

If a seller cannot be verified as a dealer, the actor treats them as a private
seller.

***

### Input

| Field | Default | Notes |
|---|---|---|
| `category` | `cars` | cars, vans, trucks, motorcycles, quads, trailers, campers, machinery, buses |
| `manufacturer` / `model` | all | as in sauto.cz URLs (`skoda` / `octavia`); an unknown value stops the run with a clear message |
| `fuel`, `gearbox`, `bodyType`, `condition`, `sellerType`, `region` | any | dropdowns |
| `district` | all | e.g. `brno-mesto`, `praha-5` |
| `priceMin` / `priceMax`, `mileageMin` / `mileageMax`, `yearFrom` / `yearTo`, `powerMinKw` | — | |
| `sortBy` | `newest` | newest, cheapest, most expensive, lowest mileage, newest year |
| `maxItems` | 100 | hard cap per run |
| `includeDetails` | `false` | details add-on |
| `outputType` | `cars` | `cars` or `dealers` |
| `includePrivateSellerContact` | `false` | see Privacy |

**Every filter was tested against the live site.** Sauto.cz silently ignores a
value it does not recognise and returns the whole catalogue with HTTP 200, so the
actor checks that a free-text make, model or district really narrowed the
results; if it did not, the run stops with an explanation and nothing is
charged.

***

### Pricing

| Event | Price |
|---|---:|
| Actor start | $0.00001 |
| **Vehicle listing** | **$0.0009** |
| Full vehicle details add-on (only with `includeDetails`) | $0.0011 |
| Dealer profile (only with `outputType: dealers`) | $0.002 |

So 1,000 vehicles cost $0.90, or $2.00 with full details. You are never charged
for an error row or a duplicate. When your maximum charge for the run is
reached, the actor stops cleanly and tells you so; it never delivers rows it has
not charged for.

***

### Output

Results go to the default dataset (one row type per run). The key-value store
holds `RUN_SUMMARY` (matched, delivered, charged, why the run stopped) and
`ERRORS` (always written, empty on a clean run).

***

### Frequently asked questions

**What data can I scrape from Sauto.cz?**
Price, mileage, year, first registration, fuel, gearbox, make and model with IDs,
variant, location, photos, the Cebia flag and the dealer; with the add-on also
VIN, description, equipment, engine power and volume, body, colour, drive, doors,
seats, service book, first owner, STK date, crash flag, VAT price, leasing price,
GPS and the dealer's full contact card.

**Does it need a Sauto.cz account?**
No. No account, no cookies, no browser: the actor reads the same public listing
data the website itself loads.

**Can I get car dealer contacts in the Czech Republic?**
Yes. Use `outputType: dealers`, or turn on the add-on for vehicle rows. Phones,
emails and IČO were present on 100% of the dealer listings measured (n = 193).

**Is there an official Sauto.cz API?**
Not a public one for third parties. This actor gives you the same listing data
as an API: start a run over the Apify API (or on a schedule) and read the
results as JSON, CSV or Excel.

**How many results can one run return?**
Up to 100,000 (`maxItems`). Past Sauto.cz's 10,000-result window the search is
split by price automatically.

**How fresh is the data?**
Live: every run reads Sauto.cz at that moment. Each row carries `scraped_at`,
`created_at`, `updated_at` and `bumped_at`.

***

### Disclaimer

This actor extracts **publicly available** listing data — no login, no session
cookies, no account. You are responsible for how you use the data, including
compliance with the GDPR. It is not affiliated with or endorsed by Sauto.cz or
Seznam.cz.

# Actor input Schema

## `category` (type: `string`):

Which Sauto.cz section to search.

## `manufacturer` (type: `string`):

Brand as it appears in sauto.cz URLs, e.g. skoda, volkswagen, mercedes-benz, bmw. Accents and capitals are fine (Škoda works). Leave empty for all makes. An unknown make stops the run with a clear message and nothing is charged.

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

Model as it appears in sauto.cz URLs, e.g. octavia, golf, 3-series. Needs a make.

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

Filter by fuel type.

## `gearbox` (type: `string`):

Filter by gearbox.

## `bodyType` (type: `string`):

Filter by body type (cars).

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

Filter by condition.

## `sellerType` (type: `string`):

Dealers are companies with a Sauto.cz dealer profile (about 93% of cars); private sellers are registered private persons (about 7%).

## `region` (type: `string`):

Filter by Czech region (kraj).

## `district` (type: `string`):

Optional district (okres) as in sauto.cz URLs, e.g. brno-mesto, praha-5, ostrava-mesto.

## `priceMin` (type: `integer`):

Lowest asking price in Czech koruna.

## `priceMax` (type: `integer`):

Highest asking price in Czech koruna.

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

Lowest odometer reading.

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

Highest odometer reading.

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

Oldest manufacturing year.

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

Newest manufacturing year.

## `powerMinKw` (type: `integer`):

Lowest engine power in kW.

## `sortBy` (type: `string`):

Order of results. Above 10,000 results the run splits the search into price bands and the sort applies inside each band.

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

How many rows to deliver (vehicles, or dealers with outputType = dealers). Beyond Sauto.cz's 10,000-result window the run splits the search by price automatically.

## `includeDetails` (type: `boolean`):

Opens each listing to add ~40 fields: VIN (72%), description (91%), full equipment list (82%), engine power (86%) and volume (91%), colour, body, drive, doors, seats, service book, first owner, STK date, all photos, GPS and, for dealers, phones, emails, website, company ID, rating and opening hours. Charged as a separate event per vehicle. About 1 extra request per vehicle.

## `outputType` (type: `string`):

vehicles: one row per listing. dealers: one row per dealer found by your filters, with phones, emails, website, company ID (IČO), address, GPS, rating, opening hours and total listings on Sauto.cz.

## `includePrivateSellerContact` (type: `boolean`):

Off by default. Private sellers (about 7% of listings) are natural persons protected by EU data-protection law (GDPR): their phone and user ID are withheld, and phone numbers or emails inside their descriptions are redacted. Dealers' business contacts are always included. Turn on only if you have a lawful basis to process this personal data.

## `maxConcurrency` (type: `integer`):

How many listing detail pages to fetch at once when details are on. 4 is fast and polite; the site showed no rate limit at 10 in our tests.

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

Not needed: Sauto.cz answers directly. Set it only if your runs start to be refused; requests then go through your proxy.

## Actor input object example

```json
{
  "category": "cars",
  "manufacturer": "skoda",
  "model": "octavia",
  "fuel": "any",
  "gearbox": "any",
  "bodyType": "any",
  "condition": "any",
  "sellerType": "any",
  "region": "any",
  "sortBy": "newest",
  "maxItems": 50,
  "includeDetails": false,
  "outputType": "cars",
  "includePrivateSellerContact": false,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

One row per vehicle (or per dealer with outputType = dealers).

## `runSummary` (type: `string`):

How many listings matched, how many were delivered and charged, and why the run stopped.

## `errors` (type: `string`):

Every error of the run (always written, empty when there were none). Errors are never charged.

# 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 = {
    "manufacturer": "skoda",
    "model": "octavia",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/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 = {
    "manufacturer": "skoda",
    "model": "octavia",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/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 '{
  "manufacturer": "skoda",
  "model": "octavia",
  "maxItems": 50
}' |
apify call oswaldocarabano/sauto-scraper --silent --output-dataset

```

## MCP server setup

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