# Bazos.sk Car Scraper (`rastriq/bazos-sk-scraper`) Actor

Scrape used car ads from auto.bazos.sk, Slovakia's most popular free classifieds: make, model, year, mileage, power, fuel, gearbox, price in EUR, town and postal code. 40 ads per page, datacenter proxy.

- **URL**: https://apify.com/rastriq/bazos-sk-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 car ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Bazos.sk Car Scraper

Scrape used car ads from **auto.bazos.sk**, the car section of Bazos, one of the most popular free classifieds sites in Slovakia. Bazos.sk Car Scraper turns the ads into clean, structured data: make, model, year, mileage, engine power, fuel type, gearbox, asking price in EUR, town, postal code, photo and ad URL. No browser and no residential proxy: 40 ads per page in a few seconds.

### 🚗 What is Bazos.sk Car Scraper?

Bazos.sk Car Scraper is a Bazos scraper and unofficial Bazos.sk API for the auto section of the site. Bazos is where a large part of Slovakia's private used car market is listed: ads are free, short and written as plain text, which makes the site a good source for real asking prices of private sellers, but hard to analyse by hand.

Bazos has **no structured vehicle fields**: there is no "year" or "mileage" box, only a title and a free-text description. Bazos.sk Car Scraper reads price, town and postal code from the listing markup and extracts the vehicle attributes from the ad text with fixed rules, then outputs one row per ad in the same format as our other car marketplace scrapers. Ads come newest first, so the actor is a good fit for scheduled runs that track new supply.

Use it to:

- 📈 **Track used car prices in Slovakia** by make, model, year and mileage.
- 🏷️ **Benchmark dealer stock** against what private sellers are asking.
- 🔔 **Spot new ads early** with a scheduled run every hour or every day.
- 🧮 **Feed valuation models** and market research with fresh asking prices in EUR.
- 📍 **Map supply by town and postal code**.

### 📋 What data does Bazos.sk Car Scraper extract?

| Field | Description |
|---|---|
| 🆔 `id` | Bazos ad ID |
| 📝 `title` | Ad title as written by the seller |
| 🏭 `make` | Car brand (Škoda, Volkswagen, BMW...), from the title |
| 🚘 `model` | Model (Octavia, Golf, X5...), from the title |
| 📅 `year` | Year of production, from the ad text |
| 🛣️ `km` | Mileage in km, from the ad text (`115.500KM`, `178tis km`...) |
| 🐎 `hp` | Engine power in hp (kW values are converted) |
| 💶 `price` | Asking price in EUR |
| 💱 `currency` | Always `EUR` |
| ⛽ `fuel_type` | `petrol`, `diesel`, `hybrid`, `electric`, `lpg` or `cng` |
| ⚙️ `gearbox` | `manual` or `automatic` |
| 📍 `city` | Town of the ad |
| 📮 `postal_code` | Slovak postal code (for example `913 24`) |
| 🗺️ `region` | Not available on Bazos: always `null` |
| 🏪 `is_professional` | Not available on Bazos: always `false` |
| 🔗 `url` | Link to the ad on auto.bazos.sk |
| 🖼️ `img_url` | Thumbnail of the first photo |
| 🌐 `source` | Always `bazos.sk` |
| 🕒 `scraped_at` | UTC timestamp of extraction |

**How complete is the data?** In our latest test run (40 ads, 14 November 2026, ad pages enabled): price, mileage and power were empty on 1 ad each, make and model on 2, year and fuel on 2-3, and gearbox on 5. Town, postal code, URL and photo were filled on every ad.

**Be aware of what is not there:**

- Vehicle attributes are only as good as the seller's text. When the text does not state a value, the field is `null`; the scraper never invents it.
- `price` is `null` when the ad has no amount in euros (for example "dohodou", by agreement).
- `region` and `is_professional` are not published by Bazos. The columns exist only so the output lines up with our other car scrapers.
- **No seller names, phone numbers, e-mails or descriptions** are saved. The scraper does not collect personal data.

### 🛠️ How to use Bazos.sk Car Scraper

1. Open Bazos.sk Car Scraper in Apify Console and click **Try for free**.
2. Optionally type a **Search text**, typically a brand such as `BMW`. Leave it empty for all car ads.
3. Set **Max pages**. The prefill is 1 page, 40 ads.
4. Keep **Fill missing year/km from the ad page** on for more complete rows, or switch it off for faster runs.
5. Keep the default **Proxy configuration** (Apify datacenter proxy). Residential proxy is not needed.
6. Click **Start**. A one-page run finishes in well under a minute.
7. Open the **Output** tab and download the results as JSON, CSV, Excel or XML, or read them through the Apify API. To monitor the market, add a **Schedule** and connect it to Google Sheets, Make, Zapier or a webhook.

#### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `brand` | string | empty | Optional search text inside the auto section, typically a brand. Also used as a hint for `make` when the title names no brand. |
| `max_pages` | integer | 3 | Listing pages to scrape, newest first. 40 ads per page; maximum 500. |
| `fetch_details` | boolean | `true` | When the listing snippet has no year or mileage, open the ad page (one extra request) to read the full text. |
| `proxyConfiguration` | object | Apify datacenter proxy | Proxy settings. A 403/429/503 is retried up to 3 times, each on a fresh proxy session. |

#### Input example

```json
{
  "brand": "Skoda",
  "max_pages": 1,
  "fetch_details": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### 📦 Output example

One item from a real run (14 November 2026):

```json
{
  "id": "197501774",
  "title": "Škoda Kodiaq SPORTLINE 2.0 TSI DSG 4x4 140kW 115.500KM ŤAŽNÉ",
  "make": "Škoda",
  "model": "Kodiaq",
  "year": 2020,
  "km": 115500,
  "hp": 190,
  "price": 25499,
  "currency": "EUR",
  "fuel_type": "petrol",
  "gearbox": "automatic",
  "city": "Trenčín",
  "region": null,
  "postal_code": "913 24",
  "is_professional": false,
  "url": "https://auto.bazos.sk/inzerat/197501774/skoda-kodiaq-sportline-20-tsi-dsg-4x4-140kw-115500km-tazne.php",
  "img_url": "https://www.bazos.sk/img/1t/774/197501774.jpg?t=1794646897",
  "source": "bazos.sk",
  "scraped_at": "2026-11-14T09:19:30.490004+00:00"
}
```

In Apify Console the **Overview** view shows title, make, model, year, km, price, fuel, gearbox, town and link; the **All fields** view adds power, postal code, photo, ID and timestamp.

### 💰 How much does it cost to scrape Bazos.sk?

Bazos.sk Car Scraper uses pay-per-event pricing. You pay only for results:

- **$2.00 per 1,000 car ads** saved to the dataset;
- **$0.005 per run start**.

No proxy or compute costs are added on top, and the extra ad-page requests of `fetch_details` are free. Some examples:

| Run | Ads | Cost |
|---|---|---|
| Test run (1 page) | 40 | about $0.09 |
| 10 pages | 400 | about $0.81 |
| 100 pages | 4,000 | about $8.01 |

With the $5 of free monthly credit on Apify's free plan you can scrape about 2,400 ads a month at no cost. Set a **maximum cost per run** in the run options if you want a hard cap on spending.

### ⚠️ Limits

- 40 ads per page; `max_pages` goes up to 500. When a page has no more ads, the run stops and keeps everything it found.
- Some Apify datacenter IPs occasionally get a 403 from Bazos. The scraper retries each request up to 3 times on a new proxy session; if a listing page still fails, the run stops there and keeps the ads already saved.
- The auto section can also hold ads for vans, motorbikes or parts. Those usually come out with an empty `make`; filter on it if you only want cars.
- A run that extracts nothing, or whose ads all lack both price and make (a sign the page layout changed), ends as **FAILED** instead of a green run with bad data.
- Results reflect Bazos.sk at run time. Ads are edited and removed quickly.

### 🔗 Related actors

- [Willhaben Scraper](https://apify.com/rastriq/willhaben-scraper): used cars in neighbouring Austria.
- [Marktplaats.nl Car Scraper](https://apify.com/rastriq/marktplaats-scraper): the largest Dutch marketplace.
- [2dehands Scraper](https://apify.com/rastriq/2dehands-scraper): used cars in Belgium.

### ❓ FAQ

**Do I need a residential proxy to use Bazos.sk Car Scraper?**
No. Our test runs used the default Apify datacenter proxy and no residential traffic. If Bazos blocks an IP, the scraper switches to a fresh proxy session by itself. The run's `SUMMARY` record in the key-value store shows how many responses were blocked.

**Why are year or mileage empty on some ads?**
Bazos has no structured fields, and some sellers simply do not write them. With `fetch_details` on, the scraper already opens the full ad when the snippet lacks year or mileage; if the full text does not state them either, the field stays `null`.

**Is it legal to scrape Bazos.sk?**
The scraper collects only public ad data (car details, price, town and link) and no personal data about sellers. You are responsible for how you use the data, including compliance with the GDPR and with Bazos' terms of use. Read more in Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

**Something broke. What should I do?**
Open an issue in the **Issues** tab with the run ID. Bazos.sk Car Scraper fails loudly instead of returning empty or broken data, so a FAILED run usually means the site changed and we need to update the parser.

# Changelog

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

# Actor input Schema

## `brand` (type: `string`):

Optional search text inside the auto section of bazos.sk, typically a car brand (for example BMW). It is also used as a hint for the make when the title does not name one. Leave empty to scrape all car ads.

## `max_pages` (type: `integer`):

Maximum listing pages to scrape (40 ads per page), newest first. The run stops earlier when there are no more ads.

## `fetch_details` (type: `boolean`):

Bazos has no structured vehicle fields; year, mileage, power, fuel and gearbox are read from the ad text. When the listing snippet does not mention year or mileage, open the ad page (one extra request per such ad) to read the full text. Turn off for faster runs with more empty fields.

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

Apify Proxy. The default datacenter proxy works; a 403/429/503 is retried up to 3 times, each time on a fresh proxy session. Residential proxy is not needed.

## Actor input object example

```json
{
  "brand": "BMW",
  "max_pages": 1,
  "fetch_details": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped ads in the default dataset.

# 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 = {
    "max_pages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/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 = {
    "max_pages": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/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 '{
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/bazos-sk-scraper --silent --output-dataset

```

## MCP server setup

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