# Sainsburys Product Search Scraper (`stealth_mode/sainsburys-product-search-scraper`) Actor

Scrape Sainsbury's product listings with 40+ data fields including pricing, promotions, stock status, reviews, and images. Perfect for price monitoring, competitor analysis, and retail market research.

- **URL**: https://apify.com/stealth\_mode/sainsburys-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Sainsbury's Product Search Scraper: Extract UK Grocery Data at Scale

---

### What Is Sainsbury's.com?

Sainsbury's is the UK's leading online supermarket, offering millions of products across groceries, fresh produce, household items, and branded goods. Its search and category pages display dynamic product information including Nectar member pricing, promotions, availability, and customer reviews. Manually tracking product data across Sainsbury's vast catalog is impractical — the **Sainsbury's Product Search Scraper** automates extraction, delivering clean, structured product records for analysis and integration.

---

### Overview

The **Sainsbury's Product Search Scraper** extracts comprehensive product data from Sainsbury's search results and category pages, transforming HTML listings into machine-readable records. It is designed for:

- **Price intelligence platforms** monitoring UK grocery pricing trends
- **Retail analysts** benchmarking competitor product assortments
- **E-commerce researchers** studying product metadata and promotions
- **Market researchers** analyzing consumer product availability and reviews
- **Supply chain teams** tracking product availability and stock status

Key strengths include support for Nectar member pricing, promotion extraction, review aggregation, and robust handling of large result sets via `max_items_per_url`.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array of strings | Direct links to Sainsbury's product search or category pages |
| `max_items_per_url` | Integer | Maximum products extracted per URL (default: 20, max recommended: 200) |
| `ignore_url_failures` | Boolean | If `true`, skips failed URLs and continues; if `false`, stops on first failure |

**Input Tips:**

- URLs can reference search results (e.g., `?q=rice`), category pages, or promotional offers pages like Nectar pricing
- Use pagination parameters (e.g., `pageNumber=2`) to scrape multiple pages — add each as a separate URL for control
- `max_items_per_url: 200` is suitable for bulk collection; lower values reduce runtime and memory

***

### Output Format

**Sample output**

```json
{
  "sain_id": "3fr9860y",
  "product_uid": "8048938",
  "favourite_uid": null,
  "eans": [
    "0000000415958"
  ],
  "product_type": "BASIC",
  "name": "Sainsbury's Strawberry & Vanilla Cones 4x110ml",
  "image": "https://assets.sainsburys-groceries.co.uk/gol/8048938/image.jpg",
  "image_zoom": "",
  "image_thumbnail": "",
  "image_thumbnail_small": "",
  "full_url": "https://www.sainsburys.co.uk/gol-ui/product/sainsburys-strawberry-vanilla-cones-4x110ml",
  "unit_price": {
    "price": 2.7,
    "measure": "ltr",
    "measure_amount": 1
  },
  "retail_price": {
    "price": 1.19,
    "measure": ""
  },
  "original_unit_price": {
    "price": 2.7,
    "measure": "ltr",
    "measure_amount": 1
  },
  "is_available": true,
  "promotions": [],
  "associations": [],
  "is_alcoholic": false,
  "relevancy_rank": 1,
  "is_spotlight": false,
  "is_intolerant": false,
  "is_mhra": false,
  "badges": [],
  "labels": [
    {
      "label_uid": "Frozen",
      "text": "Frozen",
      "alt_text": "Frozen",
      "color": "#005096",
      "link_opens_in_new_window": false
    },
    {
      "label_uid": "ALDI PRICE MATCH*",
      "text": "ALDI PRICE MATCH*",
      "alt_text": "ALDI PRICE MATCH*",
      "color": "#D70000",
      "link": "https://www.sainsburys.co.uk/gol-ui/events/aldi-price-match",
      "link_opens_in_new_window": false
    }
  ],
  "zone": null,
  "department": null,
  "reviews": {
    "is_enabled": true,
    "product_uid": "8048938",
    "total": 56,
    "average_rating": 4.75
  },
  "breadcrumbs": [],
  "details_html": "",
  "assets": {
    "plp_image": "https://assets.sainsburys-groceries.co.uk/gol/8048938/image.jpg",
    "images": [],
    "video": []
  },
  "description": [],
  "important_information": [],
  "attachments": [],
  "categories": [
    {
      "id": "419879",
      "name": "Handheld ice cream and lollies"
    }
  ],
  "is_supply_chain_orderable": false,
  "display_icons": [],
  "pdp_deep_link": "",
  "promise": {
    "type": "",
    "earliest_promise_date": null,
    "last_amendment_date": null,
    "status": {
      "label": "",
      "type": "NONE"
    }
  },
  "source": null,
  "from_url": "https://www.sainsburys.co.uk/groceries/search?searchTerm=ice+cream&utm_campaign=&utm_content=&utm_custom1=&utm_custom2=&utm_custom6=&utm_medium=&utm_source=&utm_term=&gclid=&dclid=&cmpid=&src=&gad_source=&fbclid=&msclkid=&gclsrc=&gad_campaignid=&page=2"
}
```

Each scraped product returns a rich record with 40+ fields:

#### Product Identity & URLs

| Field | Meaning |
|---|---|
| `Sain ID` | Sainsbury's internal product identifier |
| `Product UID` | Unique identifier for product tracking |
| `Favourite UID` | ID used for customer favorites/wishlist functionality |
| `EANs` | European Article Numbers (barcodes) for the product |
| `Full URL` | Direct link to the product detail page |
| `PDP Deep Link` | Deep link to product display page |
| `Source` | Data source (e.g., Sainsbury's production environment) |

#### Product Details & Classification

| Field | Meaning |
|---|---|
| `Name` | Official product name as displayed on Sainsbury's |
| `Product Type` | Category or product classification (e.g., "Fresh Produce", "Packaged Foods") |
| `Department` | Retailer department (e.g., Grocery, Fresh, Bakery) |
| `Zone` | Physical or digital zone/section within Sainsbury's |
| `Categories` | Hierarchical category tags (breadcrumb path) |
| `Breadcrumbs` | Navigation path showing product categorization |
| `Description` | Detailed product description (plain text) |
| `Details HTML` | Full HTML product details and specifications |

#### Pricing & Promotions

| Field | Meaning |
|---|---|
| `Unit Price` | Current price per unit (e.g., per 100g) |
| `Retail Price` | List/shelf price shown to customers |
| `Original Unit Price` | Pre-discount or original price for comparison |
| `Promotions` | Active promotional offers (e.g., "3 for 2", "% off") |
| `Is Spotlight` | Flag indicating featured/spotlight promotion status |

#### Images & Visual Content

| Field | Meaning |
|---|---|
| `Image` | Primary product image URL (high resolution) |
| `Image Zoom` | Zoomable high-resolution product image |
| `Image Thumbnail` | Standard thumbnail image URL |
| `Image Thumbnail Small` | Small thumbnail for list views |
| `Assets` | Collection of all associated media URLs |

#### Availability & Stock

| Field | Meaning |
|---|---|
| `Is Available` | Boolean: whether the product is currently in stock |
| `Is Supply Chain Orderable` | Whether the item can be ordered via B2B supply chain |
| `Promise` | Delivery or fulfillment promise (e.g., "Next day delivery") |

#### Customer Data & Reviews

| Field | Meaning |
|---|---|
| `Reviews` | Aggregated customer reviews and ratings |
| `Relevancy Rank` | Search result relevancy score (higher = more relevant) |

#### Attributes & Labels

| Field | Meaning |
|---|---|
| `Is Alcoholic` | Boolean: whether product contains alcohol |
| `Is Intolerant` | Boolean: flags products with common allergens/intolerances |
| `Is MHRA` | Flag for medications/health products requiring regulatory compliance |
| `Badges` | Special badges (e.g., "Organic", "Vegan", "Fairtrade") |
| `Labels` | Additional product labeling (nutritional claims, origin, etc.) |
| `Display Icons` | Visual icons for product attributes |

#### Relationships & Metadata

| Field | Meaning |
|---|---|
| `Associations` | Related or recommended products |

***

### How to Use

1. **Prepare URLs** — Navigate to Sainsbury's.co.uk, perform a search or browse a category, and copy the full URL. Examples:
   - Search: `https://www.sainsburys.co.uk/gol-ui/search/rice?pageNumber=1`
   - Category: `https://www.sainsburys.co.uk/gol-ui/browse/fresh-produce/vegetables`
   - Promotions: `https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=1`

2. **Configure input** — Paste URLs into the `urls` array and set `max_items_per_url` (typically 50–200 for balance between speed and data volume).

3. **Enable pagination** — For large result sets, add multiple URLs with different `pageNumber` parameters:

```json
   "urls": [
     "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=1",
     "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2",
     "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=3"
   ]
```

4. **Run the scraper** — Start execution and monitor logs for completion.

5. **Export & analyze** — Download results as JSON, CSV, or Excel for analysis, database import, or API integration.

**Best practices:**

- Use `ignore_url_failures: true` for resilience when scraping multiple pages
- Space out large runs to avoid rate limiting
- Regularly verify URLs remain valid, as Sainsbury's occasionally restructures pages
- Test with `max_items_per_url: 20` before running large batches

***

### Use Cases & Business Value

- **Price monitoring:** Track competitor pricing trends, promotions, and price changes over time
- **Assortment analysis:** Compare product ranges across categories and competitor stores
- **Promotion tracking:** Identify and monitor active offers, discounts, and bundle deals
- **Product research:** Analyze product attributes, badges (organic, vegan, etc.), and customer reviews
- **Market intelligence:** Benchmark UK grocery market trends, new product launches, and availability
- **Data enrichment:** Populate internal product catalogs with Sainsbury's product metadata

By automating product data collection, teams eliminate manual spreadsheet work and unlock real-time market insights.

***

### Conclusion

The **Sainsbury's Product Search Scraper** is an essential tool for retail analysts, price intelligence platforms, and supply chain professionals who need accurate, up-to-date UK grocery data. With 40+ data fields covering pricing, promotions, availability, reviews, and product classifications, it enables data-driven decisions across commerce, research, and business intelligence workflows. Start scraping today and transform Sainsbury's product listings into actionable insights.

# Actor input Schema

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

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/sainsburys-product-search-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 = {
    "urls": ["https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/sainsburys-product-search-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 '{
  "urls": [
    "https://www.sainsburys.co.uk/gol-ui/offers/nectar-prices?pageNumber=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/sainsburys-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sainsburys Product Search Scraper",
        "description": "Scrape Sainsbury's product listings with 40+ data fields including pricing, promotions, stock status, reviews, and images. Perfect for price monitoring, competitor analysis, and retail market research.",
        "version": "0.0",
        "x-build-id": "8EEPd93Q3GKfcBBea"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~sainsburys-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-sainsburys-product-search-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/stealth_mode~sainsburys-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-sainsburys-product-search-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/stealth_mode~sainsburys-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-sainsburys-product-search-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": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
