# Lazada Product Data Scraper (`aa5734814/lazada-product-scraper`) Actor

Scrape product data from Lazada across 6 SEA countries (SG/MY/TH/PH/ID/VN). Extracts prices, ratings, sales, seller, brand, LazMall. No browser needed, fast, anti-bot bypass included.

- **URL**: https://apify.com/aa5734814/lazada-product-scraper.md
- **Developed by:** [Lucas Lai](https://apify.com/aa5734814) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 40.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Lazada Product Data Scraper

Scrape product data from **Lazada** across 6 Southeast Asian countries. Uses Lazada's internal API directly with browser TLS fingerprint impersonation — no headless browser needed, lower cost, higher speed.

### Key Features

- **6 Country Sites**: Singapore, Malaysia, Thailand, Philippines, Indonesia, Vietnam
- **Keyword Search**: Search any product keyword with pagination (up to 20 pages, ~40 products/page)
- **URL Mode**: Paste any Lazada search or category URL directly
- **Cross-Country Price Comparison**: Compare prices across all 6 countries in one run
- **Advanced Filters**: Sort by relevance/price/rating/newest/best selling, filter by min/max price, min rating
- **Structured JSON Output**: Price, rating, sales, seller, brand, location, LazMall status
- **Anti-Bot Bypass**: Chrome TLS fingerprint impersonation + x5sec challenge auto-solving
- **Lightweight**: No browser needed — direct HTTP API calls, fast and cheap

### How It Works

This Actor calls Lazada's AJAX catalog API with a browser-emulated TLS handshake and automatic cookie session management. When Lazada's WAF (x5sec) serves a challenge page, the Actor automatically extracts and follows the punish redirect to obtain a valid session cookie before retrying.

- **Faster**: ~3-5 seconds per page vs 30+ seconds with browser automation
- **Cheaper**: Lower compute usage = lower cost per run
- **More Reliable**: Data comes as clean JSON, no HTML parsing fragility

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `mode` | string | yes | `keyword` | Search mode: `keyword` (search by product name) or `url` (paste Lazada URLs) |
| `keywords` | string[] | in keyword mode | — | Product keywords to search (e.g. "smartphone", "xiaomi 14") |
| `urls` | string[] | in url mode | — | Lazada search/category URLs (e.g. `https://www.lazada.sg/catalog/?q=laptop`) |
| `country` | string | | `my` | Country site: `sg`, `my`, `th`, `ph`, `id`, `vn` |
| `searchAllCountries` | boolean | | `false` | Search this keyword across ALL 6 countries in one run |
| `maxPages` | integer | | `1` | Pages to scrape per country (~40 products/page, max: 20) |
| `sortBy` | string | | `relevance` | Sort order: `relevance`, `priceAsc`, `priceDesc`, `ratingDesc`, `newest`, `soldDesc` |
| `minPrice` | number | | — | Minimum price in local currency (optional) |
| `maxPrice` | number | | — | Maximum price in local currency (optional) |
| `minRating` | number | | — | Minimum rating 1.0-5.0 (optional) |
| `comparePrices` | boolean | | `false` | Generate a price comparison report (requires `searchAllCountries: true`) |
| `proxyConfiguration` | proxy | | RESIDENTIAL | Proxy settings. **Recommended**: enable Apify RESIDENTIAL proxy (Lazada WAF blocks most cloud IPs). |

### Output

#### Product Item

Each product is saved as a dataset item:

```json
{
  "type": "product",
  "keyword": "smartphone",
  "country": "MY",
  "currency": "MYR",
  "title": "Apple iPhone 17 Pro Max 1TB",
  "url": "https://www.lazada.com.my/products/pdp-i1234567890.html",
  "imageUrl": "https://my-live-01.slatic.net/p/...",
  "price": 6453.00,
  "originalPrice": 6699.00,
  "rating": 4.97,
  "reviewCount": "483",
  "sales": 1500,
  "location": "Selangor",
  "sellerName": "UR bySwitch",
  "sellerId": "12345678",
  "brandName": "Apple",
  "isLazMall": true
}
````

#### Price Comparison Report

When `comparePrices` is enabled, an additional price comparison item is pushed:

```json
{
  "type": "price_comparison",
  "keyword": "iphone 16",
  "totalProducts": 320,
  "countries": ["SG", "MY", "TH", "PH", "ID", "VN"],
  "cheapestCountry": "MY",
  "cheapestProduct": {
    "title": "Apple iPhone 16 128GB",
    "price": 1199,
    "country": "MY",
    "url": "https://www.lazada.com.my/products/...",
    "sellerName": "Official Store"
  },
  "summary": {
    "SG": { "count": 55, "minPrice": 1299, "maxPrice": 2899, "avgPrice": 1899 },
    "MY": { "count": 48, "minPrice": 1199, "maxPrice": 2799, "avgPrice": 1799 }
  },
  "priceRange": { "min": 1199, "max": 2899 }
}
```

> **Preview the output format**: Check the dataset tab on the [actor page](https://apify.com/aa5734814/lazada-product-scraper) after a run.

### Cost Estimation

This Actor uses **Pay Per Result** pricing. Below are estimated costs for typical runs:

| Scenario | Pages | Est. Products | Est. Compute Units |
|----------|-------|---------------|-------------------|
| Single keyword, 1 country, 1 page | 1 | ~40 | ~0.05 CU |
| Single keyword, 1 country, 5 pages | 5 | ~200 | ~0.25 CU |
| Single keyword, all 6 countries, 1 page | 6 | ~240 | ~0.30 CU |
| 3 keywords, all 6 countries, 3 pages | 54 | ~2,160 | ~2.70 CU |

> Actual consumption depends on response times, WAF challenge frequency, and proxy usage. These estimates assume RESIDENTIAL proxy with ~5s per page. Proxy usage incurs additional charges (see [Apify proxy pricing](https://apify.com/pricing)).

### Quick Start

#### Apify CLI

```bash
npm -g install apify-cli

apify call AA5734814~lazada-product-scraper \
  --input '{"mode":"keyword","keywords":["smartphone"],"country":"my","maxPages":1}'
```

#### API (Python)

```python
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/AA5734814~lazada-product-scraper/runs",
    headers={"Authorization": "Bearer YOUR_API_TOKEN"},
    json={
        "mode": "keyword",
        "keywords": ["smartphone"],
        "country": "my",
        "maxPages": 1
    }
)
```

#### API (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/AA5734814~lazada-product-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"keyword","keywords":["smartphone"],"country":"sg","maxPages":1}'
```

> **Actor ID**: `AA5734814~lazada-product-scraper`

### Use Cases

- **Competitor price monitoring** — Track pricing changes across Lazada
- **Market research** — Analyze product trends in SEA markets
- **Cross-border price arbitrage** — Find cheapest country for any product
- **Brand protection** — Monitor authorized vs unauthorized sellers
- **Inventory tracking** — Check stock status and seller locations

### Notes

- **Lazada WAF**: Lazada uses x5sec WAF that blocks most datacenter IPs. If runs return 0 results, ensure RESIDENTIAL proxy is enabled in the input settings.
- **Proxy costs**: RESIDENTIAL proxy usage is billed separately by Apify based on data transferred. See [proxy pricing](https://apify.com/pricing) for details.
- **Rate limiting**: The actor uses Lazada's AJAX API (`/catalog/?ajax=true`). Excessive page counts may trigger rate limits.

### Countries Supported

| Code | Country | Domain |
|------|---------|--------|
| `sg` | Singapore | Lazada.sg |
| `my` | Malaysia | Lazada.my |
| `th` | Thailand | Lazada.co.th |
| `ph` | Philippines | Lazada.ph |
| `id` | Indonesia | Lazada.co.id |
| `vn` | Vietnam | Lazada.vn |

### License

MIT

# Actor input Schema

## `mode` (type: `string`):

Search by keyword or directly by Lazada URL

## `keywords` (type: `array`):

Product keywords to search (one per line). Required in keyword mode.

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

Lazada search/category URLs (one per line). Required in URL mode.

## `country` (type: `string`):

Country site to search (ignored when Search All Countries is enabled)

## `searchAllCountries` (type: `boolean`):

Search this keyword across ALL 6 countries (overrides Country setting)

## `maxPages` (type: `integer`):

Number of search result pages to scrape per country (~40 products per page)

## `sortBy` (type: `string`):

Sort order for search results

## `minPrice` (type: `number`):

Minimum price in local currency (optional)

## `maxPrice` (type: `number`):

Maximum price in local currency (optional)

## `minRating` (type: `number`):

Minimum rating (1.0 - 5.0, optional)

## `comparePrices` (type: `boolean`):

Generate a price comparison report when searching multiple countries

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

Proxy settings. RECOMMENDED: enable Apify RESIDENTIAL proxy — Lazada WAF blocks most cloud IPs.

## Actor input object example

```json
{
  "mode": "keyword",
  "keywords": [
    "smartphone"
  ],
  "urls": [
    "https://www.lazada.sg/catalog/?q=laptop"
  ],
  "country": "my",
  "searchAllCountries": false,
  "maxPages": 1,
  "sortBy": "relevance",
  "comparePrices": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

JSON array of scraped products. Download as JSON, CSV, or XLSX from the dataset.

# 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 = {
    "keywords": [
        "smartphone"
    ],
    "urls": [
        "https://www.lazada.sg/catalog/?q=laptop"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("aa5734814/lazada-product-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["smartphone"],
    "urls": ["https://www.lazada.sg/catalog/?q=laptop"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("aa5734814/lazada-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "smartphone"
  ],
  "urls": [
    "https://www.lazada.sg/catalog/?q=laptop"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call aa5734814/lazada-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lazada Product Data Scraper",
        "description": "Scrape product data from Lazada across 6 SEA countries (SG/MY/TH/PH/ID/VN). Extracts prices, ratings, sales, seller, brand, LazMall. No browser needed, fast, anti-bot bypass included.",
        "version": "1.0",
        "x-build-id": "aDDetEsziwQ5QXgYX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aa5734814~lazada-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aa5734814-lazada-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/aa5734814~lazada-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-aa5734814-lazada-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/aa5734814~lazada-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-aa5734814-lazada-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "keyword",
                            "url"
                        ],
                        "type": "string",
                        "description": "Search by keyword or directly by Lazada URL",
                        "default": "keyword"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Product keywords to search (one per line). Required in keyword mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Lazada search/category URLs (one per line). Required in URL mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "sg",
                            "my",
                            "th",
                            "ph",
                            "id",
                            "vn"
                        ],
                        "type": "string",
                        "description": "Country site to search (ignored when Search All Countries is enabled)",
                        "default": "my"
                    },
                    "searchAllCountries": {
                        "title": "Search All Countries",
                        "type": "boolean",
                        "description": "Search this keyword across ALL 6 countries (overrides Country setting)",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Max Pages per Country",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of search result pages to scrape per country (~40 products per page)",
                        "default": 1
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "ratingDesc",
                            "newest",
                            "soldDesc"
                        ],
                        "type": "string",
                        "description": "Sort order for search results",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min Price",
                        "type": "number",
                        "description": "Minimum price in local currency (optional)"
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "type": "number",
                        "description": "Maximum price in local currency (optional)"
                    },
                    "minRating": {
                        "title": "Min Rating",
                        "type": "number",
                        "description": "Minimum rating (1.0 - 5.0, optional)"
                    },
                    "comparePrices": {
                        "title": "Compare Prices Across Countries",
                        "type": "boolean",
                        "description": "Generate a price comparison report when searching multiple countries",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. RECOMMENDED: enable Apify RESIDENTIAL proxy — Lazada WAF blocks most cloud IPs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
