# Coles Australia Scraper: Products, Prices, Specials & Stock (`getascraper/coles-scraper`) Actor

Scrape product data, live prices, discounts, weekly specials, and stock levels from Coles Australia (coles.com.au). Supports keyword search, category walks, regional store-based pricing, and SKU lookups.

- **URL**: https://apify.com/getascraper/coles-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 product records

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

Get Coles Australia grocery products, live prices, weekly specials, and stock levels exported to your spreadsheet in minutes.

Point this scraper at any Coles search term, category page, or product SKU. It returns clean pricing, was/now markdown discounts, unit price comparisons, stock availability, store aisle locations, and full product details. No login required.

### What does this actor do?

Coles is one of Australia's two largest supermarket chains, with more than 800 stores. This scraper pulls structured product data from Coles Australia (coles.com.au) so you can track prices, specials, and availability at scale.

You can scrape three ways: by keyword search, by pasting category or weekly specials URLs, or by feeding a list of product SKUs. Pin a specific store to get the exact prices and stock shown to shoppers in that location. Results download as JSON, CSV, Excel, or XML.

### Who uses this?

- **I am a pricing analyst at a competing grocery brand.** I track Coles prices on my product range every morning so I can match or beat their specials before the weekly catalogue refreshes.
- **I am a category manager at an FMCG supplier.** I audit how many of my SKUs Coles stocks, what shelf price they set, and which lines are running half-price promotions.
- **I am a data journalist covering cost of living.** I build a weekly grocery basket dataset to measure food inflation across staple items like milk, bread, and eggs.
- **I am an online reseller.** I monitor Coles markdowns and out-of-stock items to spot arbitrage and restocking opportunities.
- **I am a market researcher.** I need state-specific pricing across multiple Coles stores to compare regional price differences for a client report.

### How to use

1. Create a free account at [apify.com](https://apify.com) if you do not have one.
2. Open this actor and click **Try for free**.
3. Choose a scraping mode: keyword search, category URLs, or a direct SKU list.
4. Enter your search term, paste Coles URLs, or add the SKUs you want.
5. Set the Coles store ID for the region whose prices you want.
6. Click **Save & Run**, then download results from the **Output** tab.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `scrapeMode` | enum | Yes | How to find products: `searchKeyword`, `providedUrls`, or `skuList`. |
| `searchQuery` | string | No | Search term, product name, or barcode. Used in keyword search mode. |
| `startUrls` | array of URLs | No | Coles search, category, or weekly specials URLs. Used in category mode. |
| `skuList` | array | No | Specific Coles product SKU IDs to scrape. Used in SKU list mode. |
| `storeId` | string | No | Coles store ID for state-specific pricing and stock. Default is 0584 (Broadway NSW). |
| `includeDescription` | boolean | No | Include the full product description text. Default: true. |
| `maxItems` | integer | No | Maximum number of products to scrape per run. Default: 100. |
| `maxRequestsPerCrawl` | integer | No | Maximum pages to load per run. Set to 0 for no limit. |
| `proxyConfiguration` | proxy | No | Proxy settings. Australian proxies are required and on by default. |

### Data table

| Field | Type | Description |
|---|---|---|
| `product_id` | string | Unique Coles product SKU. |
| `name` | string | Product name as listed on Coles. |
| `brand` | string | Brand name of the product. |
| `description` | string | Full product description text. |
| `size` | string | Pack size or volume, for example "2L" or "1 Each". |
| `availability` | boolean | Whether the product is currently in stock. |
| `availability_type` | string | Stock channel, for example "InStoreAndOnline". |
| `price` | number | Current retail price. |
| `original_price` | number | Pre-discount "was" price when the item is on special. |
| `currency` | string | Currency code, always AUD. |
| `comparable` | string | Unit price comparison, for example "$2.00 per 1L". |
| `image_url` | string | Full-resolution product image URL. |
| `category` | string | Top-level Coles category for the product. |
| `url` | string | Direct link to the Coles product page. |
| `scraped_at` | string | Timestamp when the record was extracted. |
| `aisle` | string | In-store aisle location, when available. |
| `aisle_side` | string | Side of the aisle where the product sits. |
| `retail_limit` | integer | Maximum units a shopper can buy. |
| `promotional_limit` | integer | Purchase limit that applies during a promotion. |
| `online_special` | boolean | Whether the item is an online-only special. |
| `sub_category` | string | More specific category below the top level. |
| `class_name` | string | Coles product classification label. |

You can download the dataset in JSON, HTML, CSV, or Excel from the Output tab of any run.

### Sample output

```json
{
    "product_id": "4845732",
    "name": "Celery Bunch",
    "brand": "Coles",
    "description": "Coles Celery Bunch | 1 Each",
    "size": "1 Each",
    "availability": true,
    "availability_type": "InStoreAndOnline",
    "price": 4.0,
    "original_price": 4.5,
    "currency": "AUD",
    "comparable": "$4.00 per 1ea",
    "image_url": "https://product-images.coles.com.au/4/4845732.jpg",
    "category": "Fresh produce",
    "url": "https://www.coles.com.au/product/4845732",
    "scraped_at": "2026-06-29T14:20:51.517Z",
    "aisle": "Fresh Produce",
    "aisle_side": null,
    "retail_limit": 12,
    "promotional_limit": null,
    "online_special": false,
    "sub_category": "Vegetables",
    "class_name": "Salad & Stir Fry"
}
````

### Pricing

Pricing is pay per result. You are charged only for products successfully written to your dataset. Empty runs and blocked requests cost nothing. There are no monthly subscriptions or minimum commitments.

### Tips

- **Track weekly specials.** Paste a specials URL like the half-price page as a start URL to capture every markdown in one run.
- **Compare regions.** Run the same search across different store IDs to measure how Coles prices vary by state.
- **Build a price history.** Schedule a daily run on the same products to create a time-series dataset for inflation or repricing work.
- **Start small.** Set a low `maxItems` for your first run to confirm the output matches what you need before scaling up.

### FAQ

##### Which Coles pages can I scrape?

You can scrape keyword search results, category and browse pages, weekly specials pages, and individual product SKUs. Pick the mode that matches your input.

##### How do I get prices for a specific state?

Set the `storeId` field to the Coles store you want. Coles serves region-specific prices and stock, so the store ID controls which prices appear in your results.

##### How fresh is the data?

Every run fetches live data directly from Coles. Results reflect the prices, specials, and stock shown on the site at the moment the run executes.

##### Is scraping Coles legal?

This actor reads publicly available product pages, the same pages any shopper can open without logging in. You are responsible for complying with Coles' terms of service and applicable laws. For questions or custom fields, contact the author at <devanshtiwari365@gmail.com>.

# Actor input Schema

## `scrapeMode` (type: `string`):

Choose whether to search by keyword, browse category URLs, or input a custom SKU list.

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

The search keyword, product name, or barcode/EAN to query (e.g., 'milk', '9300601385150'). Only used in Keyword Search mode.

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

Paste Coles search, category, or weekly Specials URLs (e.g., 'https://www.coles.com.au/specials/half-price') to scrape directly.

## `skuList` (type: `array`):

Input specific Coles product SKU IDs to scrape their specifications directly. Only used in Direct SKU List mode.

## `storeId` (type: `string`):

Target Coles Store ID for state-specific pricing and stock (e.g. 0584 for Broadway NSW, 0451 for Melbourne VIC).

## `includeDescription` (type: `boolean`):

Extract full text product descriptions for each item when found.

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

Maximum number of product listings to extract. Runs stop synchronously when this cap is reached.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of page requests/paginations that can be made by this crawler (0 = unlimited).

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

Australian residential proxies are required to bypass Imperva and regional IP blocks.

## Actor input object example

```json
{
  "scrapeMode": "searchKeyword",
  "searchQuery": "milk",
  "startUrls": [
    {
      "url": "https://www.coles.com.au/browse/fruit-vegetables/vegetables"
    }
  ],
  "skuList": [
    "5900530",
    "4845732"
  ],
  "storeId": "0584",
  "includeDescription": true,
  "maxItems": 100,
  "maxRequestsPerCrawl": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "scrapeMode": "searchKeyword",
    "searchQuery": "milk",
    "startUrls": [
        {
            "url": "https://www.coles.com.au/browse/fruit-vegetables/vegetables"
        }
    ],
    "skuList": [
        "5900530",
        "4845732"
    ],
    "storeId": "0584",
    "includeDescription": true,
    "maxItems": 100,
    "maxRequestsPerCrawl": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "AU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/coles-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 = {
    "scrapeMode": "searchKeyword",
    "searchQuery": "milk",
    "startUrls": [{ "url": "https://www.coles.com.au/browse/fruit-vegetables/vegetables" }],
    "skuList": [
        "5900530",
        "4845732",
    ],
    "storeId": "0584",
    "includeDescription": True,
    "maxItems": 100,
    "maxRequestsPerCrawl": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "AU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/coles-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 '{
  "scrapeMode": "searchKeyword",
  "searchQuery": "milk",
  "startUrls": [
    {
      "url": "https://www.coles.com.au/browse/fruit-vegetables/vegetables"
    }
  ],
  "skuList": [
    "5900530",
    "4845732"
  ],
  "storeId": "0584",
  "includeDescription": true,
  "maxItems": 100,
  "maxRequestsPerCrawl": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  }
}' |
apify call getascraper/coles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coles Australia Scraper: Products, Prices, Specials & Stock",
        "description": "Scrape product data, live prices, discounts, weekly specials, and stock levels from Coles Australia (coles.com.au). Supports keyword search, category walks, regional store-based pricing, and SKU lookups.",
        "version": "0.1",
        "x-build-id": "JYrxfuuTAJs0IQ4ak"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~coles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-coles-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/getascraper~coles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-coles-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/getascraper~coles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-coles-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": [
                    "scrapeMode"
                ],
                "properties": {
                    "scrapeMode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "searchKeyword",
                            "providedUrls",
                            "skuList"
                        ],
                        "type": "string",
                        "description": "Choose whether to search by keyword, browse category URLs, or input a custom SKU list.",
                        "default": "searchKeyword"
                    },
                    "searchQuery": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "The search keyword, product name, or barcode/EAN to query (e.g., 'milk', '9300601385150'). Only used in Keyword Search mode.",
                        "default": "milk"
                    },
                    "startUrls": {
                        "title": "Category / Browse URLs",
                        "type": "array",
                        "description": "Paste Coles search, category, or weekly Specials URLs (e.g., 'https://www.coles.com.au/specials/half-price') to scrape directly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "skuList": {
                        "title": "Direct SKU List",
                        "type": "array",
                        "description": "Input specific Coles product SKU IDs to scrape their specifications directly. Only used in Direct SKU List mode."
                    },
                    "storeId": {
                        "title": "Coles Store ID",
                        "type": "string",
                        "description": "Target Coles Store ID for state-specific pricing and stock (e.g. 0584 for Broadway NSW, 0451 for Melbourne VIC).",
                        "default": "0584"
                    },
                    "includeDescription": {
                        "title": "Include Product Description",
                        "type": "boolean",
                        "description": "Extract full text product descriptions for each item when found.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max Items to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of product listings to extract. Runs stop synchronously when this cap is reached.",
                        "default": 100
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max Requests limit",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of page requests/paginations that can be made by this crawler (0 = unlimited).",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Australian residential proxies are required to bypass Imperva and regional IP blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "AU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
