# UK Sold House Prices - Land Registry Price Paid Data (`devon_gtme/land-registry-price-paid`) Actor

Sold house prices for England & Wales from HM Land Registry Price Paid Data. Search by postcode, outcode or town; filter by date, price, type and new-build. Every transaction plus a comps summary (median, mean, min/max) per area. For agents, investors, analysts and valuations. No API key needed.

- **URL**: https://apify.com/devon\_gtme/land-registry-price-paid.md
- **Developed by:** [Devon Kellar](https://apify.com/devon_gtme) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Sold House Prices - Land Registry Price Paid Data by Postcode

Every residential property sale in **England & Wales**, straight from **HM Land Registry's official Price Paid Data** - the ground truth of what actually sold, where, and for how much. Search by postcode, postcode district ("outcode", e.g. `M21`), or town, and get clean transaction records **plus a ready-made comps summary for each area**.

### Built for comps

- **Estate agents pricing a listing** - pull every sale on the street (or in the outcode) for the last 12 months, sorted newest first, with the median right at the top of the summary
- **Property investors running the rule over an area** - price band + property-type filters give you exactly the comparable stock; the per-area summary (median, mean, min/max, counts by type) is the back-of-envelope done for you
- **Journalists & analysts** - area market reports from the official record, not portal asking prices
- **Valuation / AVM models** - ground-truth sold prices with full addresses, tenure and new-build flags, ready for your pipeline

### What you get

**One record per transaction:**

| Field | Example |
|---|---|
| `pricePaid` | 285000 |
| `transactionDate` | 2026-04-17 |
| `paon` / `saon` | 12 / Flat 3 |
| `street`, `locality`, `town`, `district`, `county` | HIGH STREET, ..., BOLTON, ... |
| `postcode` | BL1 4QR |
| `propertyType` | Detached / Semi-detached / Terraced / Flat / Other |
| `newBuild` | true / false |
| `estateType` | Freehold / Leasehold |
| `transactionCategory` | Standard price paid / Additional price paid |
| `recordUrl` | Link to the official Land Registry record |

**Plus one `summary` record per area** - the comps product:

| Field | Example |
|---|---|
| `area` | M21 |
| `transactionCount` | 214 |
| `medianPrice` / `meanPrice` | 365000 / 391240 |
| `minPrice` / `maxPrice` | 152000 / 1250000 |
| `byPropertyType` | { "Terraced": 98, "Semi-detached": 71, ... } |
| `latestTransaction` | Newest sale date found - your data-freshness check |

Filter the dataset by `recordType` (`transaction` / `summary`), or use the built-in **Transactions** and **Summaries** dataset views.

### Typical usage

- **Street/postcode comps:** put full postcodes in `postcodes`, keep `daysBack` at 365
- **Area report:** use an outcode (`M21`, `SW11`) - one line fetches the whole district
- **Investor screen:** town + `minPrice`/`maxPrice` + `propertyTypes` (e.g. terraced only)
- **New-build premium check:** run twice, with `newBuildOnly` on and off, compare medians

**Note on filters:** date and price filters run on the Land Registry server; property-type and new-build filters are applied during processing (the official API can't filter these server-side reliably). Heavily filtered town-wide queries therefore scan more records and take a little longer - narrow the date range or use outcodes to speed them up. The Land Registry back-end also rate-limits and has occasional wobbles; the actor paces itself and retries automatically, so large runs are steady rather than fast.

### ⚠️ Know your data: registration lag

Price Paid Data records **completions**, and Land Registry registers them **~4-8 weeks after completion** (some take longer and are backfilled later). The newest sales you see will typically be 1-2 months old - an empty most-recent-month means "not registered yet", not "nothing sold". Check the summary's `latestTransaction` field to see how fresh the data actually is. Monthly updates land around the 20th working day of each month.

### Coverage

**England and Wales only.** Scotland has its own register (Registers of Scotland) and Northern Ireland has Land & Property Services - neither is included in Price Paid Data. Excluded from PPD by Land Registry: sales that were never lodged for registration, court-ordered transfers, and some non-market transactions ("Additional price paid" category B covers repossessions, buy-to-let portfolios and transfers to non-private individuals - it's flagged in `transactionCategory` so you can exclude it from comps).

Data goes back to **1 January 1995**.

### Export & integrations

Results land in an Apify dataset - export **CSV, Excel, JSON**, or connect Google Sheets, Make, Zapier, Slack, and webhooks via Apify integrations. [Schedule](https://docs.apify.com/platform/schedules) monthly runs to keep an area file up to date.

### Data source & licence

Data produced by HM Land Registry © Crown copyright and database right 2026. Licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/). Source: [HM Land Registry Price Paid Data](https://landregistry.data.gov.uk/) via the official open-data API. This actor is not affiliated with HM Land Registry. Address data is for personal/non-commercial use per the PPD address-data terms; the price/date/type data is fully open.

---

**Need something more custom?** Sold prices joined to EPC energy ratings, planning applications, or current listings; repeat-sale detection; street-level price indexes; or a fully managed comps pipeline - message me via my Apify profile and I'll build it.

# Actor input Schema

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

Full postcodes (e.g. 'BL1 4QR') or outcodes (e.g. 'M1', 'SW11') — one summary is produced per entry. Outcodes fetch every sale in the postcode district. Leave empty to search by town instead.
## `town` (type: `string`):

Town or city name as it appears in addresses (e.g. 'Bolton', 'York'). Used only when Postcodes is empty. Note: big cities can have tens of thousands of sales per year — set Max Results and filters accordingly.
## `daysBack` (type: `integer`):

Fetch sales completed in the last N days. Ignored if explicit dates are set below. Note: Land Registry data lags completion by ~4-8 weeks, so very recent sales won't appear yet.
## `dateFrom` (type: `string`):

Explicit start completion date. Overrides Days Back when set. Data goes back to 1995.
## `dateTo` (type: `string`):

Explicit end completion date. Defaults to today.
## `minPrice` (type: `integer`):

Only include sales at or above this price.
## `maxPrice` (type: `integer`):

Only include sales at or below this price.
## `propertyTypes` (type: `array`):

Limit to specific property types. Leave empty for all.
## `newBuildOnly` (type: `boolean`):

Only include sales of newly built properties.
## `maxResults` (type: `integer`):

Maximum transactions to return across all areas (summaries are always produced).

## Actor input object example

```json
{
  "postcodes": [
    "BL1 4QR",
    "M21"
  ],
  "daysBack": 365,
  "newBuildOnly": false,
  "maxResults": 2000
}
````

# 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": [
        "BL1 4QR",
        "M21"
    ],
    "daysBack": 365,
    "maxResults": 2000
};

// Run the Actor and wait for it to finish
const run = await client.actor("devon_gtme/land-registry-price-paid").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": [
        "BL1 4QR",
        "M21",
    ],
    "daysBack": 365,
    "maxResults": 2000,
}

# Run the Actor and wait for it to finish
run = client.actor("devon_gtme/land-registry-price-paid").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": [
    "BL1 4QR",
    "M21"
  ],
  "daysBack": 365,
  "maxResults": 2000
}' |
apify call devon_gtme/land-registry-price-paid --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Sold House Prices - Land Registry Price Paid Data",
        "description": "Sold house prices for England & Wales from HM Land Registry Price Paid Data. Search by postcode, outcode or town; filter by date, price, type and new-build. Every transaction plus a comps summary (median, mean, min/max) per area. For agents, investors, analysts and valuations. No API key needed.",
        "version": "0.1",
        "x-build-id": "4etT8hXgK4jOEpiRT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devon_gtme~land-registry-price-paid/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devon_gtme-land-registry-price-paid",
                "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/devon_gtme~land-registry-price-paid/runs": {
            "post": {
                "operationId": "runs-sync-devon_gtme-land-registry-price-paid",
                "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/devon_gtme~land-registry-price-paid/run-sync": {
            "post": {
                "operationId": "run-sync-devon_gtme-land-registry-price-paid",
                "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 / Outcodes",
                        "type": "array",
                        "description": "Full postcodes (e.g. 'BL1 4QR') or outcodes (e.g. 'M1', 'SW11') — one summary is produced per entry. Outcodes fetch every sale in the postcode district. Leave empty to search by town instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "town": {
                        "title": "Town / City",
                        "type": "string",
                        "description": "Town or city name as it appears in addresses (e.g. 'Bolton', 'York'). Used only when Postcodes is empty. Note: big cities can have tens of thousands of sales per year — set Max Results and filters accordingly."
                    },
                    "daysBack": {
                        "title": "Days Back",
                        "minimum": 1,
                        "maximum": 14600,
                        "type": "integer",
                        "description": "Fetch sales completed in the last N days. Ignored if explicit dates are set below. Note: Land Registry data lags completion by ~4-8 weeks, so very recent sales won't appear yet.",
                        "default": 365
                    },
                    "dateFrom": {
                        "title": "Date From (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Explicit start completion date. Overrides Days Back when set. Data goes back to 1995."
                    },
                    "dateTo": {
                        "title": "Date To (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Explicit end completion date. Defaults to today."
                    },
                    "minPrice": {
                        "title": "Min Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include sales at or above this price."
                    },
                    "maxPrice": {
                        "title": "Max Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include sales at or below this price."
                    },
                    "propertyTypes": {
                        "title": "Property Types",
                        "type": "array",
                        "description": "Limit to specific property types. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "detached",
                                "semi-detached",
                                "terraced",
                                "flat-maisonette",
                                "other"
                            ],
                            "enumTitles": [
                                "Detached",
                                "Semi-detached",
                                "Terraced",
                                "Flat / maisonette",
                                "Other"
                            ]
                        }
                    },
                    "newBuildOnly": {
                        "title": "New Builds Only",
                        "type": "boolean",
                        "description": "Only include sales of newly built properties.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum transactions to return across all areas (summaries are always produced).",
                        "default": 2000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
