# MyDealz Deals Scraper (`automation-lab/mydealz-deals-scraper`) Actor

Scrape public MyDealz deals, vouchers, prices, merchants, categories, temperatures, comments, and timestamps for German ecommerce monitoring.

- **URL**: https://apify.com/automation-lab/mydealz-deals-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, SEO tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## MyDealz Deals Scraper

Extract public deals, vouchers, prices, merchants, categories, temperatures, comments, and timestamps from [MyDealz.de](https://www.mydealz.de/), Germany's large deal-sharing community.

### What does MyDealz Deals Scraper do?

MyDealz Deals Scraper turns public MyDealz listing pages into a clean dataset. It reads server-rendered deal cards and saves structured rows with deal titles, URLs, prices, comparison prices, discounts, merchant names, category groups, community temperature, comment counts, voucher codes, status flags, image URLs, and posting metadata.

Use it to monitor German ecommerce promotions without manually copying MyDealz pages.

### Who is it for?

- 🛒 **Retailers** tracking competitor discounts and hot promotions in Germany.
- 📈 **Price intelligence teams** collecting price drops, old prices, and community validation.
- 🔗 **Affiliate marketers** discovering deal velocity, voucher codes, and merchant activity.
- 🧾 **Resellers and marketplace analysts** watching product categories such as electronics, gaming, travel, and home.
- 🤖 **Automation builders** feeding MyDealz signals into alerts, dashboards, CRMs, and BI tools.

### Why use this scraper?

MyDealz contains community-ranked promotion data that is hard to reproduce from a merchant catalog alone. The temperature score, comment count, hot flags, and voucher markers help distinguish ordinary price changes from deals that shoppers actually engage with.

### Public data covered

The actor works with public MyDealz pages visible without login, including:

- Hot deal lists
- Latest/new deal lists
- Search result pages
- Category or group pages
- Merchant pages
- Voucher/deal listing pages

### Data fields

| Field | Description |
| --- | --- |
| `dealId` | MyDealz thread/listing ID |
| `title` | Deal or voucher title |
| `url` | Public MyDealz listing URL |
| `shareableUrl` | MyDealz share URL when available |
| `price` | Current deal price |
| `oldPrice` | Comparison or next-best price |
| `discountPercent` | Discount percentage from MyDealz metadata |
| `shippingPrice` | Shipping cost when shown |
| `isFreeShipping` | Free-shipping flag |
| `merchant` | Merchant or link host |
| `category` | MyDealz category/group |
| `temperature` | Community hotness score |
| `commentCount` | Number of comments |
| `voucherCode` | Public voucher code when present |
| `expired` | Expired flag |
| `author` | Posting user |
| `imageUrl` | MyDealz/Pepper CDN image URL |
| `publishedAt` | Posting timestamp |
| `updatedAt` | Update timestamp |
| `description` | Short listing description snippet |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape MyDealz deals?

This actor uses pay-per-event pricing. You pay a small run-start charge plus a per-result charge for each deal saved. The default target price is about **$1.50 per 1,000 saved deals** before tier discounts. You can control spend with `maxItems` and `maxPagesPerUrl`.

### How to scrape MyDealz hot deals

1. Open the actor on Apify.
2. Keep the prefilled start URL `https://www.mydealz.de/hot`.
3. Set `maxItems` to a small number for your first run, for example 30.
4. Click **Start**.
5. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `startUrls` | array | `https://www.mydealz.de/hot` | Public MyDealz listing URLs |
| `searchTerms` | array | sample keywords | Converted to MyDealz search URLs |
| `maxItems` | integer | 30 | Maximum unique deals to save |
| `maxPagesPerUrl` | integer | 2 | Pagination depth per source |
| `requestDelayMs` | integer | 750 | Delay between requests |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.mydealz.de/hot" }
  ],
  "searchTerms": ["lego"],
  "maxItems": 50,
  "maxPagesPerUrl": 2,
  "requestDelayMs": 750
}
````

### Example output

```json
{
  "dealId": "2794065",
  "title": "Panasonic LUMIX S1R2 Vollformat",
  "url": "https://www.mydealz.de/deals/panasonic-lumix-s1r2-vollformat-2794065",
  "price": 2515.9,
  "oldPrice": 2835,
  "merchant": "asgoodasnew",
  "category": "Elektronik",
  "temperature": 103.34,
  "commentCount": 0,
  "voucherCode": "CLICK100",
  "expired": false
}
```

### Search-term scraping

Instead of providing a full MyDealz search URL, add keywords to `searchTerms`. The actor converts each term to a public MyDealz search page and paginates it just like any other source.

### Category and merchant monitoring

Paste category or merchant URLs into `startUrls` when you want focused monitoring. For example, use an electronics category URL for device deals or a merchant URL to track one retailer's campaigns.

### Tips for reliable runs

- Start with 30 to 100 results while testing a workflow.
- Use specific search terms for cleaner monitoring feeds.
- Increase `maxPagesPerUrl` only when you need older listings.
- Keep the default delay unless you have a strong reason to speed up requests.
- Use MyDealz listing URLs, not private account pages.

### Integrations

Export the dataset to:

- Google Sheets for daily deal review.
- BigQuery or Snowflake for price intelligence history.
- Slack or Discord alerts for hot deals above a temperature threshold.
- Affiliate dashboards for voucher and merchant trend tracking.
- Internal repricing tools that compare `price` and `oldPrice`.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/mydealz-deals-scraper').call({
  startUrls: [{ url: 'https://www.mydealz.de/hot' }],
  maxItems: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/mydealz-deals-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.mydealz.de/hot'}],
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~mydealz-deals-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.mydealz.de/hot"}],"maxItems":50}'
```

### MCP usage

Use the Apify MCP server with this actor in Claude Code or Claude Desktop:

```bash
claude mcp add apify-mydealz "https://mcp.apify.com/?tools=automation-lab/mydealz-deals-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-mydealz": {
      "url": "https://mcp.apify.com/?tools=automation-lab/mydealz-deals-scraper"
    }
  }
}
```

Example prompts:

- "Run the MyDealz Deals Scraper for hot deals and summarize merchants with the highest temperatures."
- "Find MyDealz search results for lego and return deals under 100 EUR."
- "Compare voucher-code deals with non-voucher deals from the latest run."

### Legality

MyDealz Deals Scraper extracts publicly visible listing data. It does not log in, bypass paywalls, or access private account pages.

### Legal and ethical use

This actor extracts publicly available MyDealz listing data. You are responsible for using the data lawfully, respecting applicable terms, privacy rules, and rate limits. Do not scrape private account areas or use the output for spam.

### FAQ

#### Can I scrape MyDealz search results?

Yes. Add keywords to `searchTerms` or paste a public MyDealz search URL into `startUrls`.

#### Does this actor collect comments?

It collects comment counts from listing pages. Full comment threads are not included in v0.1 because they require extra detail-page requests.

### Troubleshooting

If a run returns fewer rows than requested, the selected source may have fewer unique listings or duplicate deals across pages. Try a broader source such as `/hot` or increase `maxPagesPerUrl`.

If URLs are rejected, verify that every `startUrls` entry is on `mydealz.de`. The actor intentionally blocks unrelated domains.

### Limitations

The first version focuses on listing-page data. It does not visit every deal detail page, so detail-only external purchase links or full comment threads may not be present. This keeps runs faster and cheaper.

### Related scrapers

- https://apify.com/automation-lab/hotukdeals-deals-scraper
- https://apify.com/automation-lab/ebay-sold-items-scraper
- https://apify.com/automation-lab/geizhals-products-scraper
- https://apify.com/automation-lab/amazon-scraper

### Changelog

- v0.1 — Initial MyDealz listing scraper with HTTP extraction, search terms, pagination, prices, merchants, categories, temperatures, vouchers, and timestamps.

### Support

Open an Apify issue if you find a public MyDealz page that should work but returns no results. Include the input JSON and run ID so the problem can be reproduced.

### Output quality checklist

- Deal URLs are absolute.
- Prices are numeric where MyDealz exposes them.
- Temperature and comment count are numeric.
- Voucher codes are only included when public in the listing payload.
- `scrapedAt` records when the row was collected.

# Actor input Schema

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

Public MyDealz listing URLs to scrape, such as hot deals, latest deals, category pages, merchant pages, voucher pages, or search pages.

## `searchTerms` (type: `array`):

Optional MyDealz search terms. Each term is converted to a public MyDealz search URL.

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

Maximum number of unique deals or vouchers to save across all sources.

## `maxPagesPerUrl` (type: `integer`):

How many paginated listing pages to visit per start URL or search term. MyDealz usually returns about 30 deals per page.

## `requestDelayMs` (type: `integer`):

Polite delay between listing page requests. Increase if MyDealz responds slowly.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.mydealz.de/hot"
    }
  ],
  "searchTerms": [
    "lego",
    "iphone"
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 2,
  "requestDelayMs": 750
}
```

# 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://www.mydealz.de/hot"
        }
    ],
    "searchTerms": [
        "lego",
        "iphone"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/mydealz-deals-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://www.mydealz.de/hot" }],
    "searchTerms": [
        "lego",
        "iphone",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/mydealz-deals-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://www.mydealz.de/hot"
    }
  ],
  "searchTerms": [
    "lego",
    "iphone"
  ]
}' |
apify call automation-lab/mydealz-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyDealz Deals Scraper",
        "description": "Scrape public MyDealz deals, vouchers, prices, merchants, categories, temperatures, comments, and timestamps for German ecommerce monitoring.",
        "version": "0.1",
        "x-build-id": "gghD5NUf9hI6XPPjr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~mydealz-deals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-mydealz-deals-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/automation-lab~mydealz-deals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-mydealz-deals-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/automation-lab~mydealz-deals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-mydealz-deals-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Public MyDealz listing URLs to scrape, such as hot deals, latest deals, category pages, merchant pages, voucher pages, or search pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional MyDealz search terms. Each term is converted to a public MyDealz search URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum deals",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique deals or vouchers to save across all sources.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many paginated listing pages to visit per start URL or search term. MyDealz usually returns about 30 deals per page.",
                        "default": 2
                    },
                    "requestDelayMs": {
                        "title": "Request delay (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between listing page requests. Increase if MyDealz responds slowly.",
                        "default": 750
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
