# Rightmove New Listings & Price-Drop Monitor (`magnova/rightmove-listings-monitor`) Actor

New Rightmove listings and price changes for any property search: address, price, previous price, bedrooms, property type, agent name, listing URL. Monitor mode delivers only changes since your last run. $0.01 per change record, no start fee, empty runs free.

- **URL**: https://apify.com/magnova/rightmove-listings-monitor.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 listing change record fetcheds

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 New Listings & Price-Drop Monitor

This Actor monitors a Rightmove property search and returns only what changed: new listings and price changes. Give it any Rightmove search-results URL — an area, a radius, a price band, a bedroom count, homes or rentals — and each run scans the first pages of that search and writes one clean record per listing that is new since the previous run or whose price has moved, with the address, current price, previous price and percentage change, bedrooms, property type, the estate agent's name, and the listing URL. Run it on a schedule and it becomes a self-updating alert feed for a patch of the UK property market: no repeated listings, no re-scanning the same homes by hand, and you only ever pay for actual changes. There is no API key, account or login to configure — the search pages it reads are the public ones anyone can open in a browser.

### What it does

Most Rightmove tools sell snapshots: run one and you get the same hundreds of listings again, and spotting what is new — or which seller just cut their price — is left to you. This Actor is built the other way round, as a monitor:

- **First run (baseline).** Attach one of your own key-value stores as the state store and the first run delivers the listings it scans as `NEW` records, remembering every scanned listing's price in your store.
- **Every later run.** Only two kinds of records come back: listings that have never been seen before (`NEW`), and listings whose price differs from the remembered price (`PRICE_DROP` when it fell, `PRICE_UPDATE` when it rose), each carrying `previousPrice`, `priceChangeAmount` and `priceChangePct`. Everything unchanged is skipped and never charged.
- **A change-type filter** lets a run deliver only new listings, only price drops, or only price changes. Prices of filtered-out listings are still remembered, so a listing you skipped as "new" today still reports its price drop next month.

Each run writes three kinds of rows to the dataset:

- **listing** rows — one per delivered change, with the fields in the output table below. These are the only rows you pay for.
- An **error** row — if the search cannot be fetched (for example Rightmove refuses the request), with the reason. Never charged, and the run ends cleanly instead of crashing.
- One **summary** row at the end of every run: how many listings were scanned, delivered, skipped as unchanged, filtered out, the total results for the search, and whether state was used. Never charged.

### Use with AI agents / MCP

The input is deliberately minimal so an agent can call this Actor zero-shot: the search URL comes prefilled with a working London search. A minimal call looks like this:

```json
{
  "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&propertyTypes=&includeSSTC=false"
}
```

A scheduled monitor call — Manchester price drops only, state store attached, scanning the first ~200 results:

```json
{
  "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E904&propertyTypes=&includeSSTC=false",
  "changeTypes": "priceDrops",
  "maxListings": 192,
  "stateStore": "<your key-value store id>"
}
```

Sample output (one price-drop row, from a real staging run):

```json
{
  "recordType": "listing",
  "changeType": "PRICE_DROP",
  "listingId": "94305204",
  "address": "Fellside, Hexham, Northumberland, NE46",
  "price": 210000,
  "previousPrice": 260000,
  "priceChangeAmount": -50000,
  "priceChangePct": -19.23,
  "currency": "GBP",
  "agentName": "…",
  "listingUrl": "https://www.rightmove.co.uk/properties/94305204"
}
```

### Inputs

| Field | Description |
|---|---|
| Rightmove search URL (required, prefilled with a London search) | The exact search to monitor. Run any search on rightmove.co.uk — area, radius, price, bedrooms, type, for-sale or to-rent — and paste the results-page URL. If the URL chooses no sort order, newest-first is applied so fresh listings surface first. |
| Change types to deliver (prefilled `all`) | `all`, `new` (new listings only), `priceDrops` (price drops only) or `priceChanges` (drops and increases, no new listings). |
| Max listings to scan (prefilled 96) | How many results to scan per run, newest first (24 per page). Scanning is free; only delivered changes are charged. |
| Listing state store (optional, for monitor mode) | A key-value store you own where the Actor remembers each listing's last known price (read/write). Without it, every run is a baseline: all scanned listings delivered as NEW and nothing remembered. |

### Output fields

| Field | Meaning |
|---|---|
| `changeType` | `NEW`, `PRICE_DROP` or `PRICE_UPDATE` — why this record was delivered. |
| `listingId` | The listing's unique Rightmove property ID. |
| `address` | Display address, e.g. "Flanders Road, London". |
| `price` | Current price in GBP (numeric). Omitted for listings with no numeric price (e.g. POA). |
| `previousPrice` | Price-change records only: the price at the previous run. |
| `priceChangeAmount` / `priceChangePct` | Price-change records only: the move in GBP and as a percentage (negative for a drop). |
| `bedrooms` | Bedroom count (0 = studio), when stated. |
| `propertyType` / `propertyTypeFullDescription` | e.g. "House", "3 bedroom house for sale". |
| `agentName` | The marketing estate agent branch — name only. Telephone numbers are never collected (see Legal and data). |
| `addedOrReduced` | The card's date text, e.g. "Added on 09/09/2026" or "Reduced on 27/06/2025". |
| `listingUrl` | Link to the public listing page. |
| `searchUrl` | The monitored search (effective URL) that produced this record. |

### Pricing

Pay per event, no start fee: **$0.01 per delivered change record** on the FREE and BRONZE Apify plans, **$0.0085** on SILVER, **$0.007** on GOLD, PLATINUM and DIAMOND. Unchanged listings, filtered-out changes, error rows and the summary row are never charged, and an empty run (no changes) is free. A typical monitored town search sees roughly 120–800 new or changed listings a month — about $1.20–$8.00 a month at list price.

### Rightmove API

Rightmove does not offer a public API for search results. This Actor works as a Rightmove API substitute: it reads the same public search-results pages a browser receives and converts them into structured, delta-filtered JSON you can feed into spreadsheets, CRMs, alert bots or other Actors. Compared with general-purpose Rightmove snapshot scrapers, the difference is the shape: snapshots hand you the whole market every run and leave change detection to you; this Actor remembers prices in a store you own and hands you only the deltas — new listings and price movements — which is what alerts, lead generation and price tracking actually consume.

### Limitations

- The scan covers the first pages of the search (up to your max-listings cap), newest first. In very large searches (a whole city), a listing beyond the cap is not tracked until it enters the scanned window.
- Price-change detection needs the state store and at least two runs: a change is measured against the price at the last run that scanned the listing, not against the listing's original asking price history.
- Listings with no numeric price (POA) are delivered when new but cannot produce price-change records.
- Fetching is deliberately gentle — pages are requested one at a time with pauses, and if Rightmove refuses a request the run stops with an error row rather than escalating. Very frequent runs against the same search are unnecessary; daily or weekly schedules match how fast listings actually change.

### FAQ

**Do I need a Rightmove account or API key?** No. The Actor reads public, logged-out search pages; there is nothing to sign up for.

**How do I monitor several areas?** Run the Actor once per search URL — or use one of the Published Tasks as a preset — each with its own state store (or the same store; state is keyed by listing ID).

**Why did my first run deliver so many records?** That is the baseline: everything scanned is new to a fresh store. Later runs deliver only changes.

**Does it collect agent phone numbers?** No — never. Only the agent's name, which is public business information. See the next section.

### Legal and data

This Actor reads only the public, logged-out Rightmove search-results pages — the same pages any visitor's browser receives without an account. It does not log in, does not use fake accounts, does not solve CAPTCHAs or bypass access controls, and does not rotate proxies: if Rightmove refuses a request, the run stops. The data collected is factual listing data — addresses, prices, property characteristics, listing dates and URLs — plus the marketing agent's name, which is public business information. **Agent telephone numbers, email addresses and all other personal contact data are never collected or emitted**, even though pages display a phone number: records are built from a strict field whitelist that excludes them.

Rightmove's terms of use prohibit automated scraping of its site. The pages used here are public and logged-out, and the data is factual listing information, but this Actor's operation may still conflict with those terms. Use it only if you have satisfied yourself that it fits your use case and your obligations; you are responsible for how you use the output. Nothing here is legal advice.

# Actor input Schema

## `changeTypes` (type: `string`):

Which changes a run delivers (and charges for). 'all' = new listings plus every price change. 'new' = only listings not seen in earlier runs. 'priceDrops' = only listings whose price fell since the last run. 'priceChanges' = price drops and increases, no new listings. Price changes are detected against the state store below; on a run without a store, every listing counts as new.

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

Maximum number of listings to scan per run, starting from the first results page (24 listings per page, newest first). Only listings that are new or price-changed are delivered and charged — scanning itself is free. Example: 96 scans roughly the first 100 results. Raise it for wide-area searches; scheduled monitor runs usually only need the first pages, where fresh listings appear.

## `searchUrl` (type: `string`):

A full Rightmove search-results URL — the search this Actor monitors. Run any search on rightmove.co.uk (area, radius, price, bedrooms, property type) and paste the results-page URL here. Example: "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490\&propertyTypes=\&includeSSTC=false". If the URL does not choose a sort order, newest-first is applied so new listings surface first.

## `stateStore` (type: `string`):

A key-value store this Actor may read and write to remember each listing's last known price — this is what makes only-new delivery and price-change detection work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers all scanned listings as a NEW baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes.

## Actor input object example

```json
{
  "changeTypes": "all",
  "maxListings": 96,
  "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&propertyTypes=&includeSSTC=false&mustHave=&dontShow=&furnishTypes=&keywords="
}
```

# 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 = {
    "changeTypes": "all",
    "maxListings": 96,
    "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&propertyTypes=&includeSSTC=false&mustHave=&dontShow=&furnishTypes=&keywords="
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/rightmove-listings-monitor").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 = {
    "changeTypes": "all",
    "maxListings": 96,
    "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&propertyTypes=&includeSSTC=false&mustHave=&dontShow=&furnishTypes=&keywords=",
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/rightmove-listings-monitor").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 '{
  "changeTypes": "all",
  "maxListings": 96,
  "searchUrl": "https://www.rightmove.co.uk/property-for-sale/find.html?locationIdentifier=REGION%5E87490&propertyTypes=&includeSSTC=false&mustHave=&dontShow=&furnishTypes=&keywords="
}' |
apify call magnova/rightmove-listings-monitor --silent --output-dataset

```

## MCP server setup

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

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/obUCzbQM5tCQKZLGP/builds/OhZUSmggpqagPWFk8/openapi.json