# Jitty UK AI Property Scraper (`abotapi/jitty-uk-scraper`) Actor

Scrape residential property listings from jitty.com, extract properties across the UK with 20+ filters, including AI vision search.

- **URL**: https://apify.com/abotapi/jitty-uk-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Real estate, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Jitty UK Property Scraper

Scrape residential property listings from [jitty.com](https://jitty.com), a UK property search platform with AI-powered features, price-per-sqft analysis, and detailed property insights. Sale listings only. Extract properties across the UK with 20+ filters including AI vision search.

### Features

- **UK-wide coverage** - search any location (London, Manchester, Bath, etc.)
- **20+ filters** - property type, price, bedrooms, ownership, condition, style, area, date added, AI vision tags, and more
- **AI vision search** - find properties by visual features (cottage, sea views, warehouse conversion, etc.)
- **Rich data** - coordinates, area, tenure, EPC, council tax, agent, features, nearby stations from detail pages
- **~23 listings per page** with automatic pagination

### Quick Start

#### Properties for sale in London
```json
{
  "mode": "search",
  "location": "london",
  "max_pages": 5
}
````

#### Flats under 500k in Greenwich

```json
{
  "mode": "search",
  "location": "greenwich",
  "property_type": "flat",
  "max_price": 500000
}
```

#### Period properties with fireplaces

```json
{
  "mode": "search",
  "location": "bath",
  "exterior_style": "period",
  "interior_features": ["fireplace"]
}
```

#### AI vision search - cottages with sea views

```json
{
  "mode": "search",
  "look_for": "sea_views",
  "property_type": "detached",
  "max_properties": 50
}
```

#### New listings in the last 24 hours

```json
{
  "mode": "search",
  "location": "london",
  "date_added": "24h",
  "max_pages": 3
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `search` | `search` (build URL from filters) or `url` (use provided URLs) |
| `urls` | array | - | URLs to scrape (url mode only) |
| `location` | string | - | Location (e.g. "london", "bath", "greenwich", "manchester") |
| `look_for` | string | - | AI vision search (e.g. "cottage", "sea\_views", "warehouse\_conversion") |
| `property_type` | string | - | `flat`, `detached`, `semi-detached`, `terraced`, `bungalow`, `maisonette`, `land`, `boat`, `mobile-home`, `parking` |
| `bedrooms` | integer | - | Minimum bedrooms (0=Studio+) |
| `min_price` | integer | - | Minimum price in GBP |
| `max_price` | integer | - | Maximum price in GBP |
| `ownership` | string | - | `freehold`, `leasehold`, `shared-ownership`, `share-of-freehold` |
| `condition` | string | - | `good`, `renovation-potential`, `renovation-needed`, `derelict` |
| `exterior_style` | string | - | `period`, `contemporary`, `early-modern`, `late-modern` |
| `date_added` | string | - | `24h`, `3d`, `1w`, `1m` |
| `min_area_sqft` | integer | - | Minimum floor area in sqft |
| `max_area_sqft` | integer | - | Maximum floor area in sqft |
| `outside_space` | string | - | `garden`, `large-garden`, `balcony`, `roof-terrace`, `communal-garden`, `patio` |
| `interior_features` | array | - | `fireplace`, `exposed-brickwork`, `high-ceilings`, `sash-windows`, `wooden-beams`, `vaulted-ceilings`, `open-plan-kitchen`, `kitchen-island`, `breakfast-bar` |
| `green_tech` | string | - | `solar-panels`, `ev-charger`, `heat-pump`, `underfloor-heating` |
| `max_properties` | integer | `10` | Max properties to scrape (0=unlimited) |
| `max_pages` | integer | `5` | Max search result pages (~23 listings/page) |
| `proxy` | object | Apify residential GB | Proxy configuration |

### Output Fields

| Field | Description |
|-------|-------------|
| `id` | Property slug/ID |
| `title` | Property street and area |
| `address` | Full address from detail page |
| `price` | Formatted price (e.g. "£2,000,000") |
| `price_numeric` | Price as integer |
| `currency` | Always "GBP" |
| `bedrooms` | Number of bedrooms |
| `bathrooms` | Number of bathrooms |
| `property_type` | Flat, Terraced, Detached, etc. |
| `property_type_detail` | More specific type (e.g. "End of Terrace") |
| `price_per_sqft` | Price per square foot |
| `area_sqft` | Floor area in square feet |
| `ownership` | Freehold, Leasehold, etc. |
| `living_spaces` | Number of living spaces |
| `council_tax_band` | Council tax band (A-H) |
| `epc_current_score` | Current EPC score |
| `epc_current_rating` | Current EPC rating (A-G) |
| `epc_potential_score` | Potential EPC score |
| `epc_potential_rating` | Potential EPC rating (A-G) |
| `lease_years_remaining` | Lease years remaining (leasehold only) |
| `estate_agent` | Estate agent name |
| `latitude` | Property latitude |
| `longitude` | Property longitude |
| `tags` | AI feature tags from search card |
| `features` | Complete feature list from detail page |
| `nearby_stations` | Transport stations with distances |
| `images` | Property image URLs (up to 10) |
| `image_count` | Total images available |
| `url` | Full property URL |

# Actor input Schema

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

Scraping mode: 'search' builds URL from filters, 'url' uses provided URLs directly

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

URLs to scrape (url mode only). Provide jitty.com search URLs.

## `location` (type: `string`):

Location to search (e.g. 'london', 'bath', 'greenwich', 'manchester'). Leave empty for all UK.

## `look_for` (type: `string`):

Search by visual features (e.g. 'cottage', 'sea\_views', 'warehouse\_conversion', 'barn\_conversion', 'character\_property'). Can be combined with location and other filters.

## `property_type` (type: `string`):

Filter by property type

## `bedrooms` (type: `integer`):

Minimum number of bedrooms (0=Studio+)

## `min_price` (type: `integer`):

Minimum price in British Pounds (use with max\_price for range)

## `max_price` (type: `integer`):

Maximum price in British Pounds

## `ownership` (type: `string`):

Filter by ownership type

## `condition` (type: `string`):

Filter by property condition

## `exterior_style` (type: `string`):

Filter by exterior style

## `date_added` (type: `string`):

Filter by when listing was added

## `min_area_sqft` (type: `integer`):

Minimum floor area in square feet

## `max_area_sqft` (type: `integer`):

Maximum floor area in square feet

## `outside_space` (type: `string`):

Filter by outdoor area type

## `interior_features` (type: `array`):

Filter by interior features. Multiple features are combined.

## `green_tech` (type: `string`):

Filter by green technology

## `max_properties` (type: `integer`):

Maximum number of properties to scrape (0=unlimited)

## `max_pages` (type: `integer`):

Maximum number of search result pages (~23 listings per page)

## `proxy` (type: `object`):

Proxy configuration. GB residential proxy recommended.

## `dataset_name` (type: `string`):

Custom dataset name (leave empty for default)

## `clear_dataset` (type: `boolean`):

Clear the dataset before scraping

## Actor input object example

```json
{
  "mode": "search",
  "location": "london",
  "max_properties": 10,
  "max_pages": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  },
  "clear_dataset": false
}
```

# Actor output Schema

## `listings` (type: `string`):

Individual property listing records with price, features, coordinates, and detail page data.

## `metadata` (type: `string`):

Scraping run metadata including timing, counts, and configuration.

# 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 = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/jitty-uk-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 = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    } }

# Run the Actor and wait for it to finish
run = client.actor("abotapi/jitty-uk-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 '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call abotapi/jitty-uk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jitty UK AI Property Scraper",
        "description": "Scrape residential property listings from jitty.com, extract properties across the UK with 20+ filters, including AI vision search.",
        "version": "0.1",
        "x-build-id": "OnuuDFrYgChalWQCy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~jitty-uk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-jitty-uk-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/abotapi~jitty-uk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-jitty-uk-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/abotapi~jitty-uk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-jitty-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Scraping mode: 'search' builds URL from filters, 'url' uses provided URLs directly",
                        "default": "search"
                    },
                    "urls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "URLs to scrape (url mode only). Provide jitty.com search URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search (e.g. 'london', 'bath', 'greenwich', 'manchester'). Leave empty for all UK.",
                        "default": "london"
                    },
                    "look_for": {
                        "title": "AI Search",
                        "type": "string",
                        "description": "Search by visual features (e.g. 'cottage', 'sea_views', 'warehouse_conversion', 'barn_conversion', 'character_property'). Can be combined with location and other filters."
                    },
                    "property_type": {
                        "title": "Property Type",
                        "enum": [
                            "flat",
                            "detached",
                            "semi-detached",
                            "terraced",
                            "bungalow",
                            "maisonette",
                            "land",
                            "boat",
                            "mobile-home",
                            "parking"
                        ],
                        "type": "string",
                        "description": "Filter by property type"
                    },
                    "bedrooms": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum number of bedrooms (0=Studio+)"
                    },
                    "min_price": {
                        "title": "Min Price (GBP)",
                        "type": "integer",
                        "description": "Minimum price in British Pounds (use with max_price for range)"
                    },
                    "max_price": {
                        "title": "Max Price (GBP)",
                        "type": "integer",
                        "description": "Maximum price in British Pounds"
                    },
                    "ownership": {
                        "title": "Ownership",
                        "enum": [
                            "freehold",
                            "leasehold",
                            "shared-ownership",
                            "share-of-freehold"
                        ],
                        "type": "string",
                        "description": "Filter by ownership type"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "good",
                            "renovation-potential",
                            "renovation-needed",
                            "derelict"
                        ],
                        "type": "string",
                        "description": "Filter by property condition"
                    },
                    "exterior_style": {
                        "title": "Exterior Style",
                        "enum": [
                            "period",
                            "contemporary",
                            "early-modern",
                            "late-modern"
                        ],
                        "type": "string",
                        "description": "Filter by exterior style"
                    },
                    "date_added": {
                        "title": "Date Added",
                        "enum": [
                            "24h",
                            "3d",
                            "1w",
                            "1m"
                        ],
                        "type": "string",
                        "description": "Filter by when listing was added"
                    },
                    "min_area_sqft": {
                        "title": "Min Area (sqft)",
                        "type": "integer",
                        "description": "Minimum floor area in square feet"
                    },
                    "max_area_sqft": {
                        "title": "Max Area (sqft)",
                        "type": "integer",
                        "description": "Maximum floor area in square feet"
                    },
                    "outside_space": {
                        "title": "Outside Space",
                        "enum": [
                            "garden",
                            "large-garden",
                            "balcony",
                            "roof-terrace",
                            "communal-garden",
                            "patio"
                        ],
                        "type": "string",
                        "description": "Filter by outdoor area type"
                    },
                    "interior_features": {
                        "title": "Interior Features",
                        "type": "array",
                        "description": "Filter by interior features. Multiple features are combined.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fireplace",
                                "exposed-brickwork",
                                "high-ceilings",
                                "sash-windows",
                                "wooden-beams",
                                "vaulted-ceilings",
                                "open-plan-kitchen",
                                "kitchen-island",
                                "breakfast-bar"
                            ]
                        }
                    },
                    "green_tech": {
                        "title": "Green Tech",
                        "enum": [
                            "solar-panels",
                            "ev-charger",
                            "heat-pump",
                            "underfloor-heating"
                        ],
                        "type": "string",
                        "description": "Filter by green technology"
                    },
                    "max_properties": {
                        "title": "Max Properties",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to scrape (0=unlimited)",
                        "default": 10
                    },
                    "max_pages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of search result pages (~23 listings per page)",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration. GB residential proxy recommended."
                    },
                    "dataset_name": {
                        "title": "Dataset Name",
                        "type": "string",
                        "description": "Custom dataset name (leave empty for default)"
                    },
                    "clear_dataset": {
                        "title": "Clear Dataset",
                        "type": "boolean",
                        "description": "Clear the dataset before scraping",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
