# Dubizzle Listing Extractor (`kawsar/dubizzle-listing-extractor`) Actor

Dubizzle listing scraper that extracts prices, mileage, specs, and location from any UAE classifieds page, so you can monitor market trends and run competitive research across all UAE cities.

- **URL**: https://apify.com/kawsar/dubizzle-listing-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Dubizzle Listing Extractor

Dubizzle Listing Extractor collects listing data from Dubizzle, the UAE's largest classifieds site. Point it at any category or search URL and it returns prices, mileage, year, brand, model, location, and images as JSON. Pagination runs automatically per URL.

### What it does

Works with any Dubizzle URL across all UAE cities: Dubai, Abu Dhabi, Ras Al Khaimah, Sharjah, Ajman, Al Ain, and Fujairah. Used cars and motors are the main use case, but property pages and most other categories work the same way.

For each listing, you get:

- Listing URL and title
- Brand, model, and year
- Price and currency (AED)
- Mileage in kilometers
- Primary listing image URL
- Seller description text
- Condition (used or new)
- Emirate and neighborhood
- Category type

Pagination runs independently for each input URL until that URL's item limit is hit or pages run out.

### How to use

#### Input

Provide one or more Dubizzle URLs in `startUrls`. `maxItems` controls how many listings to collect **per URL** — so if you pass 3 URLs with `maxItems: 20`, you can get up to 60 total results.

```json
{
  "startUrls": [
    "https://dubai.dubizzle.com/motors/used-cars/",
    "https://rak.dubizzle.com/motors/used-cars/toyota/camry/"
  ],
  "maxItems": 20,
  "requestTimeoutSecs": 90
}
````

#### URL formats that work

**Category pages** — all listings in a category:

```
https://dubai.dubizzle.com/motors/used-cars/
https://rak.dubizzle.com/motors/used-cars/
https://sharjah.dubizzle.com/motors/motorcycles/
```

**Filtered by make or make/model:**

```
https://dubai.dubizzle.com/motors/used-cars/toyota/
https://dubai.dubizzle.com/motors/used-cars/toyota/camry/
https://abudhabi.dubizzle.com/motors/used-cars/bmw/3-series/
```

**Property listings:**

```
https://dubai.dubizzle.com/properties/residential/apartments-flats/
https://rak.dubizzle.com/properties/residential/villas/
```

**With search filters already applied** — just paste the URL from your browser after filtering:

```
https://dubai.dubizzle.com/motors/used-cars/?price_max=50000&year_min=2018
```

#### Supported city subdomains

| Subdomain | City |
|---|---|
| `dubai` | Dubai |
| `abudhabi` | Abu Dhabi |
| `rak` | Ras Al Khaimah |
| `sharjah` | Sharjah |
| `ajman` | Ajman |
| `alain` | Al Ain |
| `fujairah` | Fujairah |

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | required | One or more Dubizzle listing page URLs |
| `maxItems` | integer | 20 | Max listings per URL (up to 1,000) |
| `requestTimeoutSecs` | integer | 90 | Per-request timeout in seconds (5-120) |

#### maxItems is per URL

Each URL in `startUrls` is scraped independently up to `maxItems`. If you provide 5 URLs with `maxItems: 50`, the run can produce up to 250 results total.

To collect everything from a single URL, set `maxItems: 1000`.

### Output fields

| Field | Type | Description |
|---|---|---|
| `listingUrl` | string | Direct link to the listing page |
| `listingTitle` | string | Full listing title (make, model, trim) |
| `brand` | string | Manufacturer or brand name |
| `vehicleModel` | string | Model name |
| `year` | string | Manufacturing year |
| `price` | number | Listed price |
| `currency` | string | Price currency, usually AED |
| `mileageKm` | number | Odometer reading in kilometers |
| `imageUrl` | string | URL of the primary listing image |
| `listingDescription` | string | Short description written by the seller |
| `condition` | string | `UsedCondition` or `NewCondition` |
| `addressRegion` | string | Emirate or city (e.g. Dubai, Ras Al Khaimah) |
| `addressLocality` | string | Neighborhood or area within the city |
| `category` | string | Listing category (Car, Apartment, etc.) |
| `pageUrl` | string | The input URL that produced this listing |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was collected |

Fields not available on a particular listing (e.g. mileage on a property ad) are returned as `null`.

#### Sample record

```json
{
  "listingUrl": "https://rak.dubizzle.com/motors/used-cars/ford/ecosport/2026/4/7/ford-ecosport-trend-2015-gcc-specs-well-ma-11-122---52c5001266084745ab1f32c951575ae7/",
  "listingTitle": "Ford Ecosport Trend",
  "brand": "Ford",
  "vehicleModel": "Ecosport",
  "year": "2015",
  "price": 18995,
  "currency": "AED",
  "mileageKm": 91000,
  "imageUrl": "https://dbz-images.dubizzle.com/images/2026/04/17/87016afea99b4da6aee2c03d2cb4d563-.png",
  "listingDescription": "Ford EcoSport 2015 | GCC | No Accidents | Service History | Ready to Drive",
  "condition": "UsedCondition",
  "addressRegion": "Ras Al Khaimah",
  "addressLocality": "Al Hamra Village",
  "category": "Car",
  "pageUrl": "https://rak.dubizzle.com/motors/used-cars/",
  "scrapedAt": "2026-05-20T10:30:00+00:00"
}
```

### Common uses

**Used car price tracking** — run the same URL weekly to watch prices shift. Combine `brand` + `vehicleModel` + `year` to group comparable listings.

**Property market research** — pull listings in a target area before making an offer or setting a rental price. The `addressLocality` field lets you filter by neighborhood.

**SEO keyword research** — listing titles and descriptions are written by real sellers using natural search language. Good source for long-tail keywords in the UAE automotive and real estate space.

**Competitor monitoring** — track how many listings exist in a category, what prices are being offered, and how quickly inventory turns over.

**Data pipelines** — feed structured Dubizzle data into Google Sheets, Airtable, or a database via the Apify API or webhook integrations.

**Lead generation** — collect listing URLs and contact details for outreach in target categories.

### Tips

- Paste a filtered Dubizzle URL directly from your browser — any price, year, or mileage filters you applied in the UI carry over into the URL and will be respected.
- To scrape multiple cities for the same make/model, add one URL per city to `startUrls`.
- Set `maxItems: 1000` to collect all listings for a URL (Dubizzle typically shows 25 per page).
- Property listings return `null` for `mileageKm` and `vehicleModel` — that is expected behavior.
- If a page returns no listings, the actor logs a warning and moves on to the next URL rather than failing the run.

### Limits

- Maximum 1,000 items per URL per run
- Pagination is handled automatically
- All seven UAE city subdomains are supported
- The actor uses built-in bypass infrastructure — no proxy setup required

# Actor input Schema

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

One or more Dubizzle listing page URLs to extract data from. Supports all UAE city subdomains (dubai, rak, abudhabi, ajman, sharjah, alain, fujairah) and any category path.

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

Maximum number of listings to extract per URL. Each URL in startUrls collects up to this limit independently.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrls": [
    "https://dubai.dubizzle.com/motors/used-cars/",
    "https://rak.dubizzle.com/motors/used-cars/toyota/camry/",
    "https://dubai.dubizzle.com/properties/residential/apartments-flats/"
  ],
  "maxItems": 20,
  "requestTimeoutSecs": 90
}
```

# 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 = {
    "startUrls": [
        "https://dubai.dubizzle.com/motors/used-cars/",
        "https://sharjah.dubizzle.com/motors/used-cars/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/dubizzle-listing-extractor").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 = { "startUrls": [
        "https://dubai.dubizzle.com/motors/used-cars/",
        "https://sharjah.dubizzle.com/motors/used-cars/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/dubizzle-listing-extractor").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 '{
  "startUrls": [
    "https://dubai.dubizzle.com/motors/used-cars/",
    "https://sharjah.dubizzle.com/motors/used-cars/"
  ]
}' |
apify call kawsar/dubizzle-listing-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dubizzle Listing Extractor",
        "description": "Dubizzle listing scraper that extracts prices, mileage, specs, and location from any UAE classifieds page, so you can monitor market trends and run competitive research across all UAE cities.",
        "version": "0.0",
        "x-build-id": "UmB2hFEW7Or2jRHs5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~dubizzle-listing-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-dubizzle-listing-extractor",
                "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/kawsar~dubizzle-listing-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-dubizzle-listing-extractor",
                "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/kawsar~dubizzle-listing-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-dubizzle-listing-extractor",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Dubizzle listing page URLs to extract data from. Supports all UAE city subdomains (dubai, rak, abudhabi, ajman, sharjah, alain, fujairah) and any category path.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per URL. Each URL in startUrls collects up to this limit independently.",
                        "default": 20
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 90
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
