# Electrolux Spare Parts Scraper (`boring_internet_explorer/electrolux-spare-parts-scraper`) Actor

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

- **URL**: https://apify.com/boring\_internet\_explorer/electrolux-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

## 🔧 Electrolux Spare Parts & Accessories Scraper

### ❓ What is the Electrolux Spare Parts & Accessories Scraper?

The **Electrolux Spare Parts & Accessories Scraper** is a powerful genuine spare parts data extractor that collects structured product data from the **Electrolux official online shop** — the primary source for genuine Electrolux 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 18 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 Electrolux Spare Parts Scraper?

#### 🚀 Blazing Fast

Scrapes large volumes of Electrolux 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 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 18 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 18 Electrolux 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        |
| 🇭🇺   | Hungary        |
| 🇮🇹   | Italy          |
| 🇳🇱   | Netherlands    |
| 🇳🇴   | Norway         |
| 🇵🇱   | Poland         |
| 🇵🇹   | Portugal       |
| 🇸🇰   | Slovakia       |
| 🇪🇸   | Spain          |
| 🇸🇪   | Sweden         |
| 🇨🇭   | Switzerland    |
| 🇬🇧   | United Kingdom |

#### 📦 What Electrolux 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 Electrolux Spare Parts Data Extractor Useful For?

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

Perfect for:

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

---

### 📥 Input

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

#### Supported URL Types

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

#### Input Fields

| Field                | Type   | Description                                                       |
| -------------------- | ------ | ----------------------------------------------------------------- |
| `startUrls`          | array  | One or more Electrolux 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.electrolux.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 Electrolux spare parts data across Europe?**
This scraper collects genuine Electrolux replacement parts and accessories data from the official Electrolux spare parts online shop across 18 European markets — all in one consistent structured format.

**How do I find the right Electrolux 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 Electrolux parts?**
Yes — this scraper collects data exclusively from the official Electrolux spare parts online shop, which sells only genuine OEM Electrolux replacement parts and accessories.

**Can I scrape Electrolux spare parts prices across multiple European countries?**
Yes — simply provide listing URLs from different markets. The scraper handles all 18 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 Electrolux 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 Electrolux 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 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?**
18 European markets are supported: Austria, Belgium, Czech Republic, Denmark, Finland, France, Germany, Hungary, Italy, Netherlands, Norway, Poland, Portugal, Slovakia, Spain, Sweden, Switzerland, and United Kingdom.

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

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

***

### 🔗 Want More Home Appliance Data?

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

- 🏠 [Electrolux Product Scraper](https://apify.com/boring_internet_explorer/electrolux-product-scraper) — Extract Electrolux product data across 31 European markets
- 🏠 [AEG Product Scraper](https://apify.com/boring_internet_explorer/aeg-product-scraper) — Extract AEG product data across 24 European markets
- 🔧 [AEG Spare Parts Scraper](https://apify.com/boring_internet_explorer/aeg-spare-parts-scraper) — Extract AEG genuine spare parts data across 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 Electrolux 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.electrolux.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.electrolux.dk/madlavning/emhatter/c/20019"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boring_internet_explorer/electrolux-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.electrolux.dk/madlavning/emhatter/c/20019" }] }

# Run the Actor and wait for it to finish
run = client.actor("boring_internet_explorer/electrolux-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.electrolux.dk/madlavning/emhatter/c/20019"
    }
  ]
}' |
apify call boring_internet_explorer/electrolux-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/electrolux-spare-parts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Electrolux Spare Parts Scraper",
        "description": "Extract genuine Electrolux spare parts and accessories data across 18 European markets. Scrape prices, SKU codes, stock availability, and product images for filters, dust bags, nozzles, seals, heating elements, and more replacement parts.",
        "version": "0.0",
        "x-build-id": "jtmS9TC3njn4k6qMU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/boring_internet_explorer~electrolux-spare-parts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-boring_internet_explorer-electrolux-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~electrolux-spare-parts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-boring_internet_explorer-electrolux-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~electrolux-spare-parts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-boring_internet_explorer-electrolux-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 Electrolux 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
