# Zoopla UK Property Listings Scraper (`parseforge/zoopla-scraper`) Actor

Extract UK property listings from Zoopla — prices, bedrooms, bathrooms, square footage, property type, tenure, agent info, images, and full descriptions. Free preview caps at 10 listings. Perfect for estate agents, property researchers, and data analysts.

- **URL**: https://apify.com/parseforge/zoopla-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Marketing, Real estate
- **Stats:** 14 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/main/banner.jpg?raw=true)

## 🏡 Zoopla Property Scraper

> 🚀 **Export UK property listings from Zoopla with prices, bedrooms, agent data, and full descriptions in seconds.**

> 🕒 **Last updated:** 2026-05-22 · **📊 15 fields** per record · **1,000,000 listings** · **England, Scotland, Wales**

The Zoopla Property Scraper extracts real-time property data from Zoopla - the UK's second-largest property portal. Search by city, area, or postcode for properties for sale or to rent. Every record includes price, bedrooms, bathrooms, property type, estate agent, full address, and description.

Zoopla lists over 1 million properties from thousands of UK estate agents. This scraper delivers the full dataset - no sign-up required.

**Coverage:** England, Scotland, Wales · Properties for sale and to rent · 28 listings per page · Pagination supported

| Who uses this | What they do |
|---|---|
| Property investors | Monitor prices and yields across UK cities |
| Estate agents | Benchmark competitor listings and pricing |
| Researchers | Track housing market trends and affordability |
| Relocation services | Build tailored property shortlists for clients |
| PropTech developers | Power search and recommendation engines |

### 📋 What the Zoopla Scraper does

- Searches Zoopla by any UK city, area, or postcode
- Filters by listing type (sale or rent), price range, and minimum bedrooms
- Extracts 16 data fields per listing including agent name and property type
- Paginates automatically to collect up to 1,000,000 results
- Returns structured JSON, CSV, Excel, and XML via the Apify dataset

> 💡 **Why it matters:** Zoopla's search UI shows 25-28 listings per page with no bulk export. This actor turns that into a structured, downloadable dataset in seconds.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `searchLocation` | string | City, area, or postcode (e.g. London, Manchester, SW1A) | London |
| `maxItems` | integer | Maximum records to collect (1-1,000,000) | 10 |
| `listingType` | select | For Sale or To Rent | sale |
| `minPrice` | integer | Minimum price in GBP | - |
| `maxPrice` | integer | Maximum price in GBP | - |
| `minBedrooms` | integer | Minimum number of bedrooms | - |

**Example - London flats for sale under £500k:**

```json
{
  "searchLocation": "London",
  "listingType": "sale",
  "maxPrice": 500000,
  "minBedrooms": 2,
  "maxItems": 100
}
````

**Example - Manchester rentals:**

```json
{
  "searchLocation": "Manchester",
  "listingType": "rent",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 items per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 results.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | First property photo URL |
| 📝 `title` | string | Property title (e.g. "3 bed flat for sale") |
| 🔗 `url` | string | Full Zoopla listing URL |
| 🆔 `propertyId` | string | Zoopla listing ID |
| 💷 `price` | integer | Price in GBP as integer |
| 💷 `priceDisplay` | string | Formatted price (e.g. "£450,000" or "£1,500 pcm") |
| 🏷️ `listingType` | string | "sale" or "rent" |
| 🛏️ `bedrooms` | integer | Number of bedrooms |
| 🚿 `bathrooms` | integer | Number of bathrooms |
| 🏠 `propertyType` | string | Flat, House, Apartment, etc. |
| 📍 `address` | string | Full property address |
| 📮 `postcode` | string | UK postcode extracted from address |
| 🏢 `agent` | string | Estate agent name and branch |
| 📄 `description` | string | First 300 characters of listing description |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was collected |
| ❌ `error` | string | Error message if scraping failed |

**Sample record:**

```json
{
  "imageUrl": "https://lid.zoocdn.com/645/430/f77a90f27a3d09eda75109c17c1e40801fdfba54.jpg",
  "title": "2 bed mews for sale",
  "url": "https://www.zoopla.co.uk/for-sale/details/73260646/",
  "propertyId": "73260646",
  "price": 1600000,
  "priceDisplay": "£1,600,000",
  "listingType": "sale",
  "bedrooms": 2,
  "bathrooms": 2,
  "propertyType": "House",
  "address": "Stratford Road, Kensington, London W8",
  "postcode": "W8",
  "agent": "Savills - Kensington",
  "description": "A charming two bedroom Studio house with oodles of character, wonderful proportions, two en suite bedrooms, a roof terrace and great access to ...",
  "scrapedAt": "2026-05-22T02:40:04.663Z"
}
```

### ✨ Why choose this Actor

- 🎯 **Real-time data** - no caching, always current listings
- 🗺️ **Nationwide coverage** - any UK city, area, or postcode
- 📊 **16 structured fields** - ready for analysis or import
- 🚀 **Fast** - processes 28 listings per page in seconds
- 🔄 **Pagination** - automatically collects all pages up to your limit
- 💼 **Pay-per-event pricing** - only pay for what you collect

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---|---|---|---|
| Bulk export | ✅ Up to 1M records | ❌ No | Varies |
| Real-time data | ✅ Always fresh | ✅ Yes | Varies |
| Price filters | ✅ Yes | ✅ Yes | Varies |
| Agent data | ✅ Yes | ✅ Yes | Rarely |
| Postcode extraction | ✅ Automatic | ❌ Manual | Rarely |
| Structured output | ✅ JSON/CSV/Excel | ❌ No | Varies |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 free credit
2. Open the **Zoopla Property Scraper** on Apify Store
3. Enter your `searchLocation` (e.g. "London", "Birmingham", "SW1A")
4. Set filters: listing type, price range, bedrooms
5. Set `maxItems` and click **Start**
6. Download results as CSV, Excel, JSON, or XML from the dataset

### 💼 Business use cases

#### Property Investment Analysis

Download hundreds of listings in a target postcode, filter by yield potential, and identify underpriced properties before they sell.

#### Estate Agent Benchmarking

Extract competitor listings in your area. Compare average days on market, pricing trends, and agent activity by branch.

#### Rental Market Tracking

Monitor rental prices across London boroughs or UK cities over time. Build dashboards showing rent-per-bedroom by area.

#### Property Data for PropTech

Power your application with live Zoopla data. Build recommendation engines, price estimators, or interactive search tools.

### 🔌 Automating Zoopla Scraper

Connect this Actor to your workflows with no code:

- **Make (Integromat)** - schedule daily runs and push results to Google Sheets
- **Zapier** - trigger exports when new listings appear in your search
- **Slack** - get notified with a summary of new listings each morning
- **Airtable** - sync property data to your investment tracking base
- **Google Sheets** - export via Apify's built-in Google Sheets integration

### 🌟 Beyond business use cases

#### Academic Research

Study UK housing affordability, gentrification patterns, or regional inequality using real listing data.

#### Creative Projects

Visualise the UK property market with maps, charts, or interactive data art.

#### Non-Profit Housing Work

Help housing charities understand supply and demand in high-need areas.

#### Personal Property Search

Automate your own property hunt - get all listings matching your exact criteria delivered to a spreadsheet.

### 🤖 Ask an AI assistant about this scraper

Have questions about integrating this data with your project? Ask an AI assistant: "How can I use UK property listing data to analyse investment opportunities?" or "What patterns can I find in Zoopla rental prices over time?"

### ❓ Frequently Asked Questions

**❓ Does this require a Zoopla account?**
No - all data is publicly accessible. No login required.

**❓ How many listings does Zoopla have?**
Zoopla lists over 1 million properties from thousands of UK estate agents at any time.

**❓ Can I filter by property type (flat, house)?**
The scraper returns the property type field for each listing. Filter the output dataset by `propertyType`.

**❓ Does it support all UK locations?**
Yes - any city, area, or postcode that Zoopla supports will work. Try "London", "Edinburgh", "Cardiff", "BN1", etc.

**❓ What's the maximum number of items I can collect?**
Paid users can collect up to 1,000,000 items. Free users are limited to 10 per run.

**❓ How fresh is the data?**
All data is scraped in real-time from Zoopla - never cached. Each run reflects the current live listings.

**❓ Can I get rental and sale listings in one run?**
Run the actor twice - once with `listingType: sale` and once with `listingType: rent`.

**❓ What format is the output?**
JSON by default, with one-click export to CSV, Excel, and XML from the Apify dataset view.

**❓ Can I schedule regular runs?**
Yes - Apify lets you schedule runs on a cron schedule (daily, weekly, etc.) for free.

**❓ Is agent phone data available?**
Agent phone numbers are loaded dynamically and require JavaScript execution on each listing page. This field is currently null - contact us if you need phone data.

**❓ Does this work for new-build properties?**
Yes - new homes listed on Zoopla are included in results.

**❓ What happens if Zoopla changes its website?**
ParseForge monitors all actors and updates them when source websites change. Check the Last Updated date above.

### 🔌 Integrate with any app

Google Sheets, Airtable, Notion, Make, Zapier, Slack, Microsoft Excel, Power BI, Tableau, Snowflake, BigQuery, PostgreSQL, MongoDB, REST API, Webhooks, and more - all available via Apify's integration platform.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Rightmove Scraper](https://apify.com/parseforge) | UK's largest property portal - similar data, wider coverage |
| [OnTheMarket Scraper](https://apify.com/parseforge) | Third-largest UK property portal |
| [Spareroom Scraper](https://apify.com/parseforge) | UK's leading rooms-to-rent platform |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering property, finance, travel, and more.

***

*This actor is an independent tool and is not affiliated with, endorsed by, or associated with Zoopla Limited. Property data is publicly accessible on zoopla.co.uk. Use responsibly and in accordance with Zoopla's terms of service.*

# Actor input Schema

## `searchLocation` (type: `string`):

City, area, or postcode to search (e.g. London, Manchester, SW1A 1AA)

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `listingType` (type: `string`):

Whether to search for properties for sale or to rent

## `minPrice` (type: `integer`):

Minimum price in GBP

## `maxPrice` (type: `integer`):

Maximum price in GBP

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms

## Actor input object example

```json
{
  "searchLocation": "London",
  "maxItems": 10,
  "listingType": "sale"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchLocation": "London",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/zoopla-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 = {
    "searchLocation": "London",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/zoopla-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 '{
  "searchLocation": "London",
  "maxItems": 10
}' |
apify call parseforge/zoopla-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoopla UK Property Listings Scraper",
        "description": "Extract UK property listings from Zoopla — prices, bedrooms, bathrooms, square footage, property type, tenure, agent info, images, and full descriptions. Free preview caps at 10 listings. Perfect for estate agents, property researchers, and data analysts.",
        "version": "0.1",
        "x-build-id": "RGXiMpxrzQzoMJ5b8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~zoopla-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-zoopla-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/parseforge~zoopla-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-zoopla-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/parseforge~zoopla-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-zoopla-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": [
                    "searchLocation"
                ],
                "properties": {
                    "searchLocation": {
                        "title": "Search Location",
                        "type": "string",
                        "description": "City, area, or postcode to search (e.g. London, Manchester, SW1A 1AA)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Whether to search for properties for sale or to rent",
                        "default": "sale"
                    },
                    "minPrice": {
                        "title": "Min Price (GBP)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in GBP"
                    },
                    "maxPrice": {
                        "title": "Max Price (GBP)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in GBP"
                    },
                    "minBedrooms": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```