---
title: "Rightmove API: Get UK Property Listings and Sold Prices"
description: "Pull Rightmove UK listings, sold prices and agents as JSON with 8 endpoints at 1 credit per call, with a real London search response and cURL examples."
url: https://perceptlayer.com/blog/rightmove-api-property-data
---

[Blog](https://perceptlayer.com/blog) / [API guides](https://perceptlayer.com/blog/category/api-guides)

# Rightmove API: Get UK Property Listings and Sold Prices

6 Sept 2026 Perceptlayer 8 min read

Rightmove's Real Time Data Feed is described as a way to upload listings. The Perceptlayer Rightmove API is for the reading side: eight GET endpoints return listings, single properties, sold prices, agents and location lookups as JSON, at 1 credit per successful call. One cURL call against `/v1/rightmove/search` is enough to start.

## Key takeaways

-   Rightmove's Real Time Data Feed is described as a way for agents to upload and update their own listings, not to read other people's.
-   `GET /v1/rightmove/search` needs only `channel` (BUY, RENT, COMMERCIAL\_BUY or COMMERCIAL\_RENT) and returns listings with price, bedrooms, address and coordinates.
-   Sold prices come from `GET /v1/rightmove/sold-properties`, filtered by `postcode`, `property_type`, `tenure` and `sold_in`.
-   Every one of the 8 Rightmove endpoints costs 1 credit on success. Failed calls cost nothing and return `X-Credits-Used: 0`.
-   A single search sweep is capped at about 1,000 records over 41 pages, so narrow the location to go deeper.

## Is there an official Rightmove API?

No. Rightmove's own data-feed documentation is for sending listings in, not for reading them out. Its current specifications page covers loading "UK Sales & Lettings properties", "Overseas Sales properties" and "New Homes Developers properties" onto the live site, and describes no way to search or retrieve listings ( [Rightmove Automated Datafeed Specifications](https://www.rightmove.co.uk/adf.html), 2026). Rightmove introduced the Real Time Data Feed so agents could "upload your properties and make changes to your current Rightmove listings almost instantly" ( [Rightmove news, Real Time Data Feed](https://www.rightmove.co.uk/news/?p=29205), 2015).

If you're an estate agent or a CRM vendor publishing stock, the feed is your route. If you're a developer who needs to read UK listings as JSON, that's the gap the [Rightmove API](https://perceptlayer.com/apis/rightmove) covers. It's one of the sites in the [real estate APIs](https://perceptlayer.com/verticals/real-estate) area, and it uses the same key and the same JSON conventions as the rest of the catalogue.

## What can the Rightmove API return?

Eight endpoints cover the data a Rightmove page shows: listings for sale or rent, a single property, sold prices, agents and branches, addresses, and location lookups. All are GET requests, all cost 1 credit on success, and all return JSON. The table lists each one with its required parameters.

| Endpoint | Returns | Required | Credits |
| --- | --- | --- | --- |
| [`/v1/rightmove/search`](https://perceptlayer.com/apis/rightmove/search) | Search | `channel` | 1 |
| [`/v1/rightmove/property`](https://perceptlayer.com/apis/rightmove/property) | Property | `id` | 1 |
| [`/v1/rightmove/sold-properties`](https://perceptlayer.com/apis/rightmove/sold-properties) | Sold Properties | none | 1 |
| [`/v1/rightmove/sold-property`](https://perceptlayer.com/apis/rightmove/sold-property) | Sold Property | `uuid` | 1 |
| [`/v1/rightmove/locations-typeahead`](https://perceptlayer.com/apis/rightmove/locations-typeahead) | Locations Typeahead | `query` | 1 |
| [`/v1/rightmove/agents`](https://perceptlayer.com/apis/rightmove/agents) | Agents | `channel` | 1 |
| [`/v1/rightmove/branch`](https://perceptlayer.com/apis/rightmove/branch) | Branch | `id` | 1 |
| [`/v1/rightmove/address`](https://perceptlayer.com/apis/rightmove/address) | Address | none | 1 |

The usual flow is: resolve a place name, search listings, then fetch detail for the ones you care about. For sold prices, go straight to `sold-properties` with a postcode, then open individual records with `sold-property`.

## How do you search Rightmove listings?

Call `GET /v1/rightmove/search` with a `channel` and a place. `channel` is the only required parameter. Pass `location` as free text, or `location_identifier` if you already have one. The call below searches London listings for sale, and it's the exact request behind the recorded response in the next section.

```bash
curl "https://api.perceptlayer.com/v1/rightmove/search?location=London&channel=BUY" \
  -H "X-API-Key: $API_KEY"
```

Get a key from [the free signup](https://perceptlayer.com/signup); authentication is covered in the [docs](https://docs.perceptlayer.com/authentication). Keys start with `sk_live_` and go in the `X-API-Key` header.

### Which parameters does the search endpoint take?

Search takes one required parameter and thirteen optional ones. Types and allowed values below come straight from the endpoint definition. Nothing else about defaults or page sizes is documented, so don't rely on any.

| Parameter | Type | Notes |
| --- | --- | --- |
| `channel` | string, required | One of `BUY`, `RENT`, `COMMERCIAL_BUY`, `COMMERCIAL_RENT` |
| `location` | string | Up to 120 characters |
| `location_identifier` | string | Up to 60 characters |
| `location_name` | string | Up to 120 characters |
| `radius` | integer |  |
| `page` | integer |  |
| `sort` | integer |  |
| `min_price`, `max_price` | integer | Price bounds |
| `min_bedrooms`, `max_bedrooms` | integer | Bedroom bounds |
| `property_type` | string | Up to 60 characters |
| `must_have` | string | Up to 60 characters |
| `enrich` | boolean |  |

For example, `channel=RENT&location=Manchester&min_bedrooms=2&max_price=1800` asks for rentals in Manchester with at least two bedrooms and a price ceiling of 1,800. Check the [Search endpoint page](https://perceptlayer.com/apis/rightmove/search) or the playground for the allowed `sort` values.

### What does a search response look like?

The recorded response for the London request above holds a `data` object with a `properties` array plus paging fields, and a `meta` object. Here is an excerpt, trimmed with `…`:

```json
{
  "data": {
    "properties": [
      {
        "id": 90486465,
        "bedrooms": 3,
        "bathrooms": 2,
        "displayAddress": "Cavaye Place, Chelsea, London, SW10",
        "countryCode": "GB",
        "location": {
          "latitude": 51.486678,
          "longitude": -0.180225
        },
        "propertySubType": "Apartment",
        "tenure": {
          "tenureType": "LEASEHOLD"
        },
        "price": {
          "amount": 1495000,
          "currencyCode": "GBP",
          "displayPrices": ["…"]
        },
        "customer": {
          "branchId": 298991,
          "branchDisplayName": "OB Private, Mayfair"
        },
        "displaySize": "1,285 sq. ft.",
        "channel": "BUY",
        "addedOrReduced": "Added on 03/07/2026",
        "listing_id": "90486465",
        "branch_id": 298991
      }
    ],
    "count": 60081,
    "page": 1,
    "page_size": 24,
    "channel": "BUY",
    "location_identifier": "REGION^87490",
    "has_next_page": true,
    "record_limit": {
      "max_page": 41,
      "approx_records_per_search": 1025,
      "note": "Rightmove caps a single search sweep at roughly 1,000 records over 41 pages. Narrow the location to go deeper."
    }
  },
  "meta": {
    "attempts": 1,
    "lookups": 1,
    "duration_ms": 1253
  }
}
```

The fields you'd use most are `price.amount`, `bedrooms`, `displayAddress`, `location`, `propertySubType` and `tenure.tenureType`. The listing `id` is what you pass to the property endpoint. The same recorded response shows `channel` as `COMMERCIAL_BUY` on a second, commercial listing in the array, so a residential search can return commercial stock.

## Why does a London search stop at 41 pages?

A single search sweep stops at roughly 1,000 records. The recorded response reports `count: 60081` matches for London but also `max_page: 41` and `approx_records_per_search: 1025`, and its own note says to narrow the location to go deeper. `has_next_page` tells you whether another page exists within that cap.

Treat `count` as the size of the market, not the size of your result set. To collect more than about 1,000 listings, split the area: run one search per borough, outcode or neighbourhood, and add price bands with `min_price` and `max_price` so each slice stays under the cap. Here's a short page loop in Python:

```python
import os
import requests

URL = "https://api.perceptlayer.com/v1/rightmove/search"
HEADERS = {"X-API-Key": os.environ["API_KEY"]}

def search_all(params, max_pages=41):
    listings = []
    for page in range(1, max_pages + 1):
        r = requests.get(URL, headers=HEADERS, params={**params, "page": page}, timeout=60)
        r.raise_for_status()
        data = r.json()["data"]
        listings.extend(data["properties"])
        if not data["has_next_page"]:
            break
    return listings

homes = search_all({"channel": "BUY", "location": "London"})
print(len(homes))
```

It reads the `has_next_page` flag from the recorded response shape and stops when it's false. For retries, rate limits and safe loops, see [paginating a web data API in Python](https://perceptlayer.com/blog/paginate-web-data-api-python).

## How do you get one property, or find a location first?

Use `GET /v1/rightmove/property` with the listing `id`, and `GET /v1/rightmove/locations-typeahead` to turn typed text into a location. There's no recorded response for either in this article, so the descriptions below stick to the parameters. Open each endpoint page or the playground to see the actual output.

| Endpoint | Parameters | Use it to |
| --- | --- | --- |
| `/v1/rightmove/property` | `id` (string, required) | Fetch one listing after a search returned its `id` |
| `/v1/rightmove/locations-typeahead` | `query` (string, required, up to 120 characters), `limit` (integer, optional) | Resolve a place name before searching |

```bash
curl "https://api.perceptlayer.com/v1/rightmove/locations-typeahead?query=Chelsea&limit=5" \
  -H "X-API-Key: $API_KEY"

curl "https://api.perceptlayer.com/v1/rightmove/property?id=90486465" \
  -H "X-API-Key: $API_KEY"
```

Typeahead is useful when users type a place name and you want a precise match rather than free text. The [Locations Typeahead page](https://perceptlayer.com/apis/rightmove/locations-typeahead) and the [Property page](https://perceptlayer.com/apis/rightmove/property) list the response fields.

## How do you get sold prices?

Call `GET /v1/rightmove/sold-properties`. Nothing is required, but you'll want to filter: `postcode` (up to 10 characters), `location_id` with a `location_type` of REGION, OUTCODE, POSTCODE, BRANCH or STATION, and `radius`. You can narrow by `property_type` (DETACHED, FLAT, TERRACED, SEMI\_DETACHED), `tenure` (FREEHOLD, LEASEHOLD) and `sold_in`.

```bash
curl "https://api.perceptlayer.com/v1/rightmove/sold-properties?postcode=SW10&property_type=FLAT&tenure=LEASEHOLD" \
  -H "X-API-Key: $API_KEY"
```

| Parameter | Type | Allowed values |
| --- | --- | --- |
| `postcode` | string | Up to 10 characters |
| `location_id` | integer |  |
| `location_type` | string | `REGION`, `OUTCODE`, `POSTCODE`, `BRANCH`, `STATION` |
| `radius` | integer |  |
| `page`, `page_size` | integer |  |
| `property_type` | string | `DETACHED`, `FLAT`, `TERRACED`, `SEMI_DETACHED` |
| `tenure` | string | `FREEHOLD`, `LEASEHOLD` |
| `sold_in` | integer | `3`, `6`, `12`, `24`, `120` |

To look at one sale in full, pass its `uuid` to `GET /v1/rightmove/sold-property`. We haven't recorded a sold-prices response for this article, so see the [Sold Properties page](https://perceptlayer.com/apis/rightmove/sold-properties) and the [Sold Property page](https://perceptlayer.com/apis/rightmove/sold-property) for the output, or run it in the playground.

When is the free government data a better fit? If you only need completed sale prices for England and Wales, HM Land Registry's Price Paid Data covers "all property sales in England and Wales that are sold for value and are lodged with us for registration", is released under the Open Government Licence, and is updated on the 20th working day of each month ( [HM Land Registry, Price Paid Data](https://www.gov.uk/government/statistical-data-sets/price-paid-data-downloads), 2026). It's free to download, so for bulk historical analysis it's the cheaper route. Rightmove sold-price data is the better fit when you want it alongside live listings, agents and the same JSON shape. Whichever source you use, read Rightmove's terms of use first and make sure your use of the data complies with them.

## What about agents, branches and addresses?

Three more endpoints cover the supply side. `GET /v1/rightmove/agents` needs a `channel` of BUY or RENT and takes `location` or `location_identifier` as optional filters. `GET /v1/rightmove/branch` takes a branch `id`. `GET /v1/rightmove/address` takes an optional `postcode` or `term`.

The search response already carries `branch_id`, so a typical flow is to take it from a listing and pass it to the [Branch endpoint](https://perceptlayer.com/apis/rightmove/branch). The [Agents endpoint](https://perceptlayer.com/apis/rightmove/agents) lists agents for an area, and the [Address endpoint](https://perceptlayer.com/apis/rightmove/address) helps when you start from a postcode or an address fragment instead of a listing. For listing-data design, our guide to [the real estate listing fields that matter for valuation](https://perceptlayer.com/blog/real-estate-listing-data-valuation-fields) goes through which of these fields to keep.

## What does a Rightmove API call cost?

Every Rightmove endpoint costs 1 credit per successful call. Failed calls cost nothing and return `X-Credits-Used: 0`. Each success also returns `X-Credits-Used` and `X-Credits-Remaining`, so you can track your balance as you go. See the [credits docs](https://docs.perceptlayer.com/credits) for how billing works.

The free tier gives you 1,000 credits every month after you verify an email address, with no credit card. Paid packs are prepaid and last 12 months. There's no subscription and no seats.

| Pack | Credits |
| --- | --- |
| Free | 1,000 per month |
| Starter | 10,000 |
| Build | 50,000 |
| Growth | 200,000 |
| Pro | 500,000 |
| Scale | 1,000,000 |
| Volume | 5,000,000 |

Worked example: a full sweep of one search is at most 41 pages × 1 credit = 41 credits, so the free 1,000 credits cover 24 sweeps (24 × 41 = 984). A Starter pack of 10,000 credits covers 243 sweeps (243 × 41 = 9,963). Add one `property` call per listing you want in full and each costs 1 more credit. See [pricing](https://perceptlayer.com/pricing) for what credits cost.

Rate-limited (429) and temporarily unavailable (503) responses carry a `Retry-After` header with the seconds to wait. There's no idempotency key, so a request that timed out on your side may still have been billed. The [errors docs](https://docs.perceptlayer.com/errors) and [rate limits docs](https://docs.perceptlayer.com/rate-limits) list the codes. Prices and packs are on the [pricing page](https://perceptlayer.com/pricing).

## Can an AI agent call the Rightmove API?

Yes. The Perceptlayer MCP server at `https://api.perceptlayer.com/mcp` exposes `search_endpoints`, `get_endpoint` and `call_endpoint`. The first two only look up the catalogue and cost nothing. `call_endpoint` takes an endpoint ID and its parameters, and spends credits only on success.

An agent can look up the Rightmove search endpoint, read its parameters, then call it with the user's area and budget. Setup is in the [MCP docs](https://docs.perceptlayer.com/ai-agents), and [an MCP server for web scraping](https://perceptlayer.com/blog/mcp-server-for-web-scraping) explains how the tools fit together.

To try the endpoints first, [get a free API key](https://perceptlayer.com/signup) and run your own London search in the playground on the [Rightmove API page](https://perceptlayer.com/apis/rightmove). Data is collected from publicly available sources and returned as found at the time of the call.

## APIs in this post

-   [Rightmove **1 credit per call** · 8 endpoints](https://perceptlayer.com/apis/rightmove)

## Frequently asked questions

### Does Rightmove have a public API?

No. Rightmove's published data-feed specifications cover uploading listings, and they describe no way to search or retrieve them ( [Rightmove Automated Datafeed Specifications](https://www.rightmove.co.uk/adf.html), 2026). To read listings, sold prices or agent data as JSON, use the [Rightmove API](https://perceptlayer.com/apis/rightmove) from Perceptlayer, which returns each endpoint's data with one key.

### How much does the Rightmove API cost?

Every Rightmove endpoint costs 1 credit per successful call, and failed calls cost nothing. You get 1,000 free credits every month. After that, credits come in prepaid packs from 10,000 (Starter) to 5,000,000 (Volume), so 20,000 calls × 1 credit = 20,000 credits. The [pricing page](https://perceptlayer.com/pricing) shows what each pack costs.

### How many listings can one Rightmove search return?

About 1,000. The recorded London search reported 60,081 matches but a cap of 41 pages and roughly 1,025 records per search, and its note says to narrow the location to go deeper. Split a large area into boroughs or outcodes, and add price bands, so each search stays under the cap.

### Can I get Rightmove sold prices as JSON?

Yes. `GET /v1/rightmove/sold-properties` accepts `postcode`, `property_type`, `tenure` and `sold_in`, and `GET /v1/rightmove/sold-property` takes a `uuid` for one record. Each call costs 1 credit. We haven't recorded a sold-prices response here, so check the endpoint pages for the fields it returns.

### What happens if a call fails or I run out of credits?

A failed call returns an HTTP status and a JSON error with a `code`, `message` and `request_id`, and costs nothing. When your prepaid balance reaches zero, calls return `insufficient_credits` (402) and nothing more is debited. There's no automatic top-up. The [errors docs](https://docs.perceptlayer.com/errors) list every code.

rightmove uk property real estate listings sold prices

## More from the blog

1.  [API guides](https://perceptlayer.com/blog/category/api-guides) 10 Jul 2026 Perceptlayer 7 min read
    
    ## [Zoopla API: UK Listings and Sold Prices as JSON](https://perceptlayer.com/blog/zoopla-api-property-listings-sold-prices)
    
    Search Zoopla listings by outcode, pull sold prices and a property's valuation history by UPRN, at 1 credit per call. Parameters, cURL and a sweep cost.
    
2.  [API guides](https://perceptlayer.com/blog/category/api-guides) 15 Oct 2026 Perceptlayer 7 min read
    
    ## [Redfin API: Search Homes, Then Property and Valuation](https://perceptlayer.com/blog/redfin-api-property-valuation)
    
    Four Redfin endpoints at 1 credit each: find a region, search homes with a real JSON response, then call property and valuation by property\_id.
    
3.  [API guides](https://perceptlayer.com/blog/category/api-guides) 8 Oct 2026 Perceptlayer 6 min read
    
    ## [Realestate.com.au API: Australian Listings as JSON](https://perceptlayer.com/blog/realestate-com-au-api-listings)
    
    Search realestate.com.au by location and channel (buy, rent, sold), then open each listing by URL. Parameters, a recorded Sydney response and the cost.
