# Rightmove Listing Availability Checker (`confidential_gnat/rightmove-listing-availability-checker`) Actor

Actor that checks the availability of property listings on Rightmove. It takes a list of Rightmove listing URLs as input and verifies if each listing is still active or has been removed. The output includes the URL, availability status, and any relevant metadata for each listing.

- **URL**: https://apify.com/confidential\_gnat/rightmove-listing-availability-checker.md
- **Developed by:** [Night Owl](https://apify.com/confidential_gnat) (community)
- **Categories:** Real estate, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Rightmove Listing Availability Checker

Check whether **Rightmove property listings are still active or have been removed** — at scale, on a schedule, or via API. Give the actor a list of Rightmove listing URLs and it will tell you instantly whether each one returns a live page or a dead page (that does not exist on the platform anymore).

---

### What does this actor do?

The Rightmove Listing Availability Checker takes a list of Rightmove property URLs and checks each one for availability. For each URL it returns:

- Whether the listing is **active** or **not active**
- The **page title** (if active)
- The **exact date and time** the check was performed

It works by making a lightweight HTTP request to each URL — no browser needed — making it fast and cost-efficient.

---

### Purpose

This actor is useful when you need to:

- Monitor a portfolio of saved listings and get notified when they are taken down
- Verify whether listings collected in a previous scrape are still live
- Build automated pipelines that react to listings going offline (e.g. trigger a re-search when a favourite property is removed)
- Audit a large batch of Rightmove URLs quickly without visiting each one manually

---

### How to use

#### On Apify Console (no-code)

1. Go to the actor page on Apify and click **Try for free**
2. Paste your Rightmove listing URLs into the **Listing URLs** field (one per line)
3. Optionally enable **Proxy Configuration** for large runs
4. Click **Start** and wait for the run to finish
5. Download results from the **Output** tab in JSON, CSV, or Excel

#### As an API

You can trigger a run and retrieve results programmatically using the Apify API:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<YOUR_ACTOR_ID>/runs?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      { "url": "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET" },
      { "url": "https://www.rightmove.co.uk/properties/147692663#/?channel=RES_LET" }
    ]
  }'
````

Once the run finishes, fetch the results:

```bash
curl "https://api.apify.com/v2/actor-runs/<RUN_ID>/dataset/items?token=<YOUR_API_TOKEN>"
```

#### Using automation (Zapier / Make)

Connect this actor to Zapier or Make to build workflows such as:

- Run the checker on a schedule and send an email when a listing goes offline
- Update a Google Sheet with the latest availability status
- Trigger a Slack notification when a monitored listing is removed

***

### Input

| Field                | Type          | Required | Description                                                                                          |
| -------------------- | ------------- | -------- | ---------------------------------------------------------------------------------------------------- |
| `startUrls`          | Array of URLs | Yes      | Rightmove listing URLs to check. Must match the format `https://www.rightmove.co.uk/properties/<id>` |
| `proxyConfiguration` | Object        | Yes      | Proxy settings. Cheap datacenter by default.                                                         |

#### Input example

```json
{
    "startUrls": [
        { "url": "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET" },
        { "url": "https://www.rightmove.co.uk/properties/147692663#/?channel=RES_BUY" }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

> **Note:** Duplicate URLs are automatically removed, so the same listing is never checked more than once per run.

> **Note:** URLs that do not match the expected Rightmove listing format are skipped with a warning logged to the run output.

***

### Output

Results are stored in the actor's default dataset. Each item contains:

| Field         | Type              | Description                                                  |
| ------------- | ----------------- | ------------------------------------------------------------ |
| `url`         | String            | The listing URL that was checked                             |
| `title`       | String | null    | Page title if the listing is active, `null` if not found     |
| `isActive`    | Boolean           | `true` if the listing returned HTTP 200, `false` if HTTP 404 |
| `checkedDate` | String (ISO 8601) | Date and time the check was performed                        |

#### Output example

```json
[
    {
        "url": "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET",
        "title": "3 bedroom terraced house to rent | Rightmove",
        "isActive": true,
        "checkedDate": "2026-05-26T10:34:21.000Z"
    },
    {
        "url": "https://www.rightmove.co.uk/properties/147692663#/?channel=RES_BUY",
        "title": null,
        "isActive": false,
        "checkedDate": "2026-05-26T10:34:22.000Z"
    }
]
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the Apify Console.

***

### Pricing

This actor uses **Pay-per-result** billing based on compute units consumed.

- **Estimated cost: ~$0.50 per 1,000 URLs checked**
- New Apify accounts include a free usage tier — you can check hundreds of listings at no cost

Because the actor uses lightweight HTTP requests (no browser), it is significantly cheaper to run than browser-based scrapers.

***

### Tips for large runs

- **Proxy:** For runs over a few hundred URLs, enable a **residential proxy** (higher success rate if Rightmove blocks datacenter IPs) in the Proxy Configuration field.
- **Scheduling:** Use Apify's built-in scheduler to run the actor automatically (e.g. daily) and always have up-to-date availability data.
- **Deduplication:** The actor automatically removes duplicate URLs in your input, so you don't need to clean your list before running.

***

### Upcoming updates

- **Cross-run caching** — when enabled, the actor will remember which URLs were already checked in previous runs and skip them, saving compute costs on large recurring jobs where only new listings need to be verified.

***

### FAQ & support

**Is this legal?**
This actor accesses only publicly available Rightmove listing pages, the same pages a normal browser user would visit. Always ensure your usage complies with Rightmove's Terms of Service and applicable law.

**What happens if a URL is in an unsupported format?**
The actor skips it and logs a warning: `Unsupported url, please check the actor's information to know about valid inputs.`

**Can I run this on a schedule?**
Yes — use the Apify Console scheduler or the API to trigger runs automatically.

For bugs or feature requests, open an issue on the actor's Issues tab.

# Actor input Schema

## `startUrls` (type: `array`):

List of Rightmove listing URLs to check for availability. Duplicate URLs are automatically removed. Expected format: https://www.rightmove.co.uk/properties/<id>

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

Proxy settings. Disabled by default. For large runs, a datacenter or residential proxy is recommended to avoid blocking.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET"
  ],
  "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 = {
    "startUrls": [
        "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("confidential_gnat/rightmove-listing-availability-checker").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 = {
    "startUrls": ["https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.rightmove.co.uk/properties/52075274#/?channel=RES_LET"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call confidential_gnat/rightmove-listing-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=confidential_gnat/rightmove-listing-availability-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rightmove Listing Availability Checker",
        "description": "Actor that checks the availability of property listings on Rightmove. It takes a list of Rightmove listing URLs as input and verifies if each listing is still active or has been removed. The output includes the URL, availability status, and any relevant metadata for each listing.",
        "version": "1.0",
        "x-build-id": "t4umBeMm6dpJUqs4D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/confidential_gnat~rightmove-listing-availability-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-confidential_gnat-rightmove-listing-availability-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/confidential_gnat~rightmove-listing-availability-checker/runs": {
            "post": {
                "operationId": "runs-sync-confidential_gnat-rightmove-listing-availability-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/confidential_gnat~rightmove-listing-availability-checker/run-sync": {
            "post": {
                "operationId": "run-sync-confidential_gnat-rightmove-listing-availability-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Listing URLs",
                        "type": "array",
                        "description": "List of Rightmove listing URLs to check for availability. Duplicate URLs are automatically removed. Expected format: https://www.rightmove.co.uk/properties/<id>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Disabled by default. For large runs, a datacenter or residential proxy is recommended to avoid blocking.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
