# OLX India Classifieds Scraper (`automation-lab/olx-india-classifieds-scraper`) Actor

Scrape OLX India listings with prices, locations, images, seller details, dates, descriptions, and URLs. Export classifieds to CSV or JSON.

- **URL**: https://apify.com/automation-lab/olx-india-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, NaN 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 India Classifieds Scraper

Collect public OLX India classifieds data for market research, price monitoring, local lead generation, and ecommerce intelligence.

### What does OLX India Classifieds Scraper do?

OLX India Classifieds Scraper extracts public listing data from https://www.olx.in.

It can start from search keywords, category URLs, search URLs, or direct listing URLs.

The actor saves structured records to an Apify dataset so you can export them as JSON, CSV, Excel, XML, RSS, or HTML.

Use it to monitor cars, bikes, electronics, furniture, rentals, jobs, services, and other OLX India marketplace categories.

### Who is it for?

#### 🚗 Vehicle and mobility teams

- Used car dealers tracking asking prices across Indian cities.
- Bike resellers comparing makes, kilometres, year, and locality.
- Fleet buyers watching second-hand vehicle supply before sourcing.

#### 📱 Ecommerce and resale operators

- Electronics resellers watching phone and laptop supply.
- Furniture and appliance buyers comparing local classifieds.
- Inventory teams checking whether OLX prices support resale margins.

#### 📊 Analysts, lead teams, and data teams

- Marketplace analysts studying regional supply and pricing.
- Local lead generation teams building prospect lists from public listings.
- Data teams needing repeatable OLX India exports for BI or models.

### Why use this scraper?

OLX pages are designed for browsing, not bulk analysis.

This actor turns public classifieds pages into clean rows.

You get titles, prices, locations, posting dates, images, descriptions, seller profile links, and listing URLs in one dataset.

### What OLX India data can I extract?

| Field | Description |
| --- | --- |
| listingId | OLX listing identifier when present in the URL |
| title | Classified title |
| priceText | Original price text |
| price | Parsed numeric price |
| currency | Currency code, usually INR |
| location | Locality and city shown on the listing card |
| postedDateText | Posted date shown by OLX |
| detailsText | Short category-specific details, such as year and kilometres |
| description | Public listing description from the detail page |
| imageUrls | Listing image URLs |
| sellerName | Public seller display name when available |
| sellerProfileUrl | Public OLX profile URL when available |
| memberSince | Seller membership text when available |
| category | Category when detected |
| url | Canonical listing URL |
| sourceUrl | Search or category page where the listing was found |
| scrapedAt | Extraction timestamp |

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

The actor uses pay-per-event pricing: one small start event plus one event for each saved listing.

The current default tier prices are:

| Event | What it means | Price |
| --- | --- | ---: |
| Run started | Charged once per run | $0.005 |
| Listing extracted - FREE tier | Each saved OLX India listing | $0.00010903 |
| Listing extracted - BRONZE tier | Each saved OLX India listing | $0.000094805 |
| Listing extracted - SILVER tier | Each saved OLX India listing | $0.000073948 |
| Listing extracted - GOLD tier | Each saved OLX India listing | $0.000056883 |
| Listing extracted - PLATINUM tier | Each saved OLX India listing | $0.000037922 |
| Listing extracted - DIAMOND tier | Each saved OLX India listing | $0.000026545 |

Example FREE-tier estimates before Apify platform discounts or monthly plan effects:

| Saved listings | Estimated actor charge |
| ---: | ---: |
| 20 listings | about $0.0072 |
| 100 listings | about $0.0159 |
| 1,000 listings | about $0.1140 |

Use a low `maxResults` value for quick tests.

Increase the limit when you are ready to collect larger market datasets.

### How to scrape OLX India listings

1. Open the actor on Apify.
2. Enter one or more OLX India search queries such as `car`, `bike`, or `iPhone`.
3. Optionally paste OLX India category, search, or listing URLs.
4. Set `maxResults`.
5. Keep `includeDetails` enabled if you need descriptions and seller data.
6. Click **Start**.
7. Export the dataset in your preferred format.

### Input configuration

#### searchQueries

List of keywords to search on OLX India.

Examples:

- `car`
- `bike`
- `sofa`
- `iphone`
- `laptop`

#### startUrls

Optional OLX India URLs.

You can paste:

- Search URLs.
- Category URLs.
- Direct listing URLs.

#### maxResults

Maximum number of listings saved across all sources.

The prefill is intentionally small for a cheap first run.

#### includeDetails

When enabled, the actor visits every listing page.

This adds description, seller profile, member-since text, image gallery, and structured detail fields when available.

Turn it off for faster card-only collection.

#### maxRequestRetries

Controls retry attempts for failed HTTP requests.

The default is usually enough.

### Output example

```json
{
  "listingId": "1843721446",
  "url": "https://www.olx.in/item/cars-c84-used-hyundai-creta-in-malik-pura-parli-iid-1843721446",
  "title": "Hyundai car diesel 2018",
  "priceText": "₹ 7,69,999",
  "price": 769999,
  "currency": "INR",
  "location": "Malik Pura, Parli",
  "postedDateText": "3 days ago",
  "detailsText": "2018 - 92,000 km",
  "sellerName": "Naushad Jamba set",
  "imageUrls": ["https://apollo.olx.in/v1/files/example/image"],
  "scrapedAt": "2026-05-21T08:42:46.449Z"
}
````

### Tips for better results

- Use precise keywords for niche products.
- Use category URLs when you already know the OLX section.
- Start with 20 listings to validate your workflow.
- Enable detail pages for richer records.
- Disable detail pages for faster price-only monitoring.
- Combine multiple queries in one run when comparing product segments.

### Integrations

Use the dataset with:

- Google Sheets dashboards.
- Airtable marketplace databases.
- CRM lead queues.
- Price-monitoring alerts.
- BI tools such as Looker Studio, Power BI, or Tableau.
- Internal inventory and sourcing workflows.

### API usage

You can run this actor from Apify API clients.

#### 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-india-classifieds-scraper').call({
  searchQueries: ['car'],
  maxResults: 20,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/olx-india-classifieds-scraper').call(run_input={
    'searchQueries': ['bike'],
    'maxResults': 20,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~olx-india-classifieds-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["iphone"],"maxResults":20,"includeDetails":true}'
```

### MCP usage

Connect Apify MCP to Claude Desktop or Claude Code with this tools URL:

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

Add it from Claude Code:

```bash
claude mcp add apify-olx-india --transport http "https://mcp.apify.com/?tools=automation-lab/olx-india-classifieds-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-olx-india": {
      "url": "https://mcp.apify.com/?tools=automation-lab/olx-india-classifieds-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 20 OLX India bike listings and summarize price ranges."
- "Collect OLX India iPhone listings and group them by city."
- "Find public OLX India sofa listings and export the dataset as CSV."

### Data quality notes

OLX listing availability changes quickly.

Some listings may be removed between search and detail extraction.

Phone numbers and private messaging are not collected because those flows are gated or user-specific.

### Limitations

This actor collects publicly visible data only.

It does not log in.

It does not reveal hidden phone numbers.

It does not contact sellers.

It does not bypass access controls.

### FAQ

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

The query or category may have fewer available public listings, or OLX may have removed duplicates from later pages.

Try a broader keyword or a category URL.

#### Why are some seller fields empty?

Seller fields are extracted from public detail pages when OLX displays them.

If OLX hides a value or the detail page is unavailable, the actor leaves that field empty.

#### Can this actor reveal phone numbers?

No. The actor only collects public page data and does not log in, reveal gated phone numbers, or contact sellers.

### Troubleshooting

If a run returns no data, test a broader keyword such as `car` or `bike`, then narrow your query once the workflow is confirmed.

### Legality

This actor is designed to extract publicly available OLX India listing information.

You are responsible for using the data lawfully and respecting applicable privacy, consumer protection, and marketplace terms.

Do not use the output for spam, harassment, or prohibited contact.

### Related scrapers

Other automation-lab actors may help with marketplace and ecommerce workflows:

- https://apify.com/automation-lab/olx-poland-classifieds-scraper
- https://apify.com/automation-lab/olx-portugal-classifieds-scraper
- https://apify.com/automation-lab/olx-romania-classifieds-scraper
- https://apify.com/automation-lab/mobile-de-scraper
- https://apify.com/automation-lab/facebook-marketplace-scraper

### Changelog

Initial version extracts OLX India search/category listing cards and optional detail-page data.

### Support

If a run fails, open the run page and share the run ID with support.

Include your input and the expected OLX India category or keyword.

### Performance

HTTP extraction keeps runs lightweight.

Detail-page extraction is slower because every listing URL is visited.

For large monitoring jobs, consider running without details first and enabling details only for shortlisted queries.

### Privacy

The actor stores only data shown publicly on OLX India pages during the run.

Review your downstream storage and retention policies before exporting large datasets.

### Version

Current actor version: `0.1`.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on OLX India, for example car, sofa, iPhone, or bike.

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

Optional OLX India search, category, or listing URLs. Direct listing URLs are also supported.

## `maxResults` (type: `integer`):

Maximum number of classified listings to save across all queries and URLs.

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

Visit each listing page to extract description, seller profile, breadcrumbs, attributes, and full image gallery.

## `maxRequestRetries` (type: `integer`):

Retry attempts for failed OLX India requests.

## Actor input object example

```json
{
  "searchQueries": [
    "car"
  ],
  "startUrls": [
    {
      "url": "https://www.olx.in/items/q-bike"
    }
  ],
  "maxResults": 20,
  "includeDetails": true,
  "maxRequestRetries": 3
}
```

# 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 = {
    "searchQueries": [
        "car"
    ],
    "startUrls": [
        {
            "url": "https://www.olx.in/items/q-bike"
        }
    ],
    "maxResults": 20,
    "includeDetails": true,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/olx-india-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 = {
    "searchQueries": ["car"],
    "startUrls": [{ "url": "https://www.olx.in/items/q-bike" }],
    "maxResults": 20,
    "includeDetails": True,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/olx-india-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 '{
  "searchQueries": [
    "car"
  ],
  "startUrls": [
    {
      "url": "https://www.olx.in/items/q-bike"
    }
  ],
  "maxResults": 20,
  "includeDetails": true,
  "maxRequestRetries": 3
}' |
apify call automation-lab/olx-india-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX India Classifieds Scraper",
        "description": "Scrape OLX India listings with prices, locations, images, seller details, dates, descriptions, and URLs. Export classifieds to CSV or JSON.",
        "version": "0.1",
        "x-build-id": "t0enoAtPw4x3EGaPU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~olx-india-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-olx-india-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-india-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-olx-india-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-india-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-olx-india-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",
                "properties": {
                    "searchQueries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "Keywords to search on OLX India, for example car, sofa, iPhone, or bike.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "OLX India URLs",
                        "type": "array",
                        "description": "Optional OLX India search, category, or listing URLs. Direct listing URLs are also supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of classified listings to save across all queries and URLs.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Visit listing detail pages",
                        "type": "boolean",
                        "description": "Visit each listing page to extract description, seller profile, breadcrumbs, attributes, and full image gallery.",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for failed OLX India requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```