# Zoopla Scraper (`solidcode/zoopla-scraper`) Actor

\[💰 $5 / 1K] Extract UK for-sale property listings from Zoopla — asking price, full address, postcode, beds, baths, property type, tenure, energy rating, photos, floor plans, GPS coordinates, plus estate-agent name and phone. Filter by location, price, beds, and type, or paste Zoopla URLs.

- **URL**: https://apify.com/solidcode/zoopla-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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/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

## Zoopla Scraper

Pull for-sale property listings from Zoopla at scale — asking prices, full UK addresses with postcode, beds/baths/receptions, tenure, EPC energy ratings, agent branch contacts, every listing photo, floor plans, and exact GPS coordinates for any town, city, borough, or postcode in England, Scotland, Wales, and Northern Ireland. Built for UK property investors, estate agents, mortgage and valuation teams, and proptech analysts who need fresh Zoopla data without copying listings off the site one page at a time.

### Why This Scraper?

- **Eight property-type filters** — houses, flats/apartments, detached, semi-detached, terraced, bungalows, land/plots, or any. Sent straight to Zoopla's search so you only collect — and only pay for — the types you want.
- **Full address with postcode, plus exact GPS coordinates** — latitude and longitude on every listing for mapping, geocoding, and catchment analysis; the postcode is added when you enable full details.
- **Asking price and price qualifier in one row** — the numeric GBP price alongside its qualifier ("Guide price", "Offers over", "POA") so you never misread a guide price as a fixed one.
- **Beds, baths, and reception-room counts** — three separate room counts per property, refined to exact figures from the property's own page when full details are on.
- **Tenure and EPC energy rating** — freehold vs leasehold and the A–G energy rating captured per property, the two facts mortgage and valuation teams always need.
- **Estate-agent branch name, phone, and branch URL** — a ready-made vendor-lead contact attached to every listing, not just a logo.
- **Every photo and floor plan, not just a thumbnail** — the complete image gallery as full-size URLs plus floor-plan images, with a live photo count per property.
- **Recency filter down to the last 24 hours** — limit to listings added in the last 24 hours, 3, 7, or 14 days to catch brand-new stock before it spreads.
- **Breaks Zoopla's ~1,000-results-per-search ceiling** — a broad search is split automatically into price bands so you can pull well beyond the single-search limit, with duplicates removed by listing ID.

### Use Cases

**Property Investment & Market Research**
- Track asking prices and price qualifiers across boroughs and postcodes
- Map inventory by property type to spot supply gaps
- Monitor new for-sale stock added in the last 24 hours or 7 days
- Compare price per area across towns and cities

**Estate Agency & Lead Generation**
- Build vendor-lead lists with branch name, phone, and branch URL
- Track competing agents' live for-sale stock in your patch
- Identify newly listed properties before they gain traction
- Benchmark your listings against the local market

**Mortgage & Valuation**
- Pull tenure (freehold/leasehold) and EPC ratings for risk assessment
- Gather comparable asking prices with exact bed/bath counts
- Feed addresses and coordinates into automated valuation models
- Cross-check listing descriptions for non-standard construction flags

**Relocation & Buyer Search**
- Filter by price, bedrooms, and type to shortlist matching homes
- Collect full descriptions, photos, and floor plans in one dataset
- Map candidate properties by latitude and longitude
- Watch a target area for fresh listings on a schedule

**Data & Analytics**
- Feed structured UK property data into dashboards and reports
- Enrich existing address databases with current pricing and status
- Power comparison tools and market-trend models
- Build alerts on new listings and price changes

### Getting Started

#### Search by Location

The simplest way to start — just a UK location:

```json
{
    "searchLocations": ["London"],
    "maxResults": 50
}
````

#### Filtered Search

Narrow to the stock you actually want — three-bed houses in a price band, newest first:

```json
{
    "searchLocations": ["Manchester", "Leeds"],
    "propertyType": "houses",
    "priceMin": 250000,
    "priceMax": 500000,
    "bedsMin": 3,
    "addedToSite": "7",
    "sort": "newest",
    "maxResults": 300
}
```

#### Start URLs with Full Details

Paste a Zoopla search or listing URL and enrich every result with description, tenure, EPC rating, floor plans, and postcode:

```json
{
    "startUrls": [
        "https://www.zoopla.co.uk/for-sale/property/london/",
        "https://www.zoopla.co.uk/for-sale/details/12345678/"
    ],
    "includeDetails": true,
    "maxResults": 200
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchLocations` | array | `["London"]` | UK locations to search — a town, city, borough, or postcode (e.g. "London", "Manchester", "SW1A"). Each entry runs its own search. |
| `startUrls` | array | `[]` | Power-user input. Paste Zoopla for-sale search-result URLs or individual listing URLs. When provided, these override Search Locations and Filters — any filters in the URL are used as-is. |

#### Filters

Filters apply to Search Locations only — Start URLs carry their own filters.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `propertyType` | select | `Any` | Property type: Any, Houses, Flats / Apartments, Detached, Semi-Detached, Terraced, Bungalows, or Land / Plots. |
| `priceMin` | integer | *none* | Only include listings at or above this asking price in GBP. |
| `priceMax` | integer | *none* | Only include listings at or below this asking price in GBP. |
| `bedsMin` | integer | *none* | Only include properties with at least this many bedrooms (0 = studio). |
| `bedsMax` | integer | *none* | Only include properties with at most this many bedrooms. |
| `addedToSite` | select | `Any time` | Listed within: Any time, Last 24 hours, Last 3 days, Last 7 days, or Last 14 days. |
| `sort` | select | `Newest first` | Result order: Newest first, Lowest price first, or Highest price first. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to collect across all searches and URLs. Set to 0 for unlimited. Collected in full pages of about 25, so the final page may overshoot by a few records. |
| `includeDetails` | boolean | `false` | Visit each property's own page to add the full description, tenure (freehold/leasehold), EPC energy rating, floor plans, exact room counts, and postcode. Leave off for a faster run. |

### Output

Each property is one flat row. Here's a representative result with full details enabled:

```json
{
    "listingId": "68472913",
    "title": "3 bed semi-detached house for sale",
    "status": "for_sale",
    "price": 425000,
    "priceDisplay": "£425,000",
    "priceCurrency": "GBP",
    "priceQualifier": "Guide price",
    "propertyType": "Semi-detached house",
    "beds": 3,
    "baths": 2,
    "receptions": 2,
    "areaSqft": 1184,
    "tenure": "Freehold",
    "energyRating": "C",
    "description": "A beautifully presented three-bedroom semi-detached home...",
    "address": "Elm Grove, London, SW19",
    "postcode": "SW19 4HE",
    "latitude": 51.4214,
    "longitude": -0.2065,
    "coverPhoto": "https://lid.zoocdn.com/645/430/abc123.jpg",
    "photos": ["https://lid.zoocdn.com/645/430/abc123.jpg", "https://lid.zoocdn.com/645/430/def456.jpg"],
    "floorPlan": ["https://lc.zoocdn.com/floorplan1.jpg"],
    "numPhotos": 18,
    "numFloorPlans": 1,
    "branchName": "Hamptons - Wimbledon",
    "branchPhone": "020 8000 0000",
    "branchUrl": "https://www.zoopla.co.uk/find-agents/branch/hamptons-wimbledon-12345/",
    "agentLogo": "https://st.zoocdn.com/zoopla_static_agent_logo_123.png",
    "listedOn": "2026-06-20",
    "url": "https://www.zoopla.co.uk/for-sale/details/68472913/",
    "scrapedAt": "2026-06-26T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Zoopla listing ID |
| `title` | string | Listing title / heading |
| `status` | string | `for_sale` or `under_offer` |
| `propertyType` | string | Property type as shown on Zoopla |
| `url` | string | Direct Zoopla listing URL |
| `listedOn` | string | Date the listing was first published |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Asking price as a number, in GBP |
| `priceDisplay` | string | Asking price formatted as shown (e.g. "£425,000") |
| `priceCurrency` | string | Currency code (always "GBP") |
| `priceQualifier` | string | Price qualifier — "Guide price", "Offers over", "POA", etc. |

#### Property Details

| Field | Type | Description |
|-------|------|-------------|
| `beds` | number | Number of bedrooms |
| `baths` | number | Number of bathrooms |
| `receptions` | number | Number of reception rooms |
| `areaSqft` | number | Floor area in square feet, when published |
| `tenure` | string | Freehold or leasehold (full details only) |
| `energyRating` | string | EPC energy rating A–G (full details only) |
| `description` | string | Full listing description (full details only) |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Display address |
| `postcode` | string | Postcode / outcode (full details only) |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `coverPhoto` | string | Primary image URL |
| `photos` | string\[] | All listing photo URLs, full size |
| `floorPlan` | string\[] | Floor-plan image URLs (full details only) |
| `numPhotos` | number | Number of photos on the listing |
| `numFloorPlans` | number | Number of floor plans on the listing |

#### Agent

| Field | Type | Description |
|-------|------|-------------|
| `branchName` | string | Estate-agent branch name |
| `branchPhone` | string | Branch phone number |
| `branchUrl` | string | Agent branch page URL |
| `agentLogo` | string | Agent logo image URL |

### Tips for Best Results

- **Start small** — set `maxResults` to 10–50 on your first run to confirm the data fits your needs, then scale up.
- **Use price bands to break the per-search ceiling** — a single broad location search tops out near 1,000 results. Add a price, bedroom, or property-type filter to reach more; for very large pulls the scraper also splits a wide search into price ranges automatically and removes duplicates by listing ID.
- **Turn on full details only when you need them** — `includeDetails` adds description, tenure, EPC rating, floor plans, exact room counts, and postcode by visiting each property's own page, so it's slower. Leave it off when price, address, beds/baths, agent contact, photos, and coordinates are enough.
- **Paste a Zoopla search URL to replicate an exact on-site filter** — set up your search on Zoopla with the filters you want, then drop the resulting URL into Start URLs; the actor reuses those filters as-is.
- **Filter at the source to control cost** — every filter is sent to Zoopla's search, so narrowing by type, price, or bedrooms means you collect and pay for matching listings only.
- **Search multiple locations in one run** — add several towns, boroughs, or postcodes to `searchLocations` to cover a region in a single dataset.
- **Sort by Newest first to monitor fresh stock** — pair `sort: "newest"` with an `addedToSite` window like Last 24 hours to capture brand-new listings on a schedule.

### Pricing

**From $5.00 per 1,000 results** — undercutting comparable Zoopla scrapers while returning a richer row per property. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.54 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.35 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.50 | $50.00 |
| 100,000 | $600.00 | $565.00 | $535.00 | $500.00 |

A "result" is any property row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.** Enabling full-detail enrichment makes each row richer but does not change the per-result price — it is still one charge per property.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate UK property research, market analysis, and lead generation, and collects only publicly available listing information. Users are responsible for complying with applicable laws and Zoopla's Terms of Service. Treat any personal data (such as agent contact details) in line with UK GDPR and use it only for lawful, proportionate purposes. Do not use extracted data for spam, harassment, or any unlawful activity.

# Actor input Schema

## `searchLocations` (type: `array`):

UK locations to search for properties for sale — a town, city, borough, or postcode (e.g. 'London', 'Manchester', 'SW1A'). Each entry runs its own search. Leave empty if you are pasting Start URLs below.

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

Power-user input. Paste Zoopla for-sale search-result URLs (e.g. https://www.zoopla.co.uk/for-sale/property/london/) or individual listing URLs. When provided, these override the Search Locations and Filters above — any filters in the URL are used as-is.

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

Filter by property type. Choose 'Any' to include all. Only applies to Search Locations — ignored when using Start URLs.

## `priceMin` (type: `integer`):

Only include listings at or above this asking price in GBP. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only include listings at or below this asking price in GBP. Leave empty for no maximum.

## `bedsMin` (type: `integer`):

Only include properties with at least this many bedrooms (0 = studio). Leave empty for no minimum.

## `bedsMax` (type: `integer`):

Only include properties with at most this many bedrooms. Leave empty for no upper limit.

## `addedToSite` (type: `string`):

Only include listings added to Zoopla within this period. Choose 'Any time' for no recency filter.

## `sort` (type: `string`):

How Zoopla orders results before we collect them.

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

Maximum number of listings to collect across all searches and URLs. Set to 0 for unlimited. Results are collected in full pages of about 25, so the final page may overshoot this cap by a few records. A single broad location search tops out near 1,000 results — add price, bedroom, or property-type filters to reach more, or the scraper will automatically split a wide search into price ranges to collect beyond that limit. Tip: start with 10-50 to test, then increase.

## `includeDetails` (type: `boolean`):

Visit each property's own page to add the full description, tenure (freehold/leasehold), energy (EPC) rating, floor plans, exact room counts, and postcode. Leave off for a faster run — the standard fields (price, address, beds/baths, agent contact, photos, coordinates) are always included.

## Actor input object example

```json
{
  "searchLocations": [
    "London"
  ],
  "startUrls": [],
  "propertyType": "any",
  "addedToSite": "anytime",
  "sort": "newest",
  "maxResults": 100,
  "includeDetails": false
}
```

# Actor output Schema

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

Table of scraped property listings with key fields — price, address, beds, baths, type, agent branch, and listing URL.

## `details` (type: `string`):

Full per-listing fields including description, tenure, energy rating, all photos, floor plans, coordinates, branch contact, and timestamps.

# 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 = {
    "searchLocations": [
        "London"
    ],
    "startUrls": [],
    "propertyType": "any",
    "addedToSite": "anytime",
    "sort": "newest",
    "maxResults": 100,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/zoopla-scraper").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 = {
    "searchLocations": ["London"],
    "startUrls": [],
    "propertyType": "any",
    "addedToSite": "anytime",
    "sort": "newest",
    "maxResults": 100,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/zoopla-scraper").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 '{
  "searchLocations": [
    "London"
  ],
  "startUrls": [],
  "propertyType": "any",
  "addedToSite": "anytime",
  "sort": "newest",
  "maxResults": 100,
  "includeDetails": false
}' |
apify call solidcode/zoopla-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/zoopla-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoopla Scraper",
        "description": "[💰 $5 / 1K] Extract UK for-sale property listings from Zoopla — asking price, full address, postcode, beds, baths, property type, tenure, energy rating, photos, floor plans, GPS coordinates, plus estate-agent name and phone. Filter by location, price, beds, and type, or paste Zoopla URLs.",
        "version": "1.0",
        "x-build-id": "7nHFg1wszryl5MoLd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~zoopla-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-zoopla-scraper",
                "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/solidcode~zoopla-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-zoopla-scraper",
                "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/solidcode~zoopla-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-zoopla-scraper",
                "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",
                "properties": {
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "UK locations to search for properties for sale — a town, city, borough, or postcode (e.g. 'London', 'Manchester', 'SW1A'). Each entry runs its own search. Leave empty if you are pasting Start URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Zoopla for-sale search-result URLs (e.g. https://www.zoopla.co.uk/for-sale/property/london/) or individual listing URLs. When provided, these override the Search Locations and Filters above — any filters in the URL are used as-is.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "houses",
                            "flats",
                            "detached",
                            "semi-detached",
                            "terraced",
                            "bungalows",
                            "land"
                        ],
                        "type": "string",
                        "description": "Filter by property type. Choose 'Any' to include all. Only applies to Search Locations — ignored when using Start URLs.",
                        "default": "any"
                    },
                    "priceMin": {
                        "title": "Minimum Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this asking price in GBP. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this asking price in GBP. Leave empty for no maximum."
                    },
                    "bedsMin": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at least this many bedrooms (0 = studio). Leave empty for no minimum."
                    },
                    "bedsMax": {
                        "title": "Maximum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at most this many bedrooms. Leave empty for no upper limit."
                    },
                    "addedToSite": {
                        "title": "Listed Within",
                        "enum": [
                            "anytime",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Only include listings added to Zoopla within this period. Choose 'Any time' for no recency filter.",
                        "default": "anytime"
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "How Zoopla orders results before we collect them.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all searches and URLs. Set to 0 for unlimited. Results are collected in full pages of about 25, so the final page may overshoot this cap by a few records. A single broad location search tops out near 1,000 results — add price, bedroom, or property-type filters to reach more, or the scraper will automatically split a wide search into price ranges to collect beyond that limit. Tip: start with 10-50 to test, then increase.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Property Details",
                        "type": "boolean",
                        "description": "Visit each property's own page to add the full description, tenure (freehold/leasehold), energy (EPC) rating, floor plans, exact room counts, and postcode. Leave off for a faster run — the standard fields (price, address, beds/baths, agent contact, photos, coordinates) are always included.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
