# Hebe Poland Scraper - Drugstore Products & Prices (`studio-amba/hebe-pl-scraper`) Actor

Scrape products, prices in PLN, EAN codes, stock and categories from Hebe.pl, one of Poland's largest drugstore chains. Search by keyword, browse by category or brand. No login needed.

- **URL**: https://apify.com/studio-amba/hebe-pl-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 $1.20 / 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.
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 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

## Hebe Poland Scraper

Extract products, prices, EAN codes, and availability from [Hebe.pl](https://www.hebe.pl), one of Poland's largest drugstore chains (around 350 stores plus a full online shop). Search by keyword, or browse a whole category or brand. No login, no cookies.

### Why use it

- **Price monitoring**: track PLN prices, active discounts, and the EU Omnibus 30-day-lowest price for cosmetics, skincare, and health products in the Polish market.
- **EAN matching**: most records carry the EAN barcode, so you can join Hebe prices against dm, Rossmann, or any other retailer feed.
- **Assortment analysis**: pull a full category ("Twarz", "Dermokosmetyki", "Koreańskie i Japońskie") or a full brand and see exactly what Hebe lists.
- **Stock signals**: records include an in-stock flag and the online stock level reported by Hebe's search index.

The actor reads Hebe's own search backend directly. Runs are fast (hundreds of products per request) and stable, because there is no browser rendering and no HTML parsing involved.

### Input options

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Product keyword, Polish works best (e.g. `krem do twarzy`, `szampon`, `witamina C`). Optional. |
| `category` | string | Exact Hebe category name, e.g. `Twarz`, `Ciało`, `Włosy`, `Makijaż`, `Dermokosmetyki`, `Męska Strefa`. Optional, can be combined with a query. |
| `brand` | string | Exact brand name, e.g. `Ziaja`, `Nivea`, `Bielenda`, `L'Oréal Paris`. Optional. |
| `maxResults` | integer | Maximum products to return. Default 100, hard cap 10,000 per run. |
| `proxyConfiguration` | object | Optional. The default automatic Apify proxy is enough; residential proxies are not needed. |

With no input at all, the actor searches for `krem do twarzy` so you always get data on a first test run.

#### Example input

```json
{
    "searchQuery": "krem do twarzy",
    "maxResults": 200
}
```

Category run (no keyword needed):

```json
{
    "category": "Dermokosmetyki",
    "maxResults": 1000
}
```

Brand run:

```json
{
    "brand": "Ziaja",
    "maxResults": 500
}
```

### Output fields

| Field | Example | Description |
|-------|---------|-------------|
| `productName` | `Ziaja Jaśminowa` | Full product name |
| `brand` | `Ziaja` | Brand name |
| `price` | `21.99` | Current selling price |
| `currency` | `PLN` | Always PLN, never converted |
| `originalPrice` | `27.99` | Price before discount, only when discounted |
| `discount` | `-21%` | Discount label, only when discounted |
| `omnibusPrice` | `19.99` | Lowest price of the last 30 days (EU Omnibus) |
| `category` | `Twarz > Pielęgnacja twarzy > Kremy do twarzy` | Deepest category path |
| `categories` | `["Twarz", "Kremy do twarzy"]` | All categories the product appears in |
| `ean` | `3600524029944` | EAN barcode |
| `sku` | `000000000000410264` | Hebe product ID (also part of the product URL) |
| `inStock` | `true` | `true`, `false`, or `null` when the index doesn't say |
| `stockLevel` | `9589` | Online stock units, when reported |
| `imageUrl` | `https://www.hebe.pl/dw/image/v2/...` | Main product image |
| `url` | `https://www.hebe.pl/loreal-paris-...-000000000000410264.html` | Product page |
| `productDescription` | `nawilżający krem na co dzień, 50 ml` | Short description in Polish |
| `source` | `hebe.pl` | Data source |
| `country` | `PL` | Country code |
| `scrapedAt` | `2026-08-18T09:12:44.512Z` | Scrape timestamp (ISO 8601) |

#### Example output record

```json
{
    "productName": "L'Oréal Paris Elseve Hyaluron Plump",
    "brand": "L'Oréal Paris",
    "price": 21.99,
    "currency": "PLN",
    "omnibusPrice": 14.99,
    "category": "Włosy > Pielęgnacja włosów > Szampony",
    "categories": ["Włosy", "Pielęgnacja włosów", "Szampony"],
    "ean": "3600524029944",
    "sku": "000000000000410264",
    "inStock": true,
    "stockLevel": 9589,
    "imageUrl": "https://www.hebe.pl/dw/image/v2/BDDS_PRD/on/demandware.static/-/Sites-PL_Master_Catalog/default/dw512d5fdf/images/hi-res/410264.png",
    "url": "https://www.hebe.pl/loreal-paris-nawilzajacy-szampon-do-wlosow-400-ml-000000000000410264.html",
    "productDescription": "nawilżający szampon do włosów, 400 ml",
    "source": "hebe.pl",
    "country": "PL",
    "scrapedAt": "2026-08-18T09:12:44.512Z"
}
```

### How to scrape Hebe.pl data

1. Open the actor on Apify and press **Try for free**.
2. Enter a Polish search keyword (for example `krem do twarzy`), or leave it empty and enter a category such as `Dermokosmetyki` or a brand such as `Ziaja`.
3. Set `maxResults` to the number of products you need.
4. Press **Start**. Results appear in the Output tab within seconds and can be exported as JSON, CSV, or Excel.

You can also run it from the Apify API or SDK on a schedule, for example a daily price snapshot of one category. Each run is independent and stateless.

### Cost estimate

Pricing is pay-per-event: a small fixed fee per run start plus **$0.002 per result**. 1,000 products cost about $2 plus a few cents of compute. There are no browser instances involved, so compute usage stays low even on large runs.

Note for consumers: a run's usage cost only settles after the run reports SUCCEEDED. Reading the dataset mid-run shows a partial cost that can be far below the final number.

### Limitations

- The search API pages out at **10,000 results per query**. For a bigger export, split the run by category or brand (each run has its own 10,000 window).
- `originalPrice` and `discount` only appear while a discount is active. `omnibusPrice` (the 30-day-lowest) is present on most records year-round.
- Ratings and review counts are not exposed by the search index and are not included.
- Category and brand filters need the exact Polish names used on Hebe.pl. If a filter matches nothing, the run log prints a list of valid values.
- The scraper covers the online catalog. Per-store availability of the ~350 physical stores is not included.

### Questions

Open an issue on the actor's page and I'll take a look.

# Actor input Schema

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

Product keyword in Polish for best results (e.g. 'krem do twarzy', 'szampon', 'witamina C'). Leave empty and set Category or Brand to browse instead. With everything empty the actor falls back to 'krem do twarzy'.

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

Exact Hebe category name in Polish, e.g. 'Twarz', 'Ciało', 'Włosy', 'Makijaż', 'Dermokosmetyki', 'Męska Strefa', 'Koreańskie i Japońskie'. Can be combined with a search query. If the name doesn't match, the run log lists valid values.

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

Exact brand name as used on Hebe.pl, e.g. 'Ziaja', 'Nivea', 'Bielenda', "L'Oréal Paris". Can be combined with a search query or category.

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

Maximum number of products to return. Hard cap 10,000 per run (the search API stops paging at 10,000 results per query — split larger exports by category).

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

Optional. The actor reads Hebe's open Luigi's Box search API on a third-party host that is not behind Hebe's Cloudflare and works from the free automatic proxy pool — residential proxies are not needed (see docs/site-recon/hebe-pl.md).

## Actor input object example

```json
{
  "searchQuery": "krem do twarzy",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "krem do twarzy",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/hebe-pl-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": "krem do twarzy",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/hebe-pl-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 '{
  "searchQuery": "krem do twarzy",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/hebe-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/hebe-pl-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/42wivQ7FJTABbbn7Y/builds/6PLwP4fLvN8ze0Kby/openapi.json