# Mueller Product Search Scraper (`stealth_mode/mueller-product-search-scraper`) Actor

Scrape product search results from Mueller.at with comprehensive pricing, availability, and product details. Collect 30+ fields including current prices, images, stock levels, delivery options, and energy efficiency data for retail analytics and price monitoring.

- **URL**: https://apify.com/stealth\_mode/mueller-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, 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 results

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Mueller.at Product Scraper: Extract Search Results & Pricing Data

---

### About Mueller.at

Mueller.at is Austria's leading retail e-commerce platform, offering millions of products across categories including electronics, home goods, books, and consumer products. Manually monitoring product availability, pricing, and specifications across search results is inefficient — the **Mueller.at Product Scraper** automates data collection, delivering structured product information from search pages at scale.

---

### Overview

The **Mueller.at Product Scraper** extracts product listings from Mueller search results pages, capturing 30+ data points per item. It is designed for:

- **E-commerce analysts** tracking competitor pricing and product mix
- **Price monitoring services** building dynamic pricing dashboards
- **Retailers** benchmarking product assortments and availability
- **Data scientists** analyzing retail trends and consumer product preferences
- **Aggregator platforms** feeding product data into comparison tools

Key strengths include handling pagination efficiently, respecting `max_items_per_url` limits, and gracefully managing failed URLs with the `ignore_url_failures` flag.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://www.mueller.at/search/?q=noir&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Input Parameters

| Parameter | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | Mueller.at product search result URLs. Include pagination parameters (`page=X`) to specify which results to scrape. | `["https://www.mueller.at/search/?q=noir&page=2"]` |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues even if some URLs fail. If `false`, a single failed URL stops the entire run. | `true` |
| `max_items_per_url` | Integer | Maximum number of products to extract per URL. Higher values collect more items; lower values speed up runs. Typical range: 20–200. | `200` |

> **Tip:** Mueller search URLs support query parameters (`?q=searchterm`) and pagination (`&page=N`). Adjust these to target specific product categories or price ranges.

***

### Output Format

**Sample output**

```json
{
  "assets": [
    {
      "height": 595,
      "type": "PV",
      "url": "https://static.prod.ecom.mueller.de/products/4015615550600/6814818483-PV-0.png",
      "width": 1091,
      "__typename": "SearchProductAsset"
    },
    {
      "height": 744,
      "type": "PD",
      "url": "https://static.prod.ecom.mueller.de/products/4015615550600/6814818483-PB-1.png",
      "width": 1076,
      "__typename": "SearchProductAsset"
    },
    {
      "height": 649,
      "type": "PD",
      "url": "https://static.prod.ecom.mueller.de/products/4015615550600/6814818483-PB-2.png",
      "width": 986,
      "__typename": "SearchProductAsset"
    },
    {
      "height": 601,
      "type": "PD",
      "url": "https://static.prod.ecom.mueller.de/products/4015615550600/6814818483-PB-3.png",
      "width": 1097,
      "__typename": "SearchProductAsset"
    }
  ],
  "author": "",
  "artist": "",
  "badges": [],
  "base_price": null,
  "brand": {
    "name": "PIKO",
    "__typename": "SearchProductBrand"
  },
  "campaign_price": null,
  "capacity": {
    "unit_code": "PIECE",
    "value": "1",
    "__typename": "SearchProductCapacity"
  },
  "categories": [
    {
      "name": "Spielwaren",
      "__typename": "SearchCategory"
    },
    {
      "name": "Modellbau & Modelleisenbahn",
      "__typename": "SearchCategory"
    },
    {
      "name": "Modelleisenbahn",
      "__typename": "SearchCategory"
    },
    {
      "name": "Wagen",
      "__typename": "SearchCategory"
    },
    {
      "name": "Güter- & Funktionswagen",
      "__typename": "SearchCategory"
    },
    {
      "name": "PIKO",
      "__typename": "SearchCategory"
    },
    {
      "name": "PIKO H0 WAGEN EXPERT PLUS WAGEN",
      "__typename": "SearchCategory"
    }
  ],
  "category_with_parents": [
    {
      "name": "Spielwaren",
      "__typename": "SearchCategory"
    },
    {
      "name": "Modellbau & Modelleisenbahn",
      "__typename": "SearchCategory"
    },
    {
      "name": "Modelleisenbahn",
      "__typename": "SearchCategory"
    },
    {
      "name": "Wagen",
      "__typename": "SearchCategory"
    },
    {
      "name": "Güter- & Funktionswagen",
      "__typename": "SearchCategory"
    }
  ],
  "click_and_collect": true,
  "code": "2662231",
  "color_variant_images": [],
  "current_price": {
    "currency_iso": "EUR",
    "value_without_tax": 187.5,
    "value_with_tax": 225,
    "__typename": "Price"
  },
  "energy_efficiency_label": null,
  "energy_efficiency_overview": null,
  "home_delivery": true,
  "image": {
    "height": 595,
    "url": "https://static.prod.ecom.mueller.de/products/4015615550600/6814818483-PV-0.png",
    "width": 1091,
    "__typename": "SearchProductImage"
  },
  "lowest_variant_price": null,
  "name": "PIKO H0 55060 - PIKO H0 H0 Messwagen Wechselstromversion",
  "own_brand": false,
  "path": "/p/piko-h0-55060-piko-h0-h0-messwagen-wechselstromversion-2662231/",
  "pre_order_settings": null,
  "product_data_sheet": null,
  "recommended_retail_price": {
    "currency_iso": "EUR",
    "value_without_tax": 195.83,
    "value_with_tax": 235,
    "__typename": "Price"
  },
  "release_date": null,
  "stock_level_indication": "LOW_IN_STOCK",
  "strike_price": {
    "currency_iso": "EUR",
    "value_without_tax": 159.38,
    "value_with_tax": 191.25,
    "__typename": "Price"
  },
  "from_url": "https://www.mueller.at/search/?q=noir"
}
```

Each product in the search results returns a comprehensive record with 30+ fields:

#### Product Identification

| Field | Meaning |
|---|---|
| `Code` | Unique product code/SKU in the Mueller system |
| `Name` | Product name as displayed on Mueller.at |
| `Brand` | Manufacturer or brand name |
| `Own Brand` | Whether the product is Mueller's private label |
| `Path` | Product category path within Mueller's hierarchy |
| `Categories` | All category tags assigned to the product |
| `Category With Parents` | Full category tree (e.g., Electronics > Computers > Laptops) |

#### Pricing

| Field | Meaning |
|---|---|
| `Base Price` | Original full price before any discounts |
| `Current Price` | Active selling price displayed to customers |
| `Campaign Price` | Special promotional price (if applicable) |
| `Strike Price` | Original price shown with strikethrough during sales |
| `Recommended Retail Price` | Manufacturer's suggested retail price (RRP) |
| `Lowest Variant Price` | Lowest price among product variants/SKUs |

#### Product Details & Attributes

| Field | Meaning |
|---|---|
| `Capacity` | Size, volume, or quantity (e.g., "250ml", "500GB") |
| `Color Variant Images` | URLs or metadata for images of each color/variant |
| `Image` | Primary product image URL |
| `Assets` | Additional product images, videos, or media |
| `Badges` | Labels like "New", "Sale", "Exclusive" displayed on listings |

#### Sustainability & Compliance

| Field | Meaning |
|---|---|
| `Energy Efficiency Label` | EU energy rating (A++, A, B, etc.) if applicable |
| `Energy Efficiency Overview` | Detailed energy consumption or efficiency metrics |
| `Product Data Sheet` | URL or reference to the official product datasheet |

#### Availability & Fulfillment

| Field | Meaning |
|---|---|
| `Stock Level Indication` | Availability status (in stock, low stock, out of stock) |
| `Home Delivery` | Whether the product qualifies for standard home delivery |
| `Click And Collect` | Whether in-store pickup is available |
| `Pre Order Settings` | Metadata if the product is available for pre-order |
| `Release Date` | Expected availability or launch date for pre-order items |

#### Metadata

| Field | Meaning |
|---|---|
| `Author` | Author name (for books and media) |
| `Artist` | Artist/performer name (for music, films, etc.) |

***

### How to Use

1. **Build search URLs** — Visit Mueller.at, search for products, and copy the result page URL. Include pagination parameters if needed.
   - Example: `https://www.mueller.at/search/?q=noir&page=2`

2. **Configure input** — Paste URLs into the `urls` array and set `max_items_per_url` (e.g., `200` for comprehensive collection).

3. **Run the scraper** — Start the actor and monitor progress via run logs.

4. **Download results** — Export data as JSON, CSV, or Excel for analysis.

**Best practices:**

- Adjust `max_items_per_url` based on how many products per page Mueller displays.
- Use multiple URLs with different search terms or pagination to collect diverse product sets.
- Set `ignore_url_failures: true` for large batch runs to prevent interruptions.

**Common issues:**

- Verify URLs are search result pages, not individual product detail pages.
- Check that search query parameters are correctly formatted (`?q=term&page=X`).

***

### Use Cases & Business Value

- **Price monitoring:** Track competitor pricing across product categories in real time
- **Assortment analysis:** Understand Mueller's inventory depth and breadth by category
- **Product intelligence:** Collect specifications, energy ratings, and availability for comparison tools
- **Market research:** Analyze e-commerce trends in the Austrian/German retail landscape
- **Data feeds:** Supply structured product data to price comparison platforms or marketplaces

The Mueller.at Product Scraper eliminates manual data collection, delivering clean, structured records that integrate seamlessly into pricing engines, analytics platforms, and business intelligence tools.

***

### Conclusion

The **Mueller.at Product Scraper** is a powerful tool for anyone needing systematic access to Mueller's product catalog and pricing. With detailed output across 30 fields and flexible configuration, it enables efficient market research, competitive analysis, and data-driven decision-making. Start scraping today and unlock insights hidden in search results.

# Actor input Schema

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

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.mueller.at/search/?q=noir"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.mueller.at/search/?q=noir"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/mueller-product-search-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 = {
    "urls": ["https://www.mueller.at/search/?q=noir"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/mueller-product-search-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 '{
  "urls": [
    "https://www.mueller.at/search/?q=noir"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/mueller-product-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/mueller-product-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mueller Product Search Scraper",
        "description": "Scrape product search results from Mueller.at with comprehensive pricing, availability, and product details. Collect 30+ fields including current prices, images, stock levels, delivery options, and energy efficiency data for retail analytics and price monitoring.",
        "version": "0.0",
        "x-build-id": "N6lt6Mfyg2D2DnGSs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~mueller-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-mueller-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~mueller-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-mueller-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~mueller-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-mueller-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
