# UK PPE & Safety Equipment Shelf Monitor (`zhorex/ppe-shelf-monitor`) Actor

The whole priced UK safety-equipment trade catalogue in seconds: ex-VAT and inc-VAT price, minimum order quantity, unit, brand, category and the product lifecycle stage that flags a discontinuation early. Delta mode annotates every row with what moved.

- **URL**: https://apify.com/zhorex/ppe-shelf-monitor.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 trade shelf rows

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/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

## UK PPE & Safety Equipment Shelf Monitor — The Whole Trade Catalogue (2026)

The complete priced catalogue of the UK's largest safety-equipment distributor, in about **eight seconds**: ex-VAT trade price, inc-VAT price, minimum order quantity and order interval, unit, brand, category, promotion, product URL — and the field nobody else exposes, the **product lifecycle stage**.

Measured on 2026-07-25: **14,843 catalogue entries in 16 requests, 8.2 seconds.** No API key to obtain, no browser, no proxy.

### Why the lifecycle field is the reason to run this

Every line carries one of four stages, populated on **100%** of rows:

| Stage | Count (measured) | What it tells you |
|---|---|---|
| `ESTABLISHED` | 12,524 | Core range |
| `INTRO 1` / `INTRO 2` | 1,514 / 359 | New lines entering the range — what your competitor just started stocking |
| `EXIT1` | 387 | **Being discontinued** |

A SKU moving `ESTABLISHED → EXIT1` is a discontinuation warning that arrives **weeks before the line disappears from the shelf**. If you buy, sell or specify safety equipment, that is the difference between resourcing calmly and being told a product is gone when you order it. And it exists nowhere as a feed — only by comparing today's catalogue against a stored one, which is exactly what delta mode does.

### What a row looks like

```json
{
    "sku": "5535821",
    "productName": "Arco Medium-Duty Sack Truck Solid Wheel",
    "brand": "ARCO",
    "category": "Manual Handling",
    "netPriceExVat": 89.50,
    "grossPriceIncVat": 107.40,
    "vatRatePct": 20.0,
    "currency": "GBP",
    "minOrderQuantity": 2,
    "orderQuantityInterval": 1,
    "unit": "Each",
    "productLifecycle": "ESTABLISHED",
    "promotion": null,
    "isPriceable": true,
    "suspiciousPrice": false,
    "productUrl": "https://www.arco.co.uk/products/5535821",
    "scrapedAt": "2026-07-25T21:40:00Z"
}
````

### Delta mode — every row says what moved

With `deltaMode: true`, the first run records a baseline and every later run returns the shelf **annotated**:

| `changeType` | Meaning |
|---|---|
| `lifecycle_change` | Stage transition, with `previousLifecycle` — the discontinuation warning |
| `price_up` / `price_down` | Trade price moved, with `priceChange` and `priceChangePct` |
| `supply_terms_change` | Minimum order quantity or order interval moved — a supply signal |
| `promo_change` | Promotion on the line changed |
| `new` / `delisted` | Line entered or left the catalogue |

**Deliberately, the default returns the WHOLE shelf every run, with movement as an annotation** — because a price file you cannot join to yesterday's is not a price file. If you are feeding an alerting pipeline that already holds the catalogue, `returnChangesOnly: true` gives you just the movers. Unchanged rows are billed at the ordinary row rate, never the change rate.

`delisted` only fires after a **full** sweep. On a filtered run the Actor sees a subset by design, and calling those SKUs delisted would be a lie.

```json
{
    "maxProducts": 20000,
    "deltaMode": true,
    "deltaStateKey": "weekly-shelf"
}
```

### Who this is for

| Buyer | Job |
|---|---|
| **Safety and PPE brands** | Where your lines sit against competitors on the biggest UK trade shelf, at what trade price, and which of your SKUs the distributor has moved to EXIT |
| **Distributors and resellers** | A complete competitor price file, refreshed weekly, with MOQ and pack terms included |
| **Procurement and facilities teams** | Benchmark quoted prices against the published trade price, and catch discontinuations before a reorder fails |
| **Industrial and construction analysts** | Assortment breadth, own-brand share and price movement across ~15,000 SKUs as an input-cost read |
| **Marketplace sellers** | Sourcing terms — MOQ, order interval, unit — in one normalised grid |

### Sizing your run

| Setup | Requests | Rows | At $0.003/row |
|---|---|---|---|
| Full catalogue, one-off | 16 | ~14,800 | $44 |
| Full catalogue, weekly cron | 16/week | ~14,800/week | ~$192/month |
| One brand (e.g. 3M) | 1-2 | a few hundred | cents |
| Only the lines being discontinued (`product_lifecycle:"4 EXIT1"`) | 1 | ~390 | $1.17 |

That last row is the cheapest useful query on this Actor: one request tells you everything the distributor is dropping.

### Pricing

| Event | Price | What it is |
|---|---|---|
| `product-row` | **$0.003** | One catalogue line, full field set |
| `shelf-change` | **$0.02** | One line that moved in delta mode, with its previous values |

Index entries with no name or price are **skipped and never charged** (59 of 14,843 when measured).

### Limitations, stated plainly

- **This is one distributor's catalogue** — the UK's largest safety-equipment supplier, which is what most UK PPE pricing is benchmarked against, but it is one source and the data says so.
- **Some lines carry placeholder prices.** A sack truck at £0.01 is not a bargain, it is a catalogue artefact. Those rows are returned with `suspiciousPrice: true` so they never poison an average.
- **Trade prices are list prices**, not your negotiated account price. That is precisely what makes them a benchmark.
- **Ordinary pagination does not work on this source** — page 2 returns zero rows with a success status. This Actor walks a price watermark instead, which is why it gets the whole catalogue where a naive scraper would silently return 1,000 rows and look fine.
- **No history before your first run.** Prices and lifecycle stages cannot be backfilled.
- **If the storefront rotates its public search key**, the run fails loudly with that reason and charges nothing — it does not return an empty catalogue.

### FAQ

**Do I need a proxy?** No. Verified from an ordinary IP with no challenge.

**Why does the full catalogue only take 16 requests?** Because it is harvested by price watermark at 1,000 rows a request, rather than page by page.

**Can I get just the discontinued lines?** Yes — `filterExpression: product_lifecycle:"4 EXIT1"`. One request, ~390 rows.

**Why is my first delta run the whole shelf?** It is the baseline, billed at the row rate. From the second run every row carries what moved.

### Other scrapers by Zhorex

- [UK Tyre Price & Fitment Monitor](https://apify.com/zhorex/tyre-price-monitor) — the same delta pattern on UK tyre shelves
- [DE/AT Pharmacy Price & Stock Monitor](https://apify.com/zhorex/pharmacy-price-monitor) — OTC pharmacy prices, RRP breaches and stock
- [Hostelworld Rate & Availability Monitor](https://apify.com/zhorex/hostelworld-rate-monitor) — forward-dated accommodation rates

### Legal

This Actor reads publicly visible commercial catalogue data: product names, trade prices, order terms and lifecycle stages. It collects no personal data and places no orders. Respect the distributor's terms and applicable law in your jurisdiction, and use the data for analysis rather than redistribution.

# Actor input Schema

## `brands` (type: `array`):

Narrow to specific brands, e.g. 3M, ARCO, JSP. Leave empty for the FULL catalogue — which is the point of this Actor: you need the competitor lines to benchmark your own, and the whole shelf costs 16 requests.

## `categories` (type: `array`):

Narrow to specific low-level categories as they appear in the catalogue, e.g. 'Safety Footwear'. Combined with brands using AND.

## `filterExpression` (type: `string`):

A raw index filter for anything the two fields above cannot express, e.g. product\_lifecycle:"4 EXIT1" to pull only the lines being discontinued.

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

Ceiling on rows returned. The full catalogue measured ~14,800 priceable lines, harvested in 16 requests and about 8 seconds, so the default covers it with room to spare.

## `includeUnpriceableRows` (type: `boolean`):

The catalogue contains a small number of entries with no display name and a zero price (59 of 14,843 when measured). They are skipped and never charged by default; turn this on if you are auditing the index itself rather than the shelf.

## `deltaMode` (type: `boolean`):

The first run records a baseline. Every later run returns the shelf with each row annotated by what changed since last time: a lifecycle transition (ESTABLISHED to EXIT is a discontinuation warning weeks early), a trade-price move with delta and percentage, a change in minimum order quantity or order interval, a promotion change, or a delisting. Rows that did not move are billed at the ordinary row rate, not the change rate.

## `returnChangesOnly` (type: `boolean`):

Optional, and off on purpose. Most buyers of a price file want the WHOLE shelf every run with the movement annotated — a changed-rows-only feed cannot be joined to yesterday's file. Turn this on only if you are feeding an alerting pipeline that already holds the full catalogue.

## `deltaStateKey` (type: `string`):

Names an independent delta stream so several monitors don't collide. Only used when Delta mode is on.

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

Not needed: the catalogue search answers ordinary IPs with no challenge. Leave it off unless you specifically want your traffic routed.

## Actor input object example

```json
{
  "brands": [
    "3M",
    "ARCO"
  ],
  "filterExpression": "product_lifecycle:\"4 EXIT1\"",
  "maxProducts": 20000,
  "includeUnpriceableRows": false,
  "deltaMode": false,
  "returnChangesOnly": false,
  "deltaStateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "maxProducts": 20000,
    "deltaStateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/ppe-shelf-monitor").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 = {
    "maxProducts": 20000,
    "deltaStateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/ppe-shelf-monitor").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 '{
  "maxProducts": 20000,
  "deltaStateKey": "default"
}' |
apify call zhorex/ppe-shelf-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zhorex/ppe-shelf-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK PPE & Safety Equipment Shelf Monitor",
        "description": "The whole priced UK safety-equipment trade catalogue in seconds: ex-VAT and inc-VAT price, minimum order quantity, unit, brand, category and the product lifecycle stage that flags a discontinuation early. Delta mode annotates every row with what moved.",
        "version": "0.1",
        "x-build-id": "h7jYmUfSO8kG5cGd0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~ppe-shelf-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-ppe-shelf-monitor",
                "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/zhorex~ppe-shelf-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-ppe-shelf-monitor",
                "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/zhorex~ppe-shelf-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-ppe-shelf-monitor",
                "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": {
                    "brands": {
                        "title": "Brands (optional)",
                        "type": "array",
                        "description": "Narrow to specific brands, e.g. 3M, ARCO, JSP. Leave empty for the FULL catalogue — which is the point of this Actor: you need the competitor lines to benchmark your own, and the whole shelf costs 16 requests.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories (optional)",
                        "type": "array",
                        "description": "Narrow to specific low-level categories as they appear in the catalogue, e.g. 'Safety Footwear'. Combined with brands using AND.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterExpression": {
                        "title": "Raw filter (advanced)",
                        "type": "string",
                        "description": "A raw index filter for anything the two fields above cannot express, e.g. product_lifecycle:\"4 EXIT1\" to pull only the lines being discontinued."
                    },
                    "maxProducts": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 40000,
                        "type": "integer",
                        "description": "Ceiling on rows returned. The full catalogue measured ~14,800 priceable lines, harvested in 16 requests and about 8 seconds, so the default covers it with room to spare.",
                        "default": 20000
                    },
                    "includeUnpriceableRows": {
                        "title": "Include index entries with no name or price",
                        "type": "boolean",
                        "description": "The catalogue contains a small number of entries with no display name and a zero price (59 of 14,843 when measured). They are skipped and never charged by default; turn this on if you are auditing the index itself rather than the shelf.",
                        "default": false
                    },
                    "deltaMode": {
                        "title": "Delta mode — annotate what moved",
                        "type": "boolean",
                        "description": "The first run records a baseline. Every later run returns the shelf with each row annotated by what changed since last time: a lifecycle transition (ESTABLISHED to EXIT is a discontinuation warning weeks early), a trade-price move with delta and percentage, a change in minimum order quantity or order interval, a promotion change, or a delisting. Rows that did not move are billed at the ordinary row rate, not the change rate.",
                        "default": false
                    },
                    "returnChangesOnly": {
                        "title": "Return only the rows that moved",
                        "type": "boolean",
                        "description": "Optional, and off on purpose. Most buyers of a price file want the WHOLE shelf every run with the movement annotated — a changed-rows-only feed cannot be joined to yesterday's file. Turn this on only if you are feeding an alerting pipeline that already holds the full catalogue.",
                        "default": false
                    },
                    "deltaStateKey": {
                        "title": "Delta stream name",
                        "type": "string",
                        "description": "Names an independent delta stream so several monitors don't collide. Only used when Delta mode is on.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional — not required)",
                        "type": "object",
                        "description": "Not needed: the catalogue search answers ordinary IPs with no challenge. Leave it off unless you specifically want your traffic routed.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
