# Zoopla Search Scraper(Cheap) (`data_api/zoopla-search-scraper-cheap`) Actor

Collect UK property listings from any Zoopla search. Enter search URLs or location keywords, the actor scrapes prices, addresses, postcodes, bedrooms, bathrooms, agent details, GPS coordinates, and images. Run multiple searches per run with automatic pagination. For-sale and to-rent both supported.

- **URL**: https://apify.com/data\_api/zoopla-search-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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

## Zoopla Property Search Scraper

![Zoopla Property Search Scraper](cover.jpg)

Watching the UK property market on Zoopla usually means scrolling page after page and copying out the price, address, and agent for every listing by hand. This scraper does the copying for you. Paste a Zoopla search link or type a town name, and each listing comes back as a tidy row with the price, postcode, bedrooms, agent, and map coordinates already split into fields. It pages through the results on its own, it's cheap and code-free, and you only pay for the listings you pull.

### What you get

Every Zoopla listing comes back as one row, grouped into three kinds of data:

- **Property and location** — `listingRef`, `headline`, `fullAddress`, `postalCode`, `homeType`, `bedroomCount`, `bathroomCount`, `floorAreaSqft`, `mapLat`, `mapLng`, plus the `listingUrl`
- **Price and listing state** — `priceLabel`, `priceValue`, `currencyCode`, `dealType`, `statusFlag`, `isUnderOffer`, `isFeatured`, `listedDate`
- **Agent, media, and run info** — `agentLabel`, `contactPhone`, `summaryText`, `photoLinks`, `collectedAt`, `sourceQuery`

### Quick start

1. Open zoopla.co.uk, apply your filters (area, price, bedrooms, property type), and copy the link from the address bar.
2. Hit **Try for free** and paste that link into **Zoopla search links** — or type a town name into **Location keywords** instead.
3. Set a **Listings cap per input** to decide how many results you pull per search.
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Price tracking** — follow asking prices and rents across a city or postcode and catch reductions early
- **Investment research** — filter by price, bedrooms, and home type to score for-sale or rental stock against your criteria
- **Area comparison** — line up price, bedroom count, and home type across several towns in one run
- **Agent and lead research** — collect estate and letting agent names and phone numbers from live listings
- **Portfolio monitoring** — keep an eye on under-offer status, new listings, and price flags for homes you're watching
- **Market dashboards** — feed fresh Zoopla data into your own sheet, BI tool, or model

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `listingUrls` | array of strings | One of `listingUrls` or `searchTerms` | Full Zoopla search links copied from your browser; each is crawled on its own. Prefilled with a Bristol for-sale search. |
| `searchTerms` | array of strings | One of `listingUrls` or `searchTerms` | Plain location keywords like `Leeds` or `Cardiff`; each becomes its own Zoopla search using the category below. |
| `searchCategory` | string | No | For keyword searches, choose `for-sale` or `to-rent`. Ignored for pasted links. Default `for-sale`. |
| `resultsLimit` | integer | No | Top number of listings to gather per link or keyword. Default `50`. |
| `pageLimit` | integer | No | Top number of result pages to walk through per link or keyword. Default `5`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `45`. |

#### Example input

```json
{
    "listingUrls": [
        "https://www.zoopla.co.uk/for-sale/property/bristol/?q=Bristol"
    ],
    "searchTerms": ["Leeds", "Cardiff"],
    "searchCategory": "for-sale",
    "resultsLimit": 50,
    "pageLimit": 5,
    "timeoutSeconds": 45
}
````

### Output

Every listing on the search results becomes one row, paginated automatically up to your limit. Fields that Zoopla does not publish for a given property — floor area, a second bathroom, coordinates — come back as `null` rather than guessed.

#### Example output

```json
{
    "listingRef": "73070889",
    "listingUrl": "https://www.zoopla.co.uk/for-sale/details/73070889/",
    "headline": "3 bed semi-detached house for sale",
    "priceLabel": "£285,000",
    "priceValue": 285000,
    "currencyCode": "GBP",
    "fullAddress": "Maple Avenue, Bishopston, Bristol BS7",
    "postalCode": "BS7",
    "bedroomCount": 3,
    "bathroomCount": 1,
    "homeType": "semi-detached",
    "floorAreaSqft": null,
    "summaryText": "A well-presented three-bedroom semi-detached home in Bishopston, close to Gloucester Road shops and well-rated schools.",
    "photoLinks": [
        "https://lid.zoocdn.com/800/600/a1b2c3d4e5f6.jpg",
        "https://lid.zoocdn.com/800/600/b2c3d4e5f6a1.jpg"
    ],
    "agentLabel": "Greenfield & Co",
    "contactPhone": "0117 244 1234",
    "listedDate": "2026-06-24T10:22:00",
    "statusFlag": "Just added",
    "isUnderOffer": false,
    "isFeatured": false,
    "dealType": "for-sale",
    "mapLat": 51.480123,
    "mapLng": -2.587456,
    "collectedAt": "2026-06-30T09:14:22.841Z",
    "sourceQuery": "https://www.zoopla.co.uk/for-sale/property/bristol/?q=Bristol"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingRef` | string | Zoopla's own unique code for the listing |
| `listingUrl` | string | Link to the property's detail page on Zoopla |
| `headline` | string | Listing headline, e.g. "3 bed semi-detached house for sale" |
| `priceLabel` | string | Asking price or monthly rent with its currency symbol |
| `priceValue` | integer | The price as a bare whole number, ready for sorting |
| `currencyCode` | string | Three-letter currency code, usually GBP |
| `fullAddress` | string | Complete property address with area and postcode |
| `postalCode` | string | UK postcode pulled out of the address |
| `bedroomCount` | integer | Number of bedrooms |
| `bathroomCount` | integer | Number of bathrooms |
| `homeType` | string | Detached, semi-detached, terraced, flat, bungalow, and so on |
| `floorAreaSqft` | integer | Internal floor area in square feet when Zoopla publishes it |
| `summaryText` | string | Short marketing blurb from the listing |
| `photoLinks` | array | Full-size property photo URLs |
| `agentLabel` | string | Estate or letting agent name |
| `contactPhone` | string | Phone number listed for the agent |
| `listedDate` | string | ISO 8601 date the listing first appeared |
| `statusFlag` | string | Marketing flag such as "Just added" or "Reduced" |
| `isUnderOffer` | boolean | `true` when the property is currently under offer |
| `isFeatured` | boolean | `true` when the listing is a premium featured placement |
| `dealType` | string | `for-sale` or `to-rent` |
| `mapLat` | number | Latitude coordinate of the property |
| `mapLng` | number | Longitude coordinate of the property |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `sourceQuery` | string | The search link or keyword that surfaced this listing |

### Tips for best results

- **Filter on Zoopla first.** Set your area, price band, minimum bedrooms, and home type before copying the link — the scraper pulls exactly what that search shows, so a tighter search means a cleaner dataset.
- **Keywords are great for quick multi-town runs.** Type a few town names into `searchTerms` for broad coverage; for precise postcode or price-band control, a pasted link is more reliable.
- **`resultsLimit` and `pageLimit` work together.** Each page holds about 25 listings, so a `pageLimit` of 5 gives you up to roughly 125 results per search. The run stops at whichever cap it reaches first.
- **Run it on a schedule.** Re-running the same search over time builds a price history — `collectedAt` makes it easy to see what moved between runs.
- **Raise `timeoutSeconds`** if large result sets start tripping timeout errors.

### How can I use Zoopla property data?

**How can I use the Zoopla Property Search Scraper to track UK house prices?**
Paste a Zoopla search link for your target area and run it on a schedule. Each row carries `priceLabel`, `priceValue`, `fullAddress`, and `listedDate`, so you can chart asking prices over time and flag reductions the day they show up.

**How can I compare towns on Zoopla by bedrooms and price?**
Drop several town names into `searchTerms` and run them in one go. With `priceValue`, `bedroomCount`, `homeType`, and `postalCode` on every row, you get a clean side-by-side read on where the value sits across areas.

**How can I build a UK property dataset for investment research?**
Feed in one or more search links, set `resultsLimit` to the volume you need, and export to CSV or Excel. The result is a structured property database — address, price, bedrooms, agent, and coordinates — that you can score against your own buy-to-let or flip criteria.

**How do I pull estate agent contacts from Zoopla listings?**
Run a search for your market and each row returns `agentLabel` and `contactPhone` alongside the property, so you can build an agent lookup or contact list straight from live for-sale and to-rent listings.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more full Zoopla search URLs. Copy each URL from your browser after running a search on zoopla.co.uk. Each URL is scraped independently.

## `queries` (type: `array`):

Location or keyword queries (e.g. 'London', 'Manchester'). Each query is run as a separate Zoopla search using the listing type below.

## `queryListingType` (type: `string`):

Whether query-based searches target for-sale or to-rent listings. Has no effect on Search URLs (their listing type is detected from the URL).

## `maxListingsPerInput` (type: `integer`):

Maximum number of property listings to collect per URL or query. One page returns roughly 25 listings.

## `maxPagesPerInput` (type: `integer`):

Maximum number of search result pages to paginate through per URL or query. Each page contains up to 25 listings.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds. Pages normally return in a few seconds; this mainly caps the rare stuck request before it retries. 45 is a good default.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.zoopla.co.uk/for-sale/property/london/?q=London",
    "https://www.zoopla.co.uk/to-rent/property/manchester/?q=Manchester"
  ],
  "queries": [
    "London",
    "Manchester",
    "Birmingham"
  ],
  "queryListingType": "for-sale",
  "maxListingsPerInput": 25,
  "maxPagesPerInput": 1,
  "requestTimeoutSecs": 45
}
```

# 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 = {
    "searchUrls": [
        "https://www.zoopla.co.uk/for-sale/property/wales/newport/?q=Newport"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/zoopla-search-scraper-cheap").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 = { "searchUrls": ["https://www.zoopla.co.uk/for-sale/property/wales/newport/?q=Newport"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/zoopla-search-scraper-cheap").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 '{
  "searchUrls": [
    "https://www.zoopla.co.uk/for-sale/property/wales/newport/?q=Newport"
  ]
}' |
apify call data_api/zoopla-search-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoopla Search Scraper(Cheap)",
        "description": "Collect UK property listings from any Zoopla search. Enter search URLs or location keywords, the actor scrapes prices, addresses, postcodes, bedrooms, bathrooms, agent details, GPS coordinates, and images. Run multiple searches per run with automatic pagination. For-sale and to-rent both supported.",
        "version": "0.0",
        "x-build-id": "jGnJZjaYe7yqzSsLZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~zoopla-search-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-zoopla-search-scraper-cheap",
                "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/data_api~zoopla-search-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-zoopla-search-scraper-cheap",
                "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/data_api~zoopla-search-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-zoopla-search-scraper-cheap",
                "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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "One or more full Zoopla search URLs. Copy each URL from your browser after running a search on zoopla.co.uk. Each URL is scraped independently.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Location or keyword queries (e.g. 'London', 'Manchester'). Each query is run as a separate Zoopla search using the listing type below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queryListingType": {
                        "title": "Listing type for queries",
                        "enum": [
                            "for-sale",
                            "to-rent"
                        ],
                        "type": "string",
                        "description": "Whether query-based searches target for-sale or to-rent listings. Has no effect on Search URLs (their listing type is detected from the URL).",
                        "default": "for-sale"
                    },
                    "maxListingsPerInput": {
                        "title": "Max listings per URL / query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of property listings to collect per URL or query. One page returns roughly 25 listings.",
                        "default": 25
                    },
                    "maxPagesPerInput": {
                        "title": "Max pages per URL / query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search result pages to paginate through per URL or query. Each page contains up to 25 listings.",
                        "default": 1
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 20,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Pages normally return in a few seconds; this mainly caps the rare stuck request before it retries. 45 is a good default.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
