# Bayut Scraper — UAE Real Estate Listings, Prices & Agents (`logiover/bayut-scraper`) Actor

Scrape Bayut.com property listings for sale or rent across the UAE. Extract price, beds, baths, area, location, agency, phone, WhatsApp, coordinates, permit and photos. No API key, no login.

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

## Pricing

from $1.50 / 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 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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Bayut Scraper — UAE Real Estate Listings, Prices & Agents

Pull hundreds to thousands of Bayut.com property listings — with prices, agent phone numbers, WhatsApp, and location data — straight from the UAE's #1 property portal. No API key, no login, just clean JSON.

### What does the Bayut Scraper do?

The Bayut Scraper extracts live property listings from [Bayut.com](https://www.bayut.com), the UAE's largest real estate marketplace. Instead of rendering pages in a slow browser, it talks directly to Bayut's public **Algolia search backend** — the exact same engine that powers the website's own search — so you get structured, reliable JSON at speed.

You can scrape across **all seven emirates** (Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Fujairah, and Umm Al Quwain), for both **for-sale** and **for-rent** properties. Every listing comes back with more than 40 fields, including price in **AED**, bedrooms, bathrooms, area (in both square metres and square feet), coordinates, RERA/DLD permit numbers, agency details, and — crucially for lead generation — the **agent's name, phone number, and WhatsApp**.

It's completely **keyless**: no account, no token, no cookies. A single run can return hundreds to thousands of listings. Bayut caps deep pagination at **50,000 results per query**, so narrow your filters when you need to go beyond that.

### Who is it for?

- **Real estate agents and brokers** — build fresh lead lists of competing and complementary listings, complete with agent phone numbers and WhatsApp for outreach.
- **Property investors** — source deals, compare asking prices, and spot undervalued units or high-yield rental communities.
- **PropTech and data teams** — feed clean, structured UAE property data into your own platforms, dashboards, and machine-learning models.
- **Lead-gen and marketing teams** — assemble targeted contact lists by emirate, community, or property type for campaigns.
- **Market analysts and researchers** — track price movements, off-plan supply, and rental trends per community over time.

### Use cases

- **Lead lists with agent contacts** — export every listing in a community together with the listing agent's name, phone, WhatsApp, and agency, ready for your sales pipeline.
- **Price benchmarking per community** — pull all 2-bed apartments in Dubai Marina and compute the median AED price, price-per-sqm, and range to price your own stock competitively.
- **Off-plan tracking** — monitor new off-plan and under-construction launches by emirate to catch fresh inventory the moment it appears.
- **Investment sourcing** — filter by price ceiling, bedrooms, and completion status to surface deals that match your buy-box across all seven emirates.
- **Feeding CRMs and portals** — schedule regular runs and push standardized listing data into your CRM, syndication portal, or internal database.

### Why use this scraper?

- **100% keyless** — no Bayut account, API key, or login required. Point it at a city or community and go.
- **40+ fields per listing, including agent phone & WhatsApp** — one of the few scrapers that returns direct contact details alongside every property.
- **All seven emirates** — Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Fujairah, and Umm Al Quwain, for both sale and rent.
- **Rich, precise filters** — purpose, category, property type, price, beds, baths, area, furnishing, completion status, rent frequency, and free-text search.
- **Real numbers and geo** — prices as numbers (not strings), areas in both sqm and sqft, plus latitude/longitude for mapping.
- **Export anywhere, pay per result** — download to JSON, CSV, or Excel, or connect via API and integrations. You only pay for the listings you actually get.

### What data can you extract?

Every listing returns a rich, flat JSON object. Here's every field the scraper produces:

| Field | Type | Description |
|---|---|---|
| `id` | string | Internal listing identifier. |
| `externalID` | string | Bayut's public listing ID (used in the URL). |
| `referenceNumber` | string | Agency reference / MLS-style code for the listing. |
| `title` | string | Listing headline as shown on Bayut. |
| `purpose` | string | `for-sale` or `for-rent`. |
| `price` | number | Price in AED (numeric, not a string). |
| `currency` | string | Currency code, always `AED`. |
| `rentFrequency` | string \| null | For rentals: `yearly`, `monthly`, `weekly`, or `daily`. `null` for sales. |
| `beds` | number | Number of bedrooms (0 for studios). |
| `baths` | number | Number of bathrooms. |
| `areaSqm` | number | Built-up area in square metres. |
| `areaSqft` | number | Same area converted to square feet. |
| `plotAreaSqm` | number \| null | Plot/land area in square metres, where applicable. |
| `category` | string | High-level category: `Residential` or `Commercial`. |
| `propertyType` | string | Type such as `Apartment`, `Villa`, `Townhouse`, `Office`, etc. |
| `completionStatus` | string | `ready`, `under-construction`, or `off-plan`. |
| `furnishingStatus` | string | `furnished`, `unfurnished`, or `partly-furnished`. |
| `isVerified` | boolean | `true` if the listing carries Bayut's TruCheck verification. |
| `productTier` | string | Listing prominence: `superhot`, `hot`, `featured`, or `default`. |
| `city` | string | Emirate the property sits in. |
| `community` | string | Primary community / area name. |
| `subCommunity` | string | Sub-community or tower/cluster name. |
| `locationPath` | string | Full breadcrumb, e.g. `Dubai > Dubai Islands > Bay Villas`. |
| `latitude` | number | Geographic latitude. |
| `longitude` | number | Geographic longitude. |
| `permitNumber` | string \| null | RERA/DLD permit or trakheesi number, where published. |
| `agencyName` | string | Name of the listing agency. |
| `agencyReraNumber` | string | Agency's RERA registration number. |
| `contactName` | string | Listing agent's name. |
| `phone` | string | Agent's phone number. |
| `whatsapp` | string | Agent's WhatsApp number. |
| `amenities` | array of strings | Listed amenities (e.g. `Swimming Pool`, `Gym or Health Club`). |
| `coverPhoto` | string (url) | URL of the main cover image. |
| `images` | array of urls | URLs of all listing photos. |
| `photoCount` | number | Number of photos on the listing. |
| `videoCount` | number | Number of videos on the listing. |
| `panoramaCount` | number | Number of 360° panorama tours. |
| `createdAt` | string (ISO) | When the listing was first published. |
| `updatedAt` | string (ISO) | When the listing was last updated. |
| `url` | string | Direct URL to the listing on Bayut. |
| `scrapedAt` | string (ISO) | Timestamp when this record was scraped. |

A real record from a run looks like this:

```json
{
  "externalID": "15854654",
  "referenceNumber": "103583-6vnOsx",
  "title": "Luxury Waterfront Villa | Private Beach Access | Premium Island Living",
  "purpose": "for-sale",
  "price": 4650000,
  "currency": "AED",
  "beds": 3,
  "baths": 3,
  "areaSqm": 314.2,
  "areaSqft": 3382,
  "category": "Residential",
  "propertyType": "Villas",
  "completionStatus": "under-construction",
  "furnishingStatus": "unfurnished",
  "isVerified": true,
  "productTier": "superhot",
  "city": "Dubai",
  "community": "Dubai Islands",
  "subCommunity": "Bay Villas",
  "locationPath": "Dubai > Dubai Islands > Bay Villas",
  "latitude": 25.319077,
  "longitude": 55.327553,
  "agencyName": "11Prop Realty",
  "agencyReraNumber": "36449",
  "contactName": "Ahmed Cheema",
  "phone": "+971503218049",
  "whatsapp": "971545695868",
  "amenities": ["Swimming Pool", "Gym or Health Club", "Balcony or Terrace"],
  "coverPhoto": "https://images.bayut.com/thumbnails/848452927-800x600.jpeg",
  "url": "https://www.bayut.com/property/details-15854654.html",
  "scrapedAt": "2026-07-26T09:16:00Z"
}
````

### How to use

There are two simple ways to target the listings you want. Both take a few seconds to set up.

#### Option A — By city + filters

Best when you want everything in an emirate that matches a set of criteria (price band, bedrooms, property type).

1. Set `purpose` to `for-sale` or `for-rent`.
2. Choose your emirate with `city` (e.g. `dubai`).
3. Add filters such as `propertyType`, `priceMin`, `priceMax`, `bedsMin`, and `completionStatus`.
4. Set `maxResults` to how many listings you want.
5. Click **Start** and download the results.

```json
{
  "purpose": "for-sale",
  "city": "dubai",
  "propertyType": "apartments",
  "priceMin": 1000000,
  "priceMax": 3000000,
  "bedsMin": 2,
  "completionStatus": "ready",
  "sortBy": "newest",
  "maxResults": 1000
}
```

#### Option B — By community (locationQuery)

Best when you care about a specific neighbourhood. Just type the community name and the scraper resolves it through Bayut's location index.

1. Set `purpose` and (optionally) `city`.
2. Put the community name in `locationQuery` (e.g. `"Dubai Marina"`).
3. Add any filters you want (beds, price, furnishing).
4. Set `maxResults` and run.

```json
{
  "purpose": "for-rent",
  "locationQuery": "Dubai Marina",
  "bedsMin": 1,
  "rentFrequency": "yearly",
  "sortBy": "newest",
  "maxResults": 500
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `purpose` | select: `for-sale`, `for-rent` | `for-sale` | Whether to scrape properties for sale or for rent. |
| `city` | select emirate: `dubai`, `abu-dhabi`, `sharjah`, `ajman`, `ras-al-khaimah`, `fujairah`, `umm-al-quwain` | `dubai` | The emirate to search. |
| `cities` | array | — | Advanced: multiple emirates in one run. |
| `locationQuery` | string | — | Free-text community name (e.g. `"Dubai Marina"`), resolved via Bayut's location index. |
| `locationSlugs` | array | — | Advanced: raw location slugs (e.g. `"/dubai/dubai-marina"`). |
| `category` | select: `any`, `residential`, `commercial` | `any` | High-level property category. |
| `propertyType` | select: `any`, `apartments`, `villas`, `townhouses`, `penthouses`, `residential-plots`, `residential-floors`, `offices`, `shops`, `warehouses`, `commercial-plots`, `commercial-buildings` | `any` | Specific property type. |
| `query` | string | — | Free-text keyword search. |
| `priceMin` | integer (AED) | — | Minimum price. |
| `priceMax` | integer (AED) | — | Maximum price. |
| `bedsMin` | integer | — | Minimum number of bedrooms. |
| `bathsMin` | integer | — | Minimum number of bathrooms. |
| `areaMin` | integer (sqm) | — | Minimum area in square metres. |
| `areaMax` | integer (sqm) | — | Maximum area in square metres. |
| `furnishingStatus` | select: `any`, `furnished`, `unfurnished`, `partly-furnished` | `any` | Furnishing filter. |
| `completionStatus` | select: `any`, `ready`, `off-plan` | `any` | Ready vs off-plan filter. |
| `rentFrequency` | select: `any`, `yearly`, `monthly`, `weekly`, `daily` | `any` | Rent period (rentals only). |
| `sortBy` | select: `default`, `newest`, `price-asc`, `price-desc` | `default` | Sort order of results. |
| `language` | select: `en`, `ar` | `en` | Language for text fields. |
| `maxResults` | integer | `500` | Maximum listings to return. |
| `proxyConfiguration` | object | — | Optional proxy settings (not required). |

A complete input using most options:

```json
{
  "purpose": "for-sale",
  "city": "dubai",
  "cities": [],
  "locationQuery": "Dubai Marina",
  "locationSlugs": [],
  "category": "residential",
  "propertyType": "apartments",
  "query": "",
  "priceMin": 1000000,
  "priceMax": 5000000,
  "bedsMin": 2,
  "bathsMin": 2,
  "areaMin": 90,
  "areaMax": 300,
  "furnishingStatus": "any",
  "completionStatus": "ready",
  "rentFrequency": "any",
  "sortBy": "newest",
  "language": "en",
  "maxResults": 1000
}
```

### Output example

Each item in the dataset looks like this:

```json
{
  "externalID": "15854654",
  "referenceNumber": "103583-6vnOsx",
  "title": "Luxury Waterfront Villa | Private Beach Access | Premium Island Living",
  "purpose": "for-sale",
  "price": 4650000,
  "currency": "AED",
  "beds": 3,
  "baths": 3,
  "areaSqm": 314.2,
  "areaSqft": 3382,
  "category": "Residential",
  "propertyType": "Villas",
  "completionStatus": "under-construction",
  "furnishingStatus": "unfurnished",
  "isVerified": true,
  "productTier": "superhot",
  "city": "Dubai",
  "community": "Dubai Islands",
  "subCommunity": "Bay Villas",
  "locationPath": "Dubai > Dubai Islands > Bay Villas",
  "latitude": 25.319077,
  "longitude": 55.327553,
  "agencyName": "11Prop Realty",
  "agencyReraNumber": "36449",
  "contactName": "Ahmed Cheema",
  "phone": "+971503218049",
  "whatsapp": "971545695868",
  "amenities": ["Swimming Pool", "Gym or Health Club", "Balcony or Terrace"],
  "coverPhoto": "https://images.bayut.com/thumbnails/848452927-800x600.jpeg",
  "url": "https://www.bayut.com/property/details-15854654.html",
  "scrapedAt": "2026-07-26T09:16:00Z"
}
```

### Tips for best results

- **Use `locationQuery` for precise areas.** Typing a community name like `"Business Bay"` or `"Palm Jumeirah"` is more accurate than relying on the emirate alone.
- **Narrow filters to beat the 50,000 cap.** Bayut limits deep pagination to 50k results per query. If a search is huge, split it by price band, bedrooms, or property type to capture everything.
- **For rentals, always set `rentFrequency`.** `yearly` is standard in the UAE, but set `monthly`, `weekly`, or `daily` for short-term stock so prices are comparable.
- **Sort by `newest` for fresh leads.** New listings mean agents who are actively working the deal — ideal for outreach.
- **Filter `isVerified` listings** (post-run) when you only want TruCheck-verified properties with confirmed details.
- **Know your area units.** `areaSqm` is in square metres and `areaSqft` is the same figure in square feet — pick whichever your audience expects and don't mix them.
- **Raise `maxResults`** when you need volume; lower it when you're testing filters to save time and cost.
- **Use `phone` and `whatsapp` for outreach.** These fields power your lead lists — WhatsApp especially is the primary channel for UAE property inquiries.
- **Combine `priceMin`/`priceMax` with `bedsMin`** to build a tight buy-box that surfaces only relevant investment stock.
- **Switch `language` to `ar`** if you need Arabic titles and location names for a local-facing product.

### Integrations

Apify makes it easy to send scraped listings wherever you work:

- **Google Sheets** — push results straight into a spreadsheet for analysis or sharing.
- **Slack** — get notified with new listings or run summaries in a channel.
- **Zapier** — connect Bayut data to 6,000+ apps without code.
- **Make (Integromat)** — build visual automations that route listings to your tools.
- **Webhooks** — fire a POST to your own endpoint the moment a run finishes.
- **Schedule** — run the scraper hourly, daily, or weekly to keep your data fresh automatically.

### API usage

You can trigger the scraper from anywhere. Replace `<YOUR_TOKEN>` with your Apify API token.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~bayut-scraper/runs?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "purpose": "for-sale",
    "city": "dubai",
    "propertyType": "apartments",
    "priceMax": 3000000,
    "maxResults": 500
  }'
```

**Node.js (apify-client)**

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

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });

const run = await client.actor('logiover/bayut-scraper').call({
    purpose: 'for-sale',
    city: 'dubai',
    propertyType: 'apartments',
    priceMax: 3000000,
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (apify-client)**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")

run = client.actor("logiover/bayut-scraper").call(run_input={
    "purpose": "for-sale",
    "city": "dubai",
    "propertyType": "apartments",
    "priceMax": 3000000,
    "maxResults": 500,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with AI agents (MCP)

The Bayut Scraper works with AI agents through the Model Context Protocol (MCP). Once connected via the [Apify MCP server](https://mcp.apify.com), an assistant like Claude can call the scraper directly, pass in filters, and reason over the returned listings — no glue code required. That means you can ask in plain language for a lead list or a price comparison and get structured results back.

> **Example prompt:** "Using the Bayut Scraper, find all ready 2-bedroom apartments for sale in Dubai Marina under 3,000,000 AED, then give me the five cheapest with their price, area in sqm, and the listing agent's phone and WhatsApp."

### FAQ

#### Is the Bayut Scraper really keyless?

Yes. It uses Bayut's public Algolia search backend directly, so there's no API key, no login, and no cookies to manage. You just set your filters and run it.

#### Which emirates does it cover?

All seven: Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Fujairah, and Umm Al Quwain. You can target one via `city` or several via `cities`.

#### Does it handle both sale and rent?

Yes. Set `purpose` to `for-sale` or `for-rent`. For rentals you can also filter by `rentFrequency` (yearly, monthly, weekly, or daily).

#### Do I actually get the agent's phone and WhatsApp?

Yes. Every listing includes `contactName`, `phone`, and `whatsapp`, along with the `agencyName` and `agencyReraNumber` — ideal for building outreach and lead lists.

#### How many listings can I get per run?

A single run commonly returns hundreds to thousands of listings. You control the ceiling with `maxResults`.

#### What is the 50,000 cap?

Bayut's search backend limits deep pagination to 50,000 results per query. To pull more than that from a broad search, split it into narrower queries (by price band, bedrooms, or property type).

#### Are prices returned as numbers?

Yes. The `price` field is a numeric value in AED (for example `4650000`), so you can sort, filter, and calculate on it directly. The `currency` field is always `AED`.

#### Can I tell off-plan from ready properties?

Yes. The `completionStatus` field returns `ready`, `under-construction`, or `off-plan`, and you can filter runs with the `completionStatus` input.

#### Can I export the data?

Absolutely. Results are stored in an Apify dataset and can be downloaded as JSON, CSV, or Excel, or accessed through the API and integrations like Google Sheets and Zapier.

#### Is scraping Bayut legal?

The scraper only collects publicly available listing data. You are responsible for how you use it, including compliance with Bayut's Terms of Service and applicable data-protection laws. See the section below.

#### How fresh is the data?

Data is pulled live at the moment you run the scraper, and each record carries a `scrapedAt` timestamp plus the listing's own `createdAt` and `updatedAt`. Schedule regular runs to keep it current.

#### Are there related scrapers?

Yes — see the Related scrapers section below for other UAE and international property tools.

### Is it legal?

This scraper collects only **publicly available** property data that Bayut already displays on its website. It does not bypass logins or access private information.

That said, you are responsible for how you use the data. Some fields (agent names, phone numbers, WhatsApp) are **personal data**, and how you store, process, and contact people is governed by applicable privacy and data-protection laws (such as the UAE's PDPL and, where relevant, GDPR). You should also review and respect [Bayut's Terms of Service](https://www.bayut.com/terms/). Use the output responsibly and lawfully.

### Related scrapers

Looking to expand your property data coverage? Check out these other logiover scrapers:

- **Dubizzle Scraper** — listings from Dubizzle, the UAE's other major property and classifieds marketplace.
- **Property Finder Scraper** — properties, prices, and agents from Property Finder across the UAE.
- **Zoopla Scraper** — UK residential sale and rental listings from Zoopla.
- **UK Land Registry Scraper** — official sold-price and property ownership data for England and Wales.

# Actor input Schema

## `purpose` (type: `string`):

Listings for sale or for rent.

## `city` (type: `string`):

Emirate to search. Use the advanced fields below for a specific community.

## `cities` (type: `array`):

Optional: search several emirates at once. Accepted values: dubai, abu-dhabi, sharjah, ajman, ras-al-khaimah, fujairah, umm-al-quwain. Combined with the single City above.

## `locationQuery` (type: `string`):

Optional community or tower name, e.g. 'Dubai Marina', 'Downtown Dubai', 'Jumeirah Village Circle'. Resolved against Bayut's location index for a precise filter.

## `locationSlugs` (type: `array`):

Optional raw Bayut location slugs for exact targeting, e.g. '/dubai/dubai-marina', '/dubai/business-bay'. Each is OR-combined.

## `category` (type: `string`):

Residential or commercial. Ignored if a Property type is chosen below.

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

Narrow to a specific property type.

## `query` (type: `string`):

Optional full-text search over titles, e.g. 'sea view', 'furnished studio', 'branded residence'.

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

Minimum price. For rentals this is the rent per the chosen frequency. 0 = no minimum.

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

Maximum price. 0 = no maximum.

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

Minimum number of bedrooms. 0 = any (studios count as 0).

## `bathsMin` (type: `integer`):

Minimum number of bathrooms. 0 = any.

## `areaMin` (type: `integer`):

Minimum built-up area in square metres. 0 = any.

## `areaMax` (type: `integer`):

Maximum built-up area in square metres. 0 = any.

## `furnishingStatus` (type: `string`):

Filter by furnishing status.

## `completionStatus` (type: `string`):

Ready (completed) or off-plan (under construction) properties.

## `rentFrequency` (type: `string`):

For 'For rent' only: the rental period the price refers to.

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

Result ordering.

## `language` (type: `string`):

Index language for titles and location names.

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

Maximum listings to collect. Bayut caps deep pagination at 50,000 per query; narrow filters to reach more.

## `algoliaApiKey` (type: `string`):

Optional. Only needed if Bayut rotates its public search key and the actor starts returning 403. Leave empty otherwise.

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

Optional. The Algolia endpoint works without a proxy; enable Apify Proxy for very large volumes.

## Actor input object example

```json
{
  "purpose": "for-sale",
  "city": "dubai",
  "cities": [],
  "locationQuery": "",
  "locationSlugs": [],
  "category": "any",
  "propertyType": "any",
  "query": "",
  "priceMin": 0,
  "priceMax": 0,
  "bedsMin": 0,
  "bathsMin": 0,
  "areaMin": 0,
  "areaMax": 0,
  "furnishingStatus": "any",
  "completionStatus": "any",
  "rentFrequency": "any",
  "sortBy": "default",
  "language": "en",
  "maxResults": 500,
  "algoliaApiKey": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All listings extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "cities": [],
    "locationSlugs": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/bayut-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 = {
    "cities": [],
    "locationSlugs": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/bayut-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 '{
  "cities": [],
  "locationSlugs": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/bayut-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bayut Scraper — UAE Real Estate Listings, Prices & Agents",
        "description": "Scrape Bayut.com property listings for sale or rent across the UAE. Extract price, beds, baths, area, location, agency, phone, WhatsApp, coordinates, permit and photos. No API key, no login.",
        "version": "1.0",
        "x-build-id": "AtP39TFhixWNbvyoG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~bayut-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-bayut-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/logiover~bayut-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-bayut-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/logiover~bayut-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-bayut-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": {
                    "purpose": {
                        "title": "Purpose",
                        "enum": [
                            "for-sale",
                            "for-rent"
                        ],
                        "type": "string",
                        "description": "Listings for sale or for rent.",
                        "default": "for-sale"
                    },
                    "city": {
                        "title": "City / Emirate",
                        "enum": [
                            "dubai",
                            "abu-dhabi",
                            "sharjah",
                            "ajman",
                            "ras-al-khaimah",
                            "fujairah",
                            "umm-al-quwain"
                        ],
                        "type": "string",
                        "description": "Emirate to search. Use the advanced fields below for a specific community.",
                        "default": "dubai"
                    },
                    "cities": {
                        "title": "Cities (advanced, multi-select)",
                        "type": "array",
                        "description": "Optional: search several emirates at once. Accepted values: dubai, abu-dhabi, sharjah, ajman, ras-al-khaimah, fujairah, umm-al-quwain. Combined with the single City above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Area / community (free text)",
                        "type": "string",
                        "description": "Optional community or tower name, e.g. 'Dubai Marina', 'Downtown Dubai', 'Jumeirah Village Circle'. Resolved against Bayut's location index for a precise filter.",
                        "default": ""
                    },
                    "locationSlugs": {
                        "title": "Location slugs (advanced)",
                        "type": "array",
                        "description": "Optional raw Bayut location slugs for exact targeting, e.g. '/dubai/dubai-marina', '/dubai/business-bay'. Each is OR-combined.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "any",
                            "residential",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Residential or commercial. Ignored if a Property type is chosen below.",
                        "default": "any"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "any",
                            "apartments",
                            "villas",
                            "townhouses",
                            "penthouses",
                            "residential-plots",
                            "residential-floors",
                            "offices",
                            "shops",
                            "warehouses",
                            "commercial-plots",
                            "commercial-buildings"
                        ],
                        "type": "string",
                        "description": "Narrow to a specific property type.",
                        "default": "any"
                    },
                    "query": {
                        "title": "Keyword (free text)",
                        "type": "string",
                        "description": "Optional full-text search over titles, e.g. 'sea view', 'furnished studio', 'branded residence'.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Minimum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price. For rentals this is the rent per the chosen frequency. 0 = no minimum.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Maximum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price. 0 = no maximum.",
                        "default": 0
                    },
                    "bedsMin": {
                        "title": "Minimum bedrooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum number of bedrooms. 0 = any (studios count as 0).",
                        "default": 0
                    },
                    "bathsMin": {
                        "title": "Minimum bathrooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum number of bathrooms. 0 = any.",
                        "default": 0
                    },
                    "areaMin": {
                        "title": "Minimum area (sqm)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum built-up area in square metres. 0 = any.",
                        "default": 0
                    },
                    "areaMax": {
                        "title": "Maximum area (sqm)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum built-up area in square metres. 0 = any.",
                        "default": 0
                    },
                    "furnishingStatus": {
                        "title": "Furnishing",
                        "enum": [
                            "any",
                            "furnished",
                            "unfurnished",
                            "partly-furnished"
                        ],
                        "type": "string",
                        "description": "Filter by furnishing status.",
                        "default": "any"
                    },
                    "completionStatus": {
                        "title": "Completion",
                        "enum": [
                            "any",
                            "ready",
                            "off-plan"
                        ],
                        "type": "string",
                        "description": "Ready (completed) or off-plan (under construction) properties.",
                        "default": "any"
                    },
                    "rentFrequency": {
                        "title": "Rent frequency (rentals)",
                        "enum": [
                            "any",
                            "yearly",
                            "monthly",
                            "weekly",
                            "daily"
                        ],
                        "type": "string",
                        "description": "For 'For rent' only: the rental period the price refers to.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "default",
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "default"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "ar"
                        ],
                        "type": "string",
                        "description": "Index language for titles and location names.",
                        "default": "en"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum listings to collect. Bayut caps deep pagination at 50,000 per query; narrow filters to reach more.",
                        "default": 500
                    },
                    "algoliaApiKey": {
                        "title": "Algolia key override (advanced)",
                        "type": "string",
                        "description": "Optional. Only needed if Bayut rotates its public search key and the actor starts returning 403. Leave empty otherwise.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The Algolia endpoint works without a proxy; enable Apify Proxy for very large volumes."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
