# MENA Property Gateway — Bayut + Dubizzle + DLD Data (`sian.agency/mena-property-gateway`) Actor

Unified Bayut + Dubizzle UAE property data in one run — pick one platform or both, get cross-platform agent matching, Dubai Land Department deed records, RERA permits, off-plan project metadata, bilingual EN+AR fields. Designed for UAE real-estate agencies replacing manual two-actor joins.

- **URL**: https://apify.com/sian.agency/mena-property-gateway.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 bayut listing extracteds

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

## MENA Property Gateway — Bayut + Dubizzle + DLD Data 🚀

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Bayut Scraper](https://img.shields.io/badge/SI%C3%81N-Bayut%20Scraper-93D500)](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) [![Dubizzle Scraper](https://img.shields.io/badge/SI%C3%81N-Dubizzle%20Scraper-1AE392)](https://apify.com/sian.agency/dubizzle-property-scraper?fpr=sian) [![Zillow Scraper](https://img.shields.io/badge/SI%C3%81N-Zillow%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-property-scraper?fpr=sian)

#### 🎉 NEW — Run Bayut + Dubizzle in ONE job, get cross-platform agent matching and Dubai Land Department deed records on every row
##### Purpose-built for UAE real-estate agencies that today join two separate scrapers in a spreadsheet

---

### 📋 Overview

**Stop running two separate UAE scrapers and joining their CSVs by hand.** MENA Property Gateway pulls **Bayut + Dubizzle** in one Apify job, normalizes every field to one flat row schema, and adds two enrichment layers no other Apify Store actor offers — cross-platform **agent matching** and **Dubai Land Department (DLD)** deed enrichment.

**Why UAE real-estate agencies choose us:**
- ✅ **One unified schema** — `source_platform` discriminator on every row, identical column shape across Bayut and Dubizzle, both `area_sqm` and `area_sqft` populated automatically (no more m² ↔ ft² conversions)
- ⚡ **One run, two portals** — `platforms: both` (default) hits Bayut and Dubizzle in parallel; pick one platform if you only need that side
- 🎯 **45+ data fields per row** — RERA permit, completion status, bilingual EN+AR titles, geo coordinates, agent + agency objects, photo count, and the full upstream `/details` payload on demand
- 💰 **Sister-actor parity pricing** — bulk row priced at $0.005 BRONZE (same as our standalone Bayut and Dubizzle scrapers); bundle premium lives only on the unique events you actually use
- 💎 **Cross-platform agent matching is unique on Apify Store** — `AgentMatched` event pairs the same agent's Bayut listings with their Dubizzle inventory in a dedicated `agent-match` row
- ✨ **NEW**: Dubai Land Department (DLD) deed enrichment with building floor count, parking spaces, off-plan completion %, RERA permit number, and DLD validation URL — surfaced on every Dubizzle row when enabled

> **Only need one portal?** Use the dedicated [Bayut Property Scraper](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) or [Dubizzle Property Scraper](https://apify.com/sian.agency/dubizzle-property-scraper?fpr=sian) — same SIÁN data quality, cheaper standalone curve, no bundle premium. The Gateway is the agency tool; the sister actors are the analyst tools.

---

### ✨ Features

- 🏛️ **Bayut + Dubizzle in one run** — `platforms: both` is the default; the bundle's reason to exist
- 🤝 **Cross-platform agent matching** — bundle-unique event that joins each agent's Bayut listings to their Dubizzle inventory by agent slug + name, emits a dedicated `_type: agent-match` row
- 🏛️ **Dubai Land Department (DLD) deed enrichment** — buildingInfo, floor count, parking spaces, off-plan project metadata, DLD validation URL on every Dubizzle row when enabled
- 📐 **Dual area units on every row** — Bayut returns m² natively, Dubizzle returns ft²; the bundle ships BOTH columns populated regardless of source platform
- 🌐 **Bilingual EN+AR everywhere** — `listingTitle` + `listingTitleAr` + `url` + `url_ar`; Bayut adds `listingTitleZh` (Chinese) and `listingTitleRu` (Russian) columns for international buyer dashboards
- 🔍 **5 search modes** — `location` (place name, both platforms), `locationId` (numeric ID, both platforms), `coordinates` (lat,lng,radius, Dubizzle only), `polygon` (GeoJSON area, Dubizzle only), `byurl` (paste a Dubizzle search URL)
- 📊 **HTML market report** auto-saved to the key-value store — per-platform breakdown, median price, AED/sqm + AED/sqft, breakdowns by purpose / property type / neighbourhood
- 💼 **Off-plan + RERA permit metadata** — completion status, RERA permit number, and the DLD payload combine into a ready-to-use due-diligence row
- 🔁 **Retry-helper rows** — any failed query lands as `_type: retry-helper` at the end of the dataset so you can resume the exact failures without rerunning the entire job
- 🆓 **FREE tier included** — full feature access on 1 query × 25 rows per platform, no credit card required

---

### 🎬 Quick Start

Paste a location, click run, get a unified Bayut + Dubizzle dataset in seconds. The default `platforms: both` + `location` mode is the bundle's primary workflow — every other input field is optional.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~mena-property-gateway/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"platforms":"both","searchMode":"location","queries":["Dubai Marina"]}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick your platforms

Leave `platforms: both` (the bundle default) or narrow to `bayut` / `dubizzle` if you only need that side.

#### Step 2: Add a location

Type one or more place names into `queries` — `Dubai Marina`, `Abu Dhabi`, `Jumeirah Village Circle`. For coordinate or polygon searches use the matching `searchMode` (Dubizzle only).

#### Step 3: Toggle enrichments (optional, PAID tier)

Flip `enrichDld: true` for Dubai Land Department deed data, or `matchAgentsAcrossPlatforms: true` for the bundle-unique cross-platform agent join.

**That's it! In under 60 seconds, you'll have:**

- One unified dataset with `source_platform: "bayut" | "dubizzle"` discriminator on every row
- 45+ columns including bilingual titles, both area units, agent + agency objects, and RERA permit numbers
- An HTML market report at `report.html` in the key-value store with median price, AED/sqm + AED/sqft, and per-neighbourhood breakdowns

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `platforms` | enum | Yes | `both` (default), `bayut`, or `dubizzle` |
| `searchMode` | enum | Yes | `location`, `locationId` (both platforms); `coordinates`, `polygon`, `byurl` (Dubizzle only) |
| `queries` | string\[] | Yes | Location names, numeric IDs, `lat,lng,radius_km`, polygons, or Dubizzle search URLs |
| `purpose` | enum | No | `both` (default), `for-sale`, or `for-rent` |
| `propertyType` | enum | No | `all`, `apartment`, `villa`, `townhouse`, `penthouse`, `land`, `commercial` |
| `minPrice` | int | No | Inclusive lower bound in AED |
| `maxPrice` | int | No | Inclusive upper bound in AED |
| `maxResultsPerPlatform` | int | No | Hard cap per platform per query (default 100, FREE capped at 25) |
| `enrichDetails` | bool | No | Per-listing `/details` call. PAID only. |
| `enrichDld` | bool | No | Per-Dubizzle-listing DLD deed call. PAID only. Unique on Apify Store. |
| `matchAgentsAcrossPlatforms` | bool | No | Emit cross-platform `agent-match` rows. PAID only. Bundle-unique. |

**Example — default bundle run:**

```json
{
  "platforms": "both",
  "searchMode": "location",
  "queries": ["Dubai Marina"]
}
```

**Example — agency due-diligence run with all enrichments:**

```json
{
  "platforms": "both",
  "searchMode": "location",
  "queries": ["Dubai Marina", "Jumeirah Village Circle", "Business Bay"],
  "purpose": "for-sale",
  "propertyType": "apartment",
  "minPrice": 800000,
  "maxResultsPerPlatform": 200,
  "enrichDetails": true,
  "enrichDld": true,
  "matchAgentsAcrossPlatforms": true
}
```

**Example — Dubizzle-only polygon search:**

```json
{
  "platforms": "dubizzle",
  "searchMode": "polygon",
  "queries": ["[[25.07,55.13],[25.09,55.13],[25.09,55.16],[25.07,55.16]]"]
}
```

***

### 📤 Output

Every row carries the **same flat schema** with a `source_platform` discriminator — Bayut, Dubizzle, and `bundle` (agent-match rows) all share the same column shape so you never write platform-specific transformers.

| Field | Type | Description |
|-------|------|-------------|
| `_type` | string | `listing`, `agent-match`, or `retry-helper` |
| `source_platform` | string | `bayut`, `dubizzle`, or `bundle` |
| `listing_id` | string | Platform-native listing ID (Bayut externalID, Dubizzle listing\_id) |
| `url` / `url_ar` | string | Canonical English URL + Arabic mirror (Dubizzle rows) |
| `listingTitle` / `listingTitleAr` / `listingTitleZh` / `listingTitleRu` | string | EN + AR on both platforms; ZH + RU on Bayut |
| `purpose` | string | `for-sale` or `for-rent` |
| `price` / `currency` / `rent_frequency` | number / string / string | AED price + rent cadence for rentals |
| `property_type` | string | apartment, villa, townhouse, penthouse, land, commercial |
| `bedrooms` / `bathrooms` | int | Bed/bath counts |
| `area_sqm` / `area_sqft` | number | **Both populated** regardless of source platform |
| `completion_status` | string | `completed`, `off-plan`, or `under-construction` |
| `is_verified` / `permit_number` | bool / string | Portal-side verification + RERA permit number |
| `location` / `geo` | object | Hierarchy + `{lat, lng}` coordinates |
| `agent` / `agency` | object | Normalized cross-platform agent + agency objects |
| `cover_photo` / `photo_count` | string / int | Hero image + total photo count |
| `bayut_specific` / `dubizzle_specific` | object | Platform-only fields (indyScore, categorySlug, categoryId, photos array) |
| `dld_data` | object | Dubai Land Department building/deed payload (when `enrichDld: true`) |
| `details_enriched` | object | Full upstream `/details` payload (when `enrichDetails: true`) |
| `agent_match` | object | Cross-platform agent join: counts + IDs on both sides (`agent-match` rows only) |
| `_query` | string | The query that produced this row |

**Example listing row:**

```json
{
  "_type": "listing",
  "source_platform": "bayut",
  "listing_id": "12345678",
  "url": "https://www.bayut.com/property/details-12345678.html",
  "listingTitle": "Stunning 2BR Apartment in Dubai Marina with Sea View",
  "listingTitleAr": "شقة فاخرة بغرفتي نوم في دبي مارينا مع إطلالة على البحر",
  "listingTitleZh": "迪拜码头海景两房公寓",
  "listingTitleRu": "Шикарная 2-комнатная квартира с видом на море",
  "purpose": "for-sale",
  "price": 2450000,
  "currency": "AED",
  "property_type": "apartment",
  "bedrooms": 2,
  "bathrooms": 3,
  "area_sqm": 115.6,
  "area_sqft": 1244.3,
  "completion_status": "completed",
  "is_verified": true,
  "permit_number": "65432198",
  "location": { "name": "Marina Gate 1", "neighborhood": "Dubai Marina", "city": "Dubai", "country": "United Arab Emirates" },
  "geo": { "lat": 25.0762, "lng": 55.1395 },
  "agent": { "name": "Sarah Khalifa", "slug": "sarah-khalifa-uae-properties", "id": "ag-998877" },
  "agency": { "name": "UAE Properties Group", "external_id": "10054" },
  "cover_photo": "https://images.bayut.com/thumbnails/12345678.jpg",
  "photo_count": 27,
  "created_at": "2026-05-19T08:14:00Z"
}
```

**Example agent-match row (bundle-unique):**

```json
{
  "_type": "agent-match",
  "source_platform": "bundle",
  "agent": { "name": "Sarah Khalifa", "slug": "sarah-khalifa-uae-properties" },
  "agent_match": {
    "bayut_listings_count": 18,
    "dubizzle_listings_count": 11,
    "bayut_agent_id": "ag-998877",
    "dubizzle_agent_id": "user-3344556",
    "matching_method": "name+agency",
    "dual_listed_ids": ["12345678", "12349912"]
  }
}
```

An **HTML market report** is saved to the key-value store at `report.html` with per-platform breakdown, median price, AED/sqm + AED/sqft, breakdowns by purpose / property type / neighbourhood, and per-query totals.

***

### 💼 Use Cases & Examples

#### 1. UAE Real-Estate Agency Cross-Portal Inventory Sync

**Agencies running ads on both Bayut and Dubizzle need a single source of truth for their team's daily standup.**

**Input:** `platforms: both`, `searchMode: location`, `queries: ["Dubai Marina", "Business Bay"]`
**Output:** One CSV with consistent columns across Bayut + Dubizzle — no spreadsheet joining
**Use:** Replace the daily manual two-actor join; export straight to Google Sheets, Notion, or Airtable

#### 2. Cross-Platform Agent Matching for Lead Generation

**Sales teams want to identify dual-listed agents (potential arbitrage on prices) and high-inventory agents to recruit.**

**Input:** `platforms: both`, `matchAgentsAcrossPlatforms: true`
**Output:** `_type: agent-match` rows with `bayut_listings_count`, `dubizzle_listings_count`, both agent IDs, and matching method
**Use:** Feed into your CRM to score agent recruitment opportunities or surface pricing arbitrage across portals

#### 3. DLD-Verified Off-Plan Investment Research

**Buyers and brokers performing due diligence on off-plan Dubai projects need DLD building data + RERA permit lookup on every listing.**

**Input:** `platforms: dubizzle`, `purpose: for-sale`, `enrichDld: true`
**Output:** Every row carries the full `dld_data` payload — building floor count, parking spaces, off-plan completion %, DLD validation URL, RERA permit
**Use:** Investment desks combining off-plan inventory with official Dubai Land Department metadata for risk scoring

#### 4. MENA Proptech Analytics Platforms

**SaaS proptech platforms building dashboards on top of UAE real-estate data need one schema, one API, both portals.**

**Input:** `platforms: both`, `maxResultsPerPlatform: 5000`, schedule daily via the Apify scheduler
**Output:** Identical row shape across Bayut + Dubizzle — pipe straight into Snowflake / BigQuery / Postgres without writing platform-specific transformers
**Use:** Power Looker, Tableau, Metabase, or Superset dashboards with one ELT pipeline instead of two

#### 5. Bilingual EN+AR Market Dashboards

**Bilingual UAE brands want Arabic and English titles + URLs on every row for region-aware reporting.**

**Input:** `platforms: both`, `searchMode: location`, `queries: ["Abu Dhabi"]`
**Output:** Every row has `listingTitle` + `listingTitleAr` + `url` + `url_ar`; Bayut rows add `listingTitleZh` + `listingTitleRu` for Chinese and Russian buyer-targeting
**Use:** Region-aware market dashboards, bilingual investor newsletters, multilingual SEO landing pages

#### 6. Off-Plan + RERA Compliance Workflows

**Compliance teams need every off-plan listing tagged with its RERA permit number and DLD validation URL for record-keeping.**

**Input:** `platforms: dubizzle`, `purpose: for-sale`, `propertyType: apartment`, `enrichDld: true`
**Output:** Each row carries `permit_number`, `completion_status: off-plan`, and `dld_data.validation_url` for regulator-facing audit trails
**Use:** Compliance logs, anti-money-laundering screens, RERA-permit verification automations

#### 7. Neighbourhood Price Benchmarking

**Researchers comparing AED/sqm and AED/sqft across neighbourhoods need one dataset with both area units.**

**Input:** `platforms: both`, `queries: ["Dubai Marina", "Downtown Dubai", "Palm Jumeirah", "JVC"]`, `purpose: for-sale`
**Output:** The auto-generated HTML report ships median price + AED/sqm + AED/sqft per neighbourhood, per platform
**Use:** Pricing strategy committees, real-estate economists, investment thesis decks

***

### 🔗 Integration Examples

#### JavaScript / Node.js

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

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

const run = await client.actor('sian.agency/mena-property-gateway').call({
  platforms: 'both',
  searchMode: 'location',
  queries: ['Dubai Marina'],
  enrichDld: true
});

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

// Route by source_platform for downstream pipelines
const bayut = items.filter(r => r.source_platform === 'bayut');
const dubizzle = items.filter(r => r.source_platform === 'dubizzle');
const agentMatches = items.filter(r => r._type === 'agent-match');
console.log({ bayut: bayut.length, dubizzle: dubizzle.length, matches: agentMatches.length });
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/mena-property-gateway').call(
    run_input={
        'platforms': 'both',
        'searchMode': 'location',
        'queries': ['Dubai Marina', 'Business Bay'],
        'enrichDld': True,
        'matchAgentsAcrossPlatforms': True,
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    if item['_type'] == 'agent-match':
        print(f"Agent {item['agent']['name']}: "
              f"{item['agent_match']['bayut_listings_count']} Bayut + "
              f"{item['agent_match']['dubizzle_listings_count']} Dubizzle")
    else:
        print(f"[{item['source_platform']}] {item['listingTitle']} — AED {item['price']}")
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~mena-property-gateway/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "platforms": "both",
    "searchMode": "location",
    "queries": ["Dubai Marina"],
    "enrichDld": true
  }'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger** — schedule daily, or webhook from your CRM
2. **HTTP Request** — call the actor API with your saved input config
3. **Process** — branch on `source_platform` / `_type` to route rows
4. **Action** — push Bayut rows to one pipeline, Dubizzle to another, `agent-match` rows to your CRM enrichment job

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **1 query × 25 listings per platform** — full feature access, same data quality
- Bilingual fields, both area units, RERA permit numbers, HTML market report — all included
- No credit card required
- Perfect for evaluating the unified schema and benchmarking against your current workflow

#### PAID Tier (Production Ready)

- **Unlimited queries**, up to **5,000 rows per platform per query**
- Detail enrichment (Bayut `/details/property` + Dubizzle `/details/byid`) when requested
- Dubai Land Department deed enrichment on every Dubizzle row when enabled
- Cross-platform agent matching with full Bayut + Dubizzle inventory joins
- Pay-per-result: you're only charged for successful events

#### Pricing Highlights

- **Bulk row** (Bayut + Dubizzle listings): $0.005 BRONZE — same as our standalone sister actors, NOT a bundle premium
- **Detail enrichment** (per platform): $0.008 BRONZE
- **DLD deed enrichment** (Dubizzle only): $0.012 BRONZE
- **Cross-platform agent matching** (bundle-unique): $0.015 BRONZE
- 6-tier volume curve (FREE → BRONZE → SILVER → GOLD → PLATINUM → DIAMOND) — heavy users automatically taper down to lower per-event prices

💰 **Honest headline pricing** — `BayutListingExtracted` and `DubizzleListingExtracted` are priced identically, so the Apify Store snapshot tells the truth no matter which platforms you pick.

🔗 [View current pricing on the Apify Store](https://apify.com/sian.agency/mena-property-gateway?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: Do I need both platforms enabled?**
A: No. `platforms: both` is the default (and the bundle's reason to exist), but you can narrow to `bayut` or `dubizzle` if you only need that side. For single-platform-only workflows, consider the standalone [Bayut Property Scraper](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) or [Dubizzle Property Scraper](https://apify.com/sian.agency/dubizzle-property-scraper?fpr=sian) — same data, cheaper standalone curve.

**Q: How many listings can I extract per run?**
A: FREE tier — 1 query × 25 listings per platform. PAID tier — unlimited queries, up to 5,000 rows per platform per query.

**Q: What if the same property appears on both portals?**
A: v1.0 returns BOTH rows with their respective `source_platform` discriminator. Cross-portal deduplication is on the v1.1 roadmap — UAE address normalization is a non-trivial NLP problem we want to ship right, not fast.

**Q: How does cross-platform agent matching work?**
A: When `matchAgentsAcrossPlatforms: true`, the actor fetches each agent's full inventory on both portals and emits a dedicated `_type: agent-match` row joining them by agent slug + name + agency. The row carries `bayut_listings_count`, `dubizzle_listings_count`, both agent IDs, and the matching method used.

**Q: Is Dubai Land Department data really included?**
A: Yes — set `enrichDld: true` and every Dubizzle listing comes with its DLD building/deed payload: floor count, parking spaces, off-plan completion %, RERA permit number, and DLD validation URL. This enrichment is unique on the Apify Store.

**Q: Why are both `area_sqm` AND `area_sqft` always populated?**
A: Bayut returns square metres natively, Dubizzle returns square feet. The bundle cross-computes the other unit so your downstream code never has to do unit conversion.

**Q: Does this work for KSA, Egypt, or other MENA markets?**
A: Bayut covers Saudi Arabia (KSA), Egypt (partial), and other MENA markets. Dubizzle is UAE-only. DLD enrichment is Dubai-only. For non-UAE Bayut workflows, set `platforms: bayut`.

**Q: How fresh is the data?**
A: Live every run — the actor queries the realtyAPI commercial backbone in real time, not a cached database. Each run is current as of the moment you start it.

**Q: Is this legal?**
A: Yes — we only extract publicly available property listings using a commercial real-estate-data API with proper rate limiting. See the [legal section](#%EF%B8%8F-is-it-legal-to-scrape-data) below.

***

### 🐞 Troubleshooting

**Bayut search fails with HTTP 422 for a location name**

- Try a more specific name (e.g. `Dubai Marina` not just `Marina`)
- Or switch to `searchMode: locationId` and provide the numeric externalID from Bayut

**`coordinates`, `polygon`, or `byurl` results show only Dubizzle rows**

- Bayut's API doesn't expose those endpoints — the bundle skips Bayut with a warning
- Either use `searchMode: location` / `locationId` (both platforms) or set `platforms: dubizzle`

**No `dld_data` populated even though `enrichDld: true`**

- DLD enrichment is Dubizzle-only — make sure `platforms` includes `dubizzle`
- DLD coverage is Dubai-only — Abu Dhabi / Sharjah / KSA listings won't have DLD records

**`Enrichment requested but disabled on FREE tier`**

- Detail, DLD, and agent-matching enrichments require the PAID tier
- Either upgrade your Apify account or test the unified schema with enrichment flags off

**`Bayut + Dubizzle returned 0 results` for a known location**

- Check the query spelling — UAE neighbourhood names are case-insensitive but accent-sensitive
- For non-UAE Bayut markets (KSA, Egypt), set `platforms: bayut` — Dubizzle is UAE-only

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union, the **UAE Personal Data Protection Law (PDPL)**, and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### ⚠️ Trademark Disclaimer

MENA Property Gateway is an **independent tool** developed and maintained by SIÁN Agency. It is **not affiliated with, endorsed by, or otherwise associated with** Bayut, Dubizzle, Property Finder Group, Dubizzle Limited, the Emaar Group, the Government of Dubai, the Dubai Land Department, or RERA.

- **Bayut™** is a trademark of Dubizzle Limited / Property Finder Group.
- **Dubizzle™** is a trademark of Dubizzle Limited.
- **DLD** and **RERA** are official entities of the Government of Dubai; this tool retrieves publicly available metadata only.

This tool retrieves publicly available information via a third-party commercial real-estate-data API. All trademarks are the property of their respective owners and are used here for nominative fair-use identification only.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository or contact us directly
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online> — we read every message

⭐ **Love this actor?** [Leave a 5-star review](https://apify.com/sian.agency/mena-property-gateway/reviews) — it helps us build more features for you and brings the bundle to more UAE agencies.

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `platforms` (type: `string`):

Which source(s) to pull from. `both` is the bundle's reason to exist; pick one platform if you only need that side (consider using the single-platform sister actor instead in that case).

## `searchMode` (type: `string`):

How to scope the search. `location` accepts a place name (e.g. "Dubai Marina") and works for both platforms. `locationId` accepts a numeric ID (Bayut externalID or Dubizzle locationId) — fastest path. `coordinates`, `polygon`, and `byurl` are Dubizzle-only (Bayut does not expose those endpoints) — selecting them with `platforms: both` will skip the Bayut side with a warning.

## `queries` (type: `array`):

List of queries to run. For `location` mode use plain location names ("Dubai Marina", "Abu Dhabi", "Jumeirah Village Circle"). For `locationId` use externalIDs/locationIds. For `coordinates` use "lat,lng,radius\_km". For `polygon` paste a GeoJSON-like polygon. For `byurl` paste a Dubizzle search URL.

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

Filter listings by sale/rent.

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

Filter by property type. Default returns all types.

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

Inclusive lower bound in AED.

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

Inclusive upper bound in AED.

## `maxResultsPerPlatform` (type: `integer`):

Hard cap on listings per platform per query. FREE tier is capped at 25.

## `enrichDetails` (type: `boolean`):

Per-listing detail call (Bayut `/details/property` + Dubizzle `/details/byid`). Adds amenities, photos, completionDetails, indyScore. PAID only.

## `enrichDld` (type: `boolean`):

Per-Dubizzle-listing DLD call. Adds buildingInfo, floor count, parking spaces, off-plan project metadata, DLD validation URL. UNIQUE on Apify Store. PAID only.

## `matchAgentsAcrossPlatforms` (type: `boolean`):

Bundle-unique feature. Fetches each agent's full inventory on BOTH platforms and emits a `_type: agent-match` row joining them. PAID only.

## Actor input object example

```json
{
  "platforms": "both",
  "searchMode": "location",
  "queries": [
    "Dubai Marina"
  ],
  "purpose": "both",
  "propertyType": "all",
  "maxResultsPerPlatform": 100,
  "enrichDetails": false,
  "enrichDld": false,
  "matchAgentsAcrossPlatforms": false
}
```

# Actor output Schema

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

Bayut + Dubizzle listings normalized into one schema with `source_platform` discriminator. Optional DLD deed enrichment and cross-platform agent-match rows when enabled.

## `htmlReport` (type: `string`):

HTML summary with run stats, per-platform breakdown, median price by neighbourhood, agent overlap count, and per-query totals.

# 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 = {
    "queries": [
        "Dubai Marina"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/mena-property-gateway").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 = { "queries": ["Dubai Marina"] }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/mena-property-gateway").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 '{
  "queries": [
    "Dubai Marina"
  ]
}' |
apify call sian.agency/mena-property-gateway --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/mena-property-gateway",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MENA Property Gateway — Bayut + Dubizzle + DLD Data",
        "description": "Unified Bayut + Dubizzle UAE property data in one run — pick one platform or both, get cross-platform agent matching, Dubai Land Department deed records, RERA permits, off-plan project metadata, bilingual EN+AR fields. Designed for UAE real-estate agencies replacing manual two-actor joins.",
        "version": "1.0",
        "x-build-id": "G7bv1Tywz5DOKTfht"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~mena-property-gateway/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-mena-property-gateway",
                "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/sian.agency~mena-property-gateway/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-mena-property-gateway",
                "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/sian.agency~mena-property-gateway/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-mena-property-gateway",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "platforms",
                    "searchMode",
                    "queries"
                ],
                "properties": {
                    "platforms": {
                        "title": "🏛️ Platforms to query",
                        "enum": [
                            "both",
                            "bayut",
                            "dubizzle"
                        ],
                        "type": "string",
                        "description": "Which source(s) to pull from. `both` is the bundle's reason to exist; pick one platform if you only need that side (consider using the single-platform sister actor instead in that case).",
                        "default": "both"
                    },
                    "searchMode": {
                        "title": "🔍 Search mode",
                        "enum": [
                            "location",
                            "locationId",
                            "coordinates",
                            "polygon",
                            "byurl"
                        ],
                        "type": "string",
                        "description": "How to scope the search. `location` accepts a place name (e.g. \"Dubai Marina\") and works for both platforms. `locationId` accepts a numeric ID (Bayut externalID or Dubizzle locationId) — fastest path. `coordinates`, `polygon`, and `byurl` are Dubizzle-only (Bayut does not expose those endpoints) — selecting them with `platforms: both` will skip the Bayut side with a warning.",
                        "default": "location"
                    },
                    "queries": {
                        "title": "📝 Search queries",
                        "type": "array",
                        "description": "List of queries to run. For `location` mode use plain location names (\"Dubai Marina\", \"Abu Dhabi\", \"Jumeirah Village Circle\"). For `locationId` use externalIDs/locationIds. For `coordinates` use \"lat,lng,radius_km\". For `polygon` paste a GeoJSON-like polygon. For `byurl` paste a Dubizzle search URL.",
                        "default": [
                            "Dubai Marina"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "purpose": {
                        "title": "🏷️ Listing purpose",
                        "enum": [
                            "both",
                            "for-sale",
                            "for-rent"
                        ],
                        "type": "string",
                        "description": "Filter listings by sale/rent.",
                        "default": "both"
                    },
                    "propertyType": {
                        "title": "🏠 Property type",
                        "enum": [
                            "all",
                            "apartment",
                            "villa",
                            "townhouse",
                            "penthouse",
                            "land",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Filter by property type. Default returns all types.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "💰 Minimum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Inclusive lower bound in AED."
                    },
                    "maxPrice": {
                        "title": "💰 Maximum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Inclusive upper bound in AED."
                    },
                    "maxResultsPerPlatform": {
                        "title": "📊 Max results per platform",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on listings per platform per query. FREE tier is capped at 25.",
                        "default": 100
                    },
                    "enrichDetails": {
                        "title": "🔬 Enrich with full property details",
                        "type": "boolean",
                        "description": "Per-listing detail call (Bayut `/details/property` + Dubizzle `/details/byid`). Adds amenities, photos, completionDetails, indyScore. PAID only.",
                        "default": false
                    },
                    "enrichDld": {
                        "title": "🏛️ Enrich with Dubai Land Department (DLD) deed data",
                        "type": "boolean",
                        "description": "Per-Dubizzle-listing DLD call. Adds buildingInfo, floor count, parking spaces, off-plan project metadata, DLD validation URL. UNIQUE on Apify Store. PAID only.",
                        "default": false
                    },
                    "matchAgentsAcrossPlatforms": {
                        "title": "🤝 Match agents across Bayut + Dubizzle",
                        "type": "boolean",
                        "description": "Bundle-unique feature. Fetches each agent's full inventory on BOTH platforms and emits a `_type: agent-match` row joining them. PAID only.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
