# UK Land Registry Price Paid Scraper (`automation-lab/uk-land-registry-price-paid-scraper`) Actor

Extract official UK Land Registry sold house prices by postcode, town, street, date, price, property type, tenure, and new-build filters.

- **URL**: https://apify.com/automation-lab/uk-land-registry-price-paid-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## UK Land Registry Price Paid Scraper

Extract sold house prices from the public HM Land Registry Price Paid Data API.

Use this actor to collect UK property transaction records by postcode, town, street, price, date, property type, tenure, and new-build status. It returns clean dataset rows for valuation comps, market monitoring, lead research, and proptech analytics.

### What does UK Land Registry Price Paid Scraper do?

UK Land Registry Price Paid Scraper queries the official public Price Paid Data endpoint and normalizes each transaction into a flat Apify dataset row.

It can help you answer questions such as:

- 🏠 What homes sold near this postcode?
- 📍 What has sold on a specific street?
- 💷 Which transactions fall within a target price band?
- 📅 What sold after a specific date?
- 🧱 Which records are flats, terraced homes, detached homes, or new builds?

### Who is it for?

This actor is useful for teams that need repeatable UK sold-price data.

- 🏘️ Property investors comparing purchase opportunities
- 🏢 Estate and letting agencies researching local comparables
- 📊 Proptech analysts building valuation or market datasets
- 🧾 Mortgage, insurance, and risk teams checking historical sale prices
- 🧑‍💻 Developers adding UK property data to internal tools

### Why use this actor?

The raw Land Registry Linked Data API uses nested linked-data objects and verbose field names. This actor handles pagination and converts that response into practical fields for spreadsheets, databases, and workflows.

You get:

- Typed dataset rows
- Stable field names
- Price/date/type filters
- Source URLs for traceability
- PPE pricing so small runs stay cheap

### Data source

The actor uses the public HM Land Registry Price Paid Data service at `landregistry.data.gov.uk`.

No login, cookies, or API key are required for the source.

### Input options

You can search with any combination of:

- Postcodes
- Towns or cities
- Localities
- Streets
- Minimum and maximum price paid
- Sold date from / to
- Property types
- Tenure / estate types
- New-build flag
- Maximum transaction count

### Output data

Each dataset item is one Land Registry transaction.

| Field | Description |
| --- | --- |
| `transactionId` | Land Registry transaction identifier |
| `pricePaid` | Sale price in GBP |
| `transactionDateIso` | Sale date normalized to YYYY-MM-DD |
| `postcode` | UK postcode |
| `fullAddress` | Combined address string |
| `propertyType` | Detached, semi-detached, terraced, flat/maisonette, or other |
| `estateType` | Freehold or leasehold |
| `newBuild` | Whether the sale was a new build |
| `sourceUrl` | API URL used to retrieve the record |

### Example output

```json
{
  "transactionId": "D6906A1B-D6D4-4053-83FB-C72E883E9D4E",
  "pricePaid": 83000,
  "transactionDateIso": "1996-09-24",
  "postcode": "SW2 4XR",
  "fullAddress": "26, TENHAM AVENUE, LONDON, LAMBETH, GREATER LONDON, SW2 4XR",
  "propertyType": "flat-maisonette",
  "estateType": "Leasehold",
  "newBuild": false
}
````

### How much does it cost to scrape UK Land Registry sold prices?

The actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A per-transaction fee is charged only for records saved to the dataset.
- Larger plan tiers receive lower per-record prices.

Because the data source is a public HTTP API and no browser is needed, runs are designed to be low-cost.

### How to scrape UK sold prices by postcode

1. Open the actor on Apify.
2. Add one or more postcodes, for example `SW2 4XR`.
3. Set `maxItems` to the number of transactions you need.
4. Run the actor.
5. Export the dataset as CSV, JSON, Excel, or via API.

### How to scrape sold prices by town

1. Leave postcodes empty.
2. Add a town such as `LONDON`, `MANCHESTER`, or `BRISTOL`.
3. Optionally add property type, tenure, price, or date filters.
4. Run the actor and review the normalized transaction rows.

### Tips for best results

- Use postcodes or streets for focused comparable-property research.
- Use towns with a sensible `maxItems` limit for larger market samples.
- Add date and price filters when you only need recent or target-band transactions.
- Export CSV for spreadsheet analysis and JSON for automation.

### Integrations

Use the output in:

- Google Sheets property comp trackers
- Airtable or Notion lead lists
- Internal valuation dashboards
- BI tools such as Power BI or Looker Studio
- CRM workflows for homeowner or landlord research

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/uk-land-registry-price-paid-scraper').call({
  postcodes: ['SW2 4XR'],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/uk-land-registry-price-paid-scraper').call(run_input={
    'postcodes': ['SW2 4XR'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~uk-land-registry-price-paid-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"postcodes":["SW2 4XR"],"maxItems":100}'
```

### MCP usage

Connect the actor to Claude Desktop or Claude Code through Apify MCP.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/uk-land-registry-price-paid-scraper`

Claude Code setup:

```bash
claude mcp add apify-uk-land-registry https://mcp.apify.com/?tools=automation-lab/uk-land-registry-price-paid-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-uk-land-registry": {
      "url": "https://mcp.apify.com/?tools=automation-lab/uk-land-registry-price-paid-scraper"
    }
  }
}
```

Example prompts:

- "Find Land Registry sold-price comps for SW2 4XR."
- "Extract 200 London flat transactions and summarize price bands."
- "Build a CSV of sales on Tenham Avenue."

### Legality

This actor uses public government data from HM Land Registry. You are responsible for using exported data lawfully and complying with applicable privacy, database, and commercial-use rules.

### Troubleshooting: no results

Try a broader town search or check the exact spelling and capitalization used by Land Registry. Some postcodes may have no price-paid records.

### Troubleshooting: broad searches

Town-level searches can be very large. Set a practical `maxItems` value and use date, price, and property-type filters to keep exports focused.

### Related scrapers

Other automation-lab actors that may complement this workflow:

- https://apify.com/automation-lab/rightmove-scraper
- https://apify.com/automation-lab/zoopla-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### Field reference

`transactionUri` links back to the Land Registry transaction resource.

`sourceUrl` records the API page used for retrieval.

`scrapedAt` records when the actor saved the row.

`paon` and `saon` are Land Registry address fields for primary and secondary addressable objects.

### Performance

The actor uses HTTP requests and conservative pagination. It does not launch a browser.

### Data quality

The actor preserves official source values where possible and adds normalized helper fields such as `transactionDateIso` and `fullAddress`.

### Changelog

Initial version: public API extraction, pagination, filters, normalized dataset schema, and PPE charge events.

### Support

If you need a filter or output field that is not included, open an Apify issue with an example postcode, town, or street and the expected workflow.

### FAQ

#### Can I search the whole UK?

The default actor is designed for focused searches. Use town, postcode, locality, or street filters plus `maxItems`.

#### Does this include current listings?

No. It extracts historical sold-price transactions from HM Land Registry Price Paid Data.

#### Does it need proxies?

No. The source is a public government API and the actor runs without proxy configuration.

#### Can I export to Excel?

Yes. Apify datasets can be exported as CSV, Excel-compatible formats, JSON, XML, RSS, or accessed via API.

# Actor input Schema

## `postcodes` (type: `array`):

Exact UK postcodes to search, for example SW2 4XR. Leave empty to search by town/locality/street.

## `towns` (type: `array`):

Town or city names as used by Land Registry, for example LONDON, MANCHESTER, BRISTOL.

## `localities` (type: `array`):

Optional locality filters such as LONDON or CLAPHAM.

## `streets` (type: `array`):

Optional exact street names such as TENHAM AVENUE. Best used with a low maxItems value.

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

Maximum matching sold-price records to save.

## `pageSize` (type: `integer`):

Records requested from the public Land Registry API per page.

## `dateFrom` (type: `string`):

Keep transactions on or after this date (YYYY-MM-DD). Applied after API retrieval.

## `dateTo` (type: `string`):

Keep transactions on or before this date (YYYY-MM-DD). Applied after API retrieval.

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

Keep records with price paid greater than or equal to this amount in GBP.

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

Keep records with price paid less than or equal to this amount in GBP.

## `propertyTypes` (type: `array`):

Filter by Land Registry property type.

## `estateTypes` (type: `array`):

Filter by freehold or leasehold tenure.

## `newBuild` (type: `boolean`):

Set true for new-build transactions only, false for resale only, or leave empty for both.

## Actor input object example

```json
{
  "postcodes": [
    "SW2 4XR"
  ],
  "towns": [
    "LONDON"
  ],
  "maxItems": 20,
  "pageSize": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "postcodes": [
        "SW2 4XR"
    ],
    "towns": [
        "LONDON"
    ],
    "maxItems": 20,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/uk-land-registry-price-paid-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 = {
    "postcodes": ["SW2 4XR"],
    "towns": ["LONDON"],
    "maxItems": 20,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/uk-land-registry-price-paid-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 '{
  "postcodes": [
    "SW2 4XR"
  ],
  "towns": [
    "LONDON"
  ],
  "maxItems": 20,
  "pageSize": 100
}' |
apify call automation-lab/uk-land-registry-price-paid-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Land Registry Price Paid Scraper",
        "description": "Extract official UK Land Registry sold house prices by postcode, town, street, date, price, property type, tenure, and new-build filters.",
        "version": "0.1",
        "x-build-id": "uecMgH8I16p6QBMLs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~uk-land-registry-price-paid-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-uk-land-registry-price-paid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~uk-land-registry-price-paid-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-uk-land-registry-price-paid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~uk-land-registry-price-paid-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-uk-land-registry-price-paid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "postcodes": {
                        "title": "Postcodes",
                        "type": "array",
                        "description": "Exact UK postcodes to search, for example SW2 4XR. Leave empty to search by town/locality/street.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "towns": {
                        "title": "Towns / cities",
                        "type": "array",
                        "description": "Town or city names as used by Land Registry, for example LONDON, MANCHESTER, BRISTOL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "localities": {
                        "title": "Localities",
                        "type": "array",
                        "description": "Optional locality filters such as LONDON or CLAPHAM.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "streets": {
                        "title": "Streets",
                        "type": "array",
                        "description": "Optional exact street names such as TENHAM AVENUE. Best used with a low maxItems value.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum transactions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum matching sold-price records to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Records requested from the public Land Registry API per page.",
                        "default": 100
                    },
                    "dateFrom": {
                        "title": "Sold from date",
                        "type": "string",
                        "description": "Keep transactions on or after this date (YYYY-MM-DD). Applied after API retrieval."
                    },
                    "dateTo": {
                        "title": "Sold to date",
                        "type": "string",
                        "description": "Keep transactions on or before this date (YYYY-MM-DD). Applied after API retrieval."
                    },
                    "minPrice": {
                        "title": "Minimum price paid",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep records with price paid greater than or equal to this amount in GBP."
                    },
                    "maxPrice": {
                        "title": "Maximum price paid",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep records with price paid less than or equal to this amount in GBP."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Filter by Land Registry property type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "detached",
                                "semi-detached",
                                "terraced",
                                "flat-maisonette",
                                "other"
                            ],
                            "enumTitles": [
                                "Detached",
                                "Semi-detached",
                                "Terraced",
                                "Flat / maisonette",
                                "Other"
                            ]
                        }
                    },
                    "estateTypes": {
                        "title": "Tenure / estate types",
                        "type": "array",
                        "description": "Filter by freehold or leasehold tenure.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "freehold",
                                "leasehold"
                            ],
                            "enumTitles": [
                                "Freehold",
                                "Leasehold"
                            ]
                        }
                    },
                    "newBuild": {
                        "title": "New build only?",
                        "type": "boolean",
                        "description": "Set true for new-build transactions only, false for resale only, or leave empty for both."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```