# Sauto.cz Scraper ($0.85/1K): Czech Used Cars & Prices (`tsutseisoftware/sauto-scraper`) Actor

Scrape Sauto.cz, the largest Czech car marketplace: cars, vans, trucks, motorbikes and more by make, model and every website filter. Price, mileage, year, VIN, equipment, dealers; deal score, monitoring of new, cheaper and sold cars, alerts. Ojeté vozy Sauto.cz.

- **URL**: https://apify.com/tsutseisoftware/sauto-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 car or dealers

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

## Sauto.cz Scraper: Czech Used Cars, Prices, VIN & Dealers

Scrape **Sauto.cz**, the largest Czech car marketplace (Seznam.cz), with about 110,000 used and new cars and 1,500 dealers. Search by make and model with **every filter of the website**, or paste any search, listing or dealer URL. Every row has the price, mileage, year, fuel, gearbox, place, dealer and photos; turn on the details for the VIN, the full equipment list in English, engine power, body, colour, history (first owner, service book, technical inspection, damage), VAT price and the dealer's business card.

**$0.85 per 1,000 cars ($0.75 on Gold plans), $1.85 with full details. No extra platform costs.**

> **Česky:** Scraper a API pro **ojeté vozy Sauto.cz** a nové vozy: hledání podle značky a modelu se všemi filtry webu (cena, rok výroby, najeto, palivo, převodovka, karoserie, výkon, kraj a okres, výbava), detail inzerátu s VIN a výbavou, karta autobazaru s IČO, **hlídač cen aut** s upozorněním na nové, zlevněné a prodané inzeráty (Telegram, Slack, Discord, WhatsApp), deal score proti trhu a export do Excelu, CSV nebo JSON.

### Why use this Sauto.cz scraper?

- 🚗 **All nine Sauto.cz sections:** cars, vans, trucks, motorcycles, quads, trailers, campers, work machinery and buses.
- 🔎 **Every filter of the website:** make and model (several in one run), keyword, price, year, mileage, power, engine size, fuel, gearbox, body type, drive, condition (new, used, demonstration, damaged, classic), dealer or private seller, region and district, listed within, colour, air conditioning, country of origin, certified programmes (Cebia, ŠKODA Plus, Das WeltAuto...), history (first owner, service book, valid STK), equipment (tow bar, heated seats, adaptive cruise control and 80 more), seats, doors, airbags, consumption, battery, range, weight, beds and machine hours, and sorting.
- 📈 **Whole searches, not just the first 10,000.** Sauto.cz shows at most 10,000 listings of a search; bigger searches are read in full automatically. The whole Czech car market (about 110,000 cars) in one run.
- ⚡ **Fast:** up to 1,000 cars come at once: 3,000 cars in about 20 seconds.
- 💸 **Deal score against the market:** every car compared with comparable cars (same make, model and fuel, made at most a year apart, similar mileage): the usual price, the difference in % and a score from 0 to 100. Optionally against **the whole Czech market of the model** (its newest 3,000 cars). Filter by "at least 10 % below the usual price".
- 🏪 **Dealers:** the whole stock of any dealer, a dealer list for lead generation (company ID IČO, address, map point, website, Firmy.cz page, rating, opening hours, social links, number of listings) and **Exclude dealers** to leave your own stock out.
- 📬 **Monitoring for scheduled runs:** only new cars and price changes come back, with the previous price and the change in %. **Only price drops**, a minimum change, and cars that were **sold or removed** with the reason Sauto.cz gives (taken down by the seller, expired, removed by the website, relisted under a new ID) and the days they were listed. A "new" car is a newly listed one, not an old listing that only moved into your search.
- 🔔 **Alerts:** Telegram, Slack, Discord, WhatsApp or your own webhook (Zapier, Make, n8n) after each run.
- 🕑 **Price history** over your runs: since when the price holds, lowest price in 30 and 90 days, number of changes.
- 📊 **Free market summary** (SUMMARY record): price, mileage, year and power quartiles for every make and model, cars by fuel, gearbox, body, region and seller type, your own price bands, and with monitoring the cars sold in the window and the **market days supply**.
- 🧾 **Clean, flat output:** numbers as numbers (`price`, `mileageKm`, `powerKw`, `year`), English values next to the Czech ones (`fuel` and `fuelRaw`), equipment in English and Czech, ISO dates, optional price in euros. Extra export formats: a printable HTML report or a Markdown table, besides Excel, CSV and JSON.
- 🔒 **Privacy first:** private sellers' names and IDs are never returned and e-mails and phone numbers are removed from descriptions. Dealers' contacts and private sellers' phone numbers only with their opt-in options.

### What data can you get?

| Group | Fields |
|---|---|
| Car | `id`, `url`, `title`, `category`, `make`, `model` (with IDs and URL names), `variant`, `mileageKm`, `year`, `manufacturingDate`, `firstRegistration`, `fuel`, `gearbox` (English and Czech) |
| Price | `price`, `currency`, `priceEur`, `priceByAgreement`; with details `originalPrice`, `priceWithoutVat`, `vatDeductible`, `priceIsWithoutVat`, `leasingPrice`, `monthlyPayment`, `paymentCount`, `priceNote` |
| Deal | `comparableCount`, `comparableMedianPrice`, `priceVsMedianPercent`, `dealScore`, `dealReference` |
| Place | `region`, `district`, `municipality`, `cityPart`, `zip` (with IDs); with details `latitude`, `longitude` |
| Seller | `sellerType`, `dealerId`, `dealerName`, `dealerUrl`, `dealerLogoUrl` |
| Listing | `imageUrl`, `images`, `imageCount`, `isTopped`, `isPreferredOffer`, `homeDelivery`, `stockId`, `sourceChannel`, `listedAt`, `updatedAt`, `bumpedAt`, `daysOnline`, `cebiaVerified` |
| Details | `vin`, `vinHidden`, `powerKw`, `powerHp`, `engineCcm`, `bodyType`, `condition`, `color`, `colorType`, `drive`, `gears`, `airConditioning`, `doors`, `seats`, `airbags`, `weightKg`, `loadCapacityKg`, `beds`, `machineHours`, `fuelConsumption`, `electricConsumption`, `batteryKwh`, `batteryHealthPercent`, `rangeKm`, `emissionClass`, `countryOfOrigin`, `firstOwner`, `serviceBook`, `stkValidUntil`, `damagedInPast`, `tuned`, `warrantyUntil`, `ecoTaxPaid`, `adaptedForDisabled`, `certifiedProgram`, `cebiaReportUrl`, `equipment`, `equipmentRaw`, `equipmentGrouped`, `equipmentCount`, `description`, `videos`, `validUntil` |
| Dealer card (details, dealers mode) | `dealerIco`, `dealerWebsite`, `dealerFirmyUrl`, `dealerAddress`, `dealerCity`, `dealerZip`, `dealerDistrict`, `dealerRegion`, `dealerLatitude`, `dealerLongitude`, `dealerRating`, `dealerReviewCount`, `dealerDescription`, `dealerOpeningHours`, `dealerFacebook`, `dealerInstagram`, `dealerLinkedin`, `dealerYoutube`, `dealerHomeDelivery`, `dealerListingsTotal`, `listingsMatched` |
| Contacts (options) | `dealerEmails`, `dealerPhones`, `contactNames`, `phone` of dealers (Contact person); `phone` of private sellers (Private sellers' phone numbers) |
| Price history (option) | `priceHistorySince`, `priceHistoryChanges`, `currentPriceSince`, `lowestPrice30d`, `lowestPrice90d`, `highestPrice90d`, `averagePrice90d`, `priceVsAverage90dPercent`, `isLowestPrice90d`, `priceHistory` |
| Monitoring | `changeType`, `changedFields`, `previousPrice`, `priceChange`, `priceChangePercent`, `firstSeenAt`, `removedAt`, `removalReason`, `siteStatus`, `deactivationReason`, `daysListed`, `isRelisted`, `relistedFrom`, `relistedAs` |

Measured on two samples of the 100 newest cars (19 Nov 2026): price, mileage, year, fuel, gearbox, region and photos on 100 % of rows. With details: body type, colour, power, equipment, VIN and country of origin on all or nearly all cars (a VIN may be partly hidden by the dealer), engine size about 98 %, dealer company ID about 94 % of dealers; the other details depend on what sellers fill in and vary between samples: drive, description, service book and first owner 70–80 %, damaged in the past 50–80 %, VAT price about 70 %, emission class 40–90 %, fuel consumption 30–65 %, technical inspection date about 40 %. The deal score is on 85 % of a one-model search (Škoda Octavia) and on fewer rows of mixed searches.

### How to scrape Sauto.cz

1. Enter one or more lines in **Make and model** (e.g. `Skoda Octavia`, `Volkswagen Golf`, `BMW X5`), or paste search URLs from the browser into **Sauto.cz URLs**.
2. Set the website's filters you need (price, year, mileage, fuel, region...).
3. Turn on **Add car details** if you need the VIN, equipment, engine and history.
4. Click **Start**. Download the results as Excel, CSV or JSON, or get them through the API.
5. For alerts, schedule the run (e.g. every morning), turn on **Monitoring: only new or changed listings** and add a Telegram, Slack, Discord or WhatsApp channel.

### Use cases

#### Used Škoda Octavia diesels from 2018, up to 150,000 km

```json
{
  "searches": ["Skoda Octavia"],
  "fuels": ["nafta"],
  "conditions": ["ojete"],
  "yearFrom": 2018,
  "mileageTo": 150000,
  "maxItems": 500
}
```

#### Deals in Prague: at least 10 % below comparable cars, to Telegram every morning

```json
{
  "searches": ["Volkswagen Golf", "Skoda Octavia", "Toyota Corolla"],
  "regions": ["hlavni-mesto-praha"],
  "priceTo": 400000,
  "maxPriceVsMedianPercent": -10,
  "onlyNewOrChanged": true,
  "monitoringKey": "prague-deals",
  "telegramBotToken": "123456:ABC...",
  "telegramChatId": "123456789",
  "maxItems": 0
}
```

#### Watch a competitor's stock: new cars, price drops and sold cars

```json
{
  "dealerIds": ["2173484"],
  "onlyNewOrChanged": true,
  "includeRemovedListings": true,
  "monitoringKey": "competitor-2173484",
  "maxItems": 0
}
```

#### The whole market of one model for a price analysis

```json
{
  "searches": ["Skoda Superb"],
  "conditions": ["ojete"],
  "priceBands": ["200000", "400000", "600000", "800000"],
  "maxItems": 0
}
```

Read the free SUMMARY record for price, mileage and age quartiles and the price bands, and the `dealScore` column for the cheapest cars.

#### Car dealers in South Moravia with their company ID and contacts (lead generation)

```json
{
  "outputType": "dealers",
  "dealerRegions": ["jihomoravsky-kraj"],
  "includeContacts": true,
  "maxItems": 200
}
```

#### Electric cars with a range of at least 400 km and the full details

```json
{
  "fuels": ["elektro"],
  "rangeFromKm": 400,
  "includeDetails": true,
  "maxItems": 100
}
```

#### A search copied from the browser, single listings and a dealer page

```json
{
  "startUrls": [
    { "url": "https://www.sauto.cz/inzerce/osobni/skoda/octavia?palivo=nafta&vyrobeno-od=2018" },
    { "url": "https://www.sauto.cz/osobni/detail/volkswagen/taigo/211479456" },
    { "url": "https://www.sauto.cz/detail-prodejce/autobazar-klokocka/2173484" }
  ],
  "maxItemsPerSearch": 100,
  "maxItems": 300
}
```

A search URL keeps all the filters you set on the website. Listing URLs are read with their details; a dealer page reads the dealer's whole stock.

#### Deal score, explained

Each car is compared with comparable cars: the same make, model and fuel, made at most a year apart, with a similar mileage. `comparableMedianPrice` is their median price, `priceVsMedianPercent` the difference (negative = cheaper) and `dealScore` 50 = the usual price, higher = cheaper. By default the comparison uses every car the run reads (a one-model search gives the most); with **Deal score against the whole market** it uses the newest 3,000 cars of that make and model in the Czech Republic (all of them for most models; `dealReference: market`). With fewer than 3 comparable cars the fields are empty.

#### Monitoring mode, explained

With **Monitoring: only new or changed listings**, each run remembers the cars it saw (per **Monitoring key**) and returns only newly listed cars and cars whose price changed. **Report sold and removed listings** returns the cars of the previous run that are gone, with `removalReason`: `sold` (taken down by the seller, a likely sale), `expired`, `removedBySite` or `relisted` (the same car of the same seller under a new ID, `relistedAs`), and `daysListed`. A car that is still on Sauto.cz but no longer matches your search (e.g. its price went over your limit) is not reported as removed. Unchanged cars are not returned and not charged; every page of results read in monitoring (up to 1,000 cars) and every removal check is charged as a monitoring page. One Monitoring key watches up to 25,000 listings.

### How much does it cost to scrape Sauto.cz?

| | Price |
|---|---|
| Car (or dealer) row | **$0.85 per 1,000** (Bronze $0.82, Silver $0.79, Gold and higher $0.75) |
| Add car details | **+$1.00 per 1,000** cars with details |
| Contact person (dealers' e-mails, phone numbers and contact persons) | +$0.10 per 1,000 rows that have one |
| Private sellers' phone numbers | +$0.10 per 1,000 rows that have one |
| Dealer profile (dealers mode) | +$0.99 per 1,000 dealers |
| Price history | +$0.30 per 1,000 cars with history |
| Run start | $0.003 per run |
| Extra page | $0.30 per 1,000 pages read beyond what the saved rows explain (narrow filters, the whole-market deal score) |
| Monitoring page | $0.30 per 1,000 pages read in monitoring mode (a page has up to 1,000 cars), and per sold/removed check |
| Notification | $0.001 per run that sent a notification |

Examples: 1,000 cars cost about **$0.85**, 1,000 cars with full details **$1.85**, with the dealers' contacts **$1.95**. A daily monitoring check of a search with 300 cars that finds 5 new ones costs about **$0.008**, about $0.25 a month. With the $5 of free monthly credit on the Apify free plan you get about **5,800 cars**.

Cars left out by your filters and unchanged cars in monitoring are never charged as rows. A filter that needs the details (**Description must contain**) can judge a car only after its details are read, so a car it leaves out is charged its details, not as a row. If the saved rows don't cover a run's own cost (e.g. a search with no results), the difference is charged as extra pages; the log says how many. A normal run pays nothing more. You can set a **maximum cost per run**; the run then stops before it is spent.

### Input example

```json
{
  "searches": ["Skoda Octavia"],
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "211479456",
  "source": "sauto",
  "rowType": "car",
  "url": "https://www.sauto.cz/osobni/detail/volkswagen/taigo/211479456",
  "title": "Volkswagen Taigo, TSI85 kW Life 7DSG",
  "category": "Cars",
  "make": "Volkswagen",
  "model": "Taigo",
  "variant": "TSI85 kW Life 7DSG",
  "price": 469900,
  "currency": "CZK",
  "priceWithoutVat": 388347,
  "vatDeductible": true,
  "mileageKm": 23580,
  "year": 2025,
  "firstRegistration": "2025-11-01",
  "fuel": "petrol",
  "fuelRaw": "Benzín",
  "gearbox": "automatic",
  "gears": 7,
  "bodyType": "suv",
  "color": "grey",
  "colorType": "metallic",
  "powerKw": 85,
  "powerHp": 116,
  "engineCcm": 999,
  "vin": "WVGZZZCS8SY085457",
  "vinHidden": false,
  "firstOwner": true,
  "serviceBook": true,
  "stkValidUntil": "2029-11-01",
  "certifiedProgram": "ŠKODA plus",
  "equipment": ["ABS", "Hill start assist", "Automatic headlights", "Car radio", "Keyless entry", "Bluetooth"],
  "equipmentCount": 40,
  "region": "Hlavní město Praha",
  "district": "Hlavní město Praha",
  "sellerType": "dealer",
  "dealerId": "2173484",
  "dealerName": "Autosalon Klokočka Centrum s.r.o. - Centrum zánovních a ojetých vozů",
  "dealerIco": "26435713",
  "dealerWebsite": "https://autoklokocka.cz/",
  "dealerCity": "Praha",
  "dealerRating": 3.5,
  "dealerOpeningHours": ["Mon 09:00-18:00", "Tue 09:00-18:00", "Wed 09:00-18:00", "Thu 09:00-18:00", "Fri 09:00-18:00", "Sat 09:00-13:00", "Sun closed"],
  "imageCount": 35,
  "listedAt": "2026-11-19T18:54:22",
  "comparableCount": 39,
  "comparableMedianPrice": 499900,
  "priceVsMedianPercent": -6.0,
  "dealScore": 53,
  "detailsIncluded": true,
  "searchLabel": "Volkswagen Taigo",
  "scrapedAt": "2026-11-19T18:32:43Z"
}
```

### Limitations

- **Prices** are in Czech koruna as Sauto.cz shows them; `priceEur` adds euros at the ECB rate of the day.
- **VIN:** a dealer can hide part of the VIN on Sauto.cz; such a VIN comes as the website shows it, with the hidden characters as X (`vinHidden: true`).
- **Power, body type and colour** are in the details only (the website's filters for them work without details).
- **Deal score** compares comparable cars; a mixed search (all makes) has fewer comparable cars per model, so more rows have it empty. Turn on **Deal score against the whole market** for a full comparison.
- **Sold or taken down:** Sauto.cz does not say that a car was sold; a listing its seller took down comes back as `removalReason: sold`, a likely sale.
- **Private sellers:** their names and IDs are never returned. Their phone number only with **Private sellers' phone numbers (personal data)**.
- **Filter lists in the input** are those of cars; for vans, trucks, motorcycles and the other sections use the values from a Sauto.cz URL of that section (an unknown value stops the run with the allowed values).
- **Very large runs:** the whole car market (about 110,000 cars) in one run needs 512 MB of memory (Run options); 256 MB is enough for tens of thousands of cars.
- Dates of the listing (`listedAt`, `updatedAt`, `bumpedAt`) are in Czech time with its offset (+01:00 or +02:00); `scrapedAt` is in UTC.
- No proxy is needed.

### For AI agents and API users

- Call the actor with the input above through the Apify API, the Apify MCP server or any integration; results are in the default dataset, the market summary in the `SUMMARY` record of the key-value store.
- For small answers use `"compact": true` and `"maxItems"`.
- Input errors (an unknown make, model, district or filter value) end the run before anything is read, with a message that says what to change.

### Troubleshooting

- **"does not start with a make Sauto.cz knows"** or **"has no model"**: write the make and model as the website does, e.g. `Skoda Octavia`, `Mercedes-Benz C`, `BMW X5`, or copy the search URL from the browser. The message lists the models of the make.
- **Fewer cars than on the website:** check **Max results** (default 100) and **Max listings per search**. The website's default leaves out damaged cars and classics; add them in **Condition**.
- **"Sauto.cz refused the requests"**: a request the website rejects is retried a little later; if rejections continue, the run stops with what it has saved and says so. Run it again later.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### More classified-ad scrapers

The same deal score, monitoring and alerts for another classified-ad site:

- [Bazoš Scraper & New Ad Monitor](https://apify.com/tsutseisoftware/bazos-scraper): Bazoš.cz, .sk, .pl and .at: any section or search, deal score, car fields, new and cheaper ads with alerts
- [Facebook Marketplace Scraper](https://apify.com/tsutseisoftware/facebook-marketplace-scraper): any town, ZIP code or coordinates with a strict radius: price, place, seller, deal score, sold listings, alerts
- [Vinted Scraper](https://apify.com/tsutseisoftware/vinted-scraper): 24 Vinted country sites in one run: price, brand, size, condition in English, deal score, sold items, alerts
- [AutoScout24 Scraper](https://apify.com/tsutseisoftware/autoscout24-scraper): used and new cars from all 8 AutoScout24 countries: price rating, deal score, full specs, dealer stocks, sold listings, alerts
- [Kleinanzeigen Scraper & New Ad Monitor](https://apify.com/tsutseisoftware/kleinanzeigen-scraper): Germany's biggest classifieds: searches past 1,250 ads, deal score, vehicle and electronics fields, price check, new and cheaper ads with alerts
- [Craigslist Scraper](https://apify.com/tsutseisoftware/craigslist-scraper): any Craigslist site, a whole state or country in one run: up to 10,000 ads per search, deal score, removed ads, new ad alerts

### FAQ

#### Is it legal to scrape Sauto.cz?

It reads only publicly available data that Sauto.cz shows to any visitor, without logging in, at a polite pace, and never solves captchas or other challenges. Make sure your use respects the website's terms and the law that applies to you. Private sellers' names and IDs are never returned and e-mails and phone numbers are removed from descriptions. Dealers' e-mails, phone numbers and contact persons (**Contact person (personal data)**) and private sellers' phone numbers (**Private sellers' phone numbers (personal data)**) come only with their options; they are personal data when they belong to a person, so you are responsible for processing them lawfully (e.g. GDPR in the EU: a legitimate purpose, no spam, deletion on request). A phone number the seller chose not to show is never returned. This actor is not affiliated with Sauto.cz or Seznam.cz.

#### How is it different from other Sauto.cz scrapers?

It has every filter of the website and all nine sections, reads searches over the 10,000-listing limit in full, adds a deal score against comparable cars or the whole market, reads dealer stocks and the dealer list, monitors new, cheaper and sold cars with the website's reason and relisted cars, sends alerts, keeps a price history and a market summary with market days supply, and costs $0.85 per 1,000 cars ($0.75 on Gold), $1.85 with full details, with no extra platform costs.

#### Can I get vans, trucks, motorcycles or campers?

Yes, set **Category**. Make and model lines search the makes of that section (e.g. `Iveco Daily` in trucks, `Yamaha` in motorcycles).

#### How many cars can one run return?

As many as the search has: the whole car market is about 110,000 cars. Searches over 10,000 listings are read in price ranges automatically.

#### Can I use it from an AI agent or through MCP?

Yes. The actor works with the Apify MCP server and API, and the compact output keeps agent answers short.

***

More scrapers from the same developer: [tsutseisoftware on Apify](https://apify.com/tsutseisoftware).

Also known as a Sauto.cz API, Sauto.cz car price tracker, Czech used car scraper (Czech: "ojeté vozy Sauto.cz", "hlídač cen aut", "autobazary Sauto").

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/sauto-scraper/changelog.md

# Actor input Schema

## `searches` (type: `array`):

One search per line: a make, or a make and a model as Sauto.cz names them ("Skoda Octavia", "Volkswagen Golf", "BMW X5", "Mercedes-Benz C", "Tesla"). Accents and capitals do not matter. The filters below apply to every line. Empty = the whole category with your filters.

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

Which section of Sauto.cz to search. The make, model and filters belong to it.

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

Search pages copied from the browser with all their filters (https://www.sauto.cz/inzerce/osobni/skoda/octavia?palivo=nafta\&vyrobeno-od=2018), listing URLs (read with their details) and dealer pages (https://www.sauto.cz/detail-prodejce/<name>/<number>: the dealer's whole stock).

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

How many rows to save at most (cars, or dealers in the dealers mode); 0 = no limit. Up to 1,000 cars come in one request, so big runs are quick.

## `dealerIds` (type: `array`):

Read the whole stock of these dealers (the dealerId field of the output, e.g. 2173484). Combined with "Make and model", only those cars of each dealer.

## `keyword` (type: `string`):

Words of the version or title, as the website's own search field "Varianta" (e.g. "RS", "4x4", "DSG").

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

Cars: one row per listing. Dealers: one row per car dealer that has listings in your searches (or, without a search, every dealer on Sauto.cz), with its company ID (IČO), address, map point, website, rating, opening hours, social links and number of listings; charged as "Dealer profile" ($0.99 per 1,000 dealers) besides the row.

## `conditions` (type: `array`):

Empty = new, used and demonstration cars (the website's default, without damaged cars and classics).

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

Lowest price in Czech koruna.

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

Highest price in Czech koruna.

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

Oldest year of manufacture.

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

Newest year of manufacture.

## `mileageFrom` (type: `integer`):

Lowest mileage.

## `mileageTo` (type: `integer`):

Highest mileage.

## `fuels` (type: `array`):

Only these fuels. Empty = all.

## `gearboxes` (type: `array`):

Empty = all.

## `bodyTypes` (type: `array`):

Empty = all.

## `powerFromKw` (type: `integer`):

Lowest engine power in kW.

## `powerToKw` (type: `integer`):

Highest engine power in kW.

## `engineVolumeFrom` (type: `integer`):

Smallest engine displacement.

## `engineVolumeTo` (type: `integer`):

Largest engine displacement.

## `drives` (type: `array`):

Empty = all.

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

Who sells the car.

## `regions` (type: `array`):

Only cars in these regions (kraj). Empty = the whole Czech Republic.

## `districts` (type: `array`):

Only cars in these districts (okres) as in Sauto.cz URLs, e.g. brno-mesto, praha-vychod, plzen-mesto, ostrava-mesto.

## `listingAge` (type: `string`):

Only listings put on Sauto.cz (or renewed) within this time.

## `colors` (type: `array`):

Empty = all.

## `airConditioning` (type: `array`):

Empty = all.

## `countriesOfOrigin` (type: `array`):

Where the car was first sold (imported cars). Empty = all.

## `certifiedPrograms` (type: `array`):

Only cars checked by Cebia or a maker's used-car programme (ŠKODA Plus, Das WeltAuto...).

## `history` (type: `array`):

Only cars with all of these (first owner, valid technical inspection, service book...).

## `priceOptions` (type: `array`):

Only cars with a leasing price or with VAT that a company can deduct.

## `equipment` (type: `array`):

Only cars with all of this equipment (tow bar, heated seats, adaptive cruise control...).

## `otherSpecifications` (type: `array`):

Only cars adapted for disabled drivers.

## `seatsFrom` (type: `integer`):

Fewest seats.

## `seatsTo` (type: `integer`):

Most seats.

## `doorsFrom` (type: `integer`):

Fewest doors.

## `doorsTo` (type: `integer`):

Most doors.

## `airbagsFrom` (type: `integer`):

Fewest airbags.

## `fuelConsumptionTo` (type: `integer`):

Highest average fuel consumption.

## `electricConsumptionTo` (type: `integer`):

Electric cars: highest consumption.

## `batteryCapacityFrom` (type: `integer`):

Electric cars: smallest battery capacity.

## `batteryHealthFrom` (type: `integer`):

Electric cars: lowest battery state of health.

## `rangeFromKm` (type: `integer`):

Electric cars: shortest range.

## `weightFrom` (type: `integer`):

Vans, trucks, trailers: lowest weight.

## `weightTo` (type: `integer`):

Vans, trucks, trailers: highest weight.

## `bedsFrom` (type: `integer`):

Campers and caravans: fewest beds.

## `machineHoursTo` (type: `integer`):

Work machinery: most machine hours.

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

Order of the results. "Newest first" is the website's own order: new listings and freshly promoted ones first. A search read in price ranges (over 10,000 listings) keeps the order inside each range.

## `maxItemsPerSearch` (type: `integer`):

At most this many cars from each search, make and model line or URL. Empty = no limit.

## `splitLargeSearches` (type: `boolean`):

Sauto.cz shows at most 10,000 listings of one search. On: a bigger search is read in price ranges so that all of it comes (the whole car market, about 110,000 listings, in one run). Off: the first 10,000.

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

Opens every saved listing for the VIN (unless the seller hid it), the full equipment list (in English and Czech, also by group), engine power (kW and hp) and displacement, body type, colour, drive, gears, doors, seats, first owner, service book, technical inspection date, damaged in the past, VAT price, leasing price, description, all photos and videos, the map point, and the dealer's business card (company ID IČO, address, map point, website, Firmy.cz page, rating, opening hours, social links). Charged as "Car details" ($1.00 per 1,000 listings with details). Slower: about 4 listings a second.

## `includeContacts` (type: `boolean`):

Dealers only: the dealer's e-mail addresses, phone numbers (also the one behind the website's "Show phone" button) and the names of its contact persons, in their own fields (dealerEmails, dealerPhones, phone, contactNames). Off by default. These are personal data when they belong to a person: you are responsible for processing them lawfully (GDPR) and for the anti-spam rules. They never appear in the log or in notifications. Charged as "Contact details" ($0.10 per 1,000 rows that have at least one). Turns "Add car details" on.

## `includePhoneNumbers` (type: `boolean`):

Private sellers only: the phone number the website shows behind its "Show phone" button (field phone; dealers' numbers come with "Contact person"). Off by default; a number the seller chose not to show is never returned. These are personal data when they belong to a person: you are responsible for processing them lawfully (GDPR) and for the anti-spam rules. They never appear in the log or in notifications. Charged as "Phone number" ($0.10 per 1,000 rows that have one). Turns "Add car details" on.

## `includePriceHistory` (type: `boolean`):

Every price this actor has seen for the car in your earlier runs (with the same Monitoring key): since when the price holds, number of changes, lowest price in 30 and 90 days, highest and average price in 90 days. Best with a scheduled run. Charged as "Price history" ($0.30 per 1,000 listings with history).

## `dealScoreWholeMarket` (type: `boolean`):

The deal score compares every car with comparable cars (same make, model and fuel, a year apart, similar mileage) of your searches. On: with every listing of the same make and model in the Czech Republic (the newest 3,000 of each, at most 50 models a run). Charged as "Extra page" (one per 1,000 cars read for the comparison).

## `addPriceInEur` (type: `boolean`):

The price converted to euros at the European Central Bank's rate of the day (field priceEur). Free.

## `titleKeywords` (type: `array`):

Keep only cars whose title or version contains at least one of these words.

## `excludeKeywords` (type: `array`):

Leave out cars whose title or version contains any of these words (e.g. "na díly", "bez STK").

## `descriptionKeywords` (type: `array`):

With "Add car details": keep only cars whose description contains at least one of these words.

## `excludeDescriptionKeywords` (type: `array`):

With "Add car details": leave out cars whose description contains any of these words.

## `excludeTopped` (type: `boolean`):

Leave out listings their sellers pay to keep on top.

## `onlyWithPrice` (type: `boolean`):

Leave out listings with the price "by agreement".

## `excludeDealers` (type: `array`):

Leave out cars of these dealers (name or dealer ID), e.g. your own stock in a market check.

## `minDealScore` (type: `integer`):

Keep only cars with at least this deal score (50 = the usual price of comparable cars, higher = cheaper). Cars without enough comparable cars are left out.

## `maxPriceVsMedianPercent` (type: `integer`):

Keep only cars at most this much above the median of comparable cars, e.g. -10 = at least 10 % cheaper.

## `dealerName` (type: `string`):

Only dealers whose name contains this text (e.g. "Škoda", "AAA AUTO").

## `dealerRegions` (type: `array`):

Only dealers based in these regions. Empty = all.

## `onlyNewOrChanged` (type: `boolean`):

The first run saves everything and remembers it; later runs save only new listings and listings whose price changed (with the previous price). "New" means listed since the previous run: an older listing that only moved into your search is remembered without being returned (see below). The whole search is read every run, at most 25,000 listings per Monitoring key.

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for every saved search. Empty = "default".

## `includeRemovedListings` (type: `boolean`):

Also a row for every listing that disappeared since the previous run, with the reason Sauto.cz gives (sold or taken down by the seller, expired, removed by the website, relisted under a new ID), the days it was listed and its last price. Checked only when the run read every search to its end.

## `includeUnchanged` (type: `boolean`):

Also save the listings that did not change (changeType "unchanged").

## `onlyNew` (type: `boolean`):

Only newly listed cars, no price changes.

## `onlyPriceDrops` (type: `boolean`):

Of the changed listings only those that got cheaper.

## `minPriceChangePercent` (type: `integer`):

Ignore smaller price changes (e.g. 3 = at least 3 %). The new price becomes the base anyway.

## `skipFirstRun` (type: `boolean`):

The first run only remembers the listings and saves nothing, so you get only real news from then on.

## `skipRelisted` (type: `boolean`):

Leave out "new" listings that are the same car of the same seller listed again under a new ID.

## `newMeansNewListing` (type: `boolean`):

On: a listing put on Sauto.cz before the previous run that only moved into your search (a price change, a renewal) is remembered without being returned. Off: every listing not seen before is new.

## `resetMonitoring` (type: `boolean`):

Forget the remembered state of this Monitoring key and start again.

## `salesWindowDays` (type: `integer`):

Market summary with monitoring: listings sold or removed in this many days and the market days supply (active listings divided by the daily sales).

## `priceBands` (type: `array`):

Upper edges of price bands for the market summary, e.g. 100000, 200000, 400000: the summary counts the cars in each band.

## `telegramBotToken` (type: `string`):

Token of your bot from @BotFather.

## `telegramChatId` (type: `string`):

Chat to send to.

## `slackWebhookUrl` (type: `string`):

Incoming webhook (https://hooks.slack.com/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): receives the cars as JSON.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many cars the message lists.

## `notifyOnlyChanges` (type: `boolean`):

No message after a run that saved nothing.

## `compact` (type: `boolean`):

Only the main fields: title, make, model, version, price, mileage, year, fuel, gearbox, power, body, region, district, seller, photo, deal score, monitoring fields, URL.

## `excludeEmptyFields` (type: `boolean`):

Rows without the fields that have no value (smaller files; every row may have other columns).

## `descriptionMaxLength` (type: `integer`):

Cut descriptions to this many characters. Empty = whole.

## `exportFormats` (type: `array`):

Off by default. Printable HTML report: the results as a clean, branded table with the main columns, made for printing, saving as PDF or sending to someone; for working with the data use Excel or CSV, which have every field. Markdown table: the same columns as text for AI tools, docs or GitHub. The Output tab links the files. Each file has the overview columns of every saved row and nothing is left out, so a run with tens of thousands of rows makes a file of tens of MB that can be slow to open; for big runs use the dataset or its Excel export. Excel (XLSX), CSV and JSON are always in the Output tab and under Export, at no extra cost.

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

No proxy needed: Sauto.cz answers directly. If it keeps refusing your runs, switch to Apify Proxy (automatic).

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searches": [
    "Skoda Octavia"
  ],
  "category": "osobni",
  "maxItems": 20,
  "outputType": "cars",
  "sellerType": "all",
  "sortBy": "newest",
  "splitLargeSearches": true,
  "includeDetails": false,
  "includeContacts": false,
  "includePhoneNumbers": false,
  "includePriceHistory": false,
  "dealScoreWholeMarket": false,
  "addPriceInEur": false,
  "excludeTopped": false,
  "onlyWithPrice": false,
  "onlyNewOrChanged": false,
  "includeRemovedListings": false,
  "includeUnchanged": false,
  "onlyNew": false,
  "onlyPriceDrops": false,
  "skipFirstRun": false,
  "skipRelisted": false,
  "newMeansNewListing": true,
  "resetMonitoring": false,
  "salesWindowDays": 30,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compact": false,
  "excludeEmptyFields": false,
  "exportFormats": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `cars` (type: `string`):

No description

## `excel` (type: `string`):

All saved rows as an Excel file, with every field.

## `htmlReport` (type: `string`):

The saved rows with the main columns as a clean table to print, save as PDF or send; only when "Extra export formats" includes it. Excel has every field.

## `markdown` (type: `string`):

The saved rows as a Markdown table, handy for AI tools, docs and GitHub; only when "Extra export formats" includes Markdown.

## `summary` (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 = {
    "searches": [
        "Skoda Octavia"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/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 = {
    "searches": ["Skoda Octavia"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/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 '{
  "searches": [
    "Skoda Octavia"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/sauto-scraper --silent --output-dataset

```

## MCP server setup

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