# Tesco Scraper — UK & Ireland Grocery Products & Prices (`studio-amba/tesco-ie-scraper`) Actor

Scrape the full Tesco UK and Tesco Ireland groceries catalogue: product names, GBP/EUR prices, Clubcard offers, price per unit, EAN codes, images, ratings and categories. Search by keyword, walk the department tree or scrape one category. No login, no cookies.

- **URL**: https://apify.com/studio-amba/tesco-ie-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 result scrapeds

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

## Tesco Ireland Groceries Scraper

Scrape Tesco Ireland's grocery range: product names, EUR prices, Clubcard offers, price per unit, EAN codes, images, ratings, stock and full category paths. Search by keyword, scrape one category, or walk the entire catalogue. No login, no cookies.

### Why use this actor?

Tesco is one of Ireland's largest grocers, and its online range is one of the biggest price datasets in Irish retail. This actor gives you a clean, structured feed of the Tesco Ireland grocery catalogue for price monitoring, competitor benchmarking, product matching, market research, or building a grocery price comparison. You get the same data the Tesco website shows shoppers, including Clubcard prices, without needing an account or a delivery slot.

**Two data paths, both first-class.** Keyword searches go straight to Tesco's own search API, the same one the tesco.ie site uses, so search runs are fast and return clean structured data including the real brand name. Category and full-catalogue runs read the authoritative listing data embedded in Tesco's rendered pages, including the exact product total for every category.

**Complete past the 10,000 cap.** Every Tesco listing is capped at 10,000 results, so a single broad crawl can silently truncate large departments. This actor walks the category tree (superdepartment → department → aisle → shelf) and, whenever a node's total hits the cap, descends into its child categories until every listing stays under 10,000. Products are deduped by Tesco product id (TPNC), and the run ends with a self-checking completeness assertion that compares per-category distinct coverage against the authoritative totals.

Tesco Ireland sits behind Akamai Bot Manager with hard IP-reputation blocking, so ordinary scrapers get an "Access Denied" before any product loads. For category scraping this actor routes every request through the Bright Data Web Unlocker, which solves the Akamai challenge and returns the fully rendered page, so you get reliable results run after run. Keyword search does not need Bright Data at all.

### How to scrape Tesco Ireland data

1. Add this actor to your Apify account.
2. Choose what to scrape:
   - Set `searchQuery` to scrape a keyword, e.g. `milk` or `bread`. This path needs no Bright Data key.
   - Set `categoryUrl` to scrape one category, e.g. `bakery/bread` or a full `https://www.tesco.ie/shop/en-IE/browse/...` URL.
   - Or paste a list of listing URLs into `startUrls`.
   - Leave everything empty to walk the whole grocery catalogue (all 10 grocery superdepartments).
3. For category or full-catalogue runs, provide a Bright Data API key (field `brightDataApiKey`, stored as a secret) or set the `BRIGHT_DATA_API_KEY` environment variable.
4. Set `maxProducts` to cap the run (default 100, prefilled 20 for a quick test). Set it high, e.g. `25000`, for a full-catalogue pull.
5. Run the actor. Results stream to the dataset and can be exported as JSON, CSV, Excel or fed to an API.

For category runs the actor reads the authoritative product total of every listing and paginates 200 products per page. Whenever a listing's total hits Tesco's 10,000 cap, the actor drills into that category's children so no shelf is ever truncated. Set `enumerateOnly: true` to walk the tree and report the exact catalogue size without scraping products, a cheap way to verify completeness before a full run.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search Tesco Ireland groceries by keyword (no Bright Data key needed) |
| `categoryUrl` | String | No | A Tesco Ireland category URL or slug to scrape |
| `startUrls` | Array | No | One or more Tesco Ireland listing URLs |
| `maxProducts` | Integer | No | Maximum products to return (default 100) |
| `brightDataApiKey` | String (secret) | For categories | Bright Data Web Unlocker API key. Falls back to `BRIGHT_DATA_API_KEY` env var. |
| `enumerateOnly` | Boolean | No | Walk the tree and report the authoritative catalogue size without scraping products |
| `requestDelaySecs` | Integer | No | Minimum pause between category page fetches (for very large paced runs) |
| `proxyConfiguration` | Object | No | Proxy settings for the search API path |

#### Example input

```json
{
    "searchQuery": "milk",
    "maxProducts": 100
}
````

Or a category run:

```json
{
    "categoryUrl": "bakery/bread",
    "maxProducts": 500
}
```

### Output

| Field | Type | Example | Description |
|-------|------|---------|-------------|
| `name` | String | `Brennans Family Pan Premium White Sliced Bread 800g` | Product name |
| `brand` | String | `Brennans` | Brand name (search API) or own-brand detection |
| `price` | Number | `2.09` | Current shelf price in EUR |
| `currency` | String | `EUR` | Always EUR |
| `pricePerUnit` | String | `€2.61/kg` | Unit price |
| `discount` | String | `€1.50 Clubcard Price` | Clubcard / promotion text if present |
| `ean` | String | `05011059000014` | Barcode (GTIN) where available |
| `sku` | String | `55014303` | Tesco base product number (TPNB) |
| `productId` | String | `250330059` | Tesco consumer product number (TPNC) |
| `inStock` | Boolean | `true` | Availability flag |
| `rating` | Number | `4.5` | Average review rating (0-5) |
| `reviewCount` | Integer | `12` | Number of reviews |
| `category` | String | `Bakery > Bread > White Bread` | Full category path |
| `imageUrl` | String | `https://digitalcontent.api.tesco.com/...` | Primary product image |
| `url` | String | `https://www.tesco.ie/shop/en-IE/products/250330059` | Product page URL |
| `scrapedAt` | String | `2026-07-06T12:00:00.000Z` | Timestamp |

#### Example output

```json
{
    "name": "Brennans Family Pan Premium White Sliced Bread 800g",
    "brand": "Brennans",
    "price": 2.09,
    "currency": "EUR",
    "pricePerUnit": "€2.61/kg",
    "ean": "05011059000014",
    "sku": "55014303",
    "productId": "250330059",
    "inStock": true,
    "rating": 3,
    "reviewCount": 2,
    "imageUrl": "https://digitalcontent.api.tesco.com/v2/media/ghs/2f343343-9591-4f09-93a7-1623f582d969/7cb13f8c-82e8-4e39-822c-9ea73b9d2447_716249531.jpeg",
    "category": "Bakery > Bread > White Bread",
    "categories": ["Bakery", "Bread", "White Bread"],
    "url": "https://www.tesco.ie/shop/en-IE/products/250330059",
    "scrapedAt": "2026-07-06T12:00:00.000Z"
}
```

### Cost estimate

Keyword searches fetch up to 200 products per request, so even large keyword pulls cost only a few cents of platform usage. Category runs go through the Bright Data Web Unlocker (about $0.0015 per page fetch on Bright Data's side) and also return up to 200 products per page, so a full-catalogue pull of roughly 15,000-20,000 unique products needs only a few hundred unlocker requests.

### Limitations / known issues

- Tesco Ireland's website does not expose historical prices; each run captures a snapshot (use scheduled runs to build a price history).
- `rating` and `reviewCount` are only present for products that have reviews.
- The `discount` field carries the promotion text exactly as Tesco publishes it.
- Category scraping requires a Bright Data Web Unlocker key; keyword search does not.
- A full-catalogue walk is a long run. The actor persists its progress and survives Apify server migrations: already-pushed products are never duplicated and completed categories are skipped on resume.
- Tesco Ireland currently has no third-party marketplace; if Tesco ever adds one, this actor's own-range guard will keep marketplace items out of the output.

# Actor input Schema

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

Search Tesco Ireland groceries by keyword (e.g., 'milk', 'bread', 'cheddar'). Search runs through Tesco's own search API — fast and no Bright Data key needed.

## `categoryUrl` (type: `string`):

A Tesco Ireland category to scrape. Full URL (https://www.tesco.ie/shop/en-IE/browse/bakery/bread) or a slug (bakery/bread).

## `startUrls` (type: `array`):

One or more Tesco Ireland category or search listing URLs to scrape.

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

Maximum number of products to return across all seeds. Set high (e.g., 30000) for a full-catalogue pull.

## `requestDelaySecs` (type: `integer`):

Minimum pause between category page fetches. Bright Data rate-limits rapid-fire requests to Tesco; a delay of 15-30s keeps a full-catalogue run under the limit (slower but reliable). 0 = full speed. Does not apply to keyword search.

## `enumerateOnly` (type: `boolean`):

Walk the category tree and report the authoritative catalogue size (summed leaf totals) without paginating or pushing products. Cheap completeness check.

## `brightDataApiKey` (type: `string`):

Bright Data API key for the Web Unlocker zone. Required for category and full-catalogue scraping — Tesco Ireland is behind Akamai Bot Manager. Keyword search works without it. Falls back to the BRIGHT\_DATA\_API\_KEY environment variable.

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

Proxy settings for the Tesco search API. Category page access goes through the Bright Data Web Unlocker instead.

## Actor input object example

```json
{
  "searchQuery": "milk",
  "maxProducts": 20,
  "requestDelaySecs": 0,
  "enumerateOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}
```

# 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 = {
    "searchQuery": "milk",
    "maxProducts": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/tesco-ie-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 = {
    "searchQuery": "milk",
    "maxProducts": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/tesco-ie-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 '{
  "searchQuery": "milk",
  "maxProducts": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}' |
apify call studio-amba/tesco-ie-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tesco Scraper — UK & Ireland Grocery Products & Prices",
        "description": "Scrape the full Tesco UK and Tesco Ireland groceries catalogue: product names, GBP/EUR prices, Clubcard offers, price per unit, EAN codes, images, ratings and categories. Search by keyword, walk the department tree or scrape one category. No login, no cookies.",
        "version": "0.1",
        "x-build-id": "fGWXMbJViZBGQpcQe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~tesco-ie-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-tesco-ie-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/studio-amba~tesco-ie-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-tesco-ie-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/studio-amba~tesco-ie-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-tesco-ie-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search Tesco Ireland groceries by keyword (e.g., 'milk', 'bread', 'cheddar'). Search runs through Tesco's own search API — fast and no Bright Data key needed."
                    },
                    "categoryUrl": {
                        "title": "Category URL or slug",
                        "type": "string",
                        "description": "A Tesco Ireland category to scrape. Full URL (https://www.tesco.ie/shop/en-IE/browse/bakery/bread) or a slug (bakery/bread)."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Tesco Ireland category or search listing URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to return across all seeds. Set high (e.g., 30000) for a full-catalogue pull."
                    },
                    "requestDelaySecs": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 0,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Minimum pause between category page fetches. Bright Data rate-limits rapid-fire requests to Tesco; a delay of 15-30s keeps a full-catalogue run under the limit (slower but reliable). 0 = full speed. Does not apply to keyword search.",
                        "default": 0
                    },
                    "enumerateOnly": {
                        "title": "Enumerate only (count, don't scrape)",
                        "type": "boolean",
                        "description": "Walk the category tree and report the authoritative catalogue size (summed leaf totals) without paginating or pushing products. Cheap completeness check.",
                        "default": false
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key",
                        "type": "string",
                        "description": "Bright Data API key for the Web Unlocker zone. Required for category and full-catalogue scraping — Tesco Ireland is behind Akamai Bot Manager. Keyword search works without it. Falls back to the BRIGHT_DATA_API_KEY environment variable."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the Tesco search API. Category page access goes through the Bright Data Web Unlocker instead."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
