# Bazos.cz / Bazos.sk / Bazos.at / Bazos.pl Scraper (`crawlerbros/bazos-scraper`) Actor

Search the Bazos classifieds marketplace across CZ (bazos.cz), SK (bazos.sk), AT (bazos.at), and PL (bazos.pl) by keyword. Extract title, price + currency (CZK/EUR/PLN), locality, posted date, listing URL, thumbnail, category, description length. Optional minPrice/maxPrice filter.

- **URL**: https://apify.com/crawlerbros/bazos-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 14 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Bazos Classifieds Scraper

Search the [Bazos](https://www.bazos.cz/) classifieds marketplace by keyword and extract every matching listing — title, price, locality, description, photos, and direct listing URL. Supports the Czech (`bazos.cz`), Slovak (`bazos.sk`), Austrian (`bazos.at`), and Polish (`bazos.pl`) variants. HTTP-only — no proxy, no login, no API key.

### What it does

You provide one or more search keywords; the actor runs each as a search on Bazos and returns deduplicated listings across all of them. Per listing it captures:

- **Title** — the headline of the ad
- **Price** — parsed numeric value + currency (CZK or EUR)
- **Locality** — city / district where the seller is based
- **Posted date** — the human-readable date Bazos shows on the listing
- **Description** — the snippet shown on the search-results card
- **Category** — auto-detected from the URL subdomain (`auto`, `mobil`, `reality`, `prace`, `elektro`, …)
- **Listing URL** — direct link to the full ad
- **Thumbnail** — first photo from the listing card

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array of strings (required) | `["iphone"]` | One or more search terms. Each runs as a separate Bazos search; results are deduped by listing URL across keywords. |
| `countryVariant` | enum: `CZ` / `SK` / `AT` / `PL` | `CZ` | Which Bazos to query. CZ → bazos.cz (CZK), SK → bazos.sk (EUR), AT → bazos.at (EUR), PL → bazos.pl (PLN). |
| `maxItems` | integer | `50` (1–1000) | Hard cap on total unique listings emitted across all keywords. |
| `maxPagesPerKeyword` | integer | `5` (1–50) | Per-keyword pagination cap. Each Bazos result page has ~20 listings. |
| `minPrice` | integer (optional) | – | Drop listings priced below this number (client-side filter). Listings without a parsed price are kept. |
| `maxPrice` | integer (optional) | – | Drop listings priced above this number. Listings without a parsed price are kept. |

#### Example input

```json
{
  "keywords": ["iphone 15", "macbook pro"],
  "countryVariant": "CZ",
  "maxItems": 100,
  "maxPagesPerKeyword": 5
}
````

### Output

One record per unique listing. Empty fields are omitted (no nulls).

```json
{
  "title": "iPhone 15 Pro 256GB Titanium",
  "description": "Záruka 2 roky, top stav, originální balení.",
  "descriptionLength": 41,
  "price": 24500,
  "currency": "CZK",
  "locality": "Praha 5",
  "postedText": "15.4. 2024",
  "category": "mobil",
  "listingId": "217954459",
  "listingUrl": "https://mobil.bazos.cz/inzerat/217954459/apple-iphone-15-plus-256gb-black.php",
  "thumbnailUrl": "https://mobil.bazos.cz/img/217954459-thumb.jpg",
  "countryVariant": "CZ",
  "matchedKeyword": "iphone 15",
  "scrapedAt": "2024-12-16T14:23:11+00:00"
}
```

#### Output fields

- **`title`** — headline of the ad.
- **`description`** — snippet shown on the search-results card (Bazos shows the first ~150 characters of the listing body).
- **`descriptionLength`** — derived character count of `description` (handy for filtering out near-empty listings).
- **`price`** — integer amount; absent when the seller selected "Dohodou" (negotiable) or "Zdarma" (free).
- **`currency`** — `"CZK"` for bazos.cz, `"EUR"` for bazos.sk and bazos.at, `"PLN"` for bazos.pl; absent when `price` is absent.
- **`locality`** — seller's city / district as shown on Bazos.
- **`postedText`** — Bazos's human-readable post date (e.g. `"15.4. 2024"`).
- **`category`** — Bazos's subdomain category: `auto`, `mobil`, `reality`, `prace`, `elektro`, `dum`, `hudba`, etc. Derived from the listing URL.
- **`listingId`** — Bazos's stable numeric ID for the listing.
- **`listingUrl`** — direct URL of the full ad.
- **`thumbnailUrl`** — first photo from the listing card (when present).
- **`countryVariant`** — `"CZ"`, `"SK"`, `"AT"`, or `"PL"`, matching the input.
- **`matchedKeyword`** — the search term that surfaced this listing.
- **`scrapedAt`** — ISO-8601 timestamp of extraction.

### Use cases

- **Lead generation** — track second-hand iPhone / car / property listings as they appear.
- **Price intelligence** — monitor average asking prices for a category across a marketplace.
- **Inventory enrichment** — populate a price-comparison or aggregator with Bazos's reach across CZ and SK.
- **Reseller research** — find listings whose locality matches your operating area.

### FAQ

**Does it need cookies, login, or proxy?**
No. Bazos search results are public; the actor uses a Chrome User-Agent and connects directly.

**How does pagination work?**
Bazos serves ~20 listings per page using a `crz` offset (page 2 = `crz=20`, page 3 = `crz=40`, etc.). The actor walks pages 1 through `maxPagesPerKeyword` for each keyword, stopping early if a page returns no new listings.

**What if my keyword has no results?**
The actor emits a single record `{"type": "bazos_scraper_error", "reason": "no_listings_found"}` and the run completes successfully (empty datasets aren't treated as failures). Try a broader keyword or switch the country variant.

**Can I search multiple Bazos variants in one run?**
Run the actor once per variant (CZ / SK / AT / PL). The data shapes are identical; you can merge the resulting datasets in your pipeline.

**Why are some listings missing prices?**
Bazos lets sellers list "Dohodou" (price negotiable) or "Zdarma" (free) instead of a number. In those cases `price` and `currency` are omitted from the record (per the omit-empty contract).

**Why don't I see the seller's phone number?**
Bazos requires a click-through and a CAPTCHA-like reveal step on the detail page; this scraper only walks the search-results page, which is fast and reliable. Contact details are out of scope.

# Actor input Schema

## `keywords` (type: `array`):

One or more keywords to search Bazos for. Each keyword runs as an independent search; results are deduplicated by listing URL across keywords.

## `countryVariant` (type: `string`):

Which Bazos to search. CZ = bazos.cz (Czech, prices in CZK). SK = bazos.sk (Slovak, prices in EUR).

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

Drop listings with parsed price below this. Listings without a price (Dohodou, Zdarma) are kept regardless. Currency follows countryVariant.

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

Drop listings with parsed price above this. Listings without a price are kept regardless.

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

Hard cap on the total number of unique listings emitted across all keywords. Bazos returns ~21 listings per page; the actor paginates as needed.

## `maxPagesPerKeyword` (type: `integer`):

Per-keyword pagination cap. Each Bazos result page has ~21 listings. Increase if you need deep results for popular queries.

## Actor input object example

```json
{
  "keywords": [
    "iphone"
  ],
  "countryVariant": "CZ",
  "maxItems": 50,
  "maxPagesPerKeyword": 5
}
```

# 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 = {
    "keywords": [
        "iphone"
    ],
    "countryVariant": "CZ",
    "maxItems": 50,
    "maxPagesPerKeyword": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "keywords": ["iphone"],
    "countryVariant": "CZ",
    "maxItems": 50,
    "maxPagesPerKeyword": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/bazos-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "iphone"
  ],
  "countryVariant": "CZ",
  "maxItems": 50,
  "maxPagesPerKeyword": 5
}' |
apify call crawlerbros/bazos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/bazos-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bazos.cz / Bazos.sk / Bazos.at / Bazos.pl Scraper",
        "description": "Search the Bazos classifieds marketplace across CZ (bazos.cz), SK (bazos.sk), AT (bazos.at), and PL (bazos.pl) by keyword. Extract title, price + currency (CZK/EUR/PLN), locality, posted date, listing URL, thumbnail, category, description length. Optional minPrice/maxPrice filter.",
        "version": "0.1",
        "x-build-id": "HsvH2c4v27W7q5owQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~bazos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-bazos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~bazos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-bazos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~bazos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-bazos-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more keywords to search Bazos for. Each keyword runs as an independent search; results are deduplicated by listing URL across keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryVariant": {
                        "title": "Country variant",
                        "enum": [
                            "CZ",
                            "SK",
                            "AT",
                            "PL"
                        ],
                        "type": "string",
                        "description": "Which Bazos to search. CZ = bazos.cz (Czech, prices in CZK). SK = bazos.sk (Slovak, prices in EUR).",
                        "default": "CZ"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop listings with parsed price below this. Listings without a price (Dohodou, Zdarma) are kept regardless. Currency follows countryVariant."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop listings with parsed price above this. Listings without a price are kept regardless."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the total number of unique listings emitted across all keywords. Bazos returns ~21 listings per page; the actor paginates as needed.",
                        "default": 50
                    },
                    "maxPagesPerKeyword": {
                        "title": "Maximum pages per keyword",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Per-keyword pagination cap. Each Bazos result page has ~21 listings. Increase if you need deep results for popular queries.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```