# Kaufland Scraper \[$1/1k💰] | Preise | Angebote | Reviews (`ahmed_jasarevic/kaufland-scraper`) Actor

Monitor Kaufland.de marketplace prices, UVP deals and reviews. Extract EAN, seller, variants and product data for German price comparison, market research and catalog enrichment.

- **URL**: https://apify.com/ahmed\_jasarevic/kaufland-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 product scrapeds

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

## Kaufland.de Scraper

Extract Kaufland.de product data — prices, UVP deals, EAN, sellers, variants and full review history — for German market research and price monitoring.

Scrape **product data from the Kaufland.de marketplace** — Germany's Schwarz Group online marketplace (formerly real.de) 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, UVP was-price/discount, unit price, EAN, seller, variants, specs, images, and full native review history** — at the cheapest price per 1,000 results on Apify.

### Main Use Cases

- **Kaufland Preise vergleichen & Preisvergleich** — track current price, UVP strike-through and computed discount across sellers
- **Angebote beobachten & UVP deal tracking** — `specialsOnly: true` isolates live deals with real savings
- **Marketplace seller intelligence** — identify sellers, compare offers, monitor stock
- **Kaufland Bewertungen analysieren & review sentiment** — extract full native review history with author, date, rating, title, body and verified-purchase flag
- **EAN & Produktdaten Datenbank (catalog enrichment)** — brand, EAN/GTIN, category breadcrumb, per-category specifications, variant matrix
- **DACH e-commerce analytics** — structured data for German market competitive analysis

### How It Works

1. Add the actor to your Apify account
2. Choose **Search** mode (enter a keyword like `kaffee`, `laptop`, `kopfhörer`, optionally set category ID, brand, price range, sort order, deals-only toggle) or **URL** mode (paste product, category, or search-result URLs)
3. Toggle **Fetch Full Product Details** for brand, EAN, specs, variants, and seller detail
4. Toggle **Fetch Full Review History** for per-review author/date/rating/title/body
5. Set **Max Products** and **Max Pages** to control scope
6. Run the actor. Download results as JSON, CSV, Excel, or feed them to an API.

### Track Kaufland Angebote & UVP Discounts

Kaufland's weekly Angebote (deals) carry a strike-through UVP was-price — the actor computes the discount percent directly from the site's own pricing data. Set `specialsOnly: true` to return only items currently in the deals facet, or combine it with a keyword/category to scope deal tracking. This is the fastest way to monitor promotion dynamics for German price comparison and deal tracking.

### Extract EAN & Product Data For Catalog Enrichment

Enable `fetchDetails` (a separate paid event) to visit each product page and return brand, EAN/GTIN, full category breadcrumb, per-category technical specifications and the variant matrix. Combined with `maxItems`, this builds a structured Kaufland EAN database for catalog enrichment, cross-marketplace product matching and feed cleaning.

### Analyze Kaufland Reviews For Sentiment Research

With `fetchReviews` (on by default), the actor reads each product's full native review history from Kaufland's own review service — one structured record per review with author, date, rating, title, body, verified-purchase and product-test flags. Perfect for German market review sentiment analysis, seller benchmarking and DACH consumer research.

### Monitor Marketplace Seller Prices In Real Time

Every listing record includes the current price, the UVP/was-price when on sale, marketplace seller name and rating. Schedule the actor daily (it is browser-free, so runs are cheap) to keep a live price history for MAP enforcement, repricing and Kaufland Preisvergleich.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchTerm` | string | No | — | Free-text keyword to search Kaufland.de (e.g. `kaffee`, `laptop`, `kopfhörer`) |
| `urls` | array of `{url}` | No | `[]` | Product (`/product/ID/`), category (`/c/name/~ID/`) or search (`/s/?search_value=`) URLs for URL mode |
| `mode` | enum (`search`, `url`) | No | `search` | `search` for keyword/category/brand search, `url` to paste links directly |
| `category` | string | No | — | Kaufland category ID (e.g. `5921` = Kaffeepulver). Find IDs in category URLs |
| `brand` | string | No | — | Filter by brand/manufacturer name |
| `minPrice` | integer | No | — | Minimum price filter in EUR |
| `maxPrice` | integer | No | — | Maximum price filter in EUR |
| `specialsOnly` | boolean | No | `false` | Only items in Kaufland's deals (Angebote) with UVP strike-through prices |
| `sortBy` | enum (`natural`, `price-asc`, `price-desc`, `customer-reviews`, `newest-arrivals`, `bestsellers`) | No | `natural` | Sort order for search results |
| `maxPages` | integer | No | `25` | Max result pages per search/start URL (25 ≈ 500 products); `maxItems` is hit first |
| `maxItems` | integer | No | `20` | Maximum total products to scrape; `0` = unlimited |
| `fetchDetails` | boolean | No | `false` | **Extra paid event** — visits each product page for brand, EAN/GTIN, specs, variants, breadcrumb, seller detail |
| `fetchReviews` | boolean | No | `true` | Fetches full native review history per product (one billed event per review) |
| `reviewsPerProduct` | integer | No | empty (`0` = all) | Cap on reviews fetched per product |
| `useCache` | boolean | No | `true` | Serves previously scraped results for the same URLs from the key-value store on re-runs; disable for always-fresh prices |
| `cacheTtlHours` | integer | No | `12` | How long cached results stay valid before they are refetched |
| `proxy` | object | No | `UNBLOCKER` | Apify proxy config. Defaults to the **UNBLOCKER** group, required to bypass DataDome |

### Output

#### Product records (default dataset, view `products`)

| Field | Type | Description |
| --- | --- | --- |
| `productId` | string | Kaufland product ID |
| `title` | string | Product title |
| `url` | string | Full product URL |
| `price` | number | Current selling price in EUR |
| `currency` | string | Always `EUR` |
| `originalPrice` | number | null | UVP/was-price (strike-through) when on deal |
| `discountPercent` | number | null | Computed discount % |
| `unitPrice` | string | null | Grocery unit price (e.g. `18.78 EUR/1kg`) |
| `brand` | string | null | Brand/manufacturer name |
| `ean` | string | null | European Article Number / GTIN |
| `seller` | string | null | Marketplace seller name |
| `rating` | number | null | Average customer rating (1–5) |
| `reviewCount` | integer | null | Total number of reviews |
| `image` | string | null | Primary product image URL |
| `imageUrls` | array | All product image URLs |
| `category` | string | null | Deepest category name |
| `breadcrumb` | array | Full category path |
| `specifications` | object | Per-category technical specs |
| `variants` | array | Variant options (size/color) |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Review records (separate reviews dataset, view `reviews`)

| Field | Type | Description |
| --- | --- | --- |
| `productId` | string | Kaufland product ID |
| `title` | string | Product title |
| `reviewId` | string | Review ID |
| `reviewAuthor` | string | Reviewer handle |
| `reviewRating` | number | Star rating (1–5) |
| `reviewDate` | string | Review date |
| `reviewTitle` | string | Review headline |
| `reviewBody` | string | Review text |
| `reviewVerified` | boolean | Verified-purchase flag |
| `reviewProductTest` | boolean | Product-test flag |
| `reviewMedia` | array | Review media URLs |
| `scrapedAt` | string | ISO 8601 timestamp |

### Example Input

**Search mode** (keyword + category + deals):

```json
{
  "mode": "search",
  "searchTerm": "kaffee",
  "category": "5921",
  "specialsOnly": false,
  "sortBy": "natural",
  "maxItems": 100,
  "maxPages": 5,
  "fetchReviews": true,
  "fetchDetails": false
}
```

**URL mode** (paste product or category URLs):

```json
{
  "mode": "url",
  "urls": [
    { "url": "https://www.kaufland.de/product/318524735/" },
    { "url": "https://www.kaufland.de/c/kaffee-tee/~34501/" }
  ],
  "maxItems": 50,
  "fetchReviews": true
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Example Output

**Product record**:

```json
{
  "productId": "318524735",
  "title": "EILLES KAFFEE Gourmet, 500g Bohnen",
  "url": "https://www.kaufland.de/product/318524735/",
  "price": 9.39,
  "currency": "EUR",
  "originalPrice": 12.99,
  "discountPercent": 27.7,
  "unitPrice": "18.78 EUR/1kg",
  "brand": "Eilles",
  "ean": "4006581020020",
  "seller": "GOURVITA",
  "rating": 4.86,
  "reviewCount": 7,
  "image": "https://media.cdn.kaufland.de/product-images/400x400/...",
  "imageUrls": ["..."],
  "category": "Kaffeebohnen",
  "breadcrumb": ["Startseite", "Lebensmittel", "Kaffee & Tee", "Kaffeebohnen"],
  "specifications": { "Gewicht": "500g", "Art": "Bohnen" },
  "variants": [{ "title": "1kg", "url": "https://..." }],
  "scrapedAt": "2026-09-17T16:00:00.000Z"
}
```

**Review record** (when `fetchReviews` is enabled):

```json
{
  "productId": "318524735",
  "title": "EILLES KAFFEE Gourmet, 500g Bohnen",
  "reviewId": "6962768",
  "reviewAuthor": "hm-1234567890",
  "reviewRating": 5,
  "reviewDate": "23.06.2026",
  "reviewTitle": "Top Service",
  "reviewBody": "Rich flavor, fast delivery...",
  "reviewVerified": true,
  "reviewProductTest": false,
  "scrapedAt": "2026-09-17T16:00:00.000Z"
}
```

### Integrations & Automation

- **Apify API** — run the actor programmatically from any language (REST, `apify-client` for JS/TS and Python)
- **Webhooks** — trigger downstream workflows (Slack alerts, databases, dashboards) when a run completes
- **Scheduling** — run **daily** for Kaufland price monitoring and Angebote tracking; **weekly** is enough for stable catalog/EAN enrichment. Recurring runs also keep cached results fresh (see `useCache` / `cacheTtlHours`)
- **Apify MCP server** — expose this actor to AI agents through `mcp.apify.com` for on-demand Kaufland data access

### Related Actors

- [piotrv1001/kaufland-listings-scraper](https://apify.com/piotrv1001/kaufland-listings-scraper) — Kaufland listings + PDPs across DE/CZ/SK/PL/AT storefronts
- [e-commerce/kaufland-fast-product-scraper](https://apify.com/e-commerce/kaufland-fast-product-scraper) — lightweight Kaufland listing data at scale
- [e-commerce/kaufland-product-detail-scraper](https://apify.com/e-commerce/kaufland-product-detail-scraper) — full product detail pages (price, description, attributes, breadcrumb)
- [e-commerce/kaufland-reviews-scraper](https://apify.com/e-commerce/kaufland-reviews-scraper) — Kaufland customer reviews with verified-purchase flags
- [studio-amba/kaufland-de-scraper](https://apify.com/studio-amba/kaufland-de-scraper) — Kaufland.de keyword/category/catalog data

### FAQ

#### Why use this actor instead of the official Kaufland API?

Kaufland's official **Seller API** (`sellerapi.kaufland.com`) exists only for registered marketplace sellers to manage their own inventory and orders — it is not a public product-data API. Kaufland does not offer a buyer-side public API; the legacy `real.de` API was sunset in 2022 and now only returns HTTP 410. This actor needs **no seller account, no login and no API keys** to extract the same public product data.

#### What are alternatives to this actor?

On Apify: `piotrv1001/kaufland-listings-scraper`, `e-commerce/kaufland-fast-product-scraper`, `e-commerce/kaufland-product-detail-scraper`, `e-commerce/kaufland-reviews-scraper` and `studio-amba/kaufland-de-scraper`. Off-platform: commercial scraping APIs (e.g. Bright Data Web Unlocker, ShoppingScraper, Real Data API, Octoparse). This actor is the **cheapest per 1,000 results** among the Apify Kaufland actors.

#### How do I scrape Kaufland?

Add the actor, choose **Search** mode (keyword like `kaffee` or `laptop`, optionally a category ID) or **URL** mode, set `maxItems`, and run. Kaufland.de is protected by Cloudflare + DataDome, so keep the default **UNBLOCKER** proxy group enabled — plain datacenter/residential proxies return 403.

#### Can I track Kaufland prices over time (Preisvergleich / Preismonitoring)?

Yes. Schedule the actor daily with the same `searchTerm`/`category` and store runs in your dataset. Every record includes `price`, `originalPrice`, `discountPercent` and `scrapedAt`, so you can build a price history and detect promotions as they appear.

#### Kaufland vs Amazon — which is worth scraping?

Kaufland.de is Germany's **second-largest online marketplace after Amazon** (~€4B GMV, ~32,000 sellers as of 2024/2025, operated by the Schwarz Group), with heavy grocery volume plus marketplace categories — electronics, household goods, toys, DIY — that Amazon.de also carries. This actor targets kaufland.de specifically (product, price and review data); if you also need Amazon.de data, combine it with a dedicated Amazon actor and match products by EAN.

#### Is a proxy required?

Practically yes. Kaufland.de is behind **Cloudflare + DataDome**, which block datacenter and residential IPs. The actor defaults to the Apify **UNBLOCKER** group (Apify Unblocker units) or can use a Bright Data Web Unlocker endpoint via `BRIGHT_DATA_PROXY_URL`.

#### Does it work with MCP and AI agents?

Yes. Expose the actor through the Apify MCP server (`https://mcp.apify.com`) so AI agents can fetch Kaufland product, price and review data on demand, or call it via the Apify API.

### SEO Keywords

kaufland scraper, kaufland preisvergleich, kaufland preise vergleichen, kaufland preis monitoring, kaufland angebote beobachten, kaufland uvp rabatte, kaufland produktdaten extrahieren, kaufland ean datenbank, kaufland bewertungen analysieren, kaufland reviews extrahieren, kaufland haendler recherche, kaufland seller recherche, how to scrape kaufland, kaufland price tracker, kaufland price monitoring, kaufland api alternative, kaufland marktplatz daten, kaufland lebensmittel preise, kaufland haushaltsgeraete preise, kaufland drogerie preise, kaufland spielzeug preise, real.de nachfolger, kaufland vs amazon

### For AI Agents & LLM Apps

**Purpose:** returns structured Kaufland.de product listings (price, UVP/discount, unit price, EAN, seller, rating, images) and optionally full product details and native customer reviews from the public marketplace — no login, no seller account required.

**Minimal working input (search mode):**

```json
{ "mode": "search", "searchTerm": "kaffee", "maxItems": 20 }
```

**URL-mode variant (paste specific products/categories):**

```json
{ "mode": "url", "urls": [{ "url": "https://www.kaufland.de/product/318524735/" }], "maxItems": 20 }
```

**Output fields:** `productId, title, url, price, currency, originalPrice, discountPercent, unitPrice, brand, ean, seller, rating, reviewCount, image, imageUrls, category, breadcrumb, specifications, variants, scrapedAt` — and with `fetchReviews: true`, review records: `productId, title, reviewId, reviewAuthor, reviewRating, reviewDate, reviewTitle, reviewBody, reviewVerified, reviewProductTest, reviewMedia, scrapedAt`.

**Behaviors an agent should know:**

- `fetchDetails` is a **separate paid event** ($0.0005/product) — it is `false` by default to keep default runs cheap; set `true` only when brand/EAN/specs/variants are needed.
- `fetchReviews` defaults to `true` and bills **one Review event per review** fetched ($0.001 each) — cap it with `reviewsPerProduct` (empty/`0` = all).
- DataDome blocks non-unblocking proxies: keep the default `proxy.apifyProxyGroups: ["UNBLOCKER"]` — HTTP runs without it will yield `0` results with 403s.
- `useCache: true` (default) serves previously scraped URLs from the key-value store on re-runs — set `false` (and/or lower `cacheTtlHours`) when freshly live prices are required.
- `maxItems: 0` means unlimited; `maxPages` (default 25 ≈ 500 products) caps pagination depth — set both deliberately to bound billing.
- **Billing:** pay-per-event — $0.001 per product (listing), $0.0005 per product detail (`fetchDetails`), $0.001 per review (`fetchReviews`), plus a $0.00005 actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Kaufland or the Schwarz Group**. It accesses only publicly available pages of kaufland.de — the actor performs no login bypass, no CAPTCHA solving and no access to non-public data.

Users are solely responsible for compliance with Kaufland's Terms of Service and applicable data-protection law, including the GDPR when review data includes personal data such as reviewer handles (see the `reviewAuthor` field). Publicly visible review text and ratings should not be used for unsolicited outreach or any use prohibited by the platform's terms or applicable law. This disclaimer is not legal advice.

### Competitive Positioning

Verified against Apify Store pricing pages (per 1,000 events):

| Actor | Listings / 1k | Details / 1k | Reviews / 1k |
| --- | --- | --- | --- |
| **this actor (kaufland-scraper)** | **$1.00** | **$0.50** | **$1.00** |
| piotrv1001/kaufland-listings-scraper | $2.00 | $5.00 | — |
| abotapi/kaufland-de-scraper | $2.00 | +$0.90 enrichment | — |
| studio-amba/kaufland-de-scraper | $2.00 | — | — |
| e-commerce/kaufland-fast-product-scraper | $3.50 | — | — |
| e-commerce/kaufland-product-detail-scraper | — | $4.30 | — |
| e-commerce/kaufland-reviews-scraper | — | — | $3.50 |

**This actor is the cheapest per 1,000 results on the market** — for listings ($1.00 vs $2.00–$3.50), for full product details ($0.50 vs $4.30–$5.00) and for reviews ($1.00 vs $3.50). It is also the only actor that combines listings, details and full native review history in one run.

### Technical Details

#### Proxy for anti-bot bypass (required)

**Kaufland.de is protected by Cloudflare + DataDome.** In practice, direct plain-HTTP requests and Apify datacenter/residential proxies both return **403** to Kaufland.de. To get data reliably, route the crawler through an unlocking proxy:

1. **Apify Unblocker** (recommended, built in): enable the proxy option in the actor input and select the **UNBLOCKER** group. This is the default group when none is chosen. It uses Apify Unblocker units from your plan.
2. **Bright Data Web Unlocker**: sign up at [brightdata.com](https://brightdata.com), create a Web Unlocker zone, and paste the proxy endpoint into the `BRIGHT_DATA_PROXY_URL` environment variable in your Apify account.

Without an unlocking proxy the actor still runs (and stays cheap), but expect `0 results` with `403` responses from DataDome.

#### Pricing / Cost Estimation

This actor is a **browser-free Cheerio crawler**, so runs are extremely cheap. Costs are dominated by request volume and proxy usage. Kaufland.de is protected by DataDome, so an unlocking proxy is required: the built-in **Apify Unblocker** group (billed in Apify Unblocker units) or your own **Bright Data Web Unlocker** endpoint.

##### Event-based pricing (pay per event)

| Event | What you get | Price per event | Per 1,000 |
| --- | --- | --- | --- |
| **`product`** | Product scraped (one listing record) | **$0.001** | **$1.00** |
| **`details`** | Full product page (brand, EAN, specs, variants) — `fetchDetails` | **$0.0005** | **$0.50** |
| **`review`** | One native review record (author, rating, body, …) — `fetchReviews` | **$0.001** | **$1.00** |
| **actor start** | Run start | $0.00005 | — |

> **`fetchDetails` is a separate, extra-charge event.** It is disabled by default (`false`). Enabling it calls the Apify monetization `details` event once per product. This keeps the default run cheap (listings + reviews only) while still letting advanced users get full product pages at a transparent per-event price.

#### Strategy

Kaufland.de serves its listing and product data as server-side-rendered HTML. The actor uses **CheerioCrawler** over plain HTTP — it fetches pages directly and parses them in-process. **No JavaScript rendering and no headless browser**, which makes runs roughly 10x faster and far cheaper than browser-based crawling. Reviews are the one exception: the review widget is loaded client-side, so the actor reads it from Kaufland's own JSON review service with a single HTTP GET per product (`/api/product-reviews-frontend/v1/reviews/product/{id}`).

Parsing is **DOM-first with a JSON fallback**: Kaufland renders every listing tile into the server HTML (using stable classes such as `.product-title`, `.product-price__final-price`, `.product-image__image`, `.base-price`, `.rating-stars__*`, `.product-discount__strikeout`), so the actor reads those directly. On product pages, detailed specs, brand, EAN and breadcrumb come from the spec table and DOM, merged with any embedded JSON. The actor:

1. Fetches listing pages over HTTP and extracts products (title, price, UVP, unit price, rating, seller, images)
2. Optionally visits individual product pages for full details (brand, specs, variants, breadcrumb, EAN)
3. Optionally fetches the full review history from the review service (author, date, rating, title, body, verified-purchase and product-test flags)

Realistic browser headers (rotating User-Agent, `Accept-Language: de-DE`, Sec-Fetch/Sec-CH-UA) are sent by default. They are **not enough on their own** for Kaufland.de: route the crawler through an unlocking proxy — the built-in Apify **UNBLOCKER** group (default) or a **Bright Data Web Unlocker** endpoint via `BRIGHT_DATA_PROXY_URL`.

#### Why Cheerio instead of Playwright?

Kaufland.de renders product and listing data into the server HTML response, so a full browser is unnecessary overhead. CheerioCrawler downloads that HTML with a single HTTP request and parses it with Cheerio — no browser launch, no JavaScript execution, and no chasing XHR calls for listings or details. Reviews are fetched as JSON from the same review endpoint the site's own widget uses, rather than by driving a browser. It defaults to **512 MB** memory and modest concurrency, so compute costs stay minimal. The result is significantly faster, cheaper, and more stable runs. If the site ever ships other JS-only sections, a Playwright/Bright Data browser mode can be layered back on, but the default Cheerio path already covers listings, details, and reviews.

### Known Limitations

- **Anti-bot protection** — Kaufland.de is behind Cloudflare/DataDome; Datacenter and residential IPs are blocked, so an unlocking proxy (Apify UNBLOCKER group or Bright Data Web Unlocker) is required
- **Search relevance** depends on Kaufland's own indexing — keyword search returns most relevant products, not exhaustive lists. Use `category` for scoped pulls
- **Review scraping** relies on Kaufland's product-reviews service endpoint, which may change; rating-only reviews (no text) are still returned
- **Rate limiting** — the actor uses modest concurrency (5) and respects page load times

### Disclaimer

This actor scrapes publicly available product data from kaufland.de. Users are responsible for complying with Kaufland's Terms of Service and applicable data protection regulations (GDPR). Do not collect personal data beyond what is publicly displayed on product/review pages.

### Support

For issues, feature requests, or custom modifications, please use the Issues tab on the Apify Store page.

# Actor input Schema

## `searchTerm` (type: `string`):

Free-text keyword to search Kaufland.de (e.g. 'kaffee', 'laptop', 'kopfhörer'). Used as the primary query — start here.

## `urls` (type: `array`):

Paste Kaufland product (/product/ID/), category (/c/name/~ID/), or search (/s/?search\_value=) URLs. Used in URL mode.

## `mode` (type: `string`):

Use 'search' for keyword/category/brand search, or 'url' to paste product/category/search URLs directly.

## `category` (type: `string`):

A Kaufland category ID to narrow search or browse a whole category (e.g. '5921' for Kaffeepulver). Find IDs in category page URLs: kaufland.de/c/name/~ID/.

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

Filter by brand/manufacturer name.

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

Minimum price filter in EUR.

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

Maximum price filter in EUR.

## `specialsOnly` (type: `boolean`):

Only return items currently in Kaufland's deals (Angebote) with UVP strike-through prices.

## `sortBy` (type: `string`):

How to sort results.

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

Maximum number of result pages to paginate through per search query or start URL. Total items = maxItems is reached first; this caps how deep pagination goes (default 25 ~ 500 products).

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

Maximum total number of products to scrape. Set to 0 for unlimited.

## `fetchDetails` (type: `boolean`):

PREMIUM / ADD-ON EVENT. When enabled, visits each product page for brand, breadcrumb path, EAN/GTIN, specifications, variant matrix, and seller detail. This is an extra paid event on top of plain listings and is billed separately. Slower but more complete.

## `fetchReviews` (type: `boolean`):

When enabled, fetches each product's full review history from Kaufland's product-reviews service (review id, author, date, rating, title, body, verified-purchase and product-test flags, media) and pushes one dataset item per review into the separate 'reviews' dataset. Adds one request per review page per product.

## `reviewsPerProduct` (type: `integer`):

Maximum number of reviews to fetch per product. Leave empty or set 0 to fetch ALL reviews (unlimited). Fewer = faster, more = fuller review history.

## `useCache` (type: `boolean`):

When enabled, previously scraped results for the same listing/detail/review URLs are stored in the key-value store and served instantly on re-runs instead of fetching the site again. Speeds up repeated runs of the same searches. Disable when you need always-fresh prices.

## `cacheTtlHours` (type: `integer`):

How long cached results stay valid before they are considered stale and refetched.

## `proxy` (type: `object`):

Kaufland.de is protected by DataDome, which blocks datacenter and residential proxies. Enable the proxy and select the UNBLOCKER group (the actor defaults to UNBLOCKER when no group is chosen).

## Actor input object example

```json
{
  "urls": [],
  "mode": "search",
  "specialsOnly": false,
  "sortBy": "natural",
  "maxPages": 25,
  "maxItems": 20,
  "fetchDetails": false,
  "fetchReviews": true,
  "useCache": true,
  "cacheTtlHours": 12,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `reviews` (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 = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/kaufland-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 = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/kaufland-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 '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}' |
apify call ahmed_jasarevic/kaufland-scraper --silent --output-dataset

```

## MCP server setup

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