# LuxuryEstate Real Estate Scraper (`crawlerbros/luxuryestate-scraper`) Actor

Scrape LuxuryEstate.com - a global luxury property portal listing villas, penthouses, mansions, castles and more across 90+ countries. Browse by country, region, property type and transaction (sale/rent), or fetch full listing details by URL.

- **URL**: https://apify.com/crawlerbros/luxuryestate-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## LuxuryEstate Real Estate Scraper

Scrape [LuxuryEstate.com](https://www.luxuryestate.com) — a global luxury property portal listing villas, penthouses, mansions, castles, country houses and more across 90+ countries. Browse listings for sale or rent by country, region/city, and property type, or pull full listing details (price, size, amenities, agency contact, images, video) for specific property URLs. No login, no API key, no proxy required.

### What this actor does

- **Two modes:** `browse` (search by country/region/property type/transaction, or by a specific agency) and `propertyDetails` (fetch full data for specific listing URLs)
- **Browse by agency** — set `agencyUrl` to pull a real estate agency's entire LuxuryEstate.com portfolio instead of browsing by geography
- **90+ countries** across Europe, the Americas, Africa, the Middle East, Asia-Pacific, and the Caribbean
- **15 property types**: apartments, penthouses, villas, mansions, castles, lands, and more
- **Sale or rent** transaction filter
- **Sort order**: relevance, price (low↔high), size (small↔large), most bedrooms, most rooms
- **Display currency**: view (and filter) prices in EUR, USD, GBP, CHF, AED, JPY, CNY, AUD, CAD, HKD, RUB, BRL, TRY, PLN, ILS or KRW — the source site's own live FX conversion
- **Numeric filters**: minimum/maximum price, minimum bedrooms, minimum bathrooms, minimum/maximum floor size
- **Amenity filters**: require any combination of 34 interior/exterior amenities (pool, garden, fireplace, elevator, waterfront, skylight, pond, etc.), plus dedicated garden/parking/balcony/terrace toggles
- **Cooling system filter**: restrict to listings with air conditioning or a ceiling fan
- **Rich per-listing data**: price, currency, size, bedrooms/bathrooms, amenities, coordinates, agency contact, images
- **Diacritic-tolerant location matching** — accented region/city names (e.g. `île-de-france`) resolve automatically
- **Empty fields are omitted** — every record only contains data that was actually found

### Output per property

#### Browse mode (`recordType: "propertyListing"`)

- `propertyId`, `title`, `propertyType`, `transaction` (`sale`/`rent`)
- `price` (numeric), `priceFormatted`, `currency`
- `sizeSqm` (internal floor area), `plotSizeSqm` (land/plot area)
- `bedrooms`, `bathrooms`, `rooms`
- `country`, `region`, `province`, `city`
- `latitude`, `longitude`
- `imageUrl`
- `agencyName`, `agencyUrl`, `agencyLogoUrl`
- `reference` — the listing agency's own reference code
- `datePosted`
- `amenities[]` — e.g. pool, garden, fireplace, elevator
- `heating[]` — heating system type(s), e.g. `heat_pump`, `forced_air`, when reported
- `buildYear`, `videoUrl`, `virtualTourUrl`, `floorPlanUrl` — when the listing provides them
- `exteriorMaterial[]`, `roofMaterial[]`, `floorMaterial[]` — construction materials (e.g. stucco, brick, tile, hardwood), when reported
- `lastUpdated` — when the agency last edited the listing
- `listingTier` — the agency's paid promotion tier for this listing (`elite`/`prestige`/`premium`/`collection`/`standard`); higher tiers rank first under relevance sort
- `floorNumber` — the unit's floor (0 = ground floor), when reported
- `gardenType[]` — garden type(s), e.g. `private`, `common`, when the listing has one
- `externalListingUrl` — the listing's page on a partner MLS/portal (e.g. Sotheby's International Realty), when the listing was syndicated from one
- `propertyUrl`, `sourceUrl`
- `scrapedAt`

#### Property details mode (`recordType: "propertyDetail"`)

All of the above (except `province` and `listingTier`, which are browse-only), plus:

- `description` — full listing description
- `parkingIndoor`, `parkingOutdoor`
- `images[]` — up to 30 full-resolution photo URLs
- `floorPlanImages[]`, `floorPlanUrl` — floor-plan diagrams, when the agency uploaded any
- `viewCount`, `likeCount` — the listing's page-view and favorite counters on LuxuryEstate.com
- `cooling[]` — cooling system type(s), e.g. `air_conditioning`, `ceiling_fan`, when reported
- `agencyPhone`, `agencyMobile`, `agencyEmail`, `agencyLocation`
- `address` — street address, when the listing agency made it public
- `postalCode` — postal/ZIP code (shown even when the full street address is withheld)
- `energyClass` — EU-style energy performance rating (e.g. `A+`, `B`, `G`), when provided
- `view[]` — view tags reported by the listing, e.g. `lake`, `mountains`, `city`
- `totalFloors` — the building's total floor count
- `kitchenType`, `kitchenCount` — kitchen layout (e.g. `kitchendiner`, `kitchenette`) and count, when reported
- `balconyCount` or `hasBalcony` — number of balconies when specified, otherwise a simple presence flag
- `terraceSizeSqm` or `hasTerrace` — terrace floor area when specified, otherwise a simple presence flag

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browse` | `browse` / `propertyDetails` |
| `country` | select | `italy` | Country to browse (mode=browse) |
| `location` | string | – | Optional region/city slug within the country, e.g. `lake-garda`. Ignored if `agencyUrl` is set |
| `agencyUrl` | string | – | Browse one agency's full inventory instead of by geography, e.g. `https://www.luxuryestate.com/a12123945-the-dream-real-estate-srl` (from any record's `agencyUrl` field). Overrides `country`/`location`/`propertyType`/`transaction` when set |
| `propertyType` | select | `any` | Restrict to one property type |
| `transaction` | select | `sale` | `sale` or `rent` |
| `sortBy` | select | `relevance` | `relevance` / `price-asc` / `price-desc` / `size-asc` / `size-desc` / `bedrooms-desc` / `rooms-desc` |
| `displayCurrency` | select | `EUR` | Currency for `price`/`priceFormatted` — `EUR`/`USD`/`GBP`/`CHF`/`AED`/`JPY`/`CNY`/`AUD`/`CAD`/`HKD`/`RUB`/`BRL`/`TRY`/`PLN`/`ILS`/`KRW` |
| `minPrice` / `maxPrice` | int | – | Price range filter, interpreted in `displayCurrency` |
| `minBedrooms` / `minBathrooms` | int | – | Minimum bedroom/bathroom count |
| `minSizeSqm` / `maxSizeSqm` | int | – | Internal floor area range (m²) |
| `amenities` | array | – | Only return listings with ALL selected amenities, e.g. `pool`, `garden`, `elevator`, `fireplace`, `waterfront` (mode=browse) |
| `withGarden` | boolean | `false` | Only listings with a garden (mode=browse) |
| `withParking` | boolean | `false` | Only listings with parking (mode=browse) |
| `withBalcony` | boolean | `false` | Only listings with a balcony (mode=browse) |
| `withTerrace` | boolean | `false` | Only listings with a terrace (mode=browse) |
| `coolingType` | select | `any` | Restrict to listings with `air_conditioning` or `ceiling_fan` (mode=browse) |
| `startPage` | int | `1` | First results page to fetch (15 listings/page) |
| `propertyUrls` | array | – | Full listing URLs (mode=propertyDetails) |
| `maxItems` | int | `30` | Hard cap on emitted records (1–1000) |

#### Example: villas for sale in Lake Garda, Italy, 3+ bedrooms

```json
{
  "mode": "browse",
  "country": "italy",
  "location": "lake-garda",
  "propertyType": "villas",
  "transaction": "sale",
  "minBedrooms": 3,
  "maxItems": 30
}
```

#### Example: apartments for rent in Monaco under €10,000

```json
{
  "mode": "browse",
  "country": "monaco",
  "propertyType": "apartments",
  "transaction": "rent",
  "maxPrice": 10000,
  "maxItems": 20
}
```

#### Example: waterfront houses with a pool and garden in the US

```json
{
  "mode": "browse",
  "country": "united-states",
  "propertyType": "houses",
  "amenities": ["pool", "garden", "waterfront"],
  "withParking": true,
  "maxItems": 20
}
```

#### Example: US houses priced in US dollars

```json
{
  "mode": "browse",
  "country": "united-states",
  "propertyType": "houses",
  "displayCurrency": "USD",
  "minPrice": 1000000,
  "maxItems": 20
}
```

#### Example: every listing from one agency, most expensive first

```json
{
  "mode": "browse",
  "agencyUrl": "https://www.luxuryestate.com/a12123945-the-dream-real-estate-srl",
  "sortBy": "price-desc",
  "maxItems": 50
}
```

#### Example: full details for specific listings

```json
{
  "mode": "propertyDetails",
  "propertyUrls": [
    "https://www.luxuryestate.com/p132776660-villa-for-sale-javea"
  ]
}
```

### Use cases

- **Real estate market research** — track luxury property pricing across countries and regions
- **Investment analysis** — filter by price, size and bedroom count to shortlist opportunities
- **Relocation & lifestyle platforms** — surface luxury inventory for a destination
- **Lead generation** — pull agency contact details for outreach
- **Portfolio monitoring** — periodically re-fetch specific listing URLs to track price/status changes

### FAQ

**What is LuxuryEstate.com?** A global luxury real estate marketplace aggregating listings from real estate agencies in 90+ countries, covering villas, penthouses, mansions, castles, country estates and more.

**Do I need a proxy or login?** No. The actor talks to LuxuryEstate.com directly over plain HTTPS — no proxy, no account, and no API key are required.

**How many listings are returned per page?** LuxuryEstate shows 15 listings per browse page; the actor paginates automatically up to `maxItems`.

**How do I find a region/city slug for the `location` field?** Browse luxuryestate.com in your browser, navigate to the region or city page you want, and copy everything in the URL path after the country. Some destinations are one segment (`https://www.luxuryestate.com/italy/lake-garda` → `lake-garda`), others need the full hierarchy (`https://www.luxuryestate.com/france/ile-de-france/paris/paris` → `ile-de-france/paris/paris`).

**Why are some fields missing on some records?** The actor only includes fields the source actually provides for that listing — for example, not every listing has a build year or virtual tour, so those fields are simply omitted rather than showing empty placeholders.

**What currency are prices in?** By default, all prices are shown in EUR (the source site's own default display currency), regardless of the listing's country — set `displayCurrency` to convert every price on the run to USD, GBP, CHF, AED, JPY, CNY, AUD, CAD, HKD, RUB, BRL, TRY, PLN, ILS or KRW instead. `minPrice`/`maxPrice` are interpreted in whatever `displayCurrency` you chose. See the `currency` field on each record to confirm which currency was used.

**Can I filter by amenities?** Yes — set `amenities` to any combination of pool, garden, fireplace, elevator, waterfront, sauna and 28 other codes (a listing must have ALL selected amenities), or use the dedicated `withGarden`/`withParking`/`withBalcony`/`withTerrace` toggles for those four common features.

**Can I sort results?** Yes — set `sortBy` to `price-asc`/`price-desc` for cheapest/most expensive first, `size-asc`/`size-desc` for smallest/largest first, or `bedrooms-desc`/`rooms-desc` for the biggest homes first. Default is `relevance` (the source site's own ranking).

**Can I filter by cooling system?** Yes — set `coolingType` to `air_conditioning` or `ceiling_fan` (mode=browse) to only return listings with that cooling system. Leave as the default `any` to skip this filter.

**Can I get every listing from one agency?** Yes — set `agencyUrl` to the agency's own LuxuryEstate.com page URL (found on the `agencyUrl` field of any browse/detail record, or by browsing the site directly). This returns that agency's entire portfolio instead of a geography-based search; `country`/`location`/`propertyType`/`transaction` are ignored, but price/size/bedroom/bathroom/amenity filters, sorting and currency still apply.

**Does `location` need to be typed exactly?** Accented characters are normalized automatically (e.g. `île-de-france` and `ile-de-france` both work), and casing/spacing is normalized too. If the location still can't be resolved to a valid path, the actor logs a warning and falls back to browsing the whole country rather than failing the run.

# Actor input Schema

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

What to fetch.

## `country` (type: `string`):

Country to browse (mode=browse).

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

Optional region/city path within the country, e.g. `lake-garda` or `ile-de-france/paris/paris`. Find it by browsing luxuryestate.com to the region/city you want and copying everything in the URL path after the country segment. Leave blank to browse the whole country. Ignored if `agencyUrl` is set.

## `agencyUrl` (type: `string`):

Instead of browsing by country/region, pull every listing from one real estate agency's LuxuryEstate.com page, e.g. `https://www.luxuryestate.com/a12123945-the-dream-real-estate-srl` (found on any browse/detail record's `agencyUrl` field, or by browsing luxuryestate.com to an agency's page). When set, `country`/`location`/`propertyType`/`transaction` are ignored — price/size/bedrooms/bathrooms/amenities/sort/currency filters still apply. Leave blank for normal geography-based browsing.

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

Restrict to one property type, or Any type for all types.

## `transaction` (type: `string`):

For sale or for rent listings.

## `sortBy` (type: `string`):

Order in which browse results are returned (mode=browse).

## `displayCurrency` (type: `string`):

Currency to show `price`/`priceFormatted` in (converted by the source site itself). `minPrice`/`maxPrice` are interpreted in this same currency. Leave as EUR (default) unless you need another currency.

## `minPrice` (type: `integer`):

Drop listings priced below this amount (listing's own currency).

## `maxPrice` (type: `integer`):

Drop listings priced above this amount (listing's own currency).

## `minBedrooms` (type: `integer`):

Drop listings with fewer bedrooms than this.

## `minBathrooms` (type: `integer`):

Drop listings with fewer bathrooms than this.

## `minSizeSqm` (type: `integer`):

Drop listings smaller (internal floor area) than this, in square meters.

## `maxSizeSqm` (type: `integer`):

Drop listings larger (internal floor area) than this, in square meters.

## `amenities` (type: `array`):

Only return listings that have ALL of the selected amenities/features (mode=browse). Leave empty for no amenity restriction.

## `withGarden` (type: `boolean`):

Only return listings with a garden (mode=browse).

## `withParking` (type: `boolean`):

Only return listings with parking (mode=browse).

## `withBalcony` (type: `boolean`):

Only return listings with a balcony (mode=browse).

## `withTerrace` (type: `boolean`):

Only return listings with a terrace (mode=browse).

## `coolingType` (type: `string`):

Only return listings with this cooling system (mode=browse). Leave as Any to skip this filter.

## `startPage` (type: `integer`):

First results page to fetch (15 listings per page). High-inventory countries (e.g. France, Spain, United States) have several thousand pages, so this accepts values well past 500 to reach deep pagination.

## `propertyUrls` (type: `array`):

Full LuxuryEstate.com listing URLs, e.g. `https://www.luxuryestate.com/p132776660-villa-for-sale-javea`.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "browse",
  "country": "italy",
  "propertyType": "any",
  "transaction": "sale",
  "sortBy": "relevance",
  "displayCurrency": "EUR",
  "amenities": [],
  "withGarden": false,
  "withParking": false,
  "withBalcony": false,
  "withTerrace": false,
  "coolingType": "any",
  "startPage": 1,
  "propertyUrls": [],
  "maxItems": 30
}
```

# Actor output Schema

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

Dataset containing all scraped LuxuryEstate.com property listings.

# 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 = {
    "mode": "browse",
    "country": "italy",
    "propertyType": "any",
    "transaction": "sale",
    "sortBy": "relevance",
    "displayCurrency": "EUR",
    "amenities": [],
    "withGarden": false,
    "withParking": false,
    "withBalcony": false,
    "withTerrace": false,
    "coolingType": "any",
    "startPage": 1,
    "propertyUrls": [],
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/luxuryestate-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 = {
    "mode": "browse",
    "country": "italy",
    "propertyType": "any",
    "transaction": "sale",
    "sortBy": "relevance",
    "displayCurrency": "EUR",
    "amenities": [],
    "withGarden": False,
    "withParking": False,
    "withBalcony": False,
    "withTerrace": False,
    "coolingType": "any",
    "startPage": 1,
    "propertyUrls": [],
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/luxuryestate-scraper").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 '{
  "mode": "browse",
  "country": "italy",
  "propertyType": "any",
  "transaction": "sale",
  "sortBy": "relevance",
  "displayCurrency": "EUR",
  "amenities": [],
  "withGarden": false,
  "withParking": false,
  "withBalcony": false,
  "withTerrace": false,
  "coolingType": "any",
  "startPage": 1,
  "propertyUrls": [],
  "maxItems": 30
}' |
apify call crawlerbros/luxuryestate-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/luxuryestate-scraper"
        }
    }
}

```

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/VvngRmQ8aS7Egeyg9/builds/3frJtFZeIEnOCNBxd/openapi.json