# OLX Uzbekistan Classifieds Scraper (`automation-lab/olx-uzbekistan-classifieds-scraper`) Actor

🇺🇿 Scrape public OLX.uz classifieds listings with prices, locations, images, descriptions, categories, and vehicle attributes.

- **URL**: https://apify.com/automation-lab/olx-uzbekistan-classifieds-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## OLX Uzbekistan Classifieds Scraper

Extract public marketplace listings from OLX.uz for price monitoring, inventory research, lead discovery, and regional classifieds analysis.

### What does OLX Uzbekistan Classifieds Scraper do?

OLX Uzbekistan Classifieds Scraper collects structured data from public OLX.uz category, search, and listing pages.

It is designed for users who need repeatable exports instead of manually copying classifieds from the website.

The actor starts from one or more OLX.uz URLs, follows paginated category/search pages, optionally visits listing detail pages, and saves normalized records to an Apify dataset.

Typical extracted data includes title, price, currency, location, URL, listing ID, images, category breadcrumbs, description, SKU, vehicle attributes when available, and scrape timestamp.

### Who is it for?

- 🚗 Car dealers tracking vehicle supply and prices in Uzbekistan.
- 🏠 Marketplace analysts monitoring classifieds categories over time.
- 📈 Pricing teams building regional price intelligence dashboards.
- 🧾 Researchers collecting public offer data for market studies.
- 🔎 Lead generation teams finding publicly listed opportunities.
- 🛒 Ecommerce teams comparing secondary-market prices.

### Why use this scraper?

OLX.uz pages are useful but not optimized for bulk export.

This actor converts public listing pages into clean JSON, CSV, Excel, XML, RSS, or API-accessible datasets.

It uses an HTTP-first approach and parses server-rendered structured data where available, which keeps runs lightweight and cost efficient.

### Key features

- ✅ Scrapes OLX.uz category URLs.
- ✅ Scrapes OLX.uz search result URLs.
- ✅ Scrapes individual listing URLs.
- ✅ Follows pagination with a configurable page limit.
- ✅ Optional detail-page enrichment.
- ✅ Extracts prices as numbers when available.
- ✅ Extracts image arrays.
- ✅ Extracts category breadcrumbs.
- ✅ Extracts vehicle fields such as brand, production date, and color when exposed by OLX JSON-LD.
- ✅ Saves scrape timestamps for monitoring workflows.

### Data you can extract

| Field | Description |
| --- | --- |
| `inputUrl` | The start URL supplied in the input. |
| `sourceUrl` | The category/search/listing page where the item was discovered. |
| `listingUrl` | Canonical OLX listing URL. |
| `listingId` | ID parsed from the OLX URL when present. |
| `title` | Listing title. |
| `description` | Listing detail description when detail extraction is enabled. |
| `price` | Numeric price. |
| `currency` | Currency code such as `UZS`. |
| `location` | City, district, or area name. |
| `images` | Public image URLs. |
| `categoryName` | Category name from structured data or breadcrumbs. |
| `breadcrumbs` | Category path. |
| `sku` | OLX internal SKU when exposed. |
| `brand` | Vehicle/product brand when exposed. |
| `productionDate` | Vehicle production year/date when exposed. |
| `color` | Vehicle color when exposed. |
| `scrapedAt` | ISO timestamp for the scrape. |

### How much does it cost to scrape OLX Uzbekistan classifieds?

The actor uses pay-per-event pricing.

There is a small $0.005 start event per run and a tiered per-listing event for each saved listing.

Current per-listing prices are approximately: FREE $0.000115, BRONZE $0.0001, SILVER $0.000078, GOLD $0.00006, PLATINUM $0.00004, and DIAMOND $0.000028.

For small tests, keep `maxItems` low.

For monitoring jobs, increase `maxItems` and schedule the actor through Apify.

### How to use

1. Open the actor on Apify.
2. Paste one or more OLX.uz category, search, or listing URLs.
3. Set `maxItems` to the number of listings you want.
4. Keep `includeDetails` enabled if you need descriptions and additional attributes.
5. Run the actor.
6. Download the dataset in JSON, CSV, Excel, XML, RSS, or HTML.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.olx.uz/transport/legkovye-avtomobili/" }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxPagesPerStartUrl": 2
}
````

### Input fields

#### `startUrls`

OLX.uz category, search, or individual listing URLs.

Use category URLs for broad collection.

Use listing URLs for single-record enrichment.

#### `maxItems`

Maximum number of listings saved across all start URLs.

Use a low number for test runs.

Use a higher number for production monitoring.

#### `includeDetails`

When enabled, the actor visits each listing detail page.

This improves output with descriptions, SKU, category URL, full image list, and structured attributes where OLX exposes them.

#### `maxPagesPerStartUrl`

Maximum category/search pages visited for each start URL.

This protects your runs from accidental large crawls.

### Output example

```json
{
  "listingUrl": "https://www.olx.uz/d/obyavlenie/example-ID123.html",
  "listingId": "123",
  "title": "Example car listing",
  "price": 110000000,
  "currency": "UZS",
  "location": "Хива",
  "categoryName": "Легковые автомобили",
  "images": ["https://frankfurt.apollo.olxcdn.com/.../image"],
  "scrapedAt": "2026-05-28T00:00:00.000Z"
}
```

### Tips for best results

- Start with one category URL and `maxItems: 20`.
- Increase limits only after confirming the output matches your workflow.
- Use stable category URLs for scheduled monitoring.
- Disable detail extraction for faster, lower-cost broad scans.
- Enable detail extraction when descriptions or vehicle fields matter.
- Store datasets in Apify and connect them to dashboards or alerts.

### Common OLX Uzbekistan use cases

- Track used car prices by city.
- Monitor new inventory in a category.
- Compare asking prices by model year.
- Build a regional classifieds database.
- Watch specific searches daily.
- Identify public seller/listing opportunities.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for analyst review.
- Make or Zapier for no-code workflows.
- Webhooks for alerts when new listings appear.
- Apify API for automated ingestion.
- BI warehouses after dataset export.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/olx-uzbekistan-classifieds-scraper').call({
  startUrls: [{ url: 'https://www.olx.uz/transport/legkovye-avtomobili/' }],
  maxItems: 20,
  includeDetails: true,
  maxPagesPerStartUrl: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/olx-uzbekistan-classifieds-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.olx.uz/transport/legkovye-avtomobili/'}],
    'maxItems': 20,
    'includeDetails': True,
    'maxPagesPerStartUrl': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~olx-uzbekistan-classifieds-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.olx.uz/transport/legkovye-avtomobili/"}],"maxItems":20,"includeDetails":true,"maxPagesPerStartUrl":2}'
```

### MCP usage

You can use this actor through Apify MCP tools from Claude Code or Claude Desktop.

Use the MCP server URL with the actor tool filter:

```text
https://mcp.apify.com/?tools=automation-lab/olx-uzbekistan-classifieds-scraper
```

Example prompts:

- "Run the OLX Uzbekistan scraper for cars and summarize the most expensive listings."
- "Collect 50 OLX.uz apartment listings and group them by location."
- "Monitor this OLX.uz search URL and tell me when new listings appear."

### Scheduling

Apify schedules let you run the actor hourly, daily, weekly, or monthly.

For price monitoring, schedule the same category/search URL and compare datasets over time.

For alerts, combine schedules with webhooks or integrations.

### Data quality notes

OLX.uz may expose different structured fields by category.

Vehicle categories can include brand, production date, and color.

Other categories may expose fewer attributes.

The actor keeps optional fields nullable so one dataset can support multiple OLX categories.

### Legal and ethical use

This actor extracts publicly available information.

Use it responsibly and follow OLX.uz terms, privacy rules, and applicable laws.

Do not use scraped data for spam, harassment, or prohibited profiling.

Respect removal requests and avoid collecting more data than your use case requires.

### Troubleshooting

#### Why did I get fewer items than requested?

The category/search URL may have fewer public listings available, or the page limit may be too low.

Increase `maxPagesPerStartUrl` if the category has more pages.

#### Why are seller phone numbers missing?

Phone numbers are not always publicly exposed in server-rendered HTML.

The actor focuses on public listing data available without account actions.

#### Why are some attributes null?

OLX category pages expose different JSON-LD fields by category and listing type.

Null fields mean the source page did not expose that field for the listing.

### Related scrapers

Other automation-lab actors can complement this scraper:

- https://apify.com/automation-lab/olx-poland-scraper
- https://apify.com/automation-lab/olx-romania-scraper
- https://apify.com/automation-lab/olx-ukraine-scraper
- https://apify.com/automation-lab/olx-portugal-scraper
- https://apify.com/automation-lab/olx-bulgaria-scraper

### Reliability approach

The actor avoids a browser by default.

It parses JSON-LD structured data from OLX pages.

This helps keep memory low and reduces compute cost.

If OLX changes its page structure, the actor can be updated to parse the new public structured data source.

### Changelog

- Initial version: category/search/listing extraction for OLX Uzbekistan.

### Support

If a run does not return expected data, share the run URL and the OLX.uz URL you used.

Include whether detail extraction was enabled and how many items you requested.

# Actor input Schema

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

OLX.uz category, search results, or individual listing URLs. Category/search URLs are paginated automatically.

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

Maximum number of listings to save across all start URLs.

## `includeDetails` (type: `boolean`):

Fetch each listing detail page to enrich output with description, SKU, vehicle fields, category URL, and full image list.

## `maxPagesPerStartUrl` (type: `integer`):

Safety limit for paginated category/search pages. Keep low for quick tests; increase for larger crawls.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.olx.uz/transport/legkovye-avtomobili/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxPagesPerStartUrl": 2
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.olx.uz/transport/legkovye-avtomobili/"
        }
    ],
    "maxItems": 20,
    "includeDetails": true,
    "maxPagesPerStartUrl": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/olx-uzbekistan-classifieds-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 = {
    "startUrls": [{ "url": "https://www.olx.uz/transport/legkovye-avtomobili/" }],
    "maxItems": 20,
    "includeDetails": True,
    "maxPagesPerStartUrl": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/olx-uzbekistan-classifieds-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 '{
  "startUrls": [
    {
      "url": "https://www.olx.uz/transport/legkovye-avtomobili/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxPagesPerStartUrl": 2
}' |
apify call automation-lab/olx-uzbekistan-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Uzbekistan Classifieds Scraper",
        "description": "🇺🇿 Scrape public OLX.uz classifieds listings with prices, locations, images, descriptions, categories, and vehicle attributes.",
        "version": "0.1",
        "x-build-id": "AYkYW5PJnJLgFw77T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~olx-uzbekistan-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-olx-uzbekistan-classifieds-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/automation-lab~olx-uzbekistan-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-olx-uzbekistan-classifieds-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/automation-lab~olx-uzbekistan-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-olx-uzbekistan-classifieds-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "OLX.uz category, search results, or individual listing URLs. Category/search URLs are paginated automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to save across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Visit listing detail pages",
                        "type": "boolean",
                        "description": "Fetch each listing detail page to enrich output with description, SKU, vehicle fields, category URL, and full image list.",
                        "default": true
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Maximum pages per start URL",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety limit for paginated category/search pages. Keep low for quick tests; increase for larger crawls.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```