# Zalando Products Scraper (`fetch_cat/zalando-products-scraper`) Actor

Scrape public Zalando search and category products with prices, brands, images, sizes, availability, and optional product detail fields.

- **URL**: https://apify.com/fetch\_cat/zalando-products-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 item processeds

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/docs.md):

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Zalando Products Scraper

Scrape public Zalando search and category pages into clean product rows with product IDs, prices, brands, image URLs, source pages, and parser diagnostics.

Use it for ecommerce monitoring, assortment research, merchandising reports, competitor price checks, and API-driven catalog workflows.

### At a glance

- **Primary job**: Extract priced Zalando product listings from public country-domain search and category pages.
- **Input**: Start URLs, optional search keyword/domain, result limit, proxy settings, and debug mode.
- **Output**: One dataset row per valid priced product, deduplicated by Zalando SKU/product ID.
- **Best for**: Small-to-medium recurring price and assortment checks where empty extraction should fail loudly.

### Common workflows

- **Keyword research**: Run a Zalando keyword such as `cap`, `sneakers`, or `running shoes` and export products to CSV or Excel.
- **Category monitoring**: Paste a Zalando category URL and schedule repeat runs to compare prices and availability over time.
- **Catalog enrichment**: Feed product URLs, image URLs, IDs, prices, and brands into BI, pricing, or marketplace systems.
- **Automation**: Trigger runs through the Apify API, webhooks, MCP tools, or dataset integrations.

### Input recipes

- **Small smoke test**: `startUrls: [{"url":"https://www.zalando.at/herren/?q=cap"}]`, `maxItems: 3`, residential proxy country `AT` if needed.
- **Keyword run**: Set `query: "cap"`, `domain: "zalando.at"`, and `maxItems: 25`.
- **Category monitor**: Paste a stable Zalando category URL, keep `maxItems` focused, and schedule the Actor daily or weekly.

### What data can you extract?

| Field | Description |
| --- | --- |
| `productId`, `sku` | Zalando article identifier parsed from product data or URL. |
| `url`, `pageUrl`, `sourceDomain` | Product URL, source listing/detail page, and Zalando country domain. |
| `brand`, `name` | Product brand and name when exposed in page data. |
| `price`, `originalPrice`, `currency`, `discount` | Current price and optional price metadata. |
| `color`, `sizes`, `availability` | Optional variant and availability data when exposed. |
| `imageUrls`, `description`, `breadcrumbs`, `categoryPath` | Product media and optional descriptive fields. |
| `scrapedAt`, `detailStatus`, `missingFields`, `parserVersion` | Run timestamp and diagnostics for monitoring parser quality; V1 listing runs mark `detailStatus` as `not_requested`. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Zalando start URLs | `startUrls` | Search, category, or product URLs from supported Zalando domains. | `https://www.zalando.at/herren/?q=cap` |
| Search keyword | `query` | Build a Zalando catalog search URL for the selected domain. | `cap` |
| Zalando domain | `domain` | Country domain for keyword searches. | `zalando.at` |
| Maximum products | `maxItems` | Cap saved priced products and control spend. | `25` |
| Maximum concurrency | `maxConcurrency` | Advanced throttle for cautious request pacing. | `2` |
| Proxy configuration | `proxyConfiguration` | Use Apify Proxy; residential country proxies can help with country-specific pages. | `{ "useApifyProxy": true }` |
| Debug mode | `debugMode` | Store a bounded HTML sample for parser drift diagnosis. | `false` |

### Example input

```json
{
  "startUrls": [{ "url": "https://www.zalando.at/herren/?q=cap" }],
  "query": "cap",
  "domain": "zalando.at",
  "maxItems": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "AT"
  }
}
````

### Example output

```json
{
  "productId": "UR622E08F-A11",
  "sku": "UR622E08F-A11",
  "url": "https://www.zalando.at/urban-classics-loose-stoffhose-whitesand-ur622e08f-a11.html",
  "sourceDomain": "zalando.at",
  "query": "cap",
  "pageUrl": "https://www.zalando.at/herren/?q=cap",
  "brand": "Urban Classics",
  "name": "Loose - Trousers",
  "categoryPath": [],
  "price": 34.99,
  "originalPrice": null,
  "currency": "EUR",
  "discount": null,
  "color": null,
  "sizes": [],
  "availability": null,
  "imageUrls": [],
  "description": null,
  "breadcrumbs": [],
  "scrapedAt": "2026-07-18T08:50:00.000Z",
  "detailStatus": "not_requested",
  "missingFields": [],
  "parserVersion": "zalando-products-v1"
}
```

### Pricing

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond | Charged when |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Start | `$0.005` | `$0.005` | `$0.005` | `$0.005` | `$0.005` | `$0.005` | Once when the Actor starts. |
| Item processed | `$0.0015` | `$0.0013` | `$0.0011` | `$0.0009` | `$0.0007` | `$0.0005` | Each valid priced product is saved. |

### Tips for best results

- **Start small**: Use `maxItems: 3-10` until the target domain and proxy settings are verified.
- **Use country-matched proxies**: For country domains such as `.at`, a matching residential country can improve consistency.
- **Avoid empty-success monitoring**: The Actor fails when no priced products are extracted, so scheduled jobs do not silently produce empty datasets.

### API usage

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/zalando-products-scraper").call({
  startUrls: [{ url: "https://www.zalando.at/herren/?q=cap" }],
  maxItems: 3
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/zalando-products-scraper").call(run_input={
    "startUrls": [{ "url": "https://www.zalando.at/herren/?q=cap" }],
    "maxItems": 3,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~zalando-products-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.zalando.at/herren/?q=cap"}],"maxItems":3}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/zalando-products-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/zalando-products-scraper"
    }
  }
}
```

Example prompt: "Run Zalando Products Scraper for a small Zalando Austria cap search and summarize product IDs, prices, and brands."

### Limits and caveats

- **Coverage**: Zalando country pages differ; validate a small run before scheduling large jobs.
- **Freshness**: Prices and availability can change after a run finishes.
- **Blocking**: Some domains can return edge pages or sparse HTML; use debug mode for reproducible issue reports.
- **Detail fields**: V1 prioritizes stable priced product rows; optional fields are left empty when not exposed.

### Legality and responsible use

Scrape only public data you are allowed to access. Follow Zalando terms, Apify terms, robots guidance where applicable, and privacy/data-protection laws.

### Related actors

- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder)
- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)

### FAQ

#### Why did my run fail instead of returning an empty dataset?

Empty product extraction is treated as a failure to make monitoring reliable and catch parser drift, blocking, or unsupported URLs early.

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some optional fields empty?

Zalando pages do not expose every field in every response. The Actor leaves unavailable fields empty instead of guessing.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or URL, input JSON, expected output, actual output, and one reproducible public URL from Zalando.

# Actor input Schema

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

Zalando catalog, search, category, or product listing URLs to scrape. Use public www.zalando.\* URLs only.

## `query` (type: `string`):

Optional Zalando search keyword. If provided, the Actor builds a catalog search URL for the selected domain.

## `domain` (type: `string`):

Country domain used when a search keyword is provided.

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

Maximum number of valid product rows with prices to save.

## `maxConcurrency` (type: `integer`):

Advanced throttle setting. Conservative defaults reduce blocking risk.

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

Apify Proxy settings. Datacenter proxy should be tried first; use residential only if Zalando blocks your target domain.

## `debugMode` (type: `boolean`):

Stores a bounded HTML sample in the key-value store to diagnose parser drift or edge responses.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zalando.at/herren/?q=cap"
    }
  ],
  "query": "cap",
  "domain": "zalando.at",
  "maxItems": 10,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  },
  "debugMode": 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://www.zalando.at/herren/?q=cap"
        }
    ],
    "query": "cap",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/zalando-products-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.zalando.at/herren/?q=cap" }],
    "query": "cap",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/zalando-products-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.zalando.at/herren/?q=cap"
    }
  ],
  "query": "cap",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call fetch_cat/zalando-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zalando Products Scraper",
        "description": "Scrape public Zalando search and category products with prices, brands, images, sizes, availability, and optional product detail fields.",
        "version": "0.1",
        "x-build-id": "XB9vZ5DLfb7BSs9MR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~zalando-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-zalando-products-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/fetch_cat~zalando-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-zalando-products-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/fetch_cat~zalando-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-zalando-products-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": "Zalando start URLs",
                        "type": "array",
                        "description": "Zalando catalog, search, category, or product listing URLs to scrape. Use public www.zalando.* URLs only.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Optional Zalando search keyword. If provided, the Actor builds a catalog search URL for the selected domain."
                    },
                    "domain": {
                        "title": "Zalando domain",
                        "enum": [
                            "zalando.de",
                            "zalando.at",
                            "zalando.co.uk",
                            "zalando.com",
                            "zalando.fr",
                            "zalando.it",
                            "zalando.es",
                            "zalando.nl"
                        ],
                        "type": "string",
                        "description": "Country domain used when a search keyword is provided.",
                        "default": "zalando.at"
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of valid product rows with prices to save.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Advanced throttle setting. Conservative defaults reduce blocking risk.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter proxy should be tried first; use residential only if Zalando blocks your target domain."
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Stores a bounded HTML sample in the key-value store to diagnose parser drift or edge responses.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
