# Dubizzle Scraper — UAE Property & Used Cars (`logiover/dubizzle-scraper`) Actor

Scrape Dubizzle (UAE) property for sale/rent and used-car listings. Extract price, beds, baths, size, car make, model, year, mileage, location, seller and photos. No API key, no login.

- **URL**: https://apify.com/logiover/dubizzle-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Real estate, E-commerce
- **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

## Dubizzle Scraper — UAE Property & Used Cars

Extract hundreds to thousands of Dubizzle listings — property for sale, property for rent, and used cars across all seven UAE emirates — with rich fields, real prices, and full car specs. Keyless. No login.

### What does the Dubizzle Scraper do?

The Dubizzle Scraper pulls live listings straight from **[Dubizzle](https://www.dubizzle.com/)**, the UAE's largest classifieds marketplace, using its public **Algolia** search backend — the very same engine that powers the website's own search and filters. That means you get clean, structured JSON without an API key, without a login, and without brittle HTML parsing.

It covers three sections in one place: **property for sale**, **property for rent**, and **motors** (used cars). A single run comfortably returns hundreds to thousands of ads, complete with prices in **AED**, locations, photos, seller signals, and — for cars — year, mileage, make, model, and detailed specs.

Because you are reading the same index the site reads, results come back fast and complete. Dubizzle caps deep pagination at **10,000 results per query**, so if you need more, you simply narrow your filters (by emirate, area, price, category, or car make) and run again. You control exactly what you want with a straightforward set of inputs, and you pay only for the results you keep.

### Who is it for?

This actor is built for anyone who needs UAE property or car-market data at scale, on demand:

- **Real-estate agents** who want fresh for-sale and rental listings by emirate and neighbourhood to build lead lists and track the competition.
- **Car dealers and flippers** who benchmark used-car prices by make, model, year, and mileage to buy low and price right.
- **Property investors** hunting for undervalued units, off-plan opportunities, and yield signals across Dubai, Abu Dhabi, Sharjah, and beyond.
- **PropTech and AutoTech data teams** feeding valuation models, dashboards, and internal listing databases with a reliable, structured feed.
- **Lead-generation agencies and market analysts** who turn thousands of ads into contact-ready lists and pricing reports for clients.

### Use cases

Here are five concrete things people build with it:

- **Property lead lists** — pull every for-sale or for-rent ad in a given emirate/area, then filter by seller type and contact flags for outreach.
- **Car price and mileage benchmarking** — collect all listings of a specific make/model/year range and analyze the price-vs-mileage curve.
- **Dealer inventory monitoring** — schedule daily runs to track new, sold, and price-changed cars across the motors section.
- **Investment sourcing** — surface undervalued or newly listed units by price ceiling, bedrooms, size, and completion status.
- **Feeding marketplaces and CRMs** — sync structured listings into your own portal, Airtable, HubSpot, or Salesforce via Apify integrations.

### Why use this scraper?

- **Keyless and login-free** — powered by Dubizzle's public Algolia backend; no credentials, no cookies, no account risk.
- **Property + motors in one actor** — for-sale, rental, and used-car data from a single tool with one consistent schema.
- **All seven emirates** — Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Fujairah, and Umm Al Quwain.
- **Rich, precise filters** — price, area, bedrooms, and for cars: year range, max mileage, make/model, and more.
- **Real numbers and full specs** — prices as numbers in AED, plus bedrooms/size for property and mileage/year/fuel/transmission for cars.
- **Export and pay-per-result** — download JSON, CSV, or Excel, push to Sheets/Slack/Zapier, and pay only for the records you collect.

### What data can you extract?

Every listing comes back as a flat, ready-to-use record. Fields common to all three sections are below, followed by the extra fields you get for property and for motors.

**Common fields (all sections)**

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | Dubizzle listing ID |
| `section` | string | `property-for-sale`, `property-for-rent`, or `motors` |
| `name` | string | Listing title |
| `price` | number | Price in AED |
| `priceType` | string \| null | Price qualifier (e.g. per month) when present |
| `emirate` | string | Emirate the ad is in |
| `area` | string | Neighbourhood / community |
| `locationPath` | string | Full location breadcrumb (e.g. `UAE > Dubai > Al Quoz`) |
| `category` | string | Leaf category (e.g. `townhouse`, `j7`) |
| `categoryPath` | string | Full category slug path |
| `latitude` | number \| null | Latitude (property) |
| `longitude` | number \| null | Longitude (property) |
| `url` | string | Direct link to the listing |
| `photos` | array | Image URLs |
| `photoCount` | number | Number of photos |
| `hasPhone` | boolean | Phone contact available |
| `hasWhatsapp` | boolean | WhatsApp contact available |
| `sellerType` | string | `individual` or `business` |
| `isVerifiedBusiness` | boolean \| null | Verified business seller flag |
| `isPremium` | boolean \| null | Premium/featured listing flag |
| `createdAt` | string | Listing date (ISO 8601) |
| `scrapedAt` | string | When the record was collected (ISO 8601) |

**Property-only fields**

| Field | Type | Description |
| --- | --- | --- |
| `bedrooms` | number | Number of bedrooms |
| `bathrooms` | number | Number of bathrooms |
| `sizeSqft` | number | Built-up area in square feet |
| `furnished` | boolean \| null | Furnished status |
| `completionStatus` | string \| null | e.g. `completed`, off-plan |
| `propertyReference` | string \| null | Listing/agency reference ID |
| `agentName` | string \| null | Listing agent name |
| `agencyTier` | string \| null | Agency tier/badge |
| `description` | string \| null | Listing description text |

**Motors-only fields**

| Field | Type | Description |
| --- | --- | --- |
| `year` | number | Model year |
| `kilometers` | number | Odometer reading (km) |
| `make` | string | Car make |
| `model` | string | Car model |
| `condition` | string | `used` or `new` |
| `fuelType` | string \| null | e.g. Petrol, Diesel, Electric |
| `transmission` | string \| null | e.g. Automatic, Manual |
| `bodyType` | string \| null | e.g. SUV, Sedan |
| `exteriorColor` | string \| null | Exterior colour |
| `attributes` | object | Extra car specs (trim, interior colour, steering side, etc.) |

Here is one real property record and one real motors record:

```json
{
  "id": "17777928",
  "section": "property-for-sale",
  "name": "Ready to Occupy | Prime Masaar Location | Full Amenities",
  "price": 2003300,
  "emirate": "Sharjah",
  "area": "Masaar",
  "locationPath": "UAE > Sharjah > Tilal City > Masaar",
  "category": "townhouse",
  "categoryPath": "property-for-sale/residential/townhouse",
  "latitude": 25.2599,
  "longitude": 55.5923,
  "url": "https://sharjah.dubizzle.com/property-for-sale/residential/townhouse/...",
  "photos": ["https://dbz-images.dubizzle.com/images/..."],
  "photoCount": 12,
  "hasPhone": true,
  "hasWhatsapp": true,
  "sellerType": "business",
  "bedrooms": 3,
  "bathrooms": 3,
  "sizeSqft": 1906,
  "furnished": false,
  "completionStatus": "completed",
  "propertyReference": "Ref ID 104238-YKu61k",
  "agentName": "...",
  "agencyTier": "...",
  "createdAt": "2026-07-25T00:00:00Z",
  "scrapedAt": "2026-07-26T09:20:00Z"
}
````

```json
{
  "id": "100036083",
  "section": "motors",
  "name": "AED 411/month | 2023 JAC J7 | GCC Specs | Ref#494793",
  "price": 26999,
  "emirate": "Dubai",
  "area": "Al Quoz",
  "locationPath": "UAE > Dubai > Al Quoz",
  "category": "j7",
  "categoryPath": "motors/used-cars/jac/j7",
  "url": "https://dubai.dubizzle.com/motors/used-cars/jac/j7/...",
  "photos": ["https://dbz-images.dubizzle.com/images/..."],
  "photoCount": 15,
  "hasPhone": true,
  "hasWhatsapp": true,
  "sellerType": "individual",
  "year": 2023,
  "kilometers": 32958,
  "make": "jac",
  "model": "j7",
  "condition": "used",
  "transmission": "Automatic",
  "fuelType": "Petrol",
  "bodyType": "SUV",
  "exteriorColor": "Red",
  "attributes": {
    "Trim": "Luxury",
    "Interior Color": "Brown",
    "Steering Side": "Left Hand"
  },
  "createdAt": "2026-07-24T00:00:00Z",
  "scrapedAt": "2026-07-26T09:20:00Z"
}
```

### How to use

Getting data out is a two-minute job. Pick the actor, fill in a few fields, and hit **Start**. Below are the two most common setups.

#### Option A — Property by emirate + filters

Say you want ready-to-move-in apartments for sale in Dubai Marina, priced up to 2,000,000 AED, with at least 2 bedrooms, newest first.

1. Set `section` to `property-for-sale`.
2. Set `emirate` to `dubai` and `area` to `Dubai Marina`.
3. Set `propertyCategory` to `residential`.
4. Add `priceMax` = `2000000` and `bedsMin` = `2`.
5. Set `sortBy` to `newest` and `maxResults` to `500`.
6. Click **Start**.

```json
{
  "section": "property-for-sale",
  "propertyCategory": "residential",
  "emirate": "dubai",
  "area": "Dubai Marina",
  "priceMax": 2000000,
  "bedsMin": 2,
  "sortBy": "newest",
  "maxResults": 500
}
```

#### Option B — Used cars by make / year / mileage

Now say you want used Toyota cars in Dubai, model year 2020 or newer, under 80,000 km, priced 40k–120k AED, cheapest first.

1. Set `section` to `motors`.
2. Set `emirate` to `dubai`.
3. Set `categorySlugPath` to `motors/used-cars/toyota` to target the make exactly.
4. Add `yearMin` = `2020`, `kilometersMax` = `80000`, `priceMin` = `40000`, `priceMax` = `120000`.
5. Set `sortBy` to `price-asc` and `maxResults` to `1000`.
6. Click **Start**.

```json
{
  "section": "motors",
  "emirate": "dubai",
  "categorySlugPath": "motors/used-cars/toyota",
  "yearMin": 2020,
  "kilometersMax": 80000,
  "priceMin": 40000,
  "priceMax": 120000,
  "sortBy": "price-asc",
  "maxResults": 1000
}
```

### Input parameters

Every parameter is optional except the section you want to scrape. Property-only and motors-only fields are noted.

| Parameter | Type | Applies to | Description |
| --- | --- | --- | --- |
| `section` | select | all | `property-for-sale`, `property-for-rent`, or `motors`. Default `property-for-sale`. |
| `propertyCategory` | select | property | `residential`, `commercial`, `land`, or `multiple-units`. |
| `emirate` | select | all | `dubai`, `abu-dhabi`, `sharjah`, `ajman`, `ras-al-khaimah`, `fujairah`, `umm-al-quwain`. Default `dubai`. |
| `emirates` | array | all | Advanced: scrape multiple emirates in one run. |
| `area` | string | all | Free-text neighbourhood, e.g. `Dubai Marina`, `Al Quoz`. |
| `categorySlugPath` | string | all | Advanced: exact category path, e.g. `motors/used-cars/toyota` or `property-for-sale/residential/apartments`. |
| `query` | string | all | Free-text keyword search. |
| `priceMin` | integer | all | Minimum price in AED. |
| `priceMax` | integer | all | Maximum price in AED. |
| `bedsMin` | integer | property | Minimum bedrooms. |
| `bathsMin` | integer | property | Minimum bathrooms. |
| `furnished` | select | property | `any`, `furnished`, or `unfurnished`. |
| `yearMin` | integer | motors | Minimum model year. |
| `yearMax` | integer | motors | Maximum model year. |
| `kilometersMax` | integer | motors | Maximum odometer reading (km). |
| `sortBy` | select | all | `newest`, `oldest`, `price-asc`, `price-desc`, `year-desc`, `year-asc`, `km-asc`, or `default`. |
| `maxResults` | integer | all | Maximum listings to return. Default `500`. |
| `proxyConfiguration` | object | all | Optional Apify proxy settings. |

A full input JSON using many of the options at once:

```json
{
  "section": "property-for-sale",
  "propertyCategory": "residential",
  "emirate": "dubai",
  "emirates": ["dubai", "abu-dhabi"],
  "area": "Dubai Marina",
  "categorySlugPath": "property-for-sale/residential/apartments",
  "query": "sea view",
  "priceMin": 500000,
  "priceMax": 2000000,
  "bedsMin": 2,
  "bathsMin": 2,
  "furnished": "furnished",
  "sortBy": "newest",
  "maxResults": 500,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output example

Each result is one JSON object in the dataset. A property record and a motors record look like this:

```json
{
  "id": "17777928",
  "section": "property-for-sale",
  "name": "Ready to Occupy | Prime Masaar Location | Full Amenities",
  "price": 2003300,
  "emirate": "Sharjah",
  "area": "Masaar",
  "locationPath": "UAE > Sharjah > Tilal City > Masaar",
  "category": "townhouse",
  "categoryPath": "property-for-sale/residential/townhouse",
  "latitude": 25.2599,
  "longitude": 55.5923,
  "url": "https://sharjah.dubizzle.com/property-for-sale/residential/townhouse/...",
  "photos": ["https://dbz-images.dubizzle.com/images/..."],
  "photoCount": 12,
  "hasPhone": true,
  "hasWhatsapp": true,
  "sellerType": "business",
  "bedrooms": 3,
  "bathrooms": 3,
  "sizeSqft": 1906,
  "furnished": false,
  "completionStatus": "completed",
  "propertyReference": "Ref ID 104238-YKu61k",
  "createdAt": "2026-07-25T00:00:00Z",
  "scrapedAt": "2026-07-26T09:20:00Z"
}
```

```json
{
  "id": "100036083",
  "section": "motors",
  "name": "AED 411/month | 2023 JAC J7 | GCC Specs | Ref#494793",
  "price": 26999,
  "emirate": "Dubai",
  "area": "Al Quoz",
  "locationPath": "UAE > Dubai > Al Quoz",
  "category": "j7",
  "categoryPath": "motors/used-cars/jac/j7",
  "url": "https://dubai.dubizzle.com/motors/used-cars/jac/j7/...",
  "photos": ["https://dbz-images.dubizzle.com/images/..."],
  "photoCount": 15,
  "hasPhone": true,
  "hasWhatsapp": true,
  "sellerType": "individual",
  "year": 2023,
  "kilometers": 32958,
  "make": "jac",
  "model": "j7",
  "condition": "used",
  "transmission": "Automatic",
  "fuelType": "Petrol",
  "bodyType": "SUV",
  "exteriorColor": "Red",
  "attributes": {
    "Trim": "Luxury",
    "Interior Color": "Brown",
    "Steering Side": "Left Hand"
  },
  "createdAt": "2026-07-24T00:00:00Z",
  "scrapedAt": "2026-07-26T09:20:00Z"
}
```

### Tips for best results

- **Pick the right section first.** `property-for-sale`, `property-for-rent`, and `motors` return different fields, so start there before adding filters.
- **Use `categorySlugPath` for surgical targeting.** It's the fastest way to lock onto an exact car make/model (`motors/used-cars/toyota`) or a property subtype (`property-for-sale/residential/apartments`).
- **Narrow your filters to beat the 10,000 cap.** Dubizzle limits deep pagination to 10k per query. Split big pulls by emirate, area, price band, or make and combine the datasets.
- **Sort by `newest` for fresh ads.** Ideal for lead-gen and daily monitoring so you catch listings the moment they go live.
- **Use the motors sorts for benchmarking.** `year-desc`/`year-asc` and `km-asc` make it easy to line cars up by age or mileage.
- **Use `area` free-text for neighbourhoods.** Community names like `Dubai Marina` or `Al Quoz` sharpen property results without extra config.
- **Score leads with the contact flags.** `hasPhone` and `hasWhatsapp` let you prioritize ads that are ready for outreach, and `sellerType` separates agents from private sellers.
- **Combine price bands with bedrooms/size (property) or year/mileage (motors)** to isolate exactly the segment you're analyzing.
- **Raise `maxResults`** when you need volume, and lower it for quick sampling and test runs.
- **Schedule recurring runs** to track price changes and new inventory over time instead of one-off pulls.

### Integrations

Apify makes it easy to send Dubizzle data wherever you work:

- **Google Sheets** — push new listings into a spreadsheet automatically.
- **Slack** — get notified when fresh ads matching your filters appear.
- **Zapier** — connect results to thousands of apps with no code.
- **Make (Integromat)** — build multi-step automations around your runs.
- **Webhooks** — POST results to your own endpoint the moment a run finishes.
- **Schedule** — run the scraper hourly, daily, or weekly and keep your dataset current.

### API usage

You can trigger the actor programmatically with the Apify API. Replace `<YOUR_API_TOKEN>` with your token.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~dubizzle-scraper/runs?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "section": "motors",
    "emirate": "dubai",
    "categorySlugPath": "motors/used-cars/toyota",
    "yearMin": 2020,
    "kilometersMax": 80000,
    "sortBy": "price-asc",
    "maxResults": 1000
  }'
```

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

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

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

const run = await client.actor('logiover/dubizzle-scraper').call({
  section: 'property-for-sale',
  emirate: 'dubai',
  area: 'Dubai Marina',
  priceMax: 2000000,
  bedsMin: 2,
  sortBy: 'newest',
  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_API_TOKEN>")

run = client.actor("logiover/dubizzle-scraper").call(run_input={
    "section": "motors",
    "emirate": "dubai",
    "categorySlugPath": "motors/used-cars/toyota",
    "yearMin": 2020,
    "kilometersMax": 80000,
    "sortBy": "price-asc",
    "maxResults": 1000,
})

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

### Use with AI agents (MCP)

This actor works as a tool for AI agents through the **Apify MCP (Model Context Protocol) server**. Once connected, an assistant like Claude can call the Dubizzle Scraper on its own to gather live UAE property and car data, then reason over the results — no manual runs needed.

Example prompt:

> "Using the Dubizzle Scraper, find used Toyota cars in Dubai from 2020 or newer with under 80,000 km priced below 120,000 AED, then give me the average price and the three cheapest listings."

### FAQ

#### Is the Dubizzle Scraper keyless?

Yes. It reads Dubizzle's public Algolia search backend directly, so there's no API key, no account, and no login required.

#### Can it scrape both property and cars?

Yes. Set `section` to `property-for-sale`, `property-for-rent`, or `motors` (used cars). All three come through one actor with a consistent schema.

#### Which emirates are supported?

All seven: Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Fujairah, and Umm Al Quwain. Use `emirate` for one or `emirates` for several in a single run.

#### Does it return car specs like mileage and year?

Yes. Motors listings include `year`, `kilometers`, `make`, `model`, `condition`, `fuelType`, `transmission`, `bodyType`, `exteriorColor`, and an `attributes` object with extras like trim, interior colour, and steering side.

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

Typically hundreds to thousands, depending on your filters and `maxResults`. Broad queries return large volumes; tight filters return focused sets.

#### What is the 10,000 result cap?

Dubizzle limits deep pagination to 10,000 results per query. To collect more, split the job by emirate, area, price band, or category/make and merge the datasets.

#### Are prices returned as numbers?

Yes. `price` is a numeric value in **AED**, so you can sort, filter, and run calculations without cleaning strings first.

#### Are phone numbers included?

The scraper returns availability flags — `hasPhone` and `hasWhatsapp` — so you can score and prioritize leads. It does not expose raw personal contact numbers.

#### Can I export the data?

Yes. Download results as JSON, CSV, or Excel from Apify, or stream them to Google Sheets, Slack, Zapier, Make, or your own webhook.

#### Is scraping Dubizzle legal?

The actor collects publicly available listing data. You are responsible for complying with Dubizzle's Terms of Service and applicable data-protection laws (see below).

#### How fresh is the data?

Results reflect what's live on Dubizzle at run time, and each record carries a `scrapedAt` timestamp. Schedule recurring runs to keep your dataset current.

#### Are there related scrapers?

Yes — see the Related scrapers section for Bayut, Property Finder, and other UAE property and marketplace tools.

### Is it legal?

This scraper collects **publicly available** information from Dubizzle — the same listings any visitor can browse. It does not bypass logins or access private data. That said, you are responsible for how you use the data: review and respect **Dubizzle's Terms of Service**, and handle any personal data (such as seller information) in line with applicable privacy and data-protection regulations, including using it only for legitimate purposes. When in doubt, consult legal counsel for your specific use case.

### Related scrapers

- **Bayut Scraper** — UAE property listings from Bayut.
- **Property Finder Scraper** — for-sale and rental listings from Property Finder.
- **Dubizzle sister sites** — other regional classifieds powered by the same marketplace group.
- **UK Land Registry Scraper** — property price-paid records for the UK market.
- **More UAE and property scrapers by [logiover](https://apify.com/logiover)** — explore the full catalog for Gulf real-estate and marketplace data.

# Actor input Schema

## `section` (type: `string`):

What to scrape.

## `propertyCategory` (type: `string`):

Property type group (property sections only).

## `emirate` (type: `string`):

Emirate to search.

## `emirates` (type: `array`):

Optional: search several emirates at once. Accepted: dubai, abu-dhabi, sharjah, ajman, ras-al-khaimah, fujairah, umm-al-quwain.

## `area` (type: `string`):

Optional area name, e.g. 'Dubai Marina', 'Al Quoz', 'Jumeirah Village Circle'. Must match Dubizzle's location naming.

## `categorySlugPath` (type: `string`):

Optional exact category path. Motors example: 'motors/used-cars/toyota' or 'motors/used-cars/toyota/land-cruiser'. Property example: 'property-for-sale/residential/apartments'.

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

Optional full-text search, e.g. 'sea view', 'GCC specs', 'motivated seller'.

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

Minimum price / rent. 0 = no minimum.

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

Maximum price / rent. 0 = no maximum.

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

Minimum bedrooms. 0 = any.

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

Minimum bathrooms. 0 = any.

## `furnished` (type: `string`):

Filter by furnishing (property sections only).

## `yearMin` (type: `integer`):

Minimum model year (motors only). 0 = any.

## `yearMax` (type: `integer`):

Maximum model year (motors only). 0 = any.

## `kilometersMax` (type: `integer`):

Maximum kilometres on the odometer (motors only). 0 = any.

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

Result ordering. Year/mileage sorts apply to motors.

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

Maximum ads to collect. Dubizzle caps deep pagination at 10,000 per query; narrow filters to reach more.

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

Optional. Only needed if Dubizzle rotates its public search key and the actor starts returning 403.

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

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

## Actor input object example

```json
{
  "section": "property-for-sale",
  "propertyCategory": "residential",
  "emirate": "dubai",
  "emirates": [],
  "area": "",
  "categorySlugPath": "",
  "query": "",
  "priceMin": 0,
  "priceMax": 0,
  "bedsMin": 0,
  "bathsMin": 0,
  "furnished": "any",
  "yearMin": 0,
  "yearMax": 0,
  "kilometersMax": 0,
  "sortBy": "newest",
  "maxResults": 500,
  "algoliaApiKey": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All ads 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 = {
    "emirates": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dubizzle Scraper — UAE Property & Used Cars",
        "description": "Scrape Dubizzle (UAE) property for sale/rent and used-car listings. Extract price, beds, baths, size, car make, model, year, mileage, location, seller and photos. No API key, no login.",
        "version": "1.0",
        "x-build-id": "Zan7caeaJ0DJWk0jL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~dubizzle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-dubizzle-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~dubizzle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-dubizzle-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~dubizzle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-dubizzle-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": {
                    "section": {
                        "title": "Section",
                        "enum": [
                            "property-for-sale",
                            "property-for-rent",
                            "motors"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "property-for-sale"
                    },
                    "propertyCategory": {
                        "title": "Property category",
                        "enum": [
                            "residential",
                            "commercial",
                            "land",
                            "multiple-units"
                        ],
                        "type": "string",
                        "description": "Property type group (property sections only).",
                        "default": "residential"
                    },
                    "emirate": {
                        "title": "Emirate",
                        "enum": [
                            "dubai",
                            "abu-dhabi",
                            "sharjah",
                            "ajman",
                            "ras-al-khaimah",
                            "fujairah",
                            "umm-al-quwain"
                        ],
                        "type": "string",
                        "description": "Emirate to search.",
                        "default": "dubai"
                    },
                    "emirates": {
                        "title": "Emirates (advanced, multi-select)",
                        "type": "array",
                        "description": "Optional: search several emirates at once. Accepted: dubai, abu-dhabi, sharjah, ajman, ras-al-khaimah, fujairah, umm-al-quwain.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "area": {
                        "title": "Area / neighbourhood (free text)",
                        "type": "string",
                        "description": "Optional area name, e.g. 'Dubai Marina', 'Al Quoz', 'Jumeirah Village Circle'. Must match Dubizzle's location naming.",
                        "default": ""
                    },
                    "categorySlugPath": {
                        "title": "Category slug path (advanced)",
                        "type": "string",
                        "description": "Optional exact category path. Motors example: 'motors/used-cars/toyota' or 'motors/used-cars/toyota/land-cruiser'. Property example: 'property-for-sale/residential/apartments'.",
                        "default": ""
                    },
                    "query": {
                        "title": "Keyword (free text)",
                        "type": "string",
                        "description": "Optional full-text search, e.g. 'sea view', 'GCC specs', 'motivated seller'.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Minimum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price / rent. 0 = no minimum.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Maximum price (AED)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price / rent. 0 = no maximum.",
                        "default": 0
                    },
                    "bedsMin": {
                        "title": "Minimum bedrooms (property)",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum bedrooms. 0 = any.",
                        "default": 0
                    },
                    "bathsMin": {
                        "title": "Minimum bathrooms (property)",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum bathrooms. 0 = any.",
                        "default": 0
                    },
                    "furnished": {
                        "title": "Furnishing (property)",
                        "enum": [
                            "any",
                            "furnished",
                            "unfurnished"
                        ],
                        "type": "string",
                        "description": "Filter by furnishing (property sections only).",
                        "default": "any"
                    },
                    "yearMin": {
                        "title": "Minimum year (motors)",
                        "minimum": 0,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Minimum model year (motors only). 0 = any.",
                        "default": 0
                    },
                    "yearMax": {
                        "title": "Maximum year (motors)",
                        "minimum": 0,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Maximum model year (motors only). 0 = any.",
                        "default": 0
                    },
                    "kilometersMax": {
                        "title": "Maximum mileage km (motors)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum kilometres on the odometer (motors only). 0 = any.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "newest",
                            "oldest",
                            "price-asc",
                            "price-desc",
                            "year-desc",
                            "year-asc",
                            "km-asc",
                            "default"
                        ],
                        "type": "string",
                        "description": "Result ordering. Year/mileage sorts apply to motors.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum ads to collect. Dubizzle caps deep pagination at 10,000 per query; narrow filters to reach more.",
                        "default": 500
                    },
                    "algoliaApiKey": {
                        "title": "Algolia key override (advanced)",
                        "type": "string",
                        "description": "Optional. Only needed if Dubizzle rotates its public search key and the actor starts returning 403.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
