# Rightmove New Listings Alert (`lowlanddata/rightmove-new-listings-alert`) Actor

Watch one saved Rightmove search - area, buy or rent, price and bedroom bands, radius - and get only the NEW properties each run. Built for hourly schedules with email, Slack or webhooks. No agent contact data. Quiet runs cost nothing.

- **URL**: https://apify.com/lowlanddata/rightmove-new-listings-alert.md
- **Developed by:** [Lowland Data](https://apify.com/lowlanddata) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.59 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Rightmove New Listings Alert — only what's new, privacy-safe

Watch one Rightmove search and get **only the properties that appeared since your last run** — as clean, structured JSON. Point it at a location, set your price and bedroom bands, put it on a Schedule, and every run delivers exactly the new listings: no duplicates, no re-sends, no scrolling through pages you have already seen. UK subscription services charge £9.99/month for this exact alert; here you pay per new property, and a quiet run costs you nothing beyond the actor start.

**No personal data, ever.** Built privacy-first like its parent, the [Rightmove Scraper](https://apify.com/lowlanddata/rightmove-scraper): agent phone numbers, contact routes and exact map coordinates never appear in the output — by design, not as an option. Addresses come exactly as the listing displays them; the agency appears as a business name only.

### Quick start (30 seconds)

1. Put a place name into **location** — a town (`Manchester`), area (`Camden, London`) or outcode (`SW1A`), just like the Rightmove search box.
2. Click **Start**. The first run is a baseline: it delivers the current matches and remembers them.
3. Add a Schedule (hourly works well). From now on, each run's dataset contains only properties new since the last one — the run status says so in plain words: `12 new properties since the last run`.

Optional knobs: for-sale or to-rent channel, a price band, a bedrooms band, and a search radius up to 40 miles.

### Who this is for

- **Home hunters in a competitive market.** In hot areas the first viewing request often wins. An hourly watch beats checking the site over lunch — every new match is in your inbox with price, type and photos already parsed.
- **Property sourcers watching an area.** Keep a permanent eye on a patch: every fresh listing arrives as one JSON object, ready to score, filter or forward to clients.
- **Relocation planners.** Watching a city you don't live in yet is exactly what a scheduled alert is for — set the band once, read the digest.
- **Rental hunters.** Set `channel: "rent"` and the same watch covers lettings, where speed matters even more than in sales.

### What you get

Each new property is one dataset item:

```json
{
  "propertyId": "169700001",
  "url": "https://www.rightmove.co.uk/properties/169700001",
  "title": "3 bedroom end of terrace house for sale",
  "displayAddress": "Chase Side Avenue, Enfield, EN2",
  "priceGbp": 680000,
  "currency": "GBP",
  "priceFrequency": null,
  "priceQualifier": "Guide Price",
  "bedrooms": 3,
  "bathrooms": 1,
  "propertyType": "End of Terrace",
  "channel": "buy",
  "tenureType": "FREEHOLD",
  "displaySize": "1,033 sq. ft.",
  "summary": "This well proportioned 3 bedroom house...",
  "firstVisibleDate": "2026-08-25T16:25:20Z",
  "listingUpdateReason": "new",
  "listingUpdateDate": "2026-08-25T16:25:20Z",
  "addedOrReduced": "Added on 25/08/2026",
  "agencyName": "Ian Gibbs, Enfield",
  "featured": false,
  "auction": false,
  "imageUrls": ["https://media.rightmove.co.uk/property-photo/example.jpeg"]
}
```

Field notes, so you know exactly what you are buying:

- `priceGbp` is in pounds. For rentals, `priceFrequency` says whether it is per month or per week.
- `firstVisibleDate` is when Rightmove first showed the listing — on an hourly schedule, that is usually minutes before you see it.
- `displayAddress` is the address exactly as the agent published it. Exact coordinates are deliberately never collected.
- `agencyName` is the estate agency's trading name and branch: business identity, no phone numbers, no contact links.
- `addedOrReduced` carries the site's own "Added on ..." banner, so you can double-check freshness at a glance.

### How much does a Rightmove alert cost?

$1.99 per 1,000 **new** properties delivered, pay-as-you-go — no subscription. You are billed for genuinely new listings only:

- A quiet hour where nothing new appears costs nothing beyond the actor start.
- A typical single-area watch delivers a handful of new properties a day — pennies per month, against £9.99/month for the subscription services doing the same job.

The price is all-inclusive — platform usage is covered, with no separate compute or proxy charges. Runs take seconds: the actor reads newest-first and stops as soon as it provably reaches listings it already knows. Datacenter proxies are sufficient — no residential proxy surcharge.

Free-plan runs are capped at 25 items, enough to see the baseline behaviour and output format against your real search.

### Not technical? Let your AI assistant set it up

Copy this into ChatGPT, Claude or any AI assistant, fill in the one line, and follow the conversation:

```text
Help me set up the "Rightmove New Listings Alert" actor on Apify
(https://apify.com/lowlanddata/rightmove-new-listings-alert). Guide me one step at a time.

What I want to watch: [E.G. "2-3 bedroom houses under 300k in Sheffield"]

Guide me to:
1. Propose my input values: location (as I'd type it on rightmove.co.uk), channel
   buy or rent, an optional priceMinGbp/priceMaxGbp band, bedroomsMin/bedroomsMax,
   and radiusMiles if I want nearby areas too.
2. Create a free Apify account (apify.com), open the actor page, paste the values
   into the Input form, and start a run. Explain that this first run is a baseline
   and later runs deliver only new listings.
3. Set up an hourly Schedule in the Apify Console with the same input, plus an
   email or Slack integration so new properties reach me the hour they appear.
4. If I want to watch a second area, show me how to add another Schedule with the
   new location and its own stateStoreName so the two watches don't mix.
5. If the results are what I wanted, remind me at the end to leave a quick rating
   on the actor page, and to report anything broken or missing on its Issues tab.
```

### Input

| Field                | Description                                                                                        |
| -------------------- | -------------------------------------------------------------------------------------------------- |
| `location`           | Place as you would type it on Rightmove — town, area or postcode. Required. First suggestion wins. |
| `channel`            | `buy` (default) or `rent`.                                                                         |
| `priceMinGbp`        | Only properties priced at least this many pounds (per month for rentals).                          |
| `priceMaxGbp`        | Only properties priced at most this many pounds (per month for rentals).                           |
| `bedroomsMin`        | At least this many bedrooms.                                                                       |
| `bedroomsMax`        | At most this many bedrooms.                                                                        |
| `radiusMiles`        | Widen the search this many miles around the location (0–40). 0 = the location only.                |
| `maxItems`           | Stop after this many new properties per run (default 200; free-plan runs cap at 25).               |
| `stateStoreName`     | Named store remembering what was already delivered. Give each separate watch its own name.         |
| `resetState`         | Forget everything seen so far; the next run is a fresh baseline.                                   |
| `proxyConfiguration` | Proxy settings; keep Apify proxy enabled.                                                          |

A run minimally needs a `location`; invalid combinations fail immediately with the reason in the run's status message.

### Use it from your code

Run the actor and get the new listings straight back with one HTTP call:

```bash
curl "https://api.apify.com/v2/acts/lowlanddata~rightmove-new-listings-alert/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -X POST -H "Content-Type: application/json" \
  -d '{"location": "Manchester", "priceMaxGbp": 300000, "bedroomsMin": 2}'
```

Node.js:

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('lowlanddata/rightmove-new-listings-alert').call({
  location: 'Manchester',
  priceMaxGbp: 300000,
  bedroomsMin: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
// items = only the properties new since the previous call
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lowlanddata/rightmove-new-listings-alert").call(
    run_input={"location": "Manchester", "priceMaxGbp": 300000, "bedroomsMin": 2})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

Schedules, webhooks and the Make/Zapier/n8n integrations all work out of the box — this is a standard Apify actor. A webhook on run-succeeded plus this actor is a complete alert pipeline.

### Use it with AI agents (MCP)

Claude, Cursor and other MCP-capable agents can run this watch as a tool through Apify's hosted MCP server: the agent sets up the search itself, runs it and reads the new listings — no glue code.

Claude Code:

```bash
claude mcp add apify --transport http "https://mcp.apify.com?actors=lowlanddata/rightmove-new-listings-alert"
```

Cursor or Claude Desktop (add a custom connector / MCP server with this URL):

```text
https://mcp.apify.com?actors=lowlanddata/rightmove-new-listings-alert
```

Sign in with your Apify account when prompted — runs are billed to it. Setup details per client: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

Prompts that work once connected:

- "Check my Manchester watch and summarize any new properties under 300k."
- "Watch rentals in Bristol under 1500 pounds and tell me what appeared today."
- "Anything new in my Leeds search? Rank the new listings by price per bedroom."

### Is it legal to monitor Rightmove listings?

Public listing data — prices, property details, listing dates — is public commercial information, and this actor is built so that the hard part of the question never arises: **no personal data enters your dataset in the first place.** UK GDPR sets strict rules on personal data; an output with no phone numbers, no contact routes and no coordinates beyond the address the agent chose to publish is the point of this actor, not an afterthought.

Structurally, the extractor maps a fixed whitelist of fields out of the page's data. Agent telephone numbers, contact URLs and exact coordinates are never read into the output. Requests are paced, load on the site is kept negligible — a watch run reads a page or two and stops — and no anti-bot protection is bypassed.

One honest limit: listing summaries are the agent's own words, delivered as-is. If an agent types contact details into the summary text, that text is not rewritten — the guarantee covers the data fields, not the content agents publish about themselves.

### Is there a Rightmove API for alerts?

Rightmove publishes no public API, and its own alert product is email-only. This actor is the API-shaped version: the same "tell me what's new in my search" service, delivered as structured JSON through one HTTP call, a schedule or an MCP tool — with deduplication already done and the privacy question already answered in the data itself.

### Does Rightmove block scrapers?

Rightmove serves its listings openly to ordinary requests — and this actor stays well inside that welcome. A watch run is deliberately small: it reads newest-first and stops on a streak of already-seen properties, so most runs touch only a page or two. Paced requests, standard datacenter proxies, no CAPTCHA fights — which is also why runs finish in seconds and hold up on hourly schedules.

### How do I get alerted to new Rightmove listings?

This actor **is** the alert engine — the state store and deduplication are built in, so there is nothing to compare or filter on your side. Set your search, add an hourly Schedule in the Apify Console, and attach an email or Slack integration to the runs: each message contains exactly the new properties, already parsed.

Compared with Rightmove's own email alerts: those are fine for casual browsing, but they are email-only and daily-ish. This watch gives you the same new-listings feed as **JSON you can filter** (price per bedroom, freehold only, no auctions), **webhook into anything** (Slack, Telegram, your CRM, a spreadsheet), and run as often as your schedule allows. The AI-assistant prompt above walks a non-technical user through the whole setup.

### FAQ

**How do I get Rightmove alerts faster?** Run this actor on an hourly Schedule with an email or Slack integration. Rightmove's own alerts are email digests; a scheduled watch delivers new listings as structured data within the hour they appear, ready to act on.

**Can Rightmove notify me instantly?** Not truly instantly — no service can push faster than listings are published. The practical ceiling is a tight schedule: hourly is a good default, and each run takes seconds and only bills for genuinely new properties, so frequent runs stay cheap.

**Why did my first run return so many properties?** That is the baseline: the first run delivers the current matches and remembers them, and its status says so — `N properties (baseline run - future runs deliver only new ones)`. From the second run on, you get only what appeared since.

**How does it know which properties are new?** A named state store keeps the IDs of everything already delivered. Each run reads the search newest-first, pushes the unseen properties, and stops once it hits a solid streak of known ones.

**Will a bumped or re-featured listing alert me again?** No. Rightmove agents re-feature listings to push them back to the top; this actor remembers what it has delivered for two months, so a re-featured property does not re-alert. Only genuinely new listings come through.

**Can I watch rentals instead of sales?** Yes — set `channel: "rent"`. The rent arrives in `priceGbp` and `priceFrequency` tells you whether it is per month or per week. Price bands then read as pounds per month.

**Can I watch several areas at once?** Run one Schedule per area, each with its own `stateStoreName` (say `alerts-leeds` and `alerts-york`), so the watches track independently. One actor, as many watches as you need.

**What happens if nothing new appeared — do I still pay?** Only the actor start. Billing is per new property delivered, so a quiet hour costs essentially nothing. That is what makes an hourly schedule affordable.

**Can I search by postcode?** Yes — outcodes like `SW1A` or `M20` work directly in `location`, resolved through the site's own location search just like the search box.

**How wide can the search radius go?** Up to 40 miles around the location with `radiusMiles`. 0 keeps the watch to the place itself; a few miles is usually the sweet spot for commuter-belt searches.

**What if I change my filters — price band, bedrooms?** A changed filter set is a new watch: the next run is a fresh baseline for it, so you never miss listings that the old filters excluded. Your other watches are unaffected.

**How do I start over from scratch?** Set `resetState: true` for one run. The actor forgets everything seen so far and delivers the current snapshot as a new baseline.

**How do the new listings reach my email or Slack?** Attach an email or Slack integration to the Schedule in the Apify Console — each successful run's dataset is the message body. Webhooks cover everything else: Telegram, Discord, your own endpoint.

**Does it work with Make, Zapier or n8n?** Yes — it is a standard Apify actor; all platform integrations, webhooks and schedules apply. "New dataset items" is the natural trigger.

**Can I export the results to Excel or CSV?** Yes — every dataset exports as CSV, Excel, JSON or XML from the Apify Console or API. On a scheduled watch, each run's dataset is that run's batch of new properties.

**Can I get agent phone numbers or contact details?** No — by design. Agencies appear as business names only, and exact coordinates are never collected. That is the product: alert data you can store, forward and process without a privacy review.

**Why did my run stop at 25 results?** That is the free-plan cap, meant for evaluating the output against your real search. Any paid Apify plan raises it to `maxItems` (default 200 per run).

**Does Rightmove have an API I could use instead?** No — Rightmove publishes no public listings API, and its alert product is email-only. This actor is the practical substitute: the same new-listings feed as JSON, schedulable and webhook-able.

**Can I get alerts for price reductions too?** That is its own watch — [Rightmove Price Reductions](https://apify.com/lowlanddata/rightmove-price-reductions) does for reductions what this actor does for new listings. Run both on the same schedule for full coverage of a search.

### Related scrapers

The same clean-output guarantee across the Rightmove family:

- [Rightmove Scraper](https://apify.com/lowlanddata/rightmove-scraper) — the parent: full search results on demand, not just what's new.
- [Rightmove Price Reductions](https://apify.com/lowlanddata/rightmove-price-reductions) — the reductions feed: every price cut in an area, with the old signals parsed.
- [Rightmove BMV Deal Finder](https://apify.com/lowlanddata/rightmove-bmv-deal-finder) — finds below-market-value candidates by comparing asking prices against the local market.

### Troubleshooting

The actor fails fast with the reason in the run's status message:

- **"Rightmove does not know the location ..."** — type the place as the Rightmove search box suggests it, e.g. `Camden, London` instead of an abbreviation.
- **"priceMinGbp must not be higher than priceMaxGbp."** — swap the two values.
- **A blocked-run message on the first request** — usually temporary; a retry lands on a clean proxy session. Scheduled runs simply catch up on the next tick — the state store means nothing is lost or double-delivered.
- **Every run says 0 new properties** — normal in a quiet market or a narrow band; widen `radiusMiles` or the price band if you expected more. If the search itself returns broken pages, the run fails loudly rather than silently reporting quiet — a green run with 0 items genuinely means nothing new.
- **First run delivered hundreds of items** — that is the baseline snapshot; cap it with `maxItems` if you only care about listings from today onward.

### Support

Found an issue or missing a field you need? Open an issue on the actor's **Issues tab** — reports get fixed, this actor is actively maintained.

Working well for you? A **rating on this page** takes ten seconds and helps other buyers find a privacy-clean alert among the lookalikes — it is also the clearest signal of what we should build next.

# Actor input Schema

## `location` (type: `string`):

The area to watch: a UK city, town, district or postcode as you would type it on Rightmove, e.g. "Manchester" or "SW1A". Resolved via the site's own location search.

## `channel` (type: `string`):

Search properties for sale (buy) or to rent (rent).

## `priceMinGbp` (type: `integer`):

Only include properties priced at least this many pounds. For rentals this is pounds per month.

## `priceMaxGbp` (type: `integer`):

Only include properties priced at most this many pounds. For rentals this is pounds per month.

## `bedroomsMin` (type: `integer`):

Only include properties with at least this many bedrooms.

## `bedroomsMax` (type: `integer`):

Only include properties with at most this many bedrooms.

## `radiusMiles` (type: `integer`):

Widen the search this many miles around the location. 0 = the location only.

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

Stop after this many new properties per run. Free-plan runs are capped at 25 items.

## `stateStoreName` (type: `string`):

Named store remembering which properties were already delivered, so scheduled runs emit only new ones. Use a different name to track several searches independently.

## `resetState` (type: `boolean`):

Forget everything seen so far and deliver the current snapshot as a fresh baseline.

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

Proxy settings. Keep Apify proxy enabled.

## Actor input object example

```json
{
  "location": "Manchester",
  "channel": "buy",
  "maxItems": 25,
  "stateStoreName": "rightmove-alerts-state",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

Scraped Rightmove properties, one JSON object per listing.

# 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 = {
    "location": "Manchester",
    "channel": "buy",
    "maxItems": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lowlanddata/rightmove-new-listings-alert").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 = {
    "location": "Manchester",
    "channel": "buy",
    "maxItems": 25,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lowlanddata/rightmove-new-listings-alert").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 '{
  "location": "Manchester",
  "channel": "buy",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lowlanddata/rightmove-new-listings-alert --silent --output-dataset

```

## MCP server setup

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

```

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/MnkymQ6wlw0zn02PD/builds/FZjz03hS0eg54ub94/openapi.json