# Zap.co.il Product Prices & Reviews Scraper (`amrameng/zap-products-scraper`) Actor

Merchant prices and customer reviews for any product on zap.co.il, Israel's largest price-comparison site. One record per product with offers and reviews — pick prices, reviews, or both. Target by URL, ID, category, or brand. Read-only.

- **URL**: https://apify.com/amrameng/zap-products-scraper.md
- **Developed by:** [Amram Englander](https://apify.com/amrameng) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## Zap.co.il Product Prices & Reviews Scraper

**Zap.co.il Product Prices & Reviews Scraper** extracts merchant prices and customer reviews for any product on [zap.co.il](https://www.zap.co.il/), Israel's largest price-comparison marketplace. Give it a product link, choose whether you want **prices, reviews, or both**, and get clean structured data — one record per product, with every merchant offer and every review included.

It's a simple, powerful tool for price monitoring, competitor research, and review analysis. No coding required.

### Why use this scraper?

- 💰 **Price monitoring & repricing** — track every seller's price and shipping on a product, spot the cheapest offer instantly, and react the moment a competitor cuts their price.
- 📊 **Competitive analysis** — see exactly who you're up against: which stores carry a product, where you rank on price, and how your rating stacks up.
- ⭐ **Review & sentiment insights** — collect every customer review with its rating, text, and pros to learn what buyers love (or complain about) — about your products or a rival's.
- 🔍 **Market & product research** — sweep a whole category or brand to size up demand, price ranges, and the best-reviewed models.
- ⚙️ **Automate it** — schedule runs and pull only new prices and reviews to keep your dashboards and alerts fresh.

### How to use it

1. Open the **Input** tab.
2. Paste one or more **product URLs** (or product IDs), or enter a **category** to scrape a whole section.
3. Choose **what to scrape** — prices, reviews, or both.
4. (Optional) Set a **proxy** — an Israeli proxy is recommended for the most reliable results.
5. Click **Start**. When it finishes, view or download the data as JSON, CSV, or Excel.

### Input

You only need one target. Example:

```json
{
    "productUrls": ["https://www.zap.co.il/model.aspx?modelid=1124638"],
    "parts": ["offers", "reviews"]
}
````

| Field                | Description                                                                |
| -------------------- | -------------------------------------------------------------------------- |
| `productUrls`        | One or more product page links.                                            |
| `modelIds`           | Product IDs, if you have them instead of full links.                       |
| `category`           | Scrape a whole category (e.g. `e-cellphone` for cellphones).               |
| `manufacturerFilter` | Optional — limit a category run to a single brand.                         |
| `parts`              | What to collect: `offers` (prices), `reviews`, or both (default).          |
| `maxProducts`        | Limit how many products to scrape in category mode. `0` = no limit.        |
| `maxReviews`         | Limit reviews per product (newest first). `0` = all.                       |
| `reviewsSince`       | Only reviews on or after a date (`YYYY-MM-DD`) — great for scheduled runs. |
| `proxyConfiguration` | Proxy settings; an Israeli proxy is recommended.                           |

### Output sample

One record per product, with offers and reviews nested:

```json
{
    "modelId": "1124638",
    "name": "Apple iPhone 13 128GB",
    "manufacturer": "Apple",
    "category": "Cellphones",
    "aggregateRating": 4.5,
    "reviewCount": 43,
    "offerCount": 23,
    "minPrice": 1090,
    "maxPrice": 3350,
    "offers": [
        {
            "merchantId": "3607",
            "merchantName": "Smile Phone",
            "merchantRating": 5,
            "price": 1090,
            "shippingPrice": 0,
            "shippingDays": null,
            "isMarketplace": false
        }
    ],
    "reviews": [
        {
            "reviewId": "1431390",
            "author": "Hadas",
            "date": "2024-12-03",
            "ratingStars": 5,
            "text": "An Apple product — durable and reliable…",
            "pros": ["Display quality", "Battery life"],
            "helpful": 0,
            "notHelpful": 0
        }
    ],
    "modelUrl": "https://www.zap.co.il/model.aspx?modelid=1124638",
    "scrapedAt": "2026-05-30T00:00:00.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, or HTML, or pull it via the API.

#### Output fields

| Field                                | Description                                                                        |
| ------------------------------------ | ---------------------------------------------------------------------------------- |
| `modelId`, `name`, `manufacturer`    | Product ID, name, and brand                                                        |
| `category`                           | Product category                                                                   |
| `aggregateRating`                    | Average customer rating (0–5)                                                      |
| `reviewCount`                        | Total number of reviews the product has                                            |
| `offerCount`, `minPrice`, `maxPrice` | Number of offers and price range (₪)                                               |
| `offers[]`                           | Each merchant: name, rating, price, shipping cost, delivery days, marketplace flag |
| `reviews[]`                          | Each review: author, date, rating, text, pros, helpful votes                       |
| `modelUrl`, `scrapedAt`              | Product link and capture time                                                      |

#### Output views

The **Output** tab gives you three ready-made tables of the same run:

- **Products** — one row per product
- **Offers** — one row per merchant price (great for price monitoring)
- **Reviews** — one row per review (great for sentiment analysis)

### How many products can I scrape?

As many as you like. Prices for a product come from a single page; reviews are collected in pages of ~16. Use `maxProducts` and `maxReviews` to keep runs fast and predictable, or `parts: ["offers"]` for the quickest price-only runs.

### Integrations

Connect the scraper to your stack with the Apify API, scheduling, webhooks, and integrations like Make, Zapier, Google Sheets, and Slack. Tip: feed an offer's `merchantId` into the **Zap.co.il Stores Scraper** to enrich any seller with its full profile and reviews.

### Is it legal?

The scraper collects only publicly available product information and never logs in or submits anything. Reviews and product names are in Hebrew. You are responsible for how you use the data and for complying with zap.co.il's Terms of Service and applicable law.

### Feedback

Found an issue or want a new feature? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `productUrls` (type: `array`):

zap product links, e.g. https://www.zap.co.il/model.aspx?modelid=1124638 . The model ID is parsed from each URL.

## `modelIds` (type: `array`):

Raw zap model IDs (the modelid= value), e.g. 1124638.

## `category` (type: `string`):

Scrape every product in a category. Pick from the list. Leave empty to scrape only the products you provide above.

## `manufacturerFilter` (type: `string`):

Optional. Limit a category run to a single brand using the site's brand-filter value, e.g. db188396=1951979 for Apple phones (db188396=1951988 for Samsung). Only used with a category.

## `parts` (type: `array`):

Which data to collect per product: offers (merchant prices) and/or reviews. Default both.

## `maxProducts` (type: `integer`):

Safety cap on how many products to scrape when using a category. Ignored when you pass explicit productUrls / modelIds. Set 0 for no limit.

## `maxReviews` (type: `integer`):

Cap how many reviews to collect per product (newest first). The product's reviewCount still reports the true total. Set 0 for all reviews.

## `reviewsSince` (type: `string`):

Only collect reviews written on or after this date. Reviews are newest-first, so this also stops paging early — ideal for scheduled, incremental runs. Leave blank for all dates.

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

An Israeli residential proxy is recommended for the most reliable results. This is the default.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.zap.co.il/model.aspx?modelid=1124638"
  ],
  "parts": [
    "offers",
    "reviews"
  ],
  "maxProducts": 50,
  "maxReviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "productUrls": [
        "https://www.zap.co.il/model.aspx?modelid=1124638"
    ],
    "maxProducts": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("amrameng/zap-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 = {
    "productUrls": ["https://www.zap.co.il/model.aspx?modelid=1124638"],
    "maxProducts": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("amrameng/zap-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 '{
  "productUrls": [
    "https://www.zap.co.il/model.aspx?modelid=1124638"
  ],
  "maxProducts": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}' |
apify call amrameng/zap-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zap.co.il Product Prices & Reviews Scraper",
        "description": "Merchant prices and customer reviews for any product on zap.co.il, Israel's largest price-comparison site. One record per product with offers and reviews — pick prices, reviews, or both. Target by URL, ID, category, or brand. Read-only.",
        "version": "0.1",
        "x-build-id": "KhfiHHqZCyImDq4BV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/amrameng~zap-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-amrameng-zap-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/amrameng~zap-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-amrameng-zap-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/amrameng~zap-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-amrameng-zap-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "zap product links, e.g. https://www.zap.co.il/model.aspx?modelid=1124638 . The model ID is parsed from each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "modelIds": {
                        "title": "Model IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Raw zap model IDs (the modelid= value), e.g. 1124638.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "e-cellphone",
                            "e-tv",
                            "e-fridge",
                            "e-washingmachine",
                            "e-airconditioner",
                            "e-camera",
                            "e-headphone",
                            "e-coffeemachine",
                            "e-oven",
                            "e-dishwasher",
                            "e-vaccumcleaner",
                            "e-cellwatch",
                            "e-tvgame",
                            "e-fan",
                            "e-drayer",
                            "e-hobs",
                            "c-pclaptop",
                            "c-pcdesktop",
                            "c-monitor",
                            "c-printer",
                            "c-tabletpc",
                            "b-perfume",
                            "b-shampoo",
                            "b-aftershave",
                            "b-glasses",
                            "h-grill",
                            "h-drill",
                            "h-cabinet",
                            "h-taps",
                            "h-ink",
                            "h-gardenfurniture",
                            "k-babycarriage",
                            "k-safetyseat",
                            "k-trampoline",
                            "k-lego",
                            "k-furniture",
                            "s-bycicle",
                            "s-treadmill",
                            "s-tent",
                            "s-soccer",
                            "g-watch",
                            "g-jewlery",
                            "g-stores",
                            "t-speakers",
                            "t-amplifier",
                            "p-shoe",
                            "an-dogfood"
                        ],
                        "type": "string",
                        "description": "Scrape every product in a category. Pick from the list. Leave empty to scrape only the products you provide above."
                    },
                    "manufacturerFilter": {
                        "title": "Brand filter (advanced)",
                        "type": "string",
                        "description": "Optional. Limit a category run to a single brand using the site's brand-filter value, e.g. db188396=1951979 for Apple phones (db188396=1951988 for Samsung). Only used with a category."
                    },
                    "parts": {
                        "title": "What to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which data to collect per product: offers (merchant prices) and/or reviews. Default both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "offers",
                                "reviews"
                            ],
                            "enumTitles": [
                                "Offers (prices)",
                                "Reviews"
                            ]
                        },
                        "default": [
                            "offers",
                            "reviews"
                        ]
                    },
                    "maxProducts": {
                        "title": "Max products (category mode only)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap on how many products to scrape when using a category. Ignored when you pass explicit productUrls / modelIds. Set 0 for no limit.",
                        "default": 0
                    },
                    "maxReviews": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap how many reviews to collect per product (newest first). The product's reviewCount still reports the true total. Set 0 for all reviews.",
                        "default": 0
                    },
                    "reviewsSince": {
                        "title": "Reviews since (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews written on or after this date. Reviews are newest-first, so this also stops paging early — ideal for scheduled, incremental runs. Leave blank for all dates."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "An Israeli residential proxy is recommended for the most reliable results. This is the default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IL"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
