# AEG Spare Parts Scraper (`boring_internet_explorer/aeg-spare-parts-scraper`) Actor

Extract genuine AEG spare parts and accessories data across 16 European markets. Scrape prices, SKU codes, stock availability, and product images for filters, dust bags, nozzles, seals, heating elements, and more OEM replacement parts.

- **URL**: https://apify.com/boring\_internet\_explorer/aeg-spare-parts-scraper.md
- **Developed by:** [Boring Internet Explorer](https://apify.com/boring_internet_explorer) (community)
- **Categories:** E-commerce, Lead generation, Other
- **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.

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

## 🔧 AEG Spare Parts Scraper

### ❓ What is the AEG Spare Parts Scraper?

The **AEG Spare Parts Scraper** is a powerful genuine spare parts data extractor that collects structured product data from the **AEG official online shop** — the primary source for genuine AEG replacement parts and accessories. Use this scraper to collect pricing, availability, SKU codes, part numbers, and product images for filters, dust bags, nozzles, seals, motors, hoses, heating elements, and all other OEM appliance repair parts and accessories across 16 European markets.

This European spare parts price tracker and replacement parts data extractor is highly valuable for repair businesses, parts distributors, e-commerce resellers, and appliance maintenance companies. The extracted data is normalized into a consistent structured format regardless of market, making it immediately usable for analysis, integrations, or storage.

---

### ⚡ Why Use This AEG Spare Parts Scraper?

#### 🚀 Blazing Fast

Scrapes large volumes of AEG spare parts and replacement parts data across all supported European markets with minimal compute unit cost on Apify.

#### 💰 Extremely Cost-Effective
One of the most affordable premium appliance spare parts data extractors on the Apify marketplace. Get structured genuine replacement parts data — including filters, bags, nozzles, motors, hoses, and all OEM accessories — across 16 European markets at a fraction of the cost of traditional scraping solutions, without sacrificing data quality or coverage.

#### 🌍 Full European Spare Parts Market Coverage

Supports all 16 AEG spare parts shop European markets out of the box. Simply provide any spare parts listing or product detail URL from any supported market — the scraper automatically detects the market and configuration. No setup or manual configuration needed.

| Flag | Country        |
| ---- | -------------- |
| 🇦🇹   | Austria        |
| 🇧🇪   | Belgium        |
| 🇨🇿   | Czech Republic |
| 🇩🇰   | Denmark        |
| 🇫🇮   | Finland        |
| 🇫🇷   | France         |
| 🇩🇪   | Germany        |
| 🇱🇺   | Luxembourg     |
| 🇳🇱   | Netherlands    |
| 🇵🇱   | Poland         |
| 🇵🇹   | Portugal       |
| 🇪🇸   | Spain          |
| 🇸🇪   | Sweden         |
| 🇨🇭   | Switzerland    |
| 🇺🇦   | Ukraine        |
| 🇬🇧   | United Kingdom |

#### 📦 What AEG Replacement Parts & Accessories Data Can You Scrape?

- 🔥 **Cooking** — Oven seals, heating elements, oven trays, knobs, thermostats, replacement burners
- ❄️ **Cooling** — Refrigerator shelves, door seals, water filters, ice maker parts, compressor accessories
- 🍽️ **Dishwashing** — Spray arms, baskets, door hinges, filters, drain pumps, replacement racks
- 👕 **Laundry** — Drum bearings, drive belts, door seals, drain pumps, control boards, replacement drums
- 🧹 **Vacuums** — Dust bags, HEPA filters, nozzles, hoses, floor brushes, belts, replacement motors
- 🌬️ **Air & Comfort** — Replacement filters, fan blades, motors, air purifier parts
- 🍳 **Small Appliances** — Accessories, cleaning products, descalers, compatible attachments

---

### ❓ What Is the AEG Spare Parts Data Extractor Useful For?

- **Spare parts price monitoring** — Track genuine AEG replacement parts prices across all European markets in real time
- **Appliance repair business management** — Keep your parts catalog in sync with the latest AEG OEM offerings
- **Stock availability tracking** — Monitor which replacement parts are in stock across all 16 markets
- **SKU & part number data collection** — Extract part numbers and SKU codes for parts matching across platforms
- **E-commerce spare parts integration** — Feed AEG genuine parts data into your own platform or marketplace
- **Competitor analysis** — Benchmark AEG spare parts pricing against other replacement parts suppliers

Perfect for:

- 🔧 **Appliance repair technicians** sourcing genuine AEG replacement parts
- 🏪 **Spare parts retailers** managing OEM parts catalogs and pricing
- 📦 **E-commerce resellers** selling genuine AEG accessories online
- 📊 **Procurement managers** tracking replacement parts availability and pricing
- 🏢 **Appliance maintenance companies** requiring structured spare parts data at scale

---

### 📥 Input

```json
{
  "maxItems": 5,
  "startUrls": [
    {
      "url": "https://shop.aeg.dk/madlavning/emhatter/c/20019"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Supported URL Types

| Type            | Example                                                              |
| --------------- | -------------------------------------------------------------------- |
| Product Listing | `https://shop.aeg.dk/madlavning/emhatter/c/20019`                    |
| Product Detail  | `https://shop.aeg.dk/madlavning/emhatter/parer/lysspreder/p/123456`  |

#### Input Fields

| Field                | Type   | Description                                                  |
| -------------------- | ------ | ------------------------------------------------------------ |
| `startUrls`          | array  | One or more AEG spare parts listing or product detail URLs   |
| `maxItems`           | number | Maximum number of products to scrape per URL                 |
| `proxyConfiguration` | object | Optional proxy settings                                      |

***

### 📤 Output

Each item is returned as a structured JSON object with consistent fields across all markets:

```json
{
  "scrapedAt": "2026-06-10T12:34:23.229Z",
  "url": "https://shop.aeg.dk/stovsugere/stovsugere/mundstykker/ze072-kombimundstykke-silent/p/9009229718",
  "name": "ZE072 Kombimundstykke silent",
  "sku": "9009229718",
  "category": "Støvsugere",
  "image": "https://api.electrolux-medialibrary.com/asset/.../PV/PSEEVF200FS0002R.jpg",
  "price": "150.00",
  "currency": "DKK",
  "availability": "inStock"
}
```

#### Output Fields

| Field          | Type   | Description                                |
| -------------- | ------ | ------------------------------------------ |
| `scrapedAt`    | string | ISO timestamp of when the item was scraped |
| `url`          | string | Full product page URL                      |
| `name`         | string | Part name in local language                |
| `sku`          | string | SKU / part number                          |
| `category`     | string | Product category in local language         |
| `image`        | string | Product image URL                          |
| `price`        | string | Listed price                               |
| `currency`     | string | Currency code (e.g. DKK, EUR, GBP)        |
| `availability` | string | Stock status (`inStock`, `outOfStock`)     |

***

### ❓ FAQ

**Where can I find AEG spare parts data across Europe?**
This scraper collects genuine AEG replacement parts and accessories data from the official AEG spare parts online shop across 16 European markets — all in one consistent structured format.

**How do I find the right AEG replacement part?**
Provide the spare parts listing URL for the relevant appliance category from any supported market. The scraper extracts all available parts including SKU codes and part numbers that you can use to identify compatible replacement parts.

**Are these genuine OEM AEG parts?**
Yes — this scraper collects data exclusively from the official AEG spare parts online shop, which sells only genuine OEM AEG replacement parts and accessories.

**Can I scrape AEG spare parts prices across multiple European countries?**
Yes — simply provide listing URLs from different markets. The scraper handles all 16 supported European spare parts shop markets automatically, each with the correct local currency.

**What types of replacement parts can I extract?**
You can extract all genuine AEG spare parts and accessories including filters, dust bags, nozzles, door seals, heating elements, door hinges, pump motors, drive belts, and more across all supported appliance categories.

**Can I use this as an AEG spare parts price tracker?**
Yes — run the scraper on a schedule via Apify to monitor replacement parts price changes and stock availability across any or all supported European markets.

**Can I scrape a specific AEG spare part product page?**
Yes — you can provide either a product listing URL to scrape multiple parts or a single product detail URL to extract data for one specific replacement part.

**Which markets are supported?**
16 European markets are supported: Austria, Belgium, Czech Republic, Denmark, Finland, France, Germany, Luxembourg, Netherlands, Poland, Portugal, Spain, Sweden, Switzerland, Ukraine, and United Kingdom.

**Why is my market not supported in this scraper?**
Some AEG markets do not have a dedicated spare parts online shop. For these markets, spare parts and accessories are available directly through the main AEG website. You can use the [AEG Product Scraper](https://apify.com/boring_internet_explorer/aeg-product-scraper) to scrape product data from those markets instead. Unsupported markets include: Croatia, Estonia, Greece, Hungary, Latvia, Lithuania, Romania, and Slovenia.

**What is the difference between this scraper and the AEG Product Scraper?**
The AEG Product Scraper covers main appliance products (ovens, washing machines, refrigerators etc.) across 24 markets. This scraper is dedicated to the official AEG spare parts and accessories online shop, covering genuine OEM replacement parts across 16 markets.

***

### 🔗 Want More Home Appliance Data?

If you found this scraper useful, check out our other home appliance scrapers:

- 🏠 [AEG Product Scraper](https://apify.com/boring_internet_explorer/aeg-product-scraper) — Extract AEG product data across 24 European markets
- 🏠 [Electrolux Product Scraper](https://apify.com/boring_internet_explorer/electrolux-product-scraper) — Extract Electrolux product data across 31 European markets
- 🔧 [Electrolux Spare Parts Scraper](https://apify.com/boring_internet_explorer/electrolux-spare-parts-scraper) — Extract Electrolux spare parts data across 18 European markets
- 🏠 [Juno Product Scraper](https://apify.com/boring_internet_explorer/juno-product-scraper) — Extract Juno product data from Juno Germany
- 🔧 [Zanussi Spare Parts Scraper](https://apify.com/boring_internet_explorer/zanussi-spare-parts-scraper) — Extract Zanussi genuine spare parts data across 7 European markets

# Actor input Schema

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

One or more AEG spare parts listing or product detail URLs.

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

Maximum number of products to scrape per URL.

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

Proxy configuration for the scraper.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://shop.aeg.dk/madlavning/emhatter/c/20019"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://shop.aeg.dk/madlavning/emhatter/c/20019"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boring_internet_explorer/aeg-spare-parts-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 = { "startUrls": [{ "url": "https://shop.aeg.dk/madlavning/emhatter/c/20019" }] }

# Run the Actor and wait for it to finish
run = client.actor("boring_internet_explorer/aeg-spare-parts-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 '{
  "startUrls": [
    {
      "url": "https://shop.aeg.dk/madlavning/emhatter/c/20019"
    }
  ]
}' |
apify call boring_internet_explorer/aeg-spare-parts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AEG Spare Parts Scraper",
        "description": "Extract genuine AEG spare parts and accessories data across 16 European markets. Scrape prices, SKU codes, stock availability, and product images for filters, dust bags, nozzles, seals, heating elements, and more OEM replacement parts.",
        "version": "0.0",
        "x-build-id": "x0k7h0mk642doBeSt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/boring_internet_explorer~aeg-spare-parts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-boring_internet_explorer-aeg-spare-parts-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/boring_internet_explorer~aeg-spare-parts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-boring_internet_explorer-aeg-spare-parts-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/boring_internet_explorer~aeg-spare-parts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-boring_internet_explorer-aeg-spare-parts-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more AEG spare parts listing or product detail URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of products to scrape per URL.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration for the scraper.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
