# Heureka Scraper - CZ & SK Prices, Products and Shop Offers (`s-r/heureka-scraper`) Actor

Export Heureka.cz and Heureka.sk search, barcode and category results: product title, lowest and highest price across shops, shop count, ratings, category and optional merchant offers with price per shop. For price monitoring, assortment research and Czech or Slovak market analysis.

- **URL**: https://apify.com/s-r/heureka-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 products

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

## Heureka Scraper

Heureka Scraper collects product search results and merchant offers from Heureka.cz in Czechia and Heureka.sk in Slovakia. Search by keyword, barcode, or a search or category URL copied from the site, and export structured rows for price comparison, price monitoring, assortment research, and product discovery. Each run produces a clean dataset you can download as JSON, CSV, or Excel, or read through the Apify API.

### What this Heureka scraper returns

For every product card, you get the title, the Heureka product URL, the image, the lowest and highest price across shops, the number of shops, the category, the review rating and review count, and the preview parameters Heureka shows on the card. Standalone merchant offers come back as their own rows with the merchant name and price. With `includeOffers` switched on, each product row also carries the merchant offers listed on its product page, so you see which shop sells it at which price.

### Input

Provide at least one entry in `queries` or `startUrls`. Queries accept ordinary search terms and barcode-shaped strings. Use `country: "cz"` for Czechia or `country: "sk"` for Slovakia. A copied URL chooses its own market. The `maxItems` option limits the total number of unique rows across all inputs, with a default of 100 and a maximum of 20,000. Results that occur under several inputs are delivered once, so arrange inputs in your preferred order.

The following input was used with a genuine Czech product response:

```json
{"queries":["0195949052637"],"maxItems":5}
```

That search returned Apple AirPods Pro 2. Generation USB-C MTJV3ZM/A and standalone merchant offers. A barcode query is a search entrance; Heureka does not expose a verified barcode field on the returned products. By default, `exactEanOnly` rejects semantic fallback suggestions for barcode-shaped searches. Disable it only if you want those suggestions included.

A Slovak keyword search looks like this:

```json
{"queries":["kavovar delonghi"],"country":"sk","maxItems":5}
```

And a copied search URL, here the last result page of a Czech search, works the same way:

```json
{"startUrls":["https://www.heureka.cz/?h%5Bfraze%5D=kavovar+delonghi&f=200"],"maxItems":5}
```

### Heureka Scraper options

Choose `sort` from `relevance`, `price_asc`, `price_desc`, or `review_count`. A copied URL's sorting parameter takes precedence, and its page number and category filters are retained. `includeSponsored` includes sponsored cards by default and marks them with `is_sponsored`. A sponsored and organic appearance of the same product is counted once.

Set `includeOffers` to true to collect the merchant offers initially visible on each product page. Set `includeRaw` to true if you also need the original search-card object. This can make the output much larger, especially for sponsored cards. Ordinary search results already include normalized fields for common price-comparison tasks.

### Output

The default dataset contains two row types. Product rows carry `row_type: "product"` and `_type: "product"`; standalone merchant offers use `"offer"` for both. Every row includes its source, fetch time, Heureka ID, title, country, currency, price, URL, page, and search context. Positions are assigned after deduplication.

Product rows include `product_id`, `lowest_price`, `highest_price`, `offers_count`, category information, shop count, review information, and available preview parameters. Product-line cards can include a list of variants. The lowest and highest prices are the source's displayed price range across shops. Shipping is not specified for that range, so these values should not be interpreted as confirmed delivered totals.

Standalone offer rows include `merchant`, `price`, `currency`, and a Heureka clickout URL. Czech rows use CZK; Slovak rows use EUR. Product URLs point to Heureka product pages. Merchant-offer URLs are Heureka clickout links and can contain temporary request tokens.

When requested, `offers` on a product row contains merchant, price, currency, and URL for the initially rendered offers. `offers_total` reports the broader number where available. The actor does not claim to collect additional offers hidden beyond that initial list. Failed enrichment retains the product row, leaves `offers` null, and reports a collection warning.

This is the first product row of the barcode search above, returned on 5 October 2026 (the `params` list is shortened to two of its six entries):

```json
{
  "source": "heureka-scraper",
  "fetched_at": "2026-10-05T15:02:04.000Z",
  "_type": "product",
  "row_type": "product",
  "id": "1187574991",
  "position": 1,
  "page": 1,
  "query": "0195949052637",
  "search_url": "https://www.heureka.cz/?h%5Bfraze%5D=0195949052637&f=1&o=1",
  "match_type": "fulltext",
  "is_sponsored": false,
  "title": "Apple AirPods Pro 2. Generation USB-C MTJV3ZM/A",
  "url": "https://sluchatka.heureka.cz/apple-airpods-pro-2-generation-usb-c-mtjv3zm-a/",
  "image_url": "https://img-cdn.heureka.group/v1/885a0e9a-b7d1-4e7c-9186-15abc3c0b834.jpg?width=400&height=400",
  "country": "CZ",
  "currency": "CZK",
  "price": 4409,
  "product_id": "1187574991",
  "product_type": "product",
  "lowest_price": 4409,
  "highest_price": 5190,
  "offers_count": 11,
  "category_id": "709",
  "category_name": "Sluchátka",
  "category_slug": "sluchatka",
  "shop_count": 11,
  "review_rating": 95,
  "review_count": 216,
  "params": [
    {"name": "Výrobce", "value": "Apple"},
    {"name": "Přenos zvuku", "value": "bezdrátová"}
  ],
  "variants": null,
  "offers": null,
  "offers_total": null,
  "offers_fetched": false
}
```

With `includeOffers: true`, the same product came back with `offers_fetched: true`, `offers_total: 12`, and offers such as `{"merchant": "elektroshock.cz", "price": 4409, "currency": "CZK"}` and `{"merchant": "Quikset s.r.o.", "price": 4999, "currency": "CZK"}`, each with its clickout `url`. A standalone offer row from the copied search URL above reads `"title": "DeLonghi 7313251451 spařovací jednotka"`, `"merchant": "Penepex"`, `"price": 859`, `"currency": "CZK"`.

The run output record contains delivery counts, billing counts, continuation information, and warnings. The actor follows continuation requests automatically until the requested total or the source's end is reached. A partial run can preserve useful rows while explaining why collection stopped.

### Use cases for this Heureka scraper

- **Price monitoring for brands and retailers.** Track the lowest and highest price of your products across Czech and Slovak shops, and see how many shops list them.
- **Competitor and merchant research.** With merchant offers switched on, see which shops sell a product and at which price, and spot new sellers in a category.
- **Assortment and category analysis.** Paste a category URL to export a whole Heureka category with ratings, review counts and price ranges, sorted the way you need.
- **Catalogue matching by barcode.** Search your own EAN list and keep the query next to each result to join Heureka products to your catalogue.
- **Market entry research.** Compare the same search on Heureka.cz and Heureka.sk to see differences in range and price between the two markets.

### Heureka scraper compared with other options

Heureka publishes APIs of its own, such as its marketplace and bidding APIs, but they are built for shops connected to Heureka: they manage your own feed, orders and bids, and do not return public search results or competitor prices. This actor reads the public comparison pages instead, so anyone can collect them without a merchant account.

Other Heureka actors in the Apify Store either cover search results on both sites or cover Heureka.cz only, with shop offers in some of them. This Heureka scraper combines keyword, barcode, search URL and category URL input in one run, covers both the Czech and Slovak sites, delivers each product once across all inputs, follows result pages automatically up to 20,000 rows, and can add the merchant offers of every product in the same run. A generic web scraper or a one-off script can fetch a page, but you would have to maintain the parsing, pagination and currency handling yourself.

### Pricing

The proposed starting price is $0.002 per delivered result, plus $0.0005 per run. Optional merchant-offer collection adds $0.004 per product whose offer page was successfully parsed. A standalone search offer is one result and does not trigger an extra product-offer collection event. Failed offer enrichment does not trigger that extra event. The active Store pricing panel is authoritative.

An empty search has no result charges; the run-start fee remains. Users without a paid Apify plan receive up to ten rows per run. Their run summary includes `free_tier_remaining`. Paying users can request the full supported result volume.

### FAQ

#### Does a barcode search prove the barcode of every result?

No. The barcode is passed to Heureka search, and its full-text destination signal determines whether semantic fallback suggestions are accepted. Returned records do not contain a verified GTIN field. Keep the query field as search context when joining results to your own catalogue.

#### Can I use Slovak category URLs in a Czech run?

Yes. Each copied search or category URL selects its own market. The country setting applies to plain queries. The same row ID appearing in several searches or markets is delivered once within a run.

#### Are merchant links direct shop links?

They are Heureka clickout URLs. They may redirect to a shop and include temporary source tokens. The product's main URL remains its Heureka comparison page.

#### Why are there fewer rows than maxItems?

The source may contain fewer matching results, repeated cards are deduplicated, or a barcode query may produce semantic suggestions that the default exactEanOnly setting rejects. Collection warnings explain interrupted searches or failed offer enrichment. An unreadable search response is reported as a source error rather than an ordinary empty search.

#### Can I use this Heureka scraper as an API?

Yes. Every Apify actor can be started through the Apify API or one of its client libraries, and the results can be read from the dataset endpoint as JSON, CSV or Excel. You can also schedule runs to monitor the same searches every day.

#### Which currencies are used?

Czech results are in CZK and Slovak results are in EUR. Every row carries its `currency`, so mixed runs stay unambiguous.

# Actor input Schema

## `queries` (type: `array`):

Search terms or EAN/UPC/GTIN codes. At least one query or start URL is required.

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

Copied Heureka CZ/SK search or category URLs; URL objects with a url field are accepted.

## `country` (type: `string`):

Market for queries. A start URL selects its own market.

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

Maximum unique rows across all inputs and cursor continuations.

## `sort` (type: `string`):

Result ordering. The o parameter in a start URL takes precedence.

## `includeSponsored` (type: `boolean`):

Include marked sponsored product cards, deduplicated against organic cards.

## `includeOffers` (type: `boolean`):

Collect the initially rendered merchant offers for each product. Additional product_offers event.

## `includeRaw` (type: `boolean`):

Include the original search card object as raw. Increases response and cursor size.

## `exactEanOnly` (type: `boolean`):

Reject semantic fallback suggestions for barcode-shaped queries. fulltext is a search match, not a verified GTIN.

## `cursor` (type: `string`):

Opaque continuation token. Keep the search inputs and options unchanged.

## Actor input object example

```json
{
  "queries": [
    "kavovar delonghi"
  ],
  "country": "cz",
  "maxItems": 100,
  "sort": "relevance",
  "includeSponsored": true,
  "includeOffers": false,
  "includeRaw": false,
  "exactEanOnly": true
}
```

# Actor output Schema

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

Unique products and standalone offers.

## `output` (type: `string`):

Counts, billing and collection warnings.

# 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 = {
    "queries": [
        "kavovar delonghi"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/heureka-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 = { "queries": ["kavovar delonghi"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/heureka-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 '{
  "queries": [
    "kavovar delonghi"
  ]
}' |
apify call s-r/heureka-scraper --silent --output-dataset

```

## MCP server setup

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