# John Lewis Product Scraper (`maximedupre/john-lewis-product-scraper`) Actor

Scrape John Lewis product and variant data from product URLs, category URLs, search URLs, search terms, and brand names. Get prices, stock status, images, ratings, specifications, and source URLs.

- **URL**: https://apify.com/maximedupre/john-lewis-product-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.45 / 1,000 scraped products

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

### 🛒 John Lewis product scraper for product data

John Lewis Product Scraper collects public product and variant data from [John Lewis](https://www.johnlewis.com/). Add product URLs, category URLs, search URLs, plain search terms, or brand names, then export product titles, prices, availability, variants, images, ratings, specifications, category context, source URLs, and scrape timestamps.

Use this John Lewis product scraper when you need UK retail product data for price checks, stock monitoring, catalogue research, assortment reports, or repeat ecommerce workflows. It saves one dataset row per accepted product or variant, so colour and size variants can be tracked separately when John Lewis exposes them.

For a small first run, keep the prefilled search, set `Product limit` to `25`, and leave `Page limit per target` at `1`. Review the dataset, then raise the limits for larger searches or scheduled monitoring.

### ✅ What this Actor does

- Scrapes public John Lewis product, search, brand, and category pages.
- Accepts John Lewis product URLs, category URLs, brand URLs, search URLs, search terms, and brand names.
- Saves one row per visible product or variant when variant data is available.
- Extracts product title, brand, product URL, product ID, variant URL, variant ID, SKU, product code, colour, size, and source metadata.
- Extracts current price, previous price, price range, currency, availability, stock flags, and promotion text when visible.
- Extracts ratings, review counts, main image URL, image URL arrays, breadcrumbs, category paths, descriptions, specifications, dimensions, and weight when John Lewis shows them.
- Stops at your `maxItems` limit across the run.
- Works with Apify dataset exports, API clients, schedules, webhooks, and integrations.
- Runs without a John Lewis login, cookies, or a user-provided API key.

The Actor focuses on public John Lewis product data. It does not scrape non-John-Lewis retailers, private account data, checkout data, delivery slots, historical prices, or customer review text.

### 📦 Data you can extract

Each dataset item is one John Lewis product or product variant. Fields can be empty when John Lewis does not show that value for a product.

- `productId` - John Lewis product identifier or source identifier.
- `productTitle` - product name shown by John Lewis.
- `brand` - product brand when available.
- `productUrl` - canonical product URL.
- `variantId`, `variantTitle`, `variantUrl`, `skuId`, and `productCode` - variant and SKU identifiers when available.
- `colour`, `trueColour`, and `size` - variant attributes when shown.
- `currentPrice`, `currentPriceDisplay`, `previousPrice`, `previousPriceDisplay`, `priceMin`, `priceMax`, and `priceRangeDisplay` - numeric and display price fields.
- `currency` - always `GBP`.
- `availability`, `availableToOrder`, and `outOfStock` - stock and ordering signals from the source.
- `promotions` - visible promotion text.
- `rating` and `reviewCount` - review summary values when shown.
- `mainImageUrl`, `imageUrls`, and `imageCount` - product media URLs.
- `breadcrumbs`, `categoryPath`, `mainCategory`, and `subCategory` - category context.
- `description`, `specifications`, `weight`, and `dimensions` - detail fields when visible.
- `source` - input target, target type, source URL, page number, and listing position.
- `scrapedAt` - UTC timestamp when the row was saved.

### 🧭 Common use cases

- Track John Lewis product prices for a keyword, category, brand, or saved product URL.
- Monitor availability and visible stock status for products and variants.
- Compare brands, colours, sizes, ratings, and review counts in a category.
- Build UK retail catalogue exports with images and specifications.
- Feed product rows into spreadsheets, BI tools, dashboards, or internal APIs.
- Schedule repeat Apify runs for recurring price and assortment checks.

### 🚀 How to run

1. Add one or more values to **Product targets**. You can paste John Lewis URLs or type search terms such as `coffee machine` or `toaster`.
2. Optionally add **Extra brand names** such as `Le Creuset`, `Bosch`, or `Smeg`.
3. Set **Product limit**. Use `25` for a quick first run.
4. Set **Page limit per target** if you want to continue through more search or category pages.
5. Keep **Include unavailable products** on if you want visible unavailable variants in the dataset.
6. Run the Actor and open the dataset.

The Actor handles source access for you. You do not need to add a proxy, John Lewis account, cookies, or API key.

### ⚙️ Input example

```json
{
	"targets": [
		"coffee machine",
		"https://www.johnlewis.com/search?search-term=toaster"
	],
	"brands": ["Le Creuset"],
	"maxItems": 25,
	"maxPagesPerTarget": 1,
	"includeUnavailableProducts": true
}
````

### 🧾 Output example

```json
{
	"productId": "5521950",
	"productTitle": "John Lewis 2 Slice Toaster",
	"brand": "John Lewis",
	"productUrl": "https://www.johnlewis.com/john-lewis-2-slice-toaster/p5521950",
	"variantId": "dc30c5de-668f-51bd-a9ea-0f19b8f600f0",
	"variantTitle": "John Lewis 2 Slice Toaster, Navy Blue",
	"variantUrl": "https://www.johnlewis.com/john-lewis-2-slice-toaster/navy-blue/p5521950",
	"skuId": "113614146",
	"productCode": null,
	"colour": "Navy Blue",
	"trueColour": "Navy Blue",
	"size": null,
	"currentPrice": 15,
	"currentPriceDisplay": "£15.00",
	"previousPrice": null,
	"previousPriceDisplay": null,
	"priceMin": 15,
	"priceMax": 15,
	"priceRangeDisplay": "£15.00",
	"currency": "GBP",
	"availability": "In stock",
	"availableToOrder": true,
	"outOfStock": false,
	"promotions": ["Save £5 on selected products"],
	"rating": 4.4,
	"reviewCount": 291,
	"mainImageUrl": "https://media.johnlewiscontent.com/i/JohnLewis/113614146alt2?",
	"imageUrls": [
		"https://media.johnlewiscontent.com/i/JohnLewis/113614146alt2?",
		"https://media.johnlewiscontent.com/i/JohnLewis/113614146"
	],
	"imageCount": 2,
	"breadcrumbs": ["Search results 'toaster'"],
	"categoryPath": "Search results 'toaster'",
	"mainCategory": "Search results 'toaster'",
	"subCategory": null,
	"description": null,
	"specifications": {
		"Brand": ["John Lewis"],
		"Dimensions": ["H19.4 x W30.2 x D20cm"],
		"Weight": ["1.18 kg"]
	},
	"weight": "1.18 kg",
	"dimensions": "H19.4 x W30.2 x D20cm",
	"source": {
		"target": "toaster",
		"targetType": "searchTerm",
		"url": "https://www.johnlewis.com/search?search-term=toaster",
		"pageNumber": 1,
		"position": 1
	},
	"scrapedAt": "2026-06-09T11:10:09.033Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged `$0.00445` for each product or variant collected, which is `$4.45` per 1,000 saved rows.

If a run starts but no products are saved, there is no product charge from this Actor's primary event. Keep the product limit low for your first run, check the output, then raise it for larger jobs.

### ⚠️ Limits and caveats

John Lewis can show different fields for different product types. Some products may not have variants, previous prices, reviews, specifications, descriptions, or multiple images. The Actor leaves those fields empty instead of inventing values.

Search terms and brand names are resolved through John Lewis search. For precise category filters, paste the exact John Lewis category, brand, or search URL you want to scrape.

This Actor captures the public product data visible at run time. It does not store historical prices by itself, but you can schedule repeat Apify runs and compare datasets over time.

### ❓ FAQ

#### 🔎 Does this scrape product pages or only listing pages?

It can start from both. Product URLs return product or variant rows directly. Search, category, brand, and plain-text targets collect visible product and variant data from listing pages.

#### 🗂️ Can I scrape a specific John Lewis category?

Yes. Paste the John Lewis category URL into **Product targets** and set your product and page limits.

#### 📦 Does it include unavailable products?

Yes, by default. Turn off **Include unavailable products** if you only want products and variants that John Lewis marks as available when they are visible in the source.

#### 🔐 Do I need a John Lewis account?

No. The Actor only uses public product surfaces and does not ask for John Lewis credentials, cookies, or a user API key.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~john-lewis-product-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Allegro Scraper ↗](https://apify.com/maximedupre/allegro-scraper) - Scrape marketplace product listings, prices, sellers, images, and delivery text from Allegro.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Collect live paid Shopping product ads from Google Search for ecommerce research.
- [Amazon Keywords Discovery Tool ↗](https://apify.com/maximedupre/amazon-keywords-discovery-tool) - Discover Amazon autocomplete keyword ideas for product and marketplace research.
- [OLX Scraper ↗](https://apify.com/maximedupre/olx-scraper) - Export OLX listing prices, seller details, locations, photos, and attributes.
- [Autotrader Scraper ↗](https://apify.com/maximedupre/autotrader-scraper) - Scrape public US vehicle listings with prices, VINs, seller details, photos, and source URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Add John Lewis product, category, brand, or search URLs, or plain search terms and brand names. Each row is collected as a separate source.

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

Optional brand names to collect in addition to Product targets, such as Samsung, Le Creuset, or Bosch.

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

Maximum product rows to save across the whole run. Use 25 for a quick first run.

## `maxPagesPerTarget` (type: `integer`):

Maximum listing or search pages to open for each target. Direct product URLs are not paginated.

## `includeUnavailableProducts` (type: `boolean`):

Keep products and variants that John Lewis marks as unavailable when they are visible in the source.

## Actor input object example

```json
{
  "targets": [
    "coffee machine",
    "https://www.johnlewis.com/search?search-term=toaster"
  ],
  "brands": [
    "Le Creuset"
  ],
  "maxItems": 25,
  "maxPagesPerTarget": 1,
  "includeUnavailableProducts": true
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with John Lewis product and variant rows.

# 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 = {
    "targets": [
        "coffee machine",
        "https://www.johnlewis.com/search?search-term=toaster"
    ],
    "brands": [
        "Le Creuset"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/john-lewis-product-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 = {
    "targets": [
        "coffee machine",
        "https://www.johnlewis.com/search?search-term=toaster",
    ],
    "brands": ["Le Creuset"],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/john-lewis-product-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 '{
  "targets": [
    "coffee machine",
    "https://www.johnlewis.com/search?search-term=toaster"
  ],
  "brands": [
    "Le Creuset"
  ],
  "maxItems": 25
}' |
apify call maximedupre/john-lewis-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "John Lewis Product Scraper",
        "description": "Scrape John Lewis product and variant data from product URLs, category URLs, search URLs, search terms, and brand names. Get prices, stock status, images, ratings, specifications, and source URLs.",
        "version": "0.1",
        "x-build-id": "vC2CAA6ThsKaTazIM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~john-lewis-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-john-lewis-product-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/maximedupre~john-lewis-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-john-lewis-product-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/maximedupre~john-lewis-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-john-lewis-product-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": [
                    "targets",
                    "maxItems",
                    "maxPagesPerTarget",
                    "includeUnavailableProducts"
                ],
                "properties": {
                    "targets": {
                        "title": "Product targets",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add John Lewis product, category, brand, or search URLs, or plain search terms and brand names. Each row is collected as a separate source.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "brands": {
                        "title": "Extra brand names",
                        "maxItems": 500,
                        "type": "array",
                        "description": "Optional brand names to collect in addition to Product targets, such as Samsung, Le Creuset, or Bosch.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxItems": {
                        "title": "Product limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum product rows to save across the whole run. Use 25 for a quick first run.",
                        "default": 50
                    },
                    "maxPagesPerTarget": {
                        "title": "Page limit per target",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum listing or search pages to open for each target. Direct product URLs are not paginated.",
                        "default": 1
                    },
                    "includeUnavailableProducts": {
                        "title": "Include unavailable products",
                        "type": "boolean",
                        "description": "Keep products and variants that John Lewis marks as unavailable when they are visible in the source.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```