# Bazoš Scraper & New Ad Monitor: CZ, SK, PL, AT (`tsutseisoftware/bazos-scraper`) Actor

Scrape Bazoš.cz, Bazoš.sk, Bazos.pl and Bazos.at: every section, any search URL. Watch a search for new and cheaper ads with alerts to Telegram, Slack or Discord, deal score vs. similar ads, car fields, full details. Unofficial.

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

## Pricing

from $1.89 / 1,000 ads

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

## Bazoš Scraper & New Ad Monitor: CZ, SK, PL, AT

Get classified ads from **Bazoš.cz**, **Bazoš.sk**, **Bazos.pl** and **Bazos.at**, the biggest free classifieds sites of the Czech Republic and Slovakia, as clean structured data: title, **price as a number** with its currency and type ("Dohodou", "Zdarma"), town and **postal code**, section and category, date, views, the **TOP** mark and photos. Optionally the actor opens each ad page and adds the whole description (e-mails and phone numbers removed), every photo and the map point of the postal code.

Paste **any URL** of the website (a section, a category, a search with words, postal code, radius and price) or build the search from the inputs. Every ad gets a **deal score**: its price against the median of comparable ads, so bargains stand out. Car and motorbike ads can get **vehicle fields** (make, year, mileage, power, fuel, gearbox), phones and electronics **item fields** (model, storage, RAM, battery health, condition, warranty), all read from their text. A **price check** tells you what an item goes for on Bazoš, the **price history** shows how an ad's price moved, and a **market report** shows what sells and how fast.

Built for **watching Bazoš**: schedule it every hour in monitoring mode and you get, and pay for, only the ads that are **new or cheaper**, with an **alert to Telegram, Slack, Discord, WhatsApp or your webhook**. After the first run each check **finds every new ad, even under hundreds of TOP ads**, and an hourly check without news costs a fraction of a cent.

**Price:** $2.49 per 1 000 ads; an hourly monitor of one search ≈ **$2.30 a month** plus the new ads. No proxy and no Bazoš account needed.

> **Česky / Slovensky:** Scraper inzerátů z **Bazoš.cz, Bazoš.sk, Bazos.pl a Bazos.at**: všechny rubriky, libovolná URL hledání (slovo, PSČ, okruh, cena). Cena jako číslo, obec a PSČ, datum, zobrazení, TOP, fotky, volitelně celý popis. **Hlídač nových inzerátů** s upozorněním do Telegramu, Slacku, Discordu nebo WhatsAppu (najde nové inzeráty i pod stovkami TOP inzerátů), **deal score** proti podobným inzerátům, u aut značka, rok, km, výkon, palivo a převodovka. Výstup do Excelu, CSV nebo JSON. Podporu poskytujeme i česky.

### Why use this Bazoš scraper?

- 🔔 **A new-ad alert that really sees new ads.** Bazoš lists every TOP ad first, and a popular search has hundreds of them (in our test, "iphone" in Phones had over 220), so new ads start several pages down. Watching the first page of the listing finds only TOP ads. This actor finds the new ads wherever they are in the listing and reads only those, so a check stays cheap.
- 💸 **Monitoring that charges only for news.** Unchanged ads are free. A check without a new ad costs the start fee and one checked page (see Pricing), not 100 rows again.
- 📉 **Deal score for every ad:** `dealScore` (0–100, 50 = the usual price), `priceVsMedianPercent` and the median of comparable ads (same item, not its accessories; monitoring runs remember earlier ads, so scores get better over time). Filter with **Min deal score** or **Max price vs. median**.
- 🚗 **Vehicle fields from the text** of car and motorbike ads: make, year, mileage, power in kW, engine size, fuel and gearbox. With ad pages 70–100 % of car ads get mileage, power and fuel.
- 📱 **Item fields for phones and electronics:** brand, model ("iPhone 15 Pro", "Galaxy S24 Plus"), storage, RAM, battery health in %, condition (new, like new, used, for parts) and warranty. On a page of phone ads ~95 % get the brand, ~60 % the storage.
- 🏷️ **Price check:** give a list of items ("iPhone 13 128GB", "PS5 digital", "Octavia combi 2016") and get one row each: median, quartiles, lowest and highest asking price of the matching ads (accessories, "wanted" and "for parts" ads left out) and the 5 cheapest.
- 📈 **Price history and market report:** your scheduled runs remember prices (in your own account), so every ad gets its price changes, lowest price of 90 days and so on; the market report adds what disappeared (sold) per category, median days to sell and the sell-through rate.
- 🌍 **All 4 countries and all 20 sections**, from any URL of the website: sections, categories, searches by words, postal code and radius, price, and the search of all sections.
- 🧹 **Filters before anything is paid:** words the title must (not) contain, skip TOP ads, skip "wanted" ads ("Koupím…", "Sháním…"), only ads with a price, posted in the last N days.
- 🔒 **Privacy first.** Nicknames, user IDs and phone numbers of sellers are never read; e-mails and phone numbers in descriptions are replaced with `[e-mail removed]` and `[phone removed]`.
- ⚡ **Light and cheap:** $2.49 per 1 000 ads, no proxy needed.

### What data can you get?

| Field | Example |
|---|---|
| Title, URL, ad number, country | iPhone 15 256G, https://mobil.bazos.cz/inzerat/226248460/iphone-15-256g.php, cz |
| Price | 9990 CZK, priceText "9 990 Kč", priceType `fixed` (or `negotiable`, `free`, `inText`, `offer`, `swap`) |
| Place | Kladno, postal code 273 42 (with ad pages also latitude and longitude of the postal code) |
| Section and category | phones, apple (category name with ad pages) |
| Date, views, TOP, wanted | postedAt 2026-11-12, 472 views, isTop true, isWanted false |
| Photos | first photo; with ad pages all photos and their count |
| Description | start of the description; with ad pages the whole text |
| Deal score | comparableCount 12, comparableMedianPrice 11 500, priceVsMedianPercent −13.1, dealScore 57 |
| With **Add vehicle fields** | vehicleMake Škoda, vehicleYear 2018, vehicleMileageKm 106 691, vehiclePowerKw 85, vehicleEngineCcm 999, vehicleFuel petrol, vehicleTransmission manual |
| With **Add item fields** | itemBrand Apple, itemModel iPhone 15 Pro, itemStorageGb 256, itemRamGb 8, itemBatteryPercent 89, itemCondition likeNew, itemWarranty true |
| With **Add price history** | priceHistoryChanges 2, lowestPrice90d 9 990, highestPrice90d 11 990, averagePrice90d, priceVsAverage90dPercent, isLowestPrice90d, priceHistory \[{date, price}] |
| **Price check** rows (rowType `priceCheck`) | query, matchedAds 63, priceMedian 6 000, priceQ1 4 945, priceQ3 7 440, priceMin, priceMax, cheapestUrls |
| With **Monitoring** | changeType `new`, `updated`, `removed`, `reappeared`, `unchanged`; previousPrice, priceChange, priceChangePercent, firstSeenAt, removedAt, daysOnline, isRepost |

Open the results as a table in Apify Console (views **Overview**, **Deals**, **Details**, **Vehicles**, **Phones & electronics**, **Price history**, **Price checks**, **Monitoring**, **Removed (sold) ads**) or export them to **Excel, CSV, JSON or XML**.

### How to scrape Bazoš

1. Paste a Bazoš URL into **Bazoš URLs** (set the search on the website first: words, PSČ, radius, price), or fill in **Search words** and **Sections**.
2. Set **Max ads** and, if you want, turn on **Add ad page details** or **Add vehicle fields**.
3. Click **Start**. For alerts, turn on **Monitoring: only new or changed ads**, add a notification channel and **schedule** the run (e.g. every hour).

### Use cases

#### Alert me to every new iPhone 15 in Prague under 15 000 CZK

```json
{
  "searchQueries": ["iphone 15"],
  "sections": ["phones"],
  "postalCode": "11000",
  "radiusKm": 30,
  "maxPrice": 15000,
  "skipWantedAds": true,
  "excludeKeywords": ["kryt", "obal", "sklo"],
  "onlyNewOrChanged": true,
  "telegramBotToken": "123456:ABC...",
  "telegramChatId": "-1001234567890"
}
```

Schedule it every 30 or 60 minutes. Each check finds the ads posted since the last one; you get a Telegram message with title, price, place, deal score and link.

#### Cheap used cars with mileage and power

```json
{
  "startUrls": [{ "url": "https://auto.bazos.cz/skoda/" }],
  "includeDetails": true,
  "includeVehicleFields": true,
  "minDealScore": 60,
  "maxItems": 200
}
```

#### How much is it worth? (price check)

```json
{
  "priceCheckQueries": ["iPhone 13 128GB", "PS5 digital", "Octavia combi 2016"],
  "priceCheckPages": 2
}
```

One row per item, e.g. iPhone 13 128GB: 63 matching ads, median 6 000 CZK, middle half 4 945–7 440 CZK. Asking prices of the ads on Bazoš now, not prices of sales.

#### Used iPhones with storage, battery health and condition

```json
{
  "startUrls": [{ "url": "https://mobil.bazos.cz/apple/" }],
  "includeItemFields": true,
  "includeDetails": true,
  "maxItems": 300
}
```

#### What sells, how fast and for how much (market report)

```json
{
  "startUrls": [{ "url": "https://mobil.bazos.cz/apple/" }],
  "onlyNewOrChanged": true,
  "includeMarketReport": true,
  "includePriceHistory": true,
  "monitoringKey": "apple-market"
}
```

Schedule it daily. Each run writes `MARKET_REPORT` to the key-value store (per category: ads on sale and their median price, ads gone in the last 30 days with their median last price, median days to sell, share sold within 7 days, sell-through rate) and every ad gets its price history. Both learn from your runs: the report from ads that disappear between them, the history from the prices they see.

#### Every ad of a category, as a spreadsheet

```json
{
  "startUrls": [{ "url": "https://nabytek.bazos.cz/sedacky/" }],
  "maxItems": 0
}
```

#### Search all sections of Bazoš.sk

```json
{
  "country": "sk",
  "searchQueries": ["bicykel", "elektrobicykel"],
  "maxItems": 500
}
```

#### What sold this week (removed ads)

```json
{
  "startUrls": [{ "url": "https://foto.bazos.cz/objektivy/" }],
  "onlyNewOrChanged": true,
  "includeRemovedAds": true,
  "monitoringKey": "lenses"
}
```

Run it daily: ads that disappeared come back as `removed` with `daysOnline`, price drops as `updated` with `previousPrice`.

#### Monitoring mode explained

- **First run:** the listing is read as usual (up to **Max ads** and **Max pages**); every ad is new. A short first run (e.g. **Max pages** 1) still remembers the newest ads, so the next check doesn't report old ads as new.
- **Next runs with "Monitoring: read only new ads" (default):** the actor finds the ads posted since the last check, wherever TOP ads push them in the listing, and reads only those. Each new ad is a full row (place, postal code, price, whole description, photos); its page is **not** charged as "Ad page read". With more than 50 new ads between two checks the status message says so: run more often.
- **Without it** (or with **include removed** / **include unchanged**): the whole search is read every run, which also finds **price changes** of older ads and the ads that were **removed** (sold).
- Use a different **Monitoring: key** for each watched search, or leave it empty (a key is derived from the searches).

#### Price history and market report explained

- Both are kept in your own Apify account (one per Monitoring key), nothing is kept anywhere else. They start with your first run and grow with every scheduled run.
- A price is seen only when a run reads the ad, so both read the **whole search** every run (the market report turns "read only new ads" off; with price history turn it off yourself for full histories). Narrow the search (words, postal code, category) for big sections, or run daily rather than hourly.
- **Sold** means the ad disappeared between two runs: sold, or deleted by the seller. Prices are asking prices.
- The market report is free in the runs that know no gone ads yet (the first ones); then charged once per run.

#### Notifications

Telegram, Slack, Discord, WhatsApp or any webhook (Zapier, Make, n8n). A message lists up to 10 ads (configurable) with title, price (and the previous one), place, deal score and link, never descriptions. Nothing is sent when nothing was saved, unless you turn that off.

#### Market summary (SUMMARY)

Every successful run writes a free `SUMMARY` record to the key-value store: ads on the website, read and saved, price median, quartiles, minimum and maximum by section and category, ads by posting day, TOP and wanted ads.

### How much does it cost to scrape Bazoš?

Pay per event, no platform costs on top:

| Event | Price |
|---|---|
| Ad saved | **$2.49 per 1 000** |
| Ad page read (with **Add ad page details**, and for ad URLs) | +$0.30 per 1 000 ads |
| Vehicle fields (with **Add vehicle fields**, ads with at least one field found) | +$0.50 per 1 000 ads |
| Item fields (with **Add item fields**, phone and electronics ads with at least one field found) | +$0.50 per 1 000 ads |
| Price history (with **Add price history**, ads whose history goes back before the run) | +$0.30 per 1 000 ads |
| Price check (one result row per item, plus the row itself) | $0.0075 per item |
| Market report (once per run, from the run that knows gone ads) | $0.015 |
| Monitoring: listing page checked (every page a monitoring check reads) | $0.20 per 1 000 pages |
| Extra page (pages read beyond the saved ads, e.g. ads your filters left out) | $0.20 per 1 000 pages |
| Notification (a run that sent one) | $0.001 |
| Start of a run | $0.003 |

Examples: 1 000 ads of a listing ≈ **$2.49**; with ad pages and vehicle fields ≈ $3.29; a price check of 10 items ≈ $0.10 (an item without any matching ad is not charged). An hourly check of a search without news ≈ $0.0032 (a category URL: $0.0034), so a month of hourly checks ≈ **$2.30** plus the new ads. The maximum cost per run you set in Apify is always respected.

### Input example

```json
{
  "startUrls": [{ "url": "https://mobil.bazos.cz/apple/" }],
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "bazos:cz:226248460",
  "source": "bazos.cz",
  "country": "cz",
  "url": "https://mobil.bazos.cz/inzerat/226248460/iphone-15-256g.php",
  "adId": "226248460",
  "title": "iPhone 15 256G",
  "description": "Prodam iPhone 15 256G , baterie 80% , růžová barva + kryty viz foto",
  "price": 9990,
  "currency": "CZK",
  "priceText": "9 990 Kč",
  "priceType": "fixed",
  "location": "Kladno",
  "postalCode": "273 42",
  "latitude": null,
  "longitude": null,
  "section": "phones",
  "category": "apple",
  "categoryName": null,
  "postedAt": "2026-11-12",
  "isTop": true,
  "isWanted": false,
  "views": 472,
  "imageUrl": "https://www.bazos.cz/img/1/460/226248460.jpg?t=1794392016",
  "imageUrls": [],
  "imageCount": null,
  "detailScraped": false,
  "comparableCount": 5,
  "comparableMedianPrice": 11000,
  "priceVsMedianPercent": -9.2,
  "dealScore": 55,
  "changeType": null,
  "previousPrice": null,
  "sourceUrl": "https://mobil.bazos.cz/apple/",
  "scrapedAt": "2026-11-12T18:27:35Z"
}
```

### Good to know

- **Order of the listing:** Bazoš shows TOP ads first, then the others by date. `isTop` tells them apart; **Skip TOP ads** leaves them out.
- **Dates** are days (YYYY-MM-DD); the website moves the date when a seller renews or tops an ad.
- **Ads without a number as their price** ("Dohodou", "V textu", "Zdarma") have `price` null and `priceType` set. The website's own price filter leaves them out.
- **Vehicle fields** come from what sellers write, so they are filled only where the text says it clearly. The listing has only the start of the description; with **Add ad page details** far more fields are found. Parts, tyres and accessories get none.
- **Deal score** is the price against the median of comparable ads (same item, not its accessories); a score needs a few comparable ads with a price, otherwise it stays `null`. Bigger searches (and monitoring, which remembers earlier ads) give more scores.
- **Phone numbers** are behind a verification on the website and are not read; neither are the sellers' names.
- Bazos.pl and Bazos.at are much smaller than the Czech and Slovak sites.
- **Ad URLs:** when the website rejects an ad's page, the ad is found in the website's search and saved with its listing data. An ad is reported as not found only when the website says it was deleted.

### For AI agents and API users

Run it from the Apify API, the Apify MCP server, Make, Zapier or n8n. **Compact output** keeps the core fields (id, title, price, place, section, date, deal score, link, monitoring and vehicle fields); **Leave out empty fields** drops nulls. Every field is described in the dataset schema (Output tab).

### Troubleshooting

- **"No supported URL"**: paste an address of bazos.cz/sk/pl/at: a section, a category, a search or an ad (`…/inzerat/<number>/<name>.php`, with its name exactly as on the website).
- **"is rejecting requests"**: run without a proxy (the default) and try again later.
- **Fewer ads than the website shows**: check **Max ads**, **Max pages per search** and the filters; the status message says what stopped the run.
- **Monitoring returned nothing**: nothing new since the last run with the same Monitoring key. The status message says how the search was checked.

### 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.

### More classified-ad scrapers

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

- [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

### 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.

### FAQ

#### Is it legal to scrape Bazoš?

It reads only publicly available data, without logging in, at most 60 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It does not collect sellers' names or phone numbers and removes contacts from descriptions. You are responsible for how you use the data (e.g. GDPR if you process anything personal, and the website's terms). This is an unofficial tool, not connected with Bazoš.

#### How is it different from other Bazoš scrapers?

A watcher that reads the first page of a listing sees mostly TOP ads and misses new ads below them; this one finds every new ad and charges only for news. On top of that every ad gets a deal score, car ads vehicle fields and phone ads item fields, and the price check, price history and market report come in the same actor.

#### Do I need a proxy?

No proxy needed.

#### How often should I run the monitor?

Every 30–60 minutes for a popular search, daily for a quiet one. A check without news costs about $0.003.

#### Why are some vehicle fields empty?

The seller didn't write them, or wrote them in a way that is not clear. Turn on **Add ad page details** to read the whole description.

#### How exact is the price check?

It uses the asking prices of the ads on Bazoš right now whose title has every word of your item, without accessories, other variants of the model ("iPhone 13" leaves out 13 Pro and 13 mini; write "iPhone 13 Pro" to get those), "wanted" and "for parts" ads. Write the item as sellers do ("iPhone 13 128GB", not "Apple smartphone"); use **Must not contain** for more exclusions and **Price check: pages per item** for more ads.

#### Can I get the seller's phone number?

No. The website shows it only after a verification, and we do not collect personal data of private sellers.

This actor is also known as a Bazoš API, Bazoš scraper, Bazoš hlídač, "hlídač inzerátů Bazoš" or "hlídací pes Bazoš".

# Changelog

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

# Actor input Schema

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

Any listing from bazos.cz, bazos.sk, bazos.pl or bazos.at: a section (https://auto.bazos.cz/), a category (https://mobil.bazos.cz/apple/), a search with words, postal code, radius and price (set it on the website and paste the address of the results) or the search of all sections. Also ad URLs (https://auto.bazos.cz/inzerat/<number>/<name>.php): an ad URL is read with its whole description and photos and charged as an ad with "Ad page read". A listing is always read from its first page.

## `searchQueries` (type: `array`):

Words to search, e.g. "iphone 15", "octavia combi", "lednice". Each is a separate search in every section chosen below (or in all sections when none is chosen). Combined with the postal code, radius and price below. Leave empty to read whole sections.

## `country` (type: `string`):

The Bazoš website of the searches built from "Search words" and "Sections" (pasted URLs keep their own country).

## `sections` (type: `array`):

Sections of the website to search or read. Empty with search words = all sections.

## `postalCode` (type: `string`):

Search around this postal code (PSČ), e.g. 11000 for Prague 1, 60200 for Brno, 81101 for Bratislava, 00950 for Warsaw, 1010 for Vienna. Empty = the whole country.

## `radiusKm` (type: `integer`):

With "Postal code": how far around it.

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

The website's price filter, in the currency of the country (CZK, EUR, PLN). Ads without a number as their price ("Dohodou", "V textu") are left out by the website when a price is set.

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

The website's price filter, in the currency of the country.

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

Maximum number of ads saved. You pay per saved ad. 0 = no limit.

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

Read at most this many pages (40 ads each) of every search. 0 = no limit.

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

Open each ad page to add its whole description (e-mails and phone numbers removed), every photo, the category and the map point of the postal code. Extra charge "Ad page read" per saved ad whose page was read (see the Pricing tab). Off: data of the listing pages (title, start of the description, price, place, views, date, TOP, first photo).

## `includeVehicleFields` (type: `boolean`):

For ads of the Cars and Motorbikes sections: make, year, mileage (km), power (kW), engine size (ccm), fuel and gearbox, read from the title and the description (Bazoš has no form fields for them, so they are filled only where the seller wrote them clearly; with "Add ad page details" the whole description is used and far more fields are found). Charged as "Vehicle fields" per saved ad with at least one field found (see the Pricing tab).

## `includeItemFields` (type: `boolean`):

For ads of the Phones, Computers, Electronics and Photo sections: brand, model, storage (GB), RAM, battery health (%), condition (new, like new, used, for parts) and warranty, read from the title and the description (filled only where the seller wrote them clearly; with "Add ad page details" the whole description is used). Charged as "Item fields" per saved ad with at least one field found (see the Pricing tab).

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

Every run remembers the prices it saw (in a key-value store of your account, per Monitoring key), and every ad gets its price history: changes, lowest and highest price of 30 and 90 days, average, whether the price is the lowest in 90 days, and the list of changes. The history starts with your first run; schedule the same search. Prices of older ads are seen only when the run reads them, so with monitoring turn "read only new ads" off. Charged as "Price history" per saved ad whose history goes back before the run (see the Pricing tab).

## `includeDealScore` (type: `boolean`):

Compare the price of every ad with the median price of comparable ads (same item, not its accessories): comparableCount, comparableMedianPrice, priceVsMedianPercent and dealScore (0-100, 50 = the usual price, higher = cheaper). Free. A score needs a few comparable ads, so it works best with bigger searches.

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

Keep only ads whose title contains at least one of these texts (case and diacritics don't matter).

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

Skip ads whose title or description contains any of these texts, e.g. "vadný", "na díly", "kryt".

## `skipTopAds` (type: `boolean`):

Skip ads promoted with the website's paid TOP mark (they stay on top of every listing, often for weeks).

## `skipWantedAds` (type: `boolean`):

Skip ads of people who buy instead of selling ("Koupím…", "Sháním…", "Hledám…", "Kúpim…", "Kupię…", "Suche…"). Every row has isWanted either way.

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

Skip ads without a number as their price ("Dohodou", "V textu", "Zdarma").

## `postedWithinDays` (type: `integer`):

Only ads posted or renewed in the last N days. A listing in the website's order (newest first) is read only until the older ads begin. 0 = any time.

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

Keep only ads with at least this deal score (e.g. 60 = about 20 % below the median of comparable ads). Ads without enough comparable ads are left out.

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

Keep only ads whose price is at most this many percent above (or, negative, below) the median of comparable ads, e.g. -15. Ads without enough comparable ads are left out.

## `priceCheckQueries` (type: `array`):

Items to price, e.g. "iPhone 13 128GB", "PS5 digital", "Octavia combi 2016". An ad matches when its title has every word of the item and no accessory words (kryt, obal, sklo…). Asking prices of current ads, not prices of sales.

## `priceCheckPages` (type: `integer`):

Listing pages (40 ads each) read for every item. More pages = more ads in the statistics.

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

Return only ads that are new or whose title or price changed since the previous run with the same Monitoring key (changed ads have previousPrice, priceChange and priceChangePercent). Every listing page read in this mode is charged as "Monitoring: listing page checked" (see the Pricing tab; one page = 40 ads).

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

Name of the saved state. Use a different key for each watched search (e.g. "iphone-praha"). Empty = a key derived from the searches and ad URLs of the run, so different searches never share a state. The value is stored encrypted.

## `stopAtKnownAds` (type: `boolean`):

After the first run, find the ads posted since the last check and read only those, so a check stays cheap. Bazoš shows every TOP ad first (often hundreds of them), so new ads are far down the listing and reading its first pages would miss them; this mode finds them anyway. The first run reads the listing as usual. Off = read the whole search every run (finds price changes of older ads too). Turned off by "include removed" and "include unchanged". With more than 50 new ads between two checks the status message says so: run more often.

## `includeRemovedAds` (type: `boolean`):

Also return ads of the previous run that are no longer in the search (sold or deleted), as rows with changeType "removed" (and "reappeared" when they come back), with daysOnline. Needs the whole search read every run; checked only when the run read every search completely. Charged like any other ad.

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

Also return the ads that did not change, as rows with changeType "unchanged" (charged like any other ad).

## `skipReposts` (type: `boolean`):

Do not return a new ad when the seller posted an ad of an earlier run again under another ID. Off = such ads are returned with isRepost true and repostOf.

## `includeMarketReport` (type: `boolean`):

With monitoring: every run writes MARKET_REPORT to the key-value store: per section and category the ads on sale and their median price, the ads that disappeared in the last 30 days (sold, or deleted by the seller) with their median last price, median days to sell, share sold within 7 days and the sell-through rate. It learns from the ads that disappear between your runs, so it reads the whole search every run (like "include removed") and gets better with every run. Charged once per run as "Market report" (see the Pricing tab).

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

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...). Stored encrypted.

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

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

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

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID". Stored encrypted.

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

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

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

Any HTTPS URL (Zapier, Make, n8n, your server): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `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 ads are listed in one notification (the rest as "…and N more").

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

Send nothing when the run saved no ad (e.g. a monitoring run without new ads).

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

Keep only the core fields of every row: id, title, price, place, section, category, date, TOP, views, photo, deal score, link (and the monitoring and vehicle fields).

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

Drop fields that are null or an empty list from every row (id, source, url, adId, title and scrapedAt always stay).

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

No proxy needed. Turn a proxy on only if the website starts rejecting requests.

## `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
{
  "startUrls": [
    {
      "url": "https://mobil.bazos.cz/apple/"
    }
  ],
  "country": "cz",
  "radiusKm": 25,
  "maxItems": 20,
  "maxPages": 0,
  "includeDetails": false,
  "includeVehicleFields": false,
  "includeItemFields": false,
  "includePriceHistory": false,
  "includeDealScore": true,
  "skipTopAds": false,
  "skipWantedAds": false,
  "onlyWithPrice": false,
  "priceCheckPages": 2,
  "onlyNewOrChanged": false,
  "stopAtKnownAds": true,
  "includeRemovedAds": false,
  "includeUnchanged": false,
  "skipReposts": false,
  "includeMarketReport": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compact": false,
  "excludeEmptyFields": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `ads` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `marketReport` (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": [
        {
            "url": "https://mobil.bazos.cz/apple/"
        }
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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