# Bazos.sk Scraper — Slovak Classifieds Data (`haketa/bazos-sk-scraper`) Actor

Bazos.sk scraper for Slovak classifieds. Extract listings by keyword or category: price (EUR), title, location, phone, description and photos. Great for lead generation. Export JSON, CSV, Excel.

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

## Pricing

from $1.50 / 1,000 results

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

## Bazos.sk Scraper 🇸🇰 — Slovak Classifieds Data Extractor

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/bazos-sk-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-brightgreen?style=flat-square)](https://apify.com/haketa/bazos-sk-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/bazos-sk-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1000%2B%20Items-blueviolet?style=flat-square)](https://apify.com/haketa/bazos-sk-scraper)
[![Proxy](https://img.shields.io/badge/Proxy-Datacenter%20Optimized-success?style=flat-square)](https://apify.com/haketa/bazos-sk-scraper)

Extract live classifieds listings from [Bazos.sk](https://www.bazos.sk), Slovakia's largest peer-to-peer marketplace. Collect structured real-time data across every major category—automotive, real estate, electronics, machinery, jobs, and home goods—with prices in EUR, full item descriptions, geo-locations, seller information, and direct listing links.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | [Bazos.sk](https://www.bazos.sk) (Slovakia) |
| **Data Scope** | Cars (`auto`), Phones (`mobil`), Real Estate (`reality`), Electronics (`pc`), Services (`sluzby`), Home & Garden, Machinery, and all subdomains |
| **Key Attributes** | Listing ID, URL, Title, Price (€), Location, Subdomain Category, Views, Photos, Seller Name, Full Description |
| **Output Formats** | JSON, CSV, XML, Excel (XLSX), HTML Table, RSS, Apify API |
| **Pagination Limit** | Unlimited / 1,000+ items per search query (`maxPagesPerSearch: 0` = automatic deep crawl) |
| **Proxy Requirement** | Apify Datacenter Proxy (zero residential data transfer costs) |
| **Execution Speed** | ~100 listings in 15–25 seconds; high-concurrency detail enrichment |
| **Deduplication** | Automatic deduplication by unique numeric listing ID across multi-query runs |
| **Export Integrations** | Webhooks, Google Sheets, Make, Zapier, Airbyte, Keboola, BigQuery |
| **Use Cases** | Reseller arbitrage, second-hand market intelligence, vehicle pricing, competitor tracking, real-estate analysis |

***

### 🔎 Why scrape Bazos.sk?

[Bazos.sk](https://www.bazos.sk) is the unrivaled classifieds marketplace in Slovakia, serving millions of active monthly users. Whether individuals are selling smartphones, vintage furniture, or agricultural machinery, or dealerships are listing used vehicles, Bazos is the primary trading hub for the Slovak secondary market.

Every single listing provides valuable economic signals:

- **Real-time transactional pricing** in EUR (€) across all 8 Slovak regions (Bratislava, Trnava, Trenčín, Nitra, Žilina, Banská Bystrica, Prešov, Košice).
- **Subdomain categorization** mapping directly to dedicated industry verticals (`auto.bazos.sk`, `reality.bazos.sk`, `mobil.bazos.sk`, `stroje.bazos.sk`, etc.).
- **Seller demand indicators** including visitor view counters and timestamped listing ages.

Without an automated **Bazos.sk scraper**, monitoring thousands of daily ads requires manual browsing, clicking through 20-ad pagination walls, and copying text into spreadsheets. This scraper eliminates manual work, providing an automated pipeline that feeds clean, structured data into your database, BI dashboard, or arbitrage alert engine.

***

### 🏆 Comparison: Bazos.sk Scraper vs. Alternatives

| Feature | Manual Browsing | Generic Web Crawlers | Bazos.sk Scraper (This Actor) |
|---|---|---|---|
| **Speed** | 10–20 ads / hour | 50–100 ads / min (breaks easily) | **500–1,500 ads / min** |
| **Pagination Depth** | Manual clicking | Often stops at page 2–5 | **1,000+ items / unlimited deep pagination** |
| **Data Cleanliness** | Inconsistent manual entry | Raw HTML snippets | **Strict JSON typing & clean numeric EUR** |
| **Category Handling** | Manual note-taking | Often misses subdomains | **Automatic subdomain-to-category mapping** |
| **Seller Enrichment** | Manual copy-pasting | Not supported | **Optional deep view & seller extraction** |
| **Duplicate Filtering** | High duplication risk | Basic URL hashing | **Deterministic listing ID deduplication** |
| **Proxy Cost** | N/A | High residential data costs | **100% Datacenter proxy compatible ($0 bandwidth waste)** |

***

### ✨ Key features

- 🔍 **Multi-Keyword Search**: Enter any list of keywords (`iphone 15`, `audi a6`, `traktor`, `zahradna chata`) to crawl across all Bazos verticals concurrently.
- 🎯 **Direct URL & Category Scraping**: Paste specialized category URLs or filtered queries (e.g., `https://auto.bazos.sk/audi/` or `https://reality.bazos.sk/predam/byt/`) directly into `startUrls`.
- 🔄 **Unlocked 1,000+ Deep Pagination**: Set `maxItems` to 1,000, 5,000, or more. Setting `maxPagesPerSearch: 0` enables unconstrained pagination across all available result pages.
- 💶 **Numeric EUR Price Parsing**: Parses formatted text strings like `"2 500 €"` or `"150 EUR"` into clean numeric integers for straightforward sorting, filtering, and database indexing.
- 🛡️ **Zero-Duplicate Guarantee**: Deduplication by unique numeric listing ID ensures clean datasets even across broad, overlapping keyword searches.
- 📍 **Geographic Location & Postal Codes**: Extracts town names and Slovak postal codes (PSČ) to facilitate regional pricing and proximity analysis.
- 👤 **Optional Deep Enrichment (`scrapeDetails`)**: Open individual listing pages to extract seller display names, total visitor view counts, and un-truncated full descriptions.
- 💰 **Built-in Budget & Price Filters**: Set minimum and maximum EUR thresholds to discard irrelevant listings before storage.
- ⚡ **Cost-Efficient Datacenter Support**: Optimized network requests run smoothly on standard Datacenter proxies, keeping operational costs fractions of a cent per thousand records.
- 🌐 **Full Slovak Vertical Coverage**: Seamlessly processes listings across all dedicated Bazos subdomains without special configuration.

***

### 🗂️ Supported Bazos subdomains & categories

Bazos operates separate subdomains for distinct commerce verticals. This scraper automatically handles each domain and records the vertical in the `category` attribute:

| Subdomain | Primary Category | Typical Listings Scraped |
|---|---|---|
| `auto.bazos.sk` | Cars & Vehicles | Used passenger cars, vans, motorbikes, trailers, spare parts, tires |
| `mobil.bazos.sk` | Mobile Phones & Tablets | Apple iPhones, Samsung Galaxy, smartwatches, cases, accessories |
| `reality.bazos.sk` | Real Estate | Apartments for sale/rent, family houses, land plots, commercial buildings |
| `elektro.bazos.sk` | Home Electronics | Smart TVs, audio equipment, washing machines, refrigerators, kitchen gadgets |
| `pc.bazos.sk` | Computers & Hardware | Laptops, gaming PCs, GPUs, monitors, networking gear, computer components |
| `dom.bazos.sk` | Home & Garden | Furniture, sofas, garden tools, heating systems, firewood, home decor |
| `stroje.bazos.sk` | Heavy Machinery | Tractors, excavators, metalworking machines, wood splitters, farm equipment |
| `sport.bazos.sk` | Sports & Fitness | Bicycles, e-bikes, ski gear, fitness machines, camping equipment |
| `sluzby.bazos.sk` | Professional Services | Construction trades, accounting, IT support, transport, renovations |
| `hudba.bazos.sk` | Musical Instruments | Electric & acoustic guitars, amplifiers, keyboards, drums, stage gear |
| `detske.bazos.sk` | Baby & Children Goods | Strollers, car seats, children's clothes, toys, cribs |
| `zvierata.bazos.sk` | Pets & Livestock | Dogs, cats, horses, poultry, veterinary and pet supplies |

***

### 💼 Business & analytical use cases

#### 1. Resale & Arbitrage Hunting

Identify underpriced consumer electronics, cameras, Apple devices, power tools, and musical instruments listed by motivated private sellers. Automated scraping enables rapid alert systems that trigger whenever an item is posted below median market value.

#### 2. Automotive & Used Vehicle Market Intelligence

Track vehicle inventory, asking prices, mileage, and trim packages across Slovakia. Benchmark dealership pricing against private sales on `auto.bazos.sk` and analyze depreciation curves across makes, models, and production years.

#### 3. Real Estate & Rental Property Monitoring

Monitor residential apartments, commercial real estate, and agricultural land on `reality.bazos.sk`. Track new listings per municipality, identify emerging price-per-square-meter trends, and discover off-market investment opportunities.

#### 4. B2B Machinery & Farm Equipment Sourcing

Track industrial tools, CNC machines, tractors, construction loaders, and spare parts on `stroje.bazos.sk`. Manufacturers and contractors can source used equipment at significant discounts compared to retail distributors.

#### 5. Retail Electronics Refurbishment Sourcing

Refurbishers and electronic repair shops can automate intake of broken or pre-owned laptops, smartphones, and graphics cards by monitoring incoming posts in real time.

#### 6. Academic & Macroeconomic Research

Evaluate Slovak secondary-market velocity, consumer sentiment, inflationary pricing trends, and regional purchasing power disparities over time.

***

### 📥 Input parameters

The scraper accepts JSON input via the Apify API or directly within the Apify Console.

```json
{
  "searchTerms": ["iphone 15", "thinkpad"],
  "startUrls": [
    "https://mobil.bazos.sk/apple/"
  ],
  "priceMin": 200,
  "priceMax": 1200,
  "scrapeDetails": false,
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Input fields description

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | `array` | `["iphone"]` | List of search keywords to query. Each keyword is scraped and paginated independently. |
| `startUrls` | `array` | `[]` | Optional direct Bazos listing or category URLs (e.g., `https://auto.bazos.sk/bmw/`). |
| `priceMin` | `integer` | *null* | Minimum price in EUR (€). Listings below this amount are filtered out. |
| `priceMax` | `integer` | *null* | Maximum price in EUR (€). Listings above this amount are filtered out. |
| `scrapeDetails` | `boolean` | `false` | When `true`, opens each individual ad page to extract seller name, view count, and full description. |
| `maxItems` | `integer` | `100` (prefill) | Total maximum listings to collect. Set to `0` or high numbers (e.g. `1000`) for large-scale extraction. |
| `maxPagesPerSearch` | `integer` | `0` | Maximum pages per search term. `0` = unlimited (guided by `maxItems`). |
| `proxyConfiguration` | `object` | `{ "useApifyProxy": true }` | Apify Datacenter proxies are fully supported and recommended. |

***

### 📊 Output data structure

The actor stores records in the default dataset. You can preview, filter, and export records as JSON, CSV, or Excel directly in the console.

#### 🏷️ Core listing fields

| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | `string` | 🟢 High (100%) | Unique numeric Bazos listing identifier (e.g., `"16849201"`). |
| `url` | `string` | 🟢 High (100%) | Direct canonical URL to the active listing. |
| `title` | `string` | 🟢 High (100%) | Complete title of the item or advertisement. |
| `price` | `number` | 🟢 High (98%+) | Clean integer price in EUR (€). Null if listed as negotiable ("Dohodou"). |
| `priceText` | `string` | 🟢 High (100%) | Exact raw price string as displayed on Bazos (e.g., `"450 €"`, `"Dohodou"`). |
| `currency` | `string` | 🟢 High (100%) | Currency denomination code (`"EUR"`). |
| `location` | `string` | 🟢 High (100%) | Town, district, and Slovak postal code (e.g., `"Bratislava 821 01"`). |
| `category` | `string` | 🟢 High (100%) | Subdomain classification category (`"mobil"`, `"auto"`, `"reality"`, etc.). |
| `description` | `string` | 🟢 High (100%) | Listing description snippet (or complete text if `scrapeDetails: true`). |
| `imageUrl` | `string` | 🟢 High (95%+) | High-resolution thumbnail image URL for the listing. |
| `searchTerm` | `string` | 🟡 Conditional | Search keyword that produced this item (null for `startUrls`). |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 UTC timestamp of data collection. |

#### 🔍 Detail enrichment fields (`scrapeDetails: true`)

| Field | Type | Coverage | Description |
|---|---|---|---|
| `sellerName` | `string` | 🟢 High (Detail mode) | Display name or alias of the seller/dealer. |
| `views` | `number` | 🟢 High (Detail mode) | Total counter of visitor impressions recorded on the ad. |

***

### 📦 Sample JSON output

```json
{
  "id": "16942081",
  "url": "https://mobil.bazos.sk/inzerat/16942081/apple-iphone-15-pro-128gb-titan-zaruka.php",
  "title": "Apple iPhone 15 Pro 128GB Titan Záruka",
  "price": 790,
  "priceText": "790 €",
  "currency": "EUR",
  "location": "Bratislava 831 04",
  "category": "mobil",
  "description": "Predám Apple iPhone 15 Pro v prevedení Natural Titanium s kapacitou 128GB. Telefón je v bezchybnom stave, zdravie batérie 98%, komplet príslušenstvo a platná záruka v slovenskom obchode do 11/2025.",
  "imageUrl": "https://mobil.bazos.sk/img/1/081/16942081.jpg?t=1731238491",
  "searchTerm": "iphone",
  "sellerName": "Michal K.",
  "views": 412,
  "scrapedAt": "2026-11-10T13:30:00.000Z"
}
```

***

### 🚀 Step-by-step implementation guide

#### Running via Apify Console

1. Navigate to the **Bazos.sk Scraper** on Apify Store.
2. Click **Try for free** to create a task in your workspace.
3. In the **Search Terms** field, input keywords separated by newlines (e.g. `iphone 15`, `macbook m3`).
4. Set **Max Items** to your desired target (e.g. `500`). Leave `maxPagesPerSearch` as `0` for unconstrained crawling.
5. Click **Start** to run the scraper.
6. Once completed, inspect the **Dataset** tab and export your records in CSV or JSON.

#### Running via Apify Python Client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchTerms": ["bmw m3", "audi rs3"],
    "maxItems": 250,
    "maxPagesPerSearch": 0,
    "scrapeDetails": False
}

run = client.actor("haketa/bazos-sk-scraper").call(run_input=run_input)

## Fetch results from dataset
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in dataset_items:
    print(f"[{item.get('category')}] {item.get('title')} -> {item.get('price')} EUR")
```

#### Running via Apify JavaScript / Node.js Client

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const run = await client.actor('haketa/bazos-sk-scraper').call({
    searchTerms: ['playstation 5'],
    priceMin: 300,
    priceMax: 500,
    maxItems: 100,
    maxPagesPerSearch: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully scraped ${items.length} items from Bazos.sk`);
```

***

### 💡 Practical scraping tips

- **Deep pagination across large categories**: When running broad scans on popular terms (like `notebook` or `bicykel`), keep `maxPagesPerSearch` at `0` and set `maxItems` to your desired sample size (e.g., `2500`). The actor will iterate through results automatically without hitting arbitrary page caps.
- **Narrowing down with start URLs**: For surgical scraping, visit Bazos in your browser, apply specific location or price dropdowns, and copy the final URL into `startUrls`. The scraper respects all encoded URL parameters.
- **Detail mode cost-efficiency**: If you only need price tracking, market averages, and titles, leave `scrapeDetails: false`. This keeps runtime extremely fast (thousands of items per minute) and minimizes network overhead. Turn on `scrapeDetails` only when seller names and view metrics are required for your workflow.
- **Filtering negotiable listings**: Listings without a numeric price (marked as "Dohodou") return `price: null` while preserving `"Dohodou"` in `priceText`. If your workflow requires strict numeric prices, filter for `price != null` in your downstream processing.
- **Combining multiple search keywords**: Provide multiple terms in `searchTerms` array. The scraper runs each search sequentially, deduplicating records across queries so you receive a unified, non-redundant dataset.
- **Regional Targeting**: Slovak postal codes have a 5-digit format (`811 01` for Bratislava Old Town, `040 01` for Košice). Filter by specific districts by combining postal code keywords with target search strings.

***

### 🏗️ Architecture & data processing pipeline

The scraper is engineered for high throughput and fault tolerance:

1. **Request Orchestration**: Resolves keywords and `startUrls` into optimized HTTP requests using desktop browser TLS fingerprints.
2. **Dynamic Offset Traversal**: Walks through listing results in offsets of 20 items per page (`crz` parameter), monitoring page boundaries without synthetic constraints.
3. **In-Memory Deduplication Engine**: Employs an in-memory hash set of unique listing IDs (`pushedIds`) to drop duplicate advertisements before enrichment.
4. **Detail Worker Pool**: If `scrapeDetails` is enabled, a concurrent worker pool opens individual advertisement pages to scrape seller handles and view counters with automatic jitter.
5. **Streaming Dataset Ingestion**: Streams validated records straight into the Apify Dataset, ensuring data is saved continuously even during long-running tasks.

```
[Search Terms / Start URLs]
             │
             ▼
    ┌─────────────────┐
    │ Listing Crawler │  ◄── Offset pagination (crz=0, 20, 40...)
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │ Deduplication   │  ◄── In-memory ID cache (0 duplicates)
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │ Detail Enricher │  ◄── Optional scrapeDetails worker pool
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │ Apify Dataset   │  ──► JSON / CSV / Excel / API Export
    └─────────────────┘
```

***

### 🔔 Webhook notification configuration

Trigger downstream webhooks whenever a scrape finishes. Configure an HTTP POST payload in the **Integrations** tab:

```json
{
  "event": "ACTOR.RUN.SUCCEEDED",
  "actorId": "UpwGSzxJW0L0HIEFT",
  "actorRunId": "{{runId}}",
  "datasetId": "{{defaultDatasetId}}",
  "itemCount": 500,
  "downloadCsvUrl": "https://api.apify.com/v2/datasets/{{defaultDatasetId}}/items?format=csv",
  "downloadJsonUrl": "https://api.apify.com/v2/datasets/{{defaultDatasetId}}/items?format=json"
}
```

***

### 🔍 Advanced query examples

| Search Intent | Recommended `searchTerms` | Optional Filter / URL |
|---|---|---|
| **Apple Hardware** | `["iphone 15 pro", "macbook pro m2"]` | `priceMin: 300` |
| **Used German Vehicles** | `["audi a4 avant", "bmw rad 3"]` | `startUrls: ["https://auto.bazos.sk/audi/"]` |
| **Farmland & Plots** | `["pozemok orna poda", "zahrada"]` | `startUrls: ["https://reality.bazos.sk/predam/pozemok/"]` |
| **Agricultural Machinery** | `["zetor", "traktor vlecky"]` | `startUrls: ["https://stroje.bazos.sk/traktory/"]` |
| **Retro Audio & Hi-Fi** | `["gramofon", "technics zosilnovac"]` | `priceMin: 50, priceMax: 600` |

***

### 🔄 Integrations & automated workflows

Seamlessly connect Bazos data to your operational stack:

- **Google Sheets & Airtable**: Automatically append newly posted items to a spreadsheet every hour via Apify integrations or Make.com / Zapier webhooks.
- **Slack & Discord Deal Alerts**: Configure an Apify Webhook that triggers on run completion, sending a notification whenever high-ticket items appear below a target price threshold.
- **PostgreSQL / BigQuery Pipelines**: Pipe JSON data directly into your analytical data warehouse using the Apify API or custom ETL loaders.
- **AI Agents & LLM Pipelines**: Provide live marketplace intelligence to LLM agents using structured JSON feeds.

***

### ❓ Frequently asked questions

##### How many listings can I scrape in one run?

You can scrape as many listings as Bazos has available for your query—hundreds to thousands of listings. Setting `maxPagesPerSearch: 0` ensures pagination continues across all pages until `maxItems` is satisfied or all listings have been collected.

##### Can I extract seller phone numbers?

Bazos.sk requires user interaction and SMS verification to reveal seller phone numbers on the public site. Consequently, phone numbers are masked behind verification dialogs. However, seller names, locations, view counts, and direct ad links are reliably collected.

##### What proxy type should I use?

Standard **Apify Datacenter Proxies** (`{ "useApifyProxy": true }`) work reliably and cost fractions of a cent per run. Residential proxies are unnecessary for Bazos.sk.

##### How frequently should I schedule the scraper?

For high-demand categories like electronics and cars, scheduling every 15–30 minutes helps you capture underpriced deals before other buyers. For general category tracking, daily or weekly runs are standard.

##### How does the scraper handle negotiable ("Dohodou") prices?

When a seller selects "Dohodou" instead of an integer value, the actor sets `price: null` while preserving `"Dohodou"` in the `priceText` field. This prevents numeric sorting errors while retaining full pricing context.

##### Can I filter by town or postal code?

Yes! Use Bazos.sk in your browser to enter a postal code (PSČ) and radius, copy the resulting search URL, and paste it into the `startUrls` input field. The scraper will extract only ads matching your regional criteria.

##### Does the scraper work for the Czech site (Bazos.cz)?

This actor is specialized for **Bazos.sk** (Slovakia, EUR currency). For the Czech platform with CZK currency, use our sister actor **Bazos.cz Scraper**.

##### Can I export directly to Excel or Google Sheets?

Yes! In the Apify Console Dataset tab, click Export and select **XLSX (Excel)**, **CSV**, or use the direct Apify Google Sheets integration to push data into any spreadsheet automatically.

##### Are duplicate listings removed automatically?

Yes. Every listing is indexed by its unique numerical Bazos ID. Even if an ad appears in multiple search results or category intersections, it is stored only once in the dataset.

##### What happens if a listing has no photos?

The actor sets `imageUrl: null` and continues extracting all remaining metadata without interruption.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Deep Pagination Unlock**: Upgraded pagination architecture to support seamless 1,000+ listing runs; set `maxPagesPerSearch: 0` as the default for unconstrained paging.
- **Optimized Prefill Execution**: Fine-tuned default parameters for rapid demonstration runs (<45s) on standard Datacenter proxy groups.
- **Enhanced Data Normalization**: Improved regex parsing for EUR pricing, postal code separation, and subdomain category resolution.
- **Comprehensive Schema Overhaul**: Standardized input and output schemas to comply fully with latest Apify actor specifications.

#### Version 1.1

- Added `scrapeDetails` mode for seller display names and live visitor impression counts.
- Implemented automatic retry handling with session rotation.

#### Version 1.0

- Initial release with keyword search, Start URLs, and numeric EUR price extraction.

# Changelog

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

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search across all Bazos categories, e.g. 'iphone', 'audi', 'kolo'. Each is searched separately. Leave empty if you use Start URLs.

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

Optional. Paste full Bazos search/category URLs to scrape them directly (e.g. a specific category subdomain like auto.bazos.sk). When provided, Search Terms and filters below are ignored for these URLs.

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

Only listings at or above this price.

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

Only listings at or below this price.

## `scrapeDetails` (type: `boolean`):

Open each ad for the seller name, view count and full-length description (extra demand & seller signals). Note: Bazos masks phone numbers behind a verification step, so phones are not reliably available. Slower but richer.

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

Maximum number of listings to collect across all searches. 0 = unlimited.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to scrape per search term / URL. Each page has about 20 listings. 0 = auto/unlimited governed by Max Items.

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

Apify Proxy (Datacenter) is enabled by default and works out of the box. Residential is not recommended (unnecessary per-GB cost).

## Actor input object example

```json
{
  "searchTerms": [
    "iphone"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view and export all scraped listings (JSON, CSV, Excel).

# 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 = {
    "searchTerms": [
        "iphone"
    ],
    "startUrls": [],
    "scrapeDetails": false,
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/bazos-sk-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 = {
    "searchTerms": ["iphone"],
    "startUrls": [],
    "scrapeDetails": False,
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/bazos-sk-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 '{
  "searchTerms": [
    "iphone"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 100,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/bazos-sk-scraper --silent --output-dataset

```

## MCP server setup

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