# Kaufland Scraper — Czech Marketplace Products & Prices (`studio-amba/kaufland-cz-scraper`) Actor

Scrape products from the Kaufland.cz marketplace: names, prices (CZK), sellers, brands, EAN codes, ratings, images and categories. Search by keyword, category or product URLs. No login, no cookies.

- **URL**: https://apify.com/studio-amba/kaufland-cz-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Kaufland.cz Scraper

Scrape product data from the [Kaufland.cz](https://www.kaufland.cz) marketplace
— the Czech Schwarz Group online marketplace with millions of products from
Kaufland direct sales and third-party sellers.

Search by keyword, pull a whole category, or hand it a list of product URLs. Get
back clean, structured records with prices in CZK, sellers, brands, EAN codes,
ratings, images and categories. No login, no cookies.

### Why use this actor?

Kaufland is one of the largest online marketplaces in the Czech Republic, and its
catalogue changes constantly across thousands of independent sellers. This actor
turns any keyword or category into a structured product feed you can drop into a
spreadsheet, a pricing tool, or a database.

Typical users: brands tracking how their products are priced and sold across
marketplace sellers, retailers doing competitive price monitoring, resellers
sourcing products, and analysts building assortment or market-share reports.

### What you get

- **Real marketplace prices** in CZK as numbers (not strings), plus price per
  unit (e.g. `20.98 CZK/1kg`) and strike-through / RRP where a product is on sale.
- **Seller name** for every item — the marketplace seller, or `Kaufland` for
  direct sales.
- **Brand, EAN, category, ratings and review counts** — high field coverage
  because the data comes straight from Kaufland's own product API, not scraped
  HTML.
- **All product images** in full resolution.
- **No login and no cookies** — nothing to configure beyond a keyword.

### How to scrape kaufland.cz data

1. Add the actor to your Apify account.
2. Enter a **Search Query** (a Czech keyword like `telefon`, `notebook`,
   `mixér`), or a **Category ID**, or paste **Product URLs**.
3. Set **Max Results** to how many products you want.
4. Provide a **Bright Data API key** (see below) or set the
   `BRIGHT_DATA_API_KEY` environment variable.
5. Run it. Download the results as JSON, CSV, Excel or feed them to an API.

Kaufland.cz sits behind Cloudflare and DataDome, so the actor routes its
requests through the [Bright Data](https://brightdata.com) Web Unlocker, which
solves the bot challenge and returns the data. You need a Bright Data account
with a Web Unlocker zone; the key goes in the `brightDataApiKey` input (kept
secret) or the `BRIGHT_DATA_API_KEY` environment variable.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Keyword to search the marketplace (default: `telefon`). Products are discovered by keyword and enriched with full data. |
| `categoryId` | Integer | No | A numeric Kaufland category id to pull instead of a keyword (e.g. `38551` = Pevné linky). Category ids appear in the `category` data of any scraped product. |
| `productUrls` | Array | No | One or more `https://www.kaufland.cz/product/<id>/` URLs to scrape directly. |
| `maxResults` | Integer | No | Maximum number of products to return (default: 100). |
| `brightDataApiKey` | String | Yes | Bright Data Web Unlocker API key. Falls back to the `BRIGHT_DATA_API_KEY` environment variable. |
| `proxyConfiguration` | Object | No | Apify proxy settings for auxiliary requests. |

Leave everything empty and the actor runs a default `telefon` search, so an empty
input `{}` still returns data.

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Gigaset AS690 Duo, Analog/DECT telefon, Černá"` |
| `brand` | String | `"Gigaset"` |
| `price` | Number | `1330.58` |
| `currency` | String | `"CZK"` |
| `originalPrice` | Number | `1599` (null if not on sale) |
| `pricePerUnit` | String | `"20.98 CZK/1kg"` |
| `discount` | String | `"-15%"` (null if not on sale) |
| `ean` | String | `"4250366854991"` |
| `sku` | String | `"392107431093"` (Kaufland offer id) |
| `productId` | String | `"354364255"` |
| `seller` | String | `"Macservice"` |
| `inStock` | Boolean | `true` |
| `rating` | Number | `4.86` |
| `reviewCount` | Integer | `7` |
| `url` | String | `"https://www.kaufland.cz/product/354364255/"` |
| `imageUrl` | String | Primary product image URL |
| `imageUrls` | Array | All product image URLs |
| `category` | String | `"Pevné linky"` |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
  "name": "Gigaset AS690 Duo, Analog/DECT telefon, Bezdrátové sluchátko, Černá",
  "brand": "Gigaset",
  "price": 1330.58,
  "currency": "CZK",
  "ean": "4250366854991",
  "sku": "392107431093",
  "productId": "354364255",
  "seller": "Macservice",
  "inStock": true,
  "url": "https://www.kaufland.cz/product/354364255/",
  "imageUrl": "https://media.cdn.kaufland.de/product-images/original/3521ab42d7c888ae633dc19615f39a8d.jpg",
  "imageUrls": [
    "https://media.cdn.kaufland.de/product-images/original/3521ab42d7c888ae633dc19615f39a8d.jpg"
  ],
  "category": "Pevné linky",
  "scrapedAt": "2026-07-07T09:36:04.579Z"
}
```

### How it works

Kaufland's own keyword search endpoints are blocked to automated access, so the
actor works entirely from Kaufland's public, robots-allowed product API:

1. **Enumeration.** A keyword search finds matching product ids across the
   marketplace; a category id or a list of product URLs skips straight to known
   products.
2. **Data.** Product ids are sent in batches to Kaufland's product-tiles API,
   which returns clean JSON — prices, sellers, brands, EAN codes, ratings and
   images — with very high field coverage.

Because the data is batched and comes from the API rather than parsed HTML, runs
are fast and cheap and the output is consistent.

### Cost estimate

Enumeration is cheap (about one request per ten products) and product data is
fetched in batches of up to 50, so a run of 1,000 products is roughly a few
hundred requests. Actual cost depends on your Apify plan and your Bright Data
Web Unlocker usage.

### Limitations

- Requires a Bright Data Web Unlocker key — Kaufland.cz is behind Cloudflare and
  DataDome and cannot be reached without it.
- Keyword search relevance and coverage depend on what is indexed publicly, so a
  keyword run returns the most relevant products rather than a guaranteed
  exhaustive list. Use `categoryId` for category-scoped pulls.
- `originalPrice` and `discount` are only present when a product is actually on
  sale.
- Data is scraped from the public marketplace and may change without notice.
  Respect the website's terms of service and use responsibly.

### Related scrapers

Other marketplace and e-commerce scrapers from the same catalogue:

- [Kaufland.de Scraper](https://apify.com/studio-amba/kaufland-de-scraper) — kaufland.de German marketplace
- [Otto Scraper](https://apify.com/studio-amba/otto-scraper) — otto.de products and prices
- [Idealo Scraper](https://apify.com/studio-amba/idealo-scraper) — idealo.de price comparison
- [Alternate Scraper](https://apify.com/studio-amba/alternate-scraper) — alternate.de electronics

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search the Kaufland.cz marketplace (e.g., 'telefon', 'notebook', 'mixér'). Products are discovered by keyword and enriched with the full product data.

## `categoryId` (type: `integer`):

Optional. A numeric Kaufland category id to pull products for instead of a keyword search (e.g., 38551 = Pevné linky). Category ids appear in the 'category.id' field of any scraped product.

## `productUrls` (type: `array`):

Optional. One or more Kaufland product URLs to scrape directly (https://www.kaufland.cz/product/354364255/).

## `maxResults` (type: `integer`):

Maximum number of products to return.

## `brightDataApiKey` (type: `string`):

Bright Data API key for the Web Unlocker zone. Required — Kaufland.cz is behind Cloudflare and DataDome and cannot be reached without it. Falls back to the BRIGHT\_DATA\_API\_KEY environment variable.

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

Proxy settings. Kaufland access itself goes through the Bright Data Web Unlocker; this proxy is used for any auxiliary requests.

## Actor input object example

```json
{
  "searchQuery": "telefon",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}
```

# 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 = {
    "searchQuery": "telefon",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CZ"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/kaufland-cz-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 = {
    "searchQuery": "telefon",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CZ",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/kaufland-cz-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 '{
  "searchQuery": "telefon",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}' |
apify call studio-amba/kaufland-cz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/sCLCeWYuDaENfRbcH/builds/HxGfA4l8QKiI3P3Wx/openapi.json