# Idealo.de Scraper: Prices, Offers, Specs & Reviews (`abotapi/idealo-de-price-comparison-scraper`) Actor

Scrape Idealo.de products with identity details, GTIN, price ranges, specifications, images, rating breakdowns and customer reviews. Get the complete merchant offer list, including prices, seller details, and offer pros and cons. Search by keyword or paste product URLs.

- **URL**: https://apify.com/abotapi/idealo-de-price-comparison-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (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.60 / 1,000 product results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## idealo.de Price Comparison Scraper

Extract products from **idealo.de**, Germany's largest price-comparison portal. Search by keyword or pass your own idealo.de URLs. Every product comes back as a clean, structured record with the full merchant offer list, specs, and customer reviews available on opt-in detail enrichment.

### What you get

Each product includes:

- **Identity**: product ID, product URL, title, brand, category, GTIN
- **Price**: lowest price, highest price, currency, number of merchant offers
- **Merchant offers** (detail mode): every listed merchant's price, shipping cost, total, and its pros/cons, plus a link to the offer
- **Specs** (detail mode): the full technical specification table, whatever fields the category exposes
- **Media**: preview image and the full image gallery
- **Reviews** (detail mode): overall rating, review count, star-rating breakdown, and individual reviews (author, date, title, body, rating)

> **Note on pricing fields:** idealo.de is a price-*comparison* portal: it shows a range across merchant offers, not a merchant's own "was/now" discount. There is no genuine strikethrough/list-price markup to extract here, so this actor intentionally does not emit a "was price" field; the price range (`lowPrice`/`highPrice`) and the individual offers list are the accurate representation of what idealo actually shows.

### Input

| Field | What it does |
|-------|--------------|
| `mode` | `url` (default; use your own URLs) or `search` (search by keyword) |
| `searchQuery` | Keyword to search for (search mode only) |
| `urls` | Your own idealo.de search-result, category, or product URLs (url mode only) |
| `fetchDetails` | Enrich every product with its full detail page (offers, specs, reviews, gallery) |
| `maxItems` | Maximum number of products to return |
| `maxPages` | Maximum number of search-result pages to read |
| `mcpConnectors` | Optionally forward a summary of each result to Notion, Linear, Airtable, or Apify via MCP |
| `notionParentPageUrl` | Notion connector only: the parent page under which item pages are created |
| `maxNotifyListings` | Cap on items written to each connector per run (does not affect the dataset) |

#### Example input

> URL mode is selected by default with this sample category URL.

```json
{
  "mode": "url",
  "urls": [
    "https://www.idealo.de/preisvergleich/ProductCategory/5292.html"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "DE"
  }
}
````

#### Example output

> Sample shape, values are illustrative placeholders rather than from a live product.

```json
{
  "id": "00000001",
  "url": "https://www.idealo.de/preisvergleich/OffersOfProduct/00000001_-sample-product.html",
  "title": "Sample Product 128GB Black",
  "brand": "Sample Brand",
  "category": "Sample Category/Sample Subcategory",
  "gtin": "0000000000000",
  "lowPrice": 0.00,
  "highPrice": 0.00,
  "currency": "EUR",
  "offerCount": 0,
  "rating": 0.0,
  "reviewCount": 0,
  "reviewBreakdown": { "5": 0, "4": 0, "3": 0, "2": 0, "1": 0 },
  "previewImage": "https://cdn.example.com/000000000.jpg",
  "images": ["https://cdn.example.com/000000000.jpg"],
  "description": "The product's own description text appears here when present.",
  "specs": { "Sample Spec Label": "Sample value" },
  "offers": [
    {
      "merchant": "Sample Shop",
      "price": 0.00,
      "priceFormatted": "0,00 €",
      "shipping": "Sample shipping note",
      "total": 0.00,
      "totalFormatted": "0,00 €",
      "pros": ["Sample pro"],
      "cons": ["Sample con"],
      "url": "https://www.idealo.de/redirect/sample"
    }
  ],
  "reviews": [
    {
      "author": "Jane D.",
      "date": "2026-01-01",
      "title": "Sample review title",
      "text": "The reviewer's own text appears here.",
      "rating": 5.0
    }
  ]
}
```

### Output

Each record is pushed to the dataset as a flat JSON object. With `fetchDetails` off, only the lean search-result fields are populated (`id`, `title`, `lowPrice`, `previewImage`, `offerCount`); everything else (the full `offers` list, `specs`, `reviews`, `description`, and full `images` gallery) requires `fetchDetails: true`.

### Cost profile

This source requires extra verification before pages load, which increases underlying resource usage per item, particularly with `fetchDetails` enabled (one extra page per product). Keep `maxItems` modest for trial runs.

### Plan Requirement

Runs on any Apify plan, including the free tier. Leave the proxy configuration on its provided defaults for the most reliable results.

### Send results into your apps (MCP connectors)

Select one or more MCP connectors (Notion, Linear, Airtable, or a generic Apify MCP target) under the "Export to your apps" section to mirror a condensed summary of each result into the app you already use, as results come in. The `notionParentPageUrl` field points the Notion connector at the parent page to create item pages under, and `maxNotifyListings` caps how many items are written to each connector per run. The full record always stays in the dataset regardless of connector selection; the connector output is a best-effort, human-readable digest and never blocks the run if it fails.

### Tips

- Turn on `fetchDetails` when you need merchant offers, specs, reviews, or the full gallery; leave it off for lean search-only runs.
- Use `url` mode to scrape a saved search, category page, or individual product page.
- idealo.de's search covers every product category on the site; a keyword like "waschmaschine" or "iphone 15" is enough, with no separate category filter needed.

# Actor input Schema

## `mode` (type: `string`):

Choose how to find products. Only fields belonging to the chosen mode are used.

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

Product keyword to search for, e.g. "iphone 15" or "waschmaschine". (Search mode only.)

## `urls` (type: `array`):

Paste one or more idealo.de search-result, category, or product URLs. The sample category URL is ready to run. Limits are controlled by Maximum pages and Maximum items. (URL mode only.)

## `fetchDetails` (type: `boolean`):

Pull the full record per product: complete merchant offers list with shipping and pros/cons, technical specs, full image gallery, description, and customer reviews with rating breakdown. Without this, only the lean search-result fields (id, title, price, preview image) are returned. Adds one extra page fetch per product.

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

Stop after scraping this many products across the whole run.

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

Maximum number of result pages to process for each search. The run may finish earlier when Maximum items is reached or no more products are available.

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

This source needs the proxy configuration left on its provided defaults for reliable results.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "url",
  "searchQuery": "iphone 15",
  "urls": [
    "https://www.idealo.de/preisvergleich/ProductCategory/5292.html"
  ],
  "fetchDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `offers` (type: `string`):

No description

## `reviews` (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 = {
    "mode": "url",
    "searchQuery": "iphone 15",
    "urls": [
        "https://www.idealo.de/preisvergleich/ProductCategory/5292.html"
    ],
    "fetchDetails": true,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/idealo-de-price-comparison-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 = {
    "mode": "url",
    "searchQuery": "iphone 15",
    "urls": ["https://www.idealo.de/preisvergleich/ProductCategory/5292.html"],
    "fetchDetails": True,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/idealo-de-price-comparison-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 '{
  "mode": "url",
  "searchQuery": "iphone 15",
  "urls": [
    "https://www.idealo.de/preisvergleich/ProductCategory/5292.html"
  ],
  "fetchDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call abotapi/idealo-de-price-comparison-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=abotapi/idealo-de-price-comparison-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Idealo.de Scraper: Prices, Offers, Specs & Reviews",
        "description": "Scrape Idealo.de products with identity details, GTIN, price ranges, specifications, images, rating breakdowns and customer reviews. Get the complete merchant offer list, including prices, seller details, and offer pros and cons. Search by keyword or paste product URLs.",
        "version": "1.0",
        "x-build-id": "CEbiLoJK0hROCxP2H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~idealo-de-price-comparison-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-idealo-de-price-comparison-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/abotapi~idealo-de-price-comparison-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-idealo-de-price-comparison-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/abotapi~idealo-de-price-comparison-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-idealo-de-price-comparison-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Choose how to find products. Only fields belonging to the chosen mode are used.",
                        "default": "url"
                    },
                    "searchQuery": {
                        "title": "Search keyword (search mode only)",
                        "type": "string",
                        "description": "Product keyword to search for, e.g. \"iphone 15\" or \"waschmaschine\". (Search mode only.)"
                    },
                    "urls": {
                        "title": "URLs (URL mode only)",
                        "type": "array",
                        "description": "Paste one or more idealo.de search-result, category, or product URLs. The sample category URL is ready to run. Limits are controlled by Maximum pages and Maximum items. (URL mode only.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full product detail",
                        "type": "boolean",
                        "description": "Pull the full record per product: complete merchant offers list with shipping and pros/cons, technical specs, full image gallery, description, and customer reviews with rating breakdown. Without this, only the lean search-result fields (id, title, price, preview image) are returned. Adds one extra page fetch per product.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after scraping this many products across the whole run.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of result pages to process for each search. The run may finish earlier when Maximum items is reached or no more products are available."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "This source needs the proxy configuration left on its provided defaults for reliable results."
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
