# Hagebau Price Monitor - DIY product prices for Germany (`mmdincer/hagebau-product-price-monitor`) Actor

Watches public Hagebau product pages and records the price and availability. Returns the product name, SKU, price, currency, and stock state. One run accepts up to five https://www.hagebau.de/p/ product URLs. Results as JSON, CSV or Excel. Access through API or MCP.

- **URL**: https://apify.com/mmdincer/hagebau-product-price-monitor.md
- **Developed by:** [Muhammet Mustafa Dincer](https://apify.com/mmdincer) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.62 / 1,000 product checkeds

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

> 💼 Looking for another public price watch instead? 👉 [Globus Baumarkt Price Monitor - DIY prices for Germany](https://apify.com/mmdincer/globus-baumarkt-product-price-monitor)

### 🤖 What does Hagebau do?

Hagebau watches one public product page at a time and writes the price and availability it finds in JSON-LD. It is a monitor for DIY product pages on www.hagebau.de in Germany. The first successful read stores a baseline. The next read of the same URL on the same watchlist compares the price and the availability with that baseline.

It can monitor:

- **A public Hagebau product page** that returns a JSON-LD price without a login.
- **The name, SKU, price, currency, and availability** that the parser keeps. Description, images, and people are not stored.
- **A later change** when the saved Hagebau price or availability is different. That row is a second event on the live price list.

### 💡 Why scrape Hagebau?

Hagebau replaces a manual refresh of the same product page, or a spreadsheet that someone updates by hand. The fields support a price watch. They do not support reviews, images, or a full catalogue crawl.

- A buyer can keep a short list of Hagebau products and see the current public price.
- A merchandiser can compare the saved Hagebau price with the next reading.
- A sheet can take the dataset as JSON, CSV, or Excel.
- An agent can call the same input through the Apify API or MCP.

The sample page is a real Hagebau product that returned a JSON-LD price on 13 November 2026: Handytasche »Luca«, schwarz, SKU 1095274, 19.99 EUR, availability InStoreOnly. That reading is the default input. It is one page, not a category dump.

### 🚀 How to scrape Hagebau

1. Click **Try for free**.
2. Keep the prefilled Hagebau product URL, or paste up to five product URLs.
3. Leave **Only changes** off for the first two runs so the second run still writes the current reading. Turn it on later when the dataset should list a product only after the saved reading moves.
4. Click **Run**.
5. Download the dataset as JSON, CSV, or Excel.

```json
{
  "productUrls": [
    "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

### ⚠️ Limits

Hagebau enforces the limits below. Anything not listed is not a limit the code applies.

- The path must be /p/ and one product slug. Search, account, cart, checkout, and /p/variation-change/ URLs are rejected.
- At most five URLs per run. A duplicate URL is skipped with a warning.
- Requests are at least 400 milliseconds apart. The HTTP timeout is 30 seconds.
- HTTP 403 is returned as an error and is not retried. HTTP 429 stops further products. A challenge page that has no JSON-LD is not bypassed.
- A page with no JSON-LD price is `no_data` and is not charged.
- The named baseline store is `hagebau-product-price-monitor-state`. If opening it returns HTTP 403, the run uses its default key-value store and says so. The snapshot is then not kept for the next run.
- Hagebau does not log in, does not store personal data, and does not read a review author.

Hagebau stops the run after HTTP 429 and does not request another product.

Hagebau does not retry a page that returned HTTP 403.

Hagebau does not store a review author, a seller name, a product image, or a description.

The parser walks JSON-LD blocks, including `@graph` and `hasVariant`. It keeps the first Product node that has an offer price. The price is the offer `price` field. A page that writes the price as text is still stored as a number. Availability is the last segment of the schema.org URL, so `http://schema.org/InStoreOnly` is stored as `InStoreOnly`. If that field is missing, the row stores null and the rest of the reading can still be a baseline.

A fingerprint is the price and the availability joined together. The product name and the SKU can change on the Hagebau page without counting as a price change when the price and the availability stay the same. The first time a URL is seen, the row is `baseline_saved`. The next identical fingerprint is `unchanged`. A different fingerprint is `changed` and is the only time the second event is requested.

### 💳 How much will it cost to scrape Hagebau?

The prices below are the live `pricingInfos` on this Actor. Apify bills these amounts. This code calls Actor.charge for `product-checked` and `price-changed` only.

| Event name (`Actor.charge`) | Event title | When the code charges it | Price (USD) |
|---|---|---|---|
| `apify-actor-start` | Actor Start | On the live price list. This code does not call Actor.charge for it. | FREE 0.0005 / BRONZE 0.0005 / SILVER 0.0005 / GOLD 0.0005 / PLATINUM 0.0005 / DIAMOND 0.0005 |
| `product-checked` | Product Checked | One saved product page included a price. A first baseline and a later unchanged reading both use this event. | FREE 0.00284 / BRONZE 0.00071 / SILVER 0.00067 / GOLD 0.00062 / PLATINUM 0.00062 / DIAMOND 0.00062 |
| `price-changed` | Price Changed | Charged in addition to the product check when the price or availability differs from the saved baseline. The first baseline is not this event. | FREE 0.005 / BRONZE 0.005 / SILVER 0.005 / GOLD 0.005 / PLATINUM 0.005 / DIAMOND 0.005 |

`product-checked` anchor: sian.agency/hagebau-product-scraper event product-result. `price-changed` anchor: studio-amba/hagebau-scraper event result, a flat 0.005, repeated on every tier. Start prices that were read and are not copied: sian.agency/hagebau-product-scraper apify-actor-start is FREE 0.02 and 0.005 on the other tiers. studio-amba/hagebau-scraper actor-start is 0.005. The live start price is a flat 0.0005 on every tier.

1,000 `product-checked` events at the FREE unit price of 0.00284 USD are 2.84 USD. The lowest `product-checked` unit price on this live price list is 0.00062 USD, which is 0.62 USD for 1,000 events. The lowest unit price on the live price list is 0.0005 USD for `apify-actor-start`, which would be 0.5 USD for 1,000 starts. This code does not call Actor.charge for that event.

A page without a price, an HTTP error, a challenge page, a skip after HTTP 429, and a target the spending limit cannot cover are not charged. `charged` is true only when Actor.charge returns a chargedCount that covers every event for that row. An ignored charge, which is what the SDK returns before a price is applied, is not a spending limit. The row is still stored and `charged` is false.

### 📝 Input

| Field | Required | What the code does with it |
|---|---|---|
| Product URLs | Yes | Hagebau product URLs. The path must be /p/ and one product slug. Search, account, cart, checkout, and /p/variation-change/ URLs are rejected. |
| Only changes | No | Off in the prefill, so a repeated sample still writes the current reading. On, after a baseline exists, writes a row only when the saved reading moved. A first read is always written. |
| Watchlist name | No | Runs that share this name share one baseline. The prefill is `default`. |

```json
{
  "productUrls": [
    "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

### 📊 Output

One shortened record from the public Hagebau page read on 13 November 2026, with the same field names the code writes. People, images, and the description are not fields. The tests assert this price, SKU, and availability.

```json
{
  "recordType": "observation",
  "status": "baseline_saved",
  "changeType": "baseline",
  "productUrl": "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/",
  "name": "Handytasche »Luca«, schwarz",
  "sku": "1095274",
  "gtin13": null,
  "price": 19.99,
  "currency": "EUR",
  "availability": "InStoreOnly",
  "sourceUrl": "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/",
  "attribution": "Hagebau",
  "licence": null,
  "httpStatus": 200,
  "checkedAt": "2026-11-13T21:00:00.000Z",
  "charged": false,
  "chargeOutcome": "ignored",
  "message": "Baseline saved. The reading is recorded for the next run. Actor.charge() did not bill the event."
}
```

| Field | Meaning |
|---|---|
| `status` | `baseline_saved`, `unchanged`, `changed`, `no_data`, `api_error`, `unreachable`, `rate_limited`, or `not_fetched`. |
| `price` | The JSON-LD price. A strikethrough price and a member-tier price are not selected when the first offer already has a price. |
| `availability` | The schema.org availability name, or null when the page does not write one. |
| `charged` | True only when every Actor.charge for the row was covered. |
| `licence` | Null. No written reuse grant was read. |

### 🔌 Integrations and API

Run this Actor with the Apify API, a schedule, or the Apify MCP server. Apify can send the dataset to Make, Zapier, or a webhook. This Actor does not implement a custom integration of its own.

The input object uses keys from `.actor/input_schema.json`. The slug is `mmdincer/hagebau-product-price-monitor`.

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('mmdincer/hagebau-product-price-monitor').call({"productUrls": ["https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"], "onlyChanges": false, "monitorName": "default"});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient

client = ApifyClient('<APIFY_TOKEN>')
run = client.actor('mmdincer/hagebau-product-price-monitor').call(run_input={"productUrls": ["https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"], "onlyChanges": false, "monitorName": "default"})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### ❓ FAQ

#### How do I scrape Hagebau with a small first run?

Keep the prefilled product, leave only changes off, and use the watchlist name `default`. That is one Hagebau page. Run it again with the same input. The second row should be unchanged when the page price did not move.

#### Does Hagebau charge a page that has no price?

No. `no_data`, errors, challenge pages, and targets skipped for the spending limit do not call Actor.charge. The start event on the live price list is not called by this code either.

#### What does a repeated Hagebau run compare?

It compares the price and the availability with the fingerprint stored for that URL and watchlist. The product name and the SKU can change on the page without counting as a price change when the price and the availability stay the same.

#### Where does Hagebau keep the baseline?

In the named key-value store `hagebau-product-price-monitor-state`, under a key that hashes the watchlist name and the URL. A 403 on that named store falls back to the default store for this run only.

#### Does Hagebau read the whole catalogue?

No. Hagebau reads only the product URLs in the input, and at most five of them. There is no search box and no category walker in this code.

#### What happens if Hagebau returns HTTP 403 or HTTP 429?

HTTP 403 is one error row and is not retried. HTTP 429 stops the rest of the list. The actor does not switch proxy, does not solve a challenge, and does not log in.

### ⚖️ Is it legal to scrape Hagebau?

Hagebau reads a public product page. The code does not log in and does not store personal data. The page is the Hagebau customer terms, including withdrawal. Automatisch there is the return right being treated as a withdrawal. The Kopieren sentence is limited to chatbot answers and using those answers in another chatbot. It is not a ban on the product page. No scrape, crawl, spider, or database ban was in that text, and no written reuse licence was granted. Source: https://www.hagebau.de/agb/. robots.txt for User-agent: \* Disallow's /p/variation-change/, cart-style /add/ and /remove/ paths, and account-like tools. The sample /p/{slug} path is not Disallow'd.

Not affiliated with Hagebau. Hagebau does not endorse this Actor.

This is not legal advice. You are responsible for the source's terms and, if you process personal data, for GDPR. Apify's overview: <https://blog.apify.com/is-web-scraping-legal/>.

### 🔗 Related actors

| Actor | What it does |
|---|---|
| [Globus Baumarkt Price Monitor - DIY prices for Germany](https://apify.com/mmdincer/globus-baumarkt-product-price-monitor) | Watches a different shop's public product price and availability. |
| [Wickes Price Monitor - DIY prices for the UK](https://apify.com/mmdincer/wickes-product-price-monitor) | Watches a different shop's public product price and availability. |
| [Toolstation Price Monitor - Trade prices for the UK](https://apify.com/mmdincer/toolstation-product-price-monitor) | Watches a different shop's public product price and availability. |

# Changelog

This Actor's version history is a separate document: https://apify.com/mmdincer/hagebau-product-price-monitor/changelog.md

# Actor input Schema

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

https://www.hagebau.de product pages. Search, account, cart, and checkout URLs are rejected.

## `onlyChanges` (type: `boolean`):

Leave this off for the sample so a repeated run still writes the current reading. Turn it on after a baseline exists when the dataset should list a target only if the saved reading moved. A first read is always written.

## `monitorName` (type: `string`):

Runs that share this name share one baseline.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `prices` (type: `string`):

Latest public price for each saved product.

## `summary` (type: `string`):

Targets requested, baselines, changes, and how many events Actor.charge() billed.

# 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 = {
    "productUrls": [
        "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"
    ],
    "onlyChanges": false,
    "monitorName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mmdincer/hagebau-product-price-monitor").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 = {
    "productUrls": ["https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"],
    "onlyChanges": False,
    "monitorName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("mmdincer/hagebau-product-price-monitor").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 '{
  "productUrls": [
    "https://www.hagebau.de/p/2go-handytasche-luca-schwarz-anP7000185872/"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}' |
apify call mmdincer/hagebau-product-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mmdincer/hagebau-product-price-monitor"
        }
    }
}
```

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/C9LI5xqDsvvnF64Al/builds/v3JgEcFbXZeaFkxcK/openapi.json
