# Rightmove Property Search, Price Drops and Sold Prices (`accountable_eel/rightmove-listing-lookup`) Actor

Rightmove scraper for UK property searches: address, price, bedrooms, agent, photo and link per property, newest first, for sale or to rent. New Rightmove listings alert and Rightmove price drop monitor built in, plus UK sold house prices by postcode. No login. Pay per property returned.

- **URL**: https://apify.com/accountable\_eel/rightmove-listing-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 property returneds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Rightmove Property Search, Price Drops and Sold Prices

A Rightmove scraper for UK property searches. Type a town or postcode, or paste any Rightmove search
link with its filters, and get one row per property, newest first: address, asking price, price
qualifier, bedrooms, bathrooms, agent and branch, first-listed date, coordinates, photo and link.
Turn on monitoring and the same search becomes a new Rightmove listings alert and a Rightmove price
drop monitor, and one tick adds UK sold house prices by postcode. No login, no browser, no proxy
needed. You pay per property returned.

### Who it's for

- **Property investors and buy-to-let landlords** watching a town, a postcode or a price band for
  fresh stock and reductions before other buyers ring the agent.
- **Estate agents, sourcing agents and valuers** who want a daily table of new instructions,
  price cuts and withdrawn properties in their patch, with the agent branch on every row.
- **Home hunters** who would rather get a Slack message or a Google Sheets row than refresh the
  results page ten times a day.
- **Analysts and developers** feeding Rightmove listings into n8n, Make, Clay, a database or an AI
  agent without maintaining their own scraper.

### Why this one

- **Monitoring is built in.** The other Rightmove scrapers on the Store return a snapshot and
  stop; none of memo23, automation-lab or azzouzana tracks changes between runs at all. Here a
  named watchlist remembers every property between scheduled runs and returns only what is new,
  cheaper, dearer or gone. See [Monitoring](#monitoring-only-what-changed).
- **A fraction of the run cost.** We charge $0.00005 to start a run where memo23, automation-lab
  and azzouzana all charge $0.005, so an hourly watchlist costs about a third of theirs. A run
  with nothing new or cheaper costs only that start fee.
- **Never charged for nothing.** A search with no matches, an unknown place, a run with nothing
  new or cheaper, price rises and gone properties are all free. Duplicates that shift between
  pages are removed before you are billed.
- **Sold prices in the same table.** One tick adds the median of the most recent sales for each
  postcode outcode, from Rightmove's public house-prices pages. See [Sold prices](#sold-prices).
- **Honest about what Rightmove shows.** A "gone" row means the property left the search, which is
  sold subject to contract, let or withdrawn. Rightmove never says which, and neither do we.
- **Business data only.** Agent name and branch are the listing's own business contact details.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~rightmove-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["Manchester"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

#### Setting up a search

1. In the Input tab, type one search per line: a place name (`Manchester`, `Milton Keynes`,
   `Leeds`) or an outcode (`N11`, `SW1P`), or paste a search link from rightmove.co.uk.
2. For a typed place, pick **For sale** or **To rent** and the optional price, bedroom, property
   type and radius limits under "Search filters". A pasted link keeps its own filters and its own
   sale-or-rent choice.
3. Set "Most properties to return per search" to your budget (100 by default, up to 1,000).
4. To watch the search instead of running it once, turn on monitoring under "Monitoring" and
   schedule the actor hourly or daily. The first run returns everything as new and remembers it.
5. For a place with a common name or a filter this form does not offer (tenure, keywords, "added
   in the last 24 hours"), set it on rightmove.co.uk and paste the search link. Only the sort is
   forced, to newest first.

### Input

```json
{
  "searches": [
    "Manchester"
  ]
}
```

One per line: a place name or outcode such as "Manchester" or "N11" (use the sale/rent setting below), or a search link copied from rightmove.co.uk with all its filters. Results always come back newest first. Accepted formats: Manchester, N11, https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490\&minBedrooms=2\&maxPrice=600000, https://www.rightmove.co.uk/property-to-rent/find.html?locationIdentifier=REGION%5E787.

The other settings are optional: sale or rent, price, bedrooms, property type and radius for a
typed place, "Add sold-price context", the monitoring options, and the usual output filters
(`onlyFound`, `includeKeywords`, `excludeKeywords`, `maxResults`, `columns`).

### How to filter

Optional, additive inputs on top of the existing sale/rent, price, bedrooms and radius
settings. Client-side filters run before billing — a dropped property is never charged.
Leave them empty and the dataset is the same as before, plus two alias columns:
`title` (copy of `displayAddress`) and `listedAt` (copy of `firstVisibleDate`).

**1. Only sold-subject-to-contract excluded is not a filter here** — Rightmove's search
already drops SSTC on typed places. For Manchester sales under £500,000 in a named neighbourhood:

```json
{
  "searches": ["Manchester"],
  "maxPrice": 500000,
  "cities": ["Didsbury"]
}
```

`cities` is a contains match on the address string (Rightmove has no separate city column).

**2. Like-new is not a grade on Rightmove.** Cheapest flats whose address mentions "Victorian":

```json
{
  "searches": ["Manchester"],
  "propertyType": "flat",
  "includeKeywords": ["Victorian"],
  "sortBy": "price_asc"
}
```

**3. Available-only / made-to-order do not apply** (this is housing, not goods). Exclude new-builds from the title and keep newest first (the default fetch order):

```json
{
  "searches": ["N11"],
  "excludeKeywords": ["new build"],
  "sortBy": "newest",
  "maxListings": 20
}
```

`sortBy` reorders only the properties this run fetched. Leave it empty to keep Rightmove's
newest-first page order.

### Output

One row per property. Every row starts with the search summary (`searchUrl`, `totalAvailable`,
`listingCount`, `truncated`, `newCount`, `priceDropCount`, `priceRiseCount`, `goneCount`,
`monitorStatus`, `medianPrice`), then the property:

| Field | What it is |
|---|---|
| `propertyId`, `url` | Rightmove's property ID and the link to the listing |
| `displayAddress`, `postcodeOutcode` | The address as Rightmove shows it, and its outcode (`N11`, `SW1P`) when the address carries one |
| `price`, `currency`, `priceQualifier`, `priceFrequency` | Asking price in GBP; `Guide Price`, `Offers in excess of` and similar; `monthly` or `weekly` for a rental |
| `transactionType`, `propertySubType` | `sale` or `rent`; `Detached`, `Terraced`, `Flat` and so on |
| `bedrooms`, `bathrooms`, `summary` | As the agent published them |
| `agentName`, `agentBranch` | The estate agent and its branch |
| `addedOrReduced`, `firstVisibleDate`, `listingUpdatedAt` | Rightmove's "Added today" / "Reduced on 23/09/2026" text, when it first appeared, and when it was last added or reduced |
| `latitude`, `longitude`, `imageUrl` | Location and the main photo |
| `isFeatured` | A paid featured placement, shown out of date order |
| `changeType`, `previousPrice`, `priceDeltaPct`, `firstSeenAt`, `lastSeenAt`, `daysListed` | Monitoring, null when it is off |
| `soldMedianPrice`, `soldSampleSize` | Sold-price context, null unless it is on |

Three table views are ready in the Output tab: **Overview**, **Listings** and **Changes** (new
properties, price drops, price rises and gone properties).

A search with no matches comes back as one summary row with `listingCount: 0` and is not
charged. A place Rightmove does not know comes back as `found: false`, also free.

| query | found | status | searchUrl | totalAvailable | listingCount | truncated | newCount | priceDropCount | priceRiseCount | goneCount | monitorStatus | medianPrice | properties | propertyId | url | displayAddress | title | postcodeOutcode | price | currency | priceFrequency | priceQualifier | transactionType | propertySubType | bedrooms | bathrooms | summary | agentName | agentBranch | addedOrReduced | firstVisibleDate | listedAt | listingUpdatedAt | latitude | longitude | imageUrl | isFeatured | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Manchester | true | OK | <search link on rightmove> | <total matching on rightmove> | \<properties returned (billed)> | <more results were available> | <new properties this run> | <price drops this run> | <price rises this run> | <gone properties this run> | <monitoring status> | <median asking price of this search> | \<all properties found (full list)> | <rightmove property id> | <property link> | <address> | \<title (same as address)> | <postcode outcode> | <asking price> | <currency> | \<rent period (monthly / weekly)> | \<price qualifier (guide price, offers in excess of ...)> | <sale or rent> | <property type> | <bedrooms> | <bathrooms> | <summary> | <agent> | <agent branch> | \<added / reduced> | <first listed on rightmove> | \<listed at (same as first listed)> | <last added or reduced> | <latitude> | <longitude> | <main photo> | \<featured listing (paid promotion)> | 1970-01-01T00:00:00.000Z |

A real row, from a monitored search of "Manchester" (2+ bedrooms, up to GBP 400,000, sold prices on).
The outcode is empty because Rightmove's address for this property carries none, so there is no
sold-price context for it:

```json
{
  "query": "Manchester",
  "found": true,
  "status": "OK",
  "scrapedAt": "2026-09-28T10:44:27.082Z",
  "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E904&maxPrice=400000&minBedrooms=2&radius=0.0&includeSSTC=false&sortType=6&index=0",
  "listingCount": 20,
  "totalAvailable": 4250,
  "truncated": true,
  "newCount": 20,
  "priceDropCount": 0,
  "priceRiseCount": 0,
  "goneCount": 0,
  "monitorStatus": "CHANGES",
  "medianPrice": 230000,
  "propertyId": "93644556",
  "url": "https://www.rightmove.co.uk/properties/93644556",
  "displayAddress": "Palatine Road, Manchester",
  "postcodeOutcode": null,
  "price": 190000,
  "currency": "GBP",
  "priceFrequency": null,
  "priceQualifier": "Offers Over",
  "transactionType": "sale",
  "propertySubType": "House",
  "bedrooms": 2,
  "bathrooms": 1,
  "summary": "Situated in the charming Northenden village, this stylish house on Palatine Road offers a delightful blend of...",
  "agentName": "Hunters",
  "agentBranch": "Hunters, South Manchester",
  "addedOrReduced": "Added today",
  "firstVisibleDate": "2026-09-28T11:35:59Z",
  "listingUpdatedAt": "2026-09-28T11:41:10Z",
  "latitude": 53.411098,
  "longitude": -2.254971,
  "imageUrl": "https://media.rightmove.co.uk:443/dir/crop/10:9-16:9/property-photo/5f63be185/93644556/5f63be18520036616b676a15467c01cc_max_476x317.jpeg",
  "isFeatured": false,
  "soldMedianPrice": null,
  "soldSampleSize": null,
  "changeType": "new",
  "previousPrice": null,
  "priceDeltaPct": null,
  "firstSeenAt": "2026-09-28T10:44:27.164Z",
  "lastSeenAt": "2026-09-28T10:44:27.164Z",
  "daysListed": 0
}
```

### Example runs

Three inputs that need no API key or login and return rows as they stand. Paste one into the Input
tab and press Start.

**1. A new Rightmove listings alert for two-bed homes in Manchester**

```json
{
  "searches": ["Manchester"],
  "transactionType": "sale",
  "minBedrooms": 2,
  "maxPrice": 300000,
  "maxListings": 100,
  "deltaMode": true,
  "alertOnNewOnly": true,
  "deltaName": "manchester-2-bed-under-300k"
}
```

The first run returns everything currently listed as new and remembers it. Schedule the same
input hourly and each later run returns only properties that appeared since.

**2. UK sold house prices by postcode, next to what is on the market now**

```json
{
  "searches": ["N11"],
  "maxListings": 25,
  "includeSoldPrices": true
}
```

Every row carries `soldMedianPrice` and `soldSampleSize` for its outcode, so asking price and
recent sold prices sit in one table.

**3. Rentals in Leeds, newest first**

```json
{
  "searches": ["Leeds"],
  "transactionType": "rent",
  "minBedrooms": 1,
  "maxPrice": 1200,
  "maxListings": 50
}
```

`price` is per month for a rental and `priceFrequency` says so.

### Monitoring: only what changed

Turn on "Only return properties that are new, cheaper, dearer or gone since the last run" and each
search becomes a watchlist, stored in a named key-value store on your own Apify account between runs.

- **New**: a Rightmove property ID this watchlist has never returned.
- **Price drop / price rise**: a property it has seen whose asking price moved by at least "Smallest
  price change to report" (0.5% by default) since it was last reported. `previousPrice` and
  `priceDeltaPct` (signed, negative is cheaper) say by how much.
- **Gone**: the property left the part of the search this run read. See below.
- **Unchanged properties are dropped before billing**, so a quiet run costs only the start fee and
  returns one summary row with `monitorStatus: NO_CHANGES`.
- **What is returned**: with both alert boxes off (the default) every change is returned: new,
  price drop, price rise and gone. Tick "Alert on new properties only" or "Alert on price drops" to
  narrow it; tick both for new properties and price drops only.
- **What is billed**: new and cheaper properties. Price rises and gone rows are returned free.
- **First run**: everything is new. Turn on "Seed silently" to remember it all without returning
  or billing it, so a webhook does not get a hundred messages on day one.
- **Watchlist name**: leave it empty and one is derived from your filters. Type a name to keep one
  memory across a filter change. A property not seen for 30 days is forgotten, so the store stays small.

#### Gone properties

Rightmove never says why a property left a search, so a `gone` row means it was **delisted**: most
often sold subject to contract, sometimes let, withdrawn, or edited out of your filters. Each gone
row carries the last known details, `price` (the last asking price), `firstSeenAt`, `lastSeenAt`
and `daysListed`.

How it decides: a run only sees the newest properties in your search, and one that slid below that
window is still on the market. So each property's position in the newest-first feed is remembered,
and one that disappeared is called gone only if, after counting new arrivals and properties whose
price was just reduced (Rightmove moves those to the top), it should still have been inside the
part of the search this run read. Properties near the bottom edge are never called gone, featured
placements are never used, and a run where a page failed makes no gone check at all. For a reliable
sold signal, set "Most properties to return per search" comfortably above the number of new
listings you expect between runs.

### Sold prices

Tick "Add sold-price context" and each row gets `soldMedianPrice` and `soldSampleSize`: the median
of the latest sale of each property on Rightmove's public house-prices page for that row's postcode
outcode (up to 25 recent sales). It reads one house-prices page per distinct outcode, at most 20 per
search, at no extra charge. A row whose address carries no outcode, or an outcode Rightmove has no
page for, stays empty. Individual sale records are not returned, only the median and the count.

### Pricing

- **Property returned**: $2 per 1,000 listings

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

You pay per property returned. Empty searches, unknown places, price-rise and gone rows, and
unchanged properties on a monitored search are never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~rightmove-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["Manchester"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~rightmove-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["Manchester"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~rightmove-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Rightmove scraper: new listings, price drops, sold prices" — the agent will find and run this actor.

### FAQ

**What can I type as a place?** A town, city or area (`Manchester`, `Milton Keynes`, `Camden`) or a
postcode outcode (`N11`, `SW1P`). If Rightmove does not recognise it the row says so (free), and
pasting the search link from rightmove.co.uk always works.

**Which filters can I use?** For a typed place: sale or rent, price from/to, minimum bedrooms,
property type and radius. For anything else, set it on rightmove.co.uk and paste the search link.
All its filters are kept; only the sort order is forced to newest first.

**How many properties per search?** Up to 1,000 per search per run, newest first (Rightmove itself
stops at about 1,000). `totalAvailable` tells you how many match in total.

**Does it need a proxy or a browser?** No. Rightmove serves its results pages over plain HTTP, and
this actor reads the data embedded in them. Apify's default proxy is used and no login is needed.

**Does it identify itself as a crawler?** No. It sends an ordinary browser User-Agent, and only
reads pages that Rightmove's robots.txt allows for all visitors.

**Why is one property flagged `isFeatured`?** Rightmove puts one paid featured property at the top
of every results page, out of date order. It is returned like any other row and marked so you can
filter it.

**Is a "gone" property really sold?** Not necessarily. See [Gone properties](#gone-properties).

# Actor input Schema

## `searches` (type: `array`):

One per line: a place name or outcode such as "Manchester" or "N11" (use the sale/rent setting below), or a search link copied from rightmove.co.uk with all its filters. Results always come back newest first. Accepted formats: Manchester, N11, https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490\&minBedrooms=2\&maxPrice=600000, https://www.rightmove.co.uk/property-to-rent/find.html?locationIdentifier=REGION%5E787. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. One word or phrase per line, case-insensitive. Keeps only properties whose address (title) contains at least one of these. Matches the address only. Leave empty to keep every title.

## `excludeKeywords` (type: `array`):

Optional. One word or phrase per line, case-insensitive. Drops any property whose address (title) contains one of these. Leave empty to drop nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `transactionType` (type: `string`):

Applies to a place name or outcode you type. A pasted search link keeps its own choice (property-for-sale or property-to-rent).

## `maxListings` (type: `integer`):

Newest first. Rightmove shows 24 per page and stops at about 1,000 per search; this actor pages on its own. You pay per property returned, so this is also your budget control.

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

Optional. For a rental this is per month. Ignored for pasted search links.

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

Optional. For a rental this is per month. Ignored for pasted search links.

## `minBedrooms` (type: `integer`):

Optional. Ignored for pasted search links.

## `propertyType` (type: `string`):

Optional. Ignored for pasted search links.

## `radiusMiles` (type: `string`):

How far beyond the typed place to look. Ignored for pasted search links.

## `cities` (type: `array`):

Optional. One city or area per line, case-insensitive. Keeps only properties whose address (the Title / Display address column) contains one of these. Rightmove has no separate city field — this is a contains match on the address string. Leave empty to keep every address.

## `sortBy` (type: `string`):

Optional. Sorts the properties this run actually fetched — after filtering, before "Most properties to return per search" cuts the list — not the whole marketplace. Rightmove pages are already fetched newest-first (sortType=6), so leaving this on Default reproduces the existing order exactly.

## `includeSoldPrices` (type: `boolean`):

Reads Rightmove's public house-prices page for each property's postcode outcode (at most 20 outcodes per search) and adds soldMedianPrice and soldSampleSize: the median of the most recent sales listed there. Rows whose address carries no outcode stay empty. No extra charge.

## `deltaMode` (type: `boolean`):

Turns a search into a watchlist. A property is new when its Rightmove ID was not returned by a previous run of the same watchlist; a price drop or rise when its asking price moved by at least the percentage below since it was last seen; gone when it disappeared from the part of the search the run covered (sold subject to contract, let or withdrawn). Unchanged properties are removed before you are billed, so a quiet run costs only the start fee and returns one summary row. Price rises and gone properties are returned free. Schedule it hourly or daily and send the rows to Slack, Google Sheets, n8n or your own system.

## `deltaName` (type: `string`):

Leave empty and one is derived from this run's filters, so two schedules with different filters keep separate memories. Type your own name to keep one memory across a filter change. Remembered in a named store on your account, so it survives between runs.

## `alertOnNewOnly` (type: `boolean`):

With monitoring on and this ticked, return only properties the watchlist has never seen. With this and "Alert on price drops" both off (the default) every kind of change is returned: new, price drop, price rise and gone.

## `alertOnPriceDrop` (type: `boolean`):

With monitoring on and this ticked, return only properties whose asking price dropped. Tick it together with "Alert on new properties only" to get new properties and price drops and nothing else.

## `minPriceChangePct` (type: `number`):

A property must be at least this much cheaper or dearer than when it was last reported to count as a price drop or rise. Default 0.5%: 0.5% of GBP 400,000 is GBP 2,000.

## `skipFirstRun` (type: `boolean`):

The first run of a watchlist has nothing to compare with, so every property is new. Turn this on to remember everything without returning or billing it, so a webhook does not get a hundred messages on day one. Alerts start from the second run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each listing found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "Manchester"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "transactionType": "sale",
  "maxListings": 100,
  "propertyType": "any",
  "radiusMiles": "0",
  "cities": [],
  "sortBy": "",
  "includeSoldPrices": false,
  "deltaMode": false,
  "deltaName": "",
  "alertOnNewOnly": false,
  "alertOnPriceDrop": false,
  "minPriceChangePct": 0.5,
  "skipFirstRun": false,
  "columns": [
    "searchUrl",
    "totalAvailable",
    "listingCount",
    "truncated",
    "newCount",
    "priceDropCount",
    "priceRiseCount",
    "goneCount",
    "monitorStatus",
    "medianPrice",
    "properties",
    "propertyId",
    "url",
    "displayAddress",
    "title",
    "postcodeOutcode",
    "price",
    "currency",
    "priceFrequency",
    "priceQualifier",
    "transactionType",
    "propertySubType",
    "bedrooms",
    "bathrooms",
    "summary",
    "agentName",
    "agentBranch",
    "addedOrReduced",
    "firstVisibleDate",
    "listedAt",
    "listingUpdatedAt",
    "latitude",
    "longitude",
    "imageUrl",
    "isFeatured"
  ],
  "expandRows": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "Manchester"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "cities": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/rightmove-listing-lookup").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 = {
    "searches": ["Manchester"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "cities": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/rightmove-listing-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    "Manchester"
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "cities": []
}' |
apify call accountable_eel/rightmove-listing-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/rightmove-listing-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/U7loDfc51SWVhhqit/builds/RRMkDWEi6vJ4pFoSV/openapi.json