# Zoopla UK Property API (`johnvc/zoopla-property-api`) Actor

UK property listings and sold house prices as clean, structured JSON. Search by town or postcode with no listing URL needed, and get price, beds, baths, tenure, UPRN, and dated price history including what each property last sold for and when. Pay per listing, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/zoopla-property-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, Real estate, Lead generation
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.43 / 1,000 listing 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/platform/actors/running/actors-in-store#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

## Zoopla UK Property API | Sold House Prices and Listings

UK property listings and sold house prices as clean, structured JSON. Search any town, city, or postcode area and get back live listings with full dated price history, including what each property last sold for and when.

Search by location rather than by URL. UK listings are removed quickly once a property is sold or let, so a saved listing link often points at a dead page within weeks. This Actor finds current listings from a place name, so you never have to hold a URL.

Everything here comes from public [Zoopla](https://www.zoopla.co.uk/) property pages. This is an independent tool and is not affiliated with, endorsed by, or connected to Zoopla.

### What this actor returns

- **Sold price history:** every dated event on the property, including `Sold` events going back decades, each with the price as published and a parsed numeric value
- **Listing detail:** price, bedrooms, bathrooms, reception rooms, property type, address, tenure, floor area where published
- **UPRN:** the UK government's Unique Property Reference Number, the join key for Land Registry and council datasets
- **Agent and marketing:** agent name and phone, features, tags, full description, photos, floor plans
- **Leasehold detail:** deposit, service charge, and ground rent where they apply

Every listing row also carries a one-line plain-language `summary`, so an AI agent can read a record without post-processing.

### Use cases

- **Research sold house prices.** Pull current listings for a town and read each property's sale history: what it sold for, and in what year.
- **Build a comparable-sales dataset.** Search a postcode area and export address, last sold price, and sold date for every result.
- **Track asking price against sale price.** The listing history shows the original listing price, any reductions, and the previous sale, all on one record.
- **Join to Land Registry data.** UPRN comes through on ordinary housing stock, so records match cleanly against government property datasets.
- **Monitor a local market.** Re-run a location on a schedule and diff the results to see new listings and price reductions.

### Input parameters

| Parameter | Type | Required | Default | Description | Example |
|---|---|---|---|---|---|
| `mode` | string | **Required** | `search` | `search` finds listings from a location and needs no URL. `url` collects specific listing pages you already hold. | `search` |
| `locations` | array of strings | Required in search mode | `["London"]` prefill | UK towns, cities, boroughs, or postcode areas. Up to 20 per run. | `["Manchester", "SW1"]` |
| `propertyType` | string | Optional | `For sale` | `For sale` or `to rent`. | `For sale` |
| `maxResultsPerSearch` | integer | Optional | `50` | Listings to return per location, from 1 to 2000. This is your cost control, since you are charged per listing. | `50` |
| `listingUrls` | array of strings | Required in URL mode | none | Specific listing URLs. Up to 500 per run. | `["https://www.zoopla.co.uk/for-sale/details/70012345/"]` |

```json
{
  "mode": "search",
  "locations": ["Rochdale"],
  "propertyType": "For sale",
  "maxResultsPerSearch": 50
}
```

### Example output

One dataset item per property. Every item carries a `result_type` of `listing` or `error`, so you can filter cleanly on the way out.

```json
{
  "result_type": "listing",
  "searchLabel": "Rochdale (For sale)",
  "address": "Edenfield Road, Norden, Rochdale OL11",
  "propertyType": "2 bed end terrace house for sale",
  "price": "£200,000.00",
  "priceValue": 200000,
  "bedrooms": 2,
  "uprn": "23039313",
  "lastSoldPrice": "£118,000",
  "lastSoldDate": "September 2013",
  "lastSoldValue": 118000,
  "listingHistory": [
    { "event": "Listed", "date": "May 2026", "price": "£200,000", "priceValue": 200000 },
    { "event": "Sold", "date": "September 2013", "price": "£118,000", "priceValue": 118000 }
  ],
  "listingUrl": "https://www.zoopla.co.uk/for-sale/details/73439538/",
  "summary": "2 bed end terrace house for sale at Edenfield Road, Norden, Rochdale OL11 listed at £200,000.00. Last sold for £118,000 in September 2013."
}
```

Alongside the fields above, a listing row can also carry `propertyId`, `propertyTitle`, `currency`, `bathrooms`, `receptions`, `propertySize`, `tenure`, `availability`, `listingLabel`, `features`, `tags`, `description`, `images`, `floorPlans`, `deposit`, `serviceCharge`, `groundRent`, `agentName`, `agentPhone`, `countryCode`, and `fetched_at`.

A search or URL that returns nothing produces a row with `result_type: "error"` and a plain-language `error_message`, so a failure never disappears silently.

### Pricing

Pay per result. One event, `listing-scraped`, is charged once for every listing pushed to the dataset.

Listings that are no longer live are **not charged**. The source does not bill us for a removed listing, so we do not bill you for one either. Use `maxResultsPerSearch` to cap what a run can cost. Current rates are shown on the Store card.

### How to get started

1. [View on Apify Store](https://apify.com/johnvc/zoopla-property-api?fpr=9n7kx3) and click Try for free.
2. Leave **Mode** on `search`, and enter a town or postcode area under **Locations**.
3. Run it. Results appear on the Output tab and export as JSON, CSV, or Excel. The **Sold prices and history** view shows sale history directly.

Starting from code instead? The [example repo with a Python quick start and MCP walkthrough](https://github.com/johnisanerd/Apify-Zoopla-Property-API) has a runnable script and setup steps for every MCP client.

### 🔌 Use this API from Claude (MCP)

Add this Actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Cursor, or any other MCP client through the hosted Apify MCP server:

```
https://mcp.apify.com/?tools=actors,docs,johnvc/zoopla-property-api
```

With [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial):

```
claude mcp add --transport http zoopla "https://mcp.apify.com/?tools=actors,docs,johnvc/zoopla-property-api"
```

Then ask your agent something like "what did houses on Edenfield Road in Rochdale last sell for".

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The Zoopla UK Property API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/zoopla-property-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: Track UK Sold House Prices on a Schedule

One run tells you what a street looks like today. The useful version is the same town collected week after week, so you can see what came on, what got reduced, and how asking prices sit against the last recorded sale. The [Apify platform integrations](https://docs.apify.com/platform/integrations) do that part for you, with no server and no cron job of your own.

#### Tasks and schedules: the core monitoring recipe

The pattern is one saved task per place you care about, and one schedule across all of them.

1. **Create a task.** A [saved task](https://docs.apify.com/platform/actors/running/tasks) is this Actor plus a saved input. Give each area its own named task, for example *"Rochdale for sale"* with `mode: "search"`, `locations: ["Rochdale"]`, and `maxResultsPerSearch: 50`. On the Actor page, click **Create empty task**, fill in the input, and save.
2. **Attach a schedule.** Open [Schedules](https://docs.apify.com/platform/schedules) in Apify Console, create a schedule with a cron expression, and add your tasks to it. Useful strings: `0 7 * * *` for every morning at 7 AM, `0 */6 * * *` for every six hours, `0 9 * * 1` for Monday mornings. One schedule can trigger many tasks, so a single "weekly market check" schedule can cover every town on your list.
3. **Diff the runs.** Each run appends to the task's dataset list. Compare `priceValue` for the same `listingUrl` across two runs and you have reductions; anything with a new `propertyId` is a new instruction.

The published task [Track UK Asking Price Changes in a Town Weekly](https://apify.com/johnvc/zoopla-property-api/examples/track-uk-asking-price-changes-in-a-town-weekly?fpr=9n7kx3) is this recipe already wired up.

#### n8n

There is no dedicated community node for this Actor yet, so use the [Apify n8n integration](https://docs.apify.com/platform/integrations/n8n), which can run any Actor and read its dataset. A price-drop workflow is four nodes: **Schedule Trigger** every Monday at 7 AM, then the **Apify** node running `johnvc/zoopla-property-api` for your location, then a **Filter** keeping rows where `priceValue` is below the value you stored last week, then a **Slack** or email node with the address and the listing link.

#### Make and Zapier

Both platforms have native Apify integrations, [Apify on Make](https://docs.apify.com/platform/integrations/make) and [Apify on Zapier](https://docs.apify.com/platform/integrations/zapier), with "Run Actor" and "Get Dataset Items" actions. The same pattern applies: trigger on a schedule, run the Actor, filter on price, then notify or store.

#### Supabase: keep a house price history

Comparables are only useful if you keep them. [Supabase](https://supabase.com/) (hosted Postgres) works well, and there are two routes.

- **No code:** in n8n, send the Apify node's output straight into the built-in Supabase node, one row per listing after each scheduled run.
- **A few lines of Python:** run the Actor and bulk-insert the listing rows into a table.

```python
from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("https://YOUR_PROJECT.supabase.co", "YOUR_SERVICE_ROLE_KEY")

run = apify.actor("johnvc/zoopla-property-api").call(
    run_input={
        "mode": "search",
        "locations": ["Rochdale"],
        "propertyType": "For sale",
        "maxResultsPerSearch": 50,
    }
)

rows = [
    {
        "address": item.get("address"),
        "price_value": item.get("priceValue"),
        "bedrooms": item.get("bedrooms"),
        "uprn": item.get("uprn"),
        "last_sold_price": item.get("lastSoldPrice"),
        "last_sold_date": item.get("lastSoldDate"),
        "last_sold_value": item.get("lastSoldValue"),
        "listing_url": item.get("listingUrl"),
        "fetched_at": item.get("fetched_at"),
    }
    for item in apify.dataset(run.default_dataset_id).iterate_items()
    if item.get("result_type") == "listing"
]

if rows:
    supabase.table("uk_house_prices").insert(rows).execute()
```

Point that at a weekly schedule and the table becomes your own comparable-sales history, keyed on UPRN so it joins to Land Registry data.

#### MCP and AI agents

The Actor is exposed through the [Apify MCP server](https://mcp.apify.com/), so Claude, Cursor, and any other MCP client can run a live search as a tool and answer questions like "what did three bed terraces in Rochdale last sell for, and what are they asking now". The published task [Get UK Sold House Prices in Claude via MCP](https://apify.com/johnvc/zoopla-property-api/examples/get-uk-sold-house-prices-in-claude-via-mcp?fpr=9n7kx3) walks through the setup for [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial).

#### Webhooks

For anything custom, attach an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) to the `ACTOR.RUN.SUCCEEDED` event. When a scheduled run finishes, Apify posts the run details and dataset ID to your endpoint, which can then fetch the rows and update a sheet, a dashboard, or an alert.

### Speed and reliability

A location search takes a couple of minutes. The Actor collects in chunks and pushes each chunk before fetching the next, so a long run still returns data as it goes.

Search inputs and listing URLs are both validated before anything is sent upstream. A malformed URL is rejected locally rather than forwarded, because bad input sent to the source can stall an entire collection.

### 🔗 Related Tools

Property research rarely stops at the listing. These Actors cover the questions that come next.

- [Realestate.com.au Property API](https://apify.com/johnvc/realestate-au-property-api?fpr=9n7kx3) for the same shape of listing and sold-price data in Australia.
- [Google Maps Places Scraper](https://apify.com/johnvc/google-maps-places-api?fpr=9n7kx3) for the shops, schools, and amenities around an address, the thing buyers actually ask about after price.
- [Google Maps Directions API](https://apify.com/johnvc/google-maps-directions-api?fpr=9n7kx3) for commute times from a postcode to a workplace or station, which is how most buyers filter a shortlist.
- [Google Local API](https://apify.com/johnvc/google-local-api?fpr=9n7kx3) for local pack results, useful for pulling the estate agents and trades operating in an area.
- [FuelPrices API](https://apify.com/johnvc/fuelprices?fpr=9n7kx3) for local cost-of-living context alongside the housing numbers.

Free alternatives exist. [Fast Zoopla Properties Scraper](https://apify.com/tri_angle/fast-zoopla-properties-scraper?fpr=9n7kx3) is one, but the Store reports its run success rate at around 34 percent, and it works from search URLs you build yourself. This API searches from a place name, returns a dated price history on each row, and writes a plain-language error row instead of failing silently when a listing has gone.

### Applications

Ready-to-run examples of this API in action. Open any one and run it in a single click.

#### Check Sold House Prices for Any UK Town or Postcode

Search a town or postcode area and read the last sold price and date on every result returned.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/check-sold-house-prices-for-any-uk-town-or-postcode?fpr=9n7kx3)

#### Zoopla Property Data API: UK Listings as JSON

Structured JSON for UK for-sale listings, ready to call from your own code or an agent.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/zoopla-property-data-api-uk-listings-as-json?fpr=9n7kx3)

#### Track UK Asking Price Changes in a Town Weekly

Run the same town on a weekly schedule and diff asking prices to catch reductions.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/track-uk-asking-price-changes-in-a-town-weekly?fpr=9n7kx3)

#### Get UK Sold House Prices in Claude via MCP

Add the Actor to an MCP client and ask for sale history in plain English.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/get-uk-sold-house-prices-in-claude-via-mcp?fpr=9n7kx3)

#### Export a UK House Price Dataset to CSV or Excel

Build a house price dataset for a location and export it in one click.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/export-a-uk-house-price-dataset-to-csv-or-excel?fpr=9n7kx3)

#### Compare Asking Price to Last Sold Price by Town

Put today's asking price next to the property's previous sale on the same row.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/compare-asking-price-to-last-sold-price-by-town?fpr=9n7kx3)

#### 查询英国城镇房屋成交价与历史价格 (Check UK Town Sold Prices and Price History)

输入英国城镇或邮编，获取每套房屋的成交价、成交日期与完整价格历史。Enter a UK town or postcode and get each property's sold price, sold date, and full price history.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/chaxun-yingguo-fangwu-chengjiaojia?fpr=9n7kx3)

#### 获取英国在售房源与价格数据 (Get UK For-Sale Listings and Price Data)

按地点获取英国在售房源的价格、卧室数、房屋类型与产权信息。Collect UK for-sale listings by location with price, bedrooms, property type, and tenure.
[Run this task](https://apify.com/johnvc/zoopla-property-api/examples/huoqu-yingguo-zaishou-fangyuan-shuju?fpr=9n7kx3)

### FAQ

#### How do I check sold house prices?

Run a search for the town or postcode area you care about. Every returned property carries its `listingHistory`, and any `Sold` event in that history gives the sale price and date. The `lastSoldPrice` and `lastSoldDate` fields lift the most recent sale out for convenience.

#### How far back does the sale history go?

It depends on the property, and it is whatever the source holds. In live testing across ordinary housing stock, sale events went back to the late 1990s.

#### Do all properties have a sold price?

No. New-build homes have never been sold before, and some listings carry no recorded history. Very expensive or unusual properties are also more likely to have gaps. Ordinary housing stock reliably carries history.

#### What is a UPRN and why does it matter?

The Unique Property Reference Number is the UK government's identifier for an individual address. It lets you join these records to Land Registry, council tax, and planning datasets without fuzzy address matching.

#### Can I search for rentals instead?

Yes. Set **Listing type** to `to rent`. Rental rows carry the rent, and deposit where published.

#### Why should I search by location instead of pasting listing URLs?

UK listings are removed quickly once a property is sold or let. A URL saved even a few weeks ago frequently points at a page that no longer exists. Searching by location always returns what is live right now.

#### What happens if a listing has been removed?

You get an error row saying so, and you are not charged for it.

#### Does it return council tax band or EPC ratings?

No. Those fields are not returned by this source in practice, so they are deliberately not part of the output rather than being present and always empty.

#### Can I get a Zoopla estimate or valuation through this API?

No. The Actor returns what the listing publishes: the asking price, the dated price history, and the last recorded sale. It does not return the site's own automated valuation. If you want an estimate of value, the usual approach is to build it yourself from `lastSoldValue` and `priceValue` across comparable properties in the same postcode area.

#### Is the Zoopla API accessible?

Zoopla's own public developer API has been restricted for years, which is why most people searching for it end up somewhere like this page. This Actor is an independent tool that reads public [Zoopla](https://www.zoopla.co.uk/) listing pages and returns them as JSON. It is not the official API, and it is not affiliated with, endorsed by, or connected to Zoopla.

#### Can I schedule this UK property Scraper?

Yes, and this is where the Actor earns its keep. Any run can be automated on a [schedule](https://docs.apify.com/platform/schedules). Create a [saved task](https://docs.apify.com/platform/actors/running/tasks) holding the input you want, for example one town in `locations` with `maxResultsPerSearch` set to your budget, then attach a schedule from the Actor's **Actions** menu, then **Schedule**. Cron examples: `0 7 * * *` runs every morning at 7 AM, `0 */6 * * *` runs every six hours, `0 9 * * 1` runs Monday mornings. One schedule can trigger many tasks at once, so a single weekly schedule can cover a dozen towns. The full monitoring recipe, including how to diff two runs for price reductions, is in the Integrations section above.

#### Should I use an official API or a web Scraper for UK house price data?

An official [API](https://en.wikipedia.org/wiki/API) is the cleaner option when it exists, is open, and returns the fields you need. For UK property that is rarely the case: the portal APIs are gated or partner-only, and the open government data lags the market by months. [Web scraping](https://en.wikipedia.org/wiki/Web_scraping) fills the gap, and this Actor gives you the scraper's coverage behind an API-shaped interface: send JSON input, get JSON rows back, with no quota to negotiate and no HTML parsing on your side.

#### Can I use this Actor with the Apify API?

Yes. The Apify API can start runs, schedule them, check status, and fetch datasets, so you can drive the whole thing from your own backend. Official `apify-client` packages exist for both Python and Node.js. The exact endpoints and a ready-made snippet are on the [Actor's API tab](https://apify.com/johnvc/zoopla-property-api/api?fpr=9n7kx3).

#### Can I use this Actor through an MCP Server?

Yes. It is available through the hosted [Apify MCP server](https://mcp.apify.com/), so you can add it as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Cursor, or any other MCP client. The Actor-specific URL is `https://mcp.apify.com/?tools=actors,docs,johnvc/zoopla-property-api`. See the [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp) for client setup.

#### Can I integrate this Actor with other apps?

Yes. Through [Apify integrations](https://docs.apify.com/platform/integrations) the output can go almost anywhere: [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [n8n](https://docs.apify.com/platform/integrations/n8n), Google Drive, and Google Sheets among others. For anything not on the list, an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` will post the run and dataset ID to your own endpoint. The Integrations section above has the full recipes.

#### How can I collect other UK property and location data?

Pair this API with the neighbouring Actors in the same portfolio. [Google Maps Places Scraper](https://apify.com/johnvc/google-maps-places-api?fpr=9n7kx3) gets the amenities around an address, [Google Maps Directions API](https://apify.com/johnvc/google-maps-directions-api?fpr=9n7kx3) gets commute times from a postcode, [Google Local API](https://apify.com/johnvc/google-local-api?fpr=9n7kx3) finds the agents and trades working an area, and [FuelPrices API](https://apify.com/johnvc/fuelprices?fpr=9n7kx3) adds running-cost context. Join them on the address or postcode you already have from this Actor.

#### How do I get property leads from this data?

Every listing row carries `agentName` and `agentPhone` where the listing publishes them, so a location search doubles as a list of the agents active in that area. Combine that with `lastSoldDate` to find owners who bought a long time ago, or filter on the `listingLabel` field for stock sitting as reduced or under offer. Note that the data covers properties and marketing agents, not private individuals.

#### How many listings can this Scraper return in one run?

`maxResultsPerSearch` goes up to 2000 per location, and a run accepts up to 20 locations in search mode or up to 500 URLs in URL mode. Since you are charged per listing returned, treat that setting as your budget control rather than a target.

#### Is it legal to scrape UK property listings?

Collecting public data is generally lawful in the UK and the US, though the details depend on what you collect and what you do with it. Apify has a readable summary in [is web scraping legal](https://blog.apify.com/is-web-scraping-legal/). This Actor only returns information already published on public [Zoopla](https://www.zoopla.co.uk/) listing pages, and it collects no personal data about private individuals.

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/zoopla-property-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.10

# Actor input Schema

## `mode` (type: `string`):

How to find properties. Search finds listings from a location and needs no URL, and is the reliable option because UK listings are removed quickly once sold or let. URL collects specific listing pages you already hold.

## `locations` (type: `array`):

UK towns, cities, boroughs, or postcode areas to search, for example "London", "Manchester", or "SW1". Used in search mode. Up to 20 per run.

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

Whether to search properties for sale or to rent. Defaults to 'For sale'. Used in search mode.

## `maxResultsPerSearch` (type: `integer`):

How many listings to return for each location searched. Defaults to 50. You are charged per listing returned, so this is also your cost control.

## `listingUrls` (type: `array`):

Specific Zoopla listing URLs to collect, for example https://www.zoopla.co.uk/for-sale/details/70012345/. Used in URL mode. A listing that has been sold or let is reported and not charged.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "London"
  ],
  "propertyType": "For sale",
  "maxResultsPerSearch": 50
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: collected listings and any error rows.

## `overview` (type: `string`):

Tabular overview of every listing. Columns: address, type, price, price value, beds, baths, tenure, and the listing link.

## `soldPrices` (type: `string`):

Each property with its last sold price and date, the numeric sold value, the full dated price history, and its UPRN for joining to Land Registry data.

# 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 = {
    "locations": [
        "London"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/zoopla-property-api").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 = { "locations": ["London"] }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/zoopla-property-api").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 '{
  "locations": [
    "London"
  ]
}' |
apify call johnvc/zoopla-property-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnvc/zoopla-property-api"
        }
    }
}

```

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/aQh5hsmxuT39Qvp09/builds/Tw82v8qWThkdirrgr/openapi.json