# MediaMarkt & Saturn Scraper (`unfenced-group/mediamarkt-scraper`) Actor

Scrape MediaMarkt and Saturn products across DE, BE, AT, ES and PL: prices, EAN-13, specs, energy class, sellers, discounts, and delivery status. Pay per result.

- **URL**: https://apify.com/unfenced-group/mediamarkt-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (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.34 / 1,000 product 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## MediaMarkt & Saturn Scraper

Extract structured product data from **MediaMarkt** and **Saturn** — Europe's largest consumer electronics retailers. Search by keyword, crawl category or brand pages, or pass product listing URLs directly. Get prices, EAN-13 barcodes, specs, energy class, marketplace sellers, discounts and delivery status in clean JSON.

Supports **5 country shops**: Germany (DE), Belgium (BE), Austria (AT), Spain (ES) and Poland (PL). Saturn (Germany only) is also supported with the same input.

![MediaMarkt & Saturn Scraper](https://api.apify.com/v2/key-value-stores/lJlifu6C8YQfZMPKE/records/mediamarkt-scraper-banner.png)

### What it does

- **Search** any keyword across MediaMarkt or Saturn and collect every product on the results pages
- **Crawl** category, brand, and campaign listing URLs from any supported country
- **Extract** prices, strike prices (was/now), discount percentages, and marketplace seller details
- **Collect** EAN-13 barcodes, highlighted specs (CPU, RAM, storage, GPU), and energy efficiency class
- **Track** delivery status, pickup availability, and stock across countries
- **Monitor** ratings, review counts, promotional badges, and refurbished availability

### Input

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | A single keyword to search (e.g. `laptop`, `iphone 15`, `samsung tv`). |
| `searchQueries` | array | Multiple keywords in one run. Each becomes its own search. |
| `startUrls` | array | MediaMarkt or Saturn listing URLs: search, category, brand or campaign pages. |
| `retailer` | string | `mediamarkt` (default) or `saturn`. Saturn is Germany only. |
| `country` | string | Country shop for keyword searches: `de`, `be`, `at`, `es`, `pl`. Default `de`. |
| `maxResults` | integer | Overall ceiling on products returned across all sources. `0` = unlimited. Default `50`. |
| `maxResultsPerUrl` | integer | Optional per-source cap. Each search query and each start URL stops after this many products, while `maxResults` stays the overall ceiling. `0` = no per-source limit. Default `0`. |
| `maxPages` | integer | Maximum listing pages per search or URL (12 products/page, max 30). Default `30`. |
| `fetchOffers` | boolean | Visit each product detail page and collect every marketplace seller's offer (seller, rating, price, shipping, delivery window, condition), not just the buy-box winner. Default `false`. |
| `maxOffersPerProduct` | integer | Cap on marketplace offers collected per product when `fetchOffers` is on. Sorted cheapest first. Default `50`. |
| `includeVariantPrices` | boolean | Visit each product detail page and add the per-variant list (colour/size label, price, availability per variant). Default `false`. |
| `sortOrder` | string | Sort: `relevant`, `price_asc`, `price_desc`, `rating`, `topseller`, `newest`, `availability`. |
| `minPrice` | number | Filter to minimum price in EUR. |
| `maxPrice` | number | Filter to maximum price in EUR. |
| `condition` | string | `all` (default), `new`, or `refurbished`. |
| `minRating` | integer | Minimum star rating (1–5). |
| `sellerType` | string | `all` (default), `mediamarkt` (own stock only), or `marketplace`. |
| `proxyConfiguration` | object | Proxy settings. Default: Apify Residential (required for MediaMarkt). |

#### Example — search MediaMarkt Germany

```json
{
  "searchQuery": "laptop",
  "country": "de",
  "maxResults": 100,
  "sortOrder": "price_asc"
}
````

#### Example — search Saturn Germany, top-rated headphones

```json
{
  "searchQuery": "kopfhörer",
  "retailer": "saturn",
  "maxResults": 50,
  "sortOrder": "rating"
}
```

#### Example — crawl a category across multiple countries

```json
{
  "startUrls": [
    { "url": "https://www.mediamarkt.de/de/category/laptops-notebooks-362.html" },
    { "url": "https://www.mediamarkt.at/de/category/laptops-notebooks-362.html" },
    { "url": "https://www.mediamarkt.es/es/category/laptops-362.html" }
  ],
  "maxResults": 200,
  "sortOrder": "topseller"
}
```

#### Example — daily price feed, newest arrivals, price cap

```json
{
  "searchQuery": "gaming laptop",
  "country": "de",
  "sortOrder": "newest",
  "maxPrice": 1500,
  "condition": "new",
  "maxResults": 50
}
```

### Output

Every run writes one record per product to the dataset.

#### Fields (always present)

| Field | Type | Description |
|---|---|---|
| `productId` | string | MediaMarkt/Saturn internal product ID. |
| `ean` | string|null | EAN-13 barcode. |
| `title` | string | Full product title. |
| `brand` | string|null | Brand / manufacturer. |
| `url` | string|null | Full product page URL. |
| `retailer` | string | `mediamarkt` or `saturn`. |
| `country` | string | Two-letter country code (`de`, `at`, `es`, etc.). |
| `assortmentType` | string|null | `OWN` (MediaMarkt stock) or `MARKETPLACE`. |
| `price` | number|null | Current selling price in EUR. |
| `currency` | string | Always `EUR`. |
| `strikePrice` | number|null | Previous / crossed-out price (was-price). |
| `discountPercentage` | number|null | Discount vs the strike price. |
| `shippingCost` | number|null | Shipping cost (0 = free). |
| `promoPrice` | number|null | Promotional price, if active. |
| `installmentMonthlyRate` | number|null | Monthly instalment rate, if offered. |
| `installmentMonths` | integer|null | Instalment duration in months. |
| `seller` | string|null | Marketplace seller name, if applicable. |
| `sellerRating` | number|null | Marketplace seller rating. |
| `rating` | number|null | Average customer review rating (0–5). |
| `reviewCount` | integer|null | Total number of reviews. |
| `isAvailableForDelivery` | boolean|null | Whether home delivery is available. |
| `isAvailableForPickup` | boolean|null | Whether in-store pickup is available. |
| `isAvailableAndBuyable` | boolean|null | Whether the product can be added to cart. |
| `onlineStatus` | string|null | Raw online status code (e.g. `AVAILABLE`, `MP_OFFER`). |
| `deliveryStatus` | string|null | Delivery status description. |
| `deliveryDisplayStatus` | string|null | Display status (e.g. `AVAILABLE`). |
| `fulfillmentEarliest` | string|null | ISO timestamp of earliest possible delivery. |
| `fulfillmentLatest` | string|null | ISO timestamp of latest possible delivery. |
| `pickupStatus` | string|null | In-store pickup status. |
| `energyClass` | string|null | EU energy efficiency class (A, B, C, etc.). |
| `imageUrl` | string|null | Main product image URL (600px). |
| `featureImages` | array | Additional product images. |
| `category` | array | Category breadcrumb path, broadest first. |
| `highlightedSpecs` | array | Key specs as `{ name, value }` pairs (CPU, RAM, storage, GPU, etc.). |
| `badges` | array | Promotional badge names (e.g. `Bestseller`, `Neuheit`). |
| `refurbishedAvailable` | boolean | Whether a refurbished offer exists for this product. |
| `offers` | array | With `fetchOffers`: every marketplace seller's offer, cheapest first. Each entry has `sellerName`, `sellerRating`, `sellerReviewCount`, `price`, `currency`, `strikePrice`, `strikePriceType`, `condition`, `isBestOffer`, `deliveryCost`, `deliveryEarliest`, `deliveryLatest`. Seller names are company-level marketplace stores; no personal data is collected. |
| `offerCount` | integer | With `fetchOffers`: number of marketplace offers found. |
| `variants` | array | With `includeVariantPrices`: each variant with `productId`, `variantGroup`, `value`, `name`, `imageUrl`, `price`, `isAvailableForDelivery`. |
| `variantCount` | integer | With `includeVariantPrices`: number of variants found. |
| `sourcePage` | integer | Listing page the product came from. |
| `sourceUrl` | string | The listing URL it was found on. |
| `scrapedAt` | string | ISO timestamp. |

#### Example output record

```json
{
  "productId": "170065194",
  "ean": "4262560964161",
  "title": "LENOVO | 15,6\" | Intel N6000 | Office 2024 | Notebook",
  "brand": "LENOVO",
  "url": "https://www.mediamarkt.de/de/product/...",
  "retailer": "mediamarkt",
  "country": "de",
  "assortmentType": "MARKETPLACE",
  "price": 399,
  "currency": "EUR",
  "strikePrice": 599,
  "discountPercentage": 33,
  "shippingCost": 0,
  "seller": "cybernerds",
  "sellerRating": 4.47,
  "rating": 4.78,
  "reviewCount": 9,
  "isAvailableForDelivery": true,
  "isAvailableForPickup": false,
  "deliveryStatus": "AVAILABLE_WITHIN_REASONABLE_TIME_FRAME",
  "fulfillmentEarliest": "2026-06-20T06:00:00.000Z",
  "fulfillmentLatest": "2026-06-22T16:00:00.000Z",
  "energyClass": null,
  "imageUrl": "https://assets.mmsrg.com/isr/166325/c1/-/ASSET_MP_177987196?...",
  "category": ["Computer & Büro", "Laptops & Notebooks", "15 Zoll Laptops"],
  "highlightedSpecs": [
    { "name": "Prozessor", "value": "Intel Pentium Silver N6000 Prozessor" },
    { "name": "Arbeitsspeicher-Größe", "value": "16 GB" },
    { "name": "Festplattenkapazität 1. Festplatte", "value": "512 GB" },
    { "name": "Grafikkarte", "value": "UHD Graphics" }
  ],
  "badges": ["WM-Highlight"],
  "refurbishedAvailable": false,
  "scrapedAt": "2026-06-19T15:15:30.000Z"
}
```

### Pricing

**$0.00149 per result** — you only pay for products extracted. Higher subscription tiers receive an automatic volume discount (down to $0.00119 at Diamond tier).

### Notes

- **Proxy:** MediaMarkt requires country-matched residential IPs. The actor uses Apify Residential by default, pinned to the target country. This is factored into the price.
- **Netherlands:** `mediamarkt.nl` requires NL residential IPs which are currently unavailable in the Apify proxy pool. Use a startUrl approach with a custom NL proxy if needed.
- **Sort and filters:** Sort order () and condition/seller-type/rating filters work server-side. Price filters (/) are applied as post-fetch client-side filters — products are fetched first, then filtered by price before output. This means all pages are crawled and then filtered, which is reliable but uses full pagination. For tight price ranges, combining with a targeted search query (e.g. `playstation 5`) is more efficient than a broad query.
- **Saturn:** Only available in Germany (`saturn.de`). Select `retailer: "saturn"` with any keyword search.

***

### Need a custom scraper?

**[Unfenced Group](https://www.unfencedgroup.nl)** builds Apify actors for any website — for free.

If the site you need isn't in our portfolio yet, just ask. We scope, build, and publish it at no cost to you. You only pay for results — we absorb the compute and proxy costs ourselves.

**Get in touch:** [www.unfencedgroup.nl](https://www.unfencedgroup.nl)

# Actor input Schema

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

A single keyword to search (e.g. 'laptop', 'iphone', 'samsung tv').

## `searchQueries` (type: `array`):

Several keywords to search in one run. Each becomes its own search.

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

MediaMarkt or Saturn search, category, brand or campaign listing URLs from any supported country.

## `retailer` (type: `string`):

Retailer to use for keyword searches. Saturn is only available in Germany.

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

Country shop to use for keyword searches. Italy uses MediaWorld (same platform as MediaMarkt). Ignored when using startUrls or retailer=saturn.

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

Overall ceiling on products returned across all sources (search queries + start URLs combined). 0 = unlimited.

## `maxResultsPerUrl` (type: `integer`):

Optional per-source cap. Each search query and each start URL stops after this many products, while 'Max results' still applies as the overall ceiling. 0 = no per-source limit. Useful when crawling several URLs in one run so the first source does not consume the whole budget.

## `fetchOffers` (type: `boolean`):

Visit each product's detail page and collect every marketplace seller's offer (seller name, rating, price, shipping, delivery window, condition), not just the buy-box winner. Slower and visits one extra page per product.

## `maxOffersPerProduct` (type: `integer`):

Cap on marketplace offers collected per product when 'Fetch all marketplace seller offers' is on. Offers are sorted cheapest first.

## `includeVariantPrices` (type: `boolean`):

Visit each product's detail page and add the per-variant list (colour/size/storage label, price and availability per variant). Visits one extra page per product.

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

Maximum listing pages to crawl per search query or start URL. Each page returns up to 12 products. Max supported by the site is 30.

## `sortOrder` (type: `string`):

How to sort the results. Applies to keyword searches and startUrls.

## `minPrice` (type: `number`):

Filter products to this minimum price. Leave empty for no lower bound.

## `maxPrice` (type: `number`):

Filter products to this maximum price. Leave empty for no upper bound.

## `condition` (type: `string`):

Filter by product condition.

## `minRating` (type: `integer`):

Only return products with this star rating or higher (1–5).

## `sellerType` (type: `string`):

Filter by who sells the product.

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

Proxy to use. MediaMarkt blocks Apify datacenter IPs — Apify Residential is used by default. You can override this with your own proxy if needed.

## Actor input object example

```json
{
  "searchQuery": "laptop",
  "searchQueries": [],
  "startUrls": [],
  "retailer": "mediamarkt",
  "country": "de",
  "maxResults": 5,
  "maxResultsPerUrl": 0,
  "fetchOffers": false,
  "maxOffersPerProduct": 50,
  "includeVariantPrices": false,
  "maxPages": 30,
  "sortOrder": "relevant",
  "condition": "all",
  "sellerType": "all",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "laptop"
};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/mediamarkt-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": "laptop" }

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/mediamarkt-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 '{
  "searchQuery": "laptop"
}' |
apify call unfenced-group/mediamarkt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MediaMarkt & Saturn Scraper",
        "description": "Scrape MediaMarkt and Saturn products across DE, BE, AT, ES and PL: prices, EAN-13, specs, energy class, sellers, discounts, and delivery status. Pay per result.",
        "version": "0.0",
        "x-build-id": "wyX8WD61fy5aMN5tp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~mediamarkt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-mediamarkt-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/unfenced-group~mediamarkt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-mediamarkt-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/unfenced-group~mediamarkt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-mediamarkt-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "A single keyword to search (e.g. 'laptop', 'iphone', 'samsung tv')."
                    },
                    "searchQueries": {
                        "title": "Search queries (multiple)",
                        "type": "array",
                        "description": "Several keywords to search in one run. Each becomes its own search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "MediaMarkt or Saturn search, category, brand or campaign listing URLs from any supported country.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "retailer": {
                        "title": "Retailer",
                        "enum": [
                            "mediamarkt",
                            "saturn"
                        ],
                        "type": "string",
                        "description": "Retailer to use for keyword searches. Saturn is only available in Germany.",
                        "default": "mediamarkt"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "de",
                            "be",
                            "at",
                            "es",
                            "pl",
                            "it"
                        ],
                        "type": "string",
                        "description": "Country shop to use for keyword searches. Italy uses MediaWorld (same platform as MediaMarkt). Ignored when using startUrls or retailer=saturn.",
                        "default": "de"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Overall ceiling on products returned across all sources (search queries + start URLs combined). 0 = unlimited.",
                        "default": 5
                    },
                    "maxResultsPerUrl": {
                        "title": "Max results per source",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional per-source cap. Each search query and each start URL stops after this many products, while 'Max results' still applies as the overall ceiling. 0 = no per-source limit. Useful when crawling several URLs in one run so the first source does not consume the whole budget.",
                        "default": 0
                    },
                    "fetchOffers": {
                        "title": "Fetch all marketplace seller offers",
                        "type": "boolean",
                        "description": "Visit each product's detail page and collect every marketplace seller's offer (seller name, rating, price, shipping, delivery window, condition), not just the buy-box winner. Slower and visits one extra page per product.",
                        "default": false
                    },
                    "maxOffersPerProduct": {
                        "title": "Max offers per product",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on marketplace offers collected per product when 'Fetch all marketplace seller offers' is on. Offers are sorted cheapest first.",
                        "default": 50
                    },
                    "includeVariantPrices": {
                        "title": "Include variant prices",
                        "type": "boolean",
                        "description": "Visit each product's detail page and add the per-variant list (colour/size/storage label, price and availability per variant). Visits one extra page per product.",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Max pages per URL",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum listing pages to crawl per search query or start URL. Each page returns up to 12 products. Max supported by the site is 30.",
                        "default": 30
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "relevant",
                            "price_asc",
                            "price_desc",
                            "rating",
                            "topseller",
                            "newest",
                            "availability"
                        ],
                        "type": "string",
                        "description": "How to sort the results. Applies to keyword searches and startUrls.",
                        "default": "relevant"
                    },
                    "minPrice": {
                        "title": "Min price (€)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter products to this minimum price. Leave empty for no lower bound."
                    },
                    "maxPrice": {
                        "title": "Max price (€)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter products to this maximum price. Leave empty for no upper bound."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "all",
                            "new",
                            "refurbished"
                        ],
                        "type": "string",
                        "description": "Filter by product condition.",
                        "default": "all"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return products with this star rating or higher (1–5)."
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "all",
                            "mediamarkt",
                            "marketplace"
                        ],
                        "type": "string",
                        "description": "Filter by who sells the product.",
                        "default": "all"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy to use. MediaMarkt blocks Apify datacenter IPs — Apify Residential is used by default. You can override this with your own proxy if needed.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
