# PropertyFinder Scraper — Agent Database (Email & Phone) (`memo23/apify-propertyfinder-cheerio-ppe`) Actor

PropertyFinder scraper with an instant agent database — 8,500+ UAE & Qatar agents with email, phone, WhatsApp & deal stats, filterable by City / Brokerage / Language. Or live-scrape property listings, agents & brokers across UAE, Saudi, Qatar & Egypt. Pure HTTP. JSON/CSV.

- **URL**: https://apify.com/memo23/apify-propertyfinder-cheerio-ppe.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 17 total users, 16 monthly users, 96.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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/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

## PropertyFinder Scraper — Agent Database (Email, Phone & WhatsApp)

Pull PropertyFinder agent contacts **instantly** from a pre-collected database of **8,500+ UAE & Qatar agents** — every record with email, phone, WhatsApp, brokerage and deal stats — or live-scrape any PropertyFinder search, property, agent, or broker URL for rent/sale listings and full agent/broker data across **UAE, Saudi Arabia, Qatar and Egypt**.

> The Gulf's biggest property portal, turned into a lead list. Nobody else on Apify serves PropertyFinder agent contacts — the other scrapers return properties only. This one gives you the agents behind them, with WhatsApp numbers.

### ⚡ Instant Agent Database — UAE & Gulf agents, no scraping

The fastest way to get PropertyFinder agents: skip scraping entirely and pull straight from our continuously-growing database of **8,500+ agents across the UAE and Qatar** — instant, uncapped, nothing to get blocked.

**How to use it:** in the **⚡ Instant Database Mode** section of the input, pick a **Country** (UAE / Qatar) — optionally narrow by **City**, **Brokerage**, **Language** or **Nationality** — and run. Leave the live-scraping Start URLs empty. You're billed only per agent delivered.

**Each database agent includes:** name, email, phone, **WhatsApp number**, position, bio, superagent & verified flags, total properties, for-sale/for-rent counts, years of experience, star rating & review count, license number, nationality, languages, sale/rent transaction counts, deal volume, photo, and the full brokerage block (name, location, agent count) — plus the profile URL.

**Coverage:** 8,500+ agents, **100% with an email, 93% with a WhatsApp number** — the primary contact channel in the Gulf. Cities span Dubai, Abu Dhabi, Sharjah, Ajman, Ras Al Khaimah, Doha and more. (Saudi Arabia & Egypt don't expose an agent directory on PropertyFinder — their agents are being added from property-listing data.)

**Need a whole country as a clean CSV, or pushed to your CRM via API?** Reach out via the Support section below for bulk datasets.

### Why Use This Scraper?

- ✅ **The only PropertyFinder scraper with agent contacts** — email, phone *and* WhatsApp, instantly
- ✅ **Four markets in one** — UAE, Saudi Arabia, Qatar, Egypt
- ✅ **WhatsApp numbers** — the channel that actually converts in the Gulf
- ✅ **Rich per-agent data** — brokerage, deal volume, transaction counts, ratings, languages, nationality
- ✅ **Live property scraping too** — rent/sale listings with full detail, plus agents & brokers
- ✅ **Pure HTTP** — no headless browser, no CAPTCHA solver

### Overview

This actor serves two audiences from one tool: **lead-gen teams, recruiters and brokerages** who want PropertyFinder agent contacts without scraping, and **investors, analysts and proptech teams** who want property and market data across the Gulf.

Instant Database mode returns a flat agent row per agent, straight from the store. Live-scrape mode (search / property / agent / broker URLs) returns property listings, agent profiles, and broker/agency data. Both run pure-HTTP.

### Supported Inputs

#### Instant Database filters (no URL needed)

| Field | Example | Notes |
|---|---|---|
| `dbCountry` | `ae` | ae / sa / qa / eg |
| `dbCity` | `Dubai` | office city/emirate, optional |
| `dbBrokerage` | `Betterhomes` | brokerage name contains, optional |
| `dbLanguage` | `Russian` | agent language, optional |
| `dbNationality` | `India` | agent nationality, optional |
| `dbHasEmail` / `dbHasPhone` / `dbHasWhatsapp` | `true` | require that contact field |
| `instantDatabase` | `true` | force database mode (auto-on if any filter is set) |

#### Live-scrape URL types

| URL type | Example |
|---|---|
| Search / listings | `https://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1` |
| Buy / rent category | `https://www.propertyfinder.ae/en/buy/apartments-for-sale.html` |
| Property detail | `https://www.propertyfinder.ae/en/plp/buy/apartment-for-sale-...-12345.html` |
| Agent profile | `https://www.propertyfinder.ae/en/agent/{slug}-{id}` |
| Agent directory | `https://www.propertyfinder.ae/en/find-agent` |
| Broker / agency | `https://www.propertyfinder.ae/en/broker/{slug}-{id}` |
| Saudi Arabia (propertyfinder.sa) | `https://www.propertyfinder.sa/en/search?c=1&fu=0&ob=mr` |

Works across `.ae`, `.sa`, `.qa`, `.eg` — e.g. paste a **propertyfinder.sa** search URL to pull Saudi listings (Riyadh, Jeddah, Dammam…) with SAR prices.

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1",
    "https://www.propertyfinder.ae/en/find-agent"
  ]
}
````

#### Unsupported inputs

- ❌ Content behind a PropertyFinder login
- ❌ Markets outside ae / sa / qa / eg
- ❌ Non-propertyfinder domains

### Use Cases

| Audience | Use case |
|---|---|
| **Lead-gen teams / brokerages** | Pull thousands of Gulf agent contacts (email + phone + WhatsApp) instantly by country/city |
| **Recruiters** | Build brokerage rosters filtered by city, brokerage, language, or experience |
| **Investors / analysts** | Track rent/sale listings and pricing across UAE and the Gulf |
| **Proptech / CRM** | Enrich a pipeline with verified agent + brokerage data |
| **Market researchers** | Bulk-export PropertyFinder property and agent data for analysis |

### How It Works

![How PropertyFinder Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-propertyfinder.png)

1. **Choose a mode** — Instant Database (country/city/brokerage/language filters) for agent contacts, or live scrape (search / property / agent / broker URL) for listings and profiles
2. **Instant Database path** — the actor queries our pre-collected store and returns matching agents in seconds; no requests to PropertyFinder
3. **Live-scrape path** — the actor reads PropertyFinder's server-rendered data (`__NEXT_DATA__`) directly, paginating search results and parsing full property/agent/broker detail — pure HTTP, no browser
4. **Output** — one row per agent (database) or per property / agent / broker (live scrape), JSON or CSV

### Input Configuration

#### Common scenarios

**1. Instant Database — every UAE agent with a WhatsApp number**

```json
{
  "dbCountry": "ae",
  "dbHasWhatsapp": true,
  "maxItems": 500
}
```

**2. Instant Database — Dubai agents at a specific brokerage who speak Russian**

```json
{
  "dbCountry": "ae",
  "dbCity": "Dubai",
  "dbBrokerage": "Betterhomes",
  "dbLanguage": "Russian",
  "maxItems": 100
}
```

**3. Live scrape — for-sale listings by URL**

```json
{
  "startUrls": ["https://www.propertyfinder.ae/en/buy/apartments-for-sale.html"],
  "maxItems": 200
}
```

### Pricing

Pay-per-event — you're billed only for what's delivered:

| Event | Price | Charged when |
|---|---|---|
| **Result** | $0.002 | Per record delivered — an agent from the database, or a property / agent / broker from a live scrape |
| Actor start | Apify platform rate | Standard per-GB run-start charge |

Instant Database queries report the total number of matching agents alongside the delivered rows, so you can see how many match your filters before raising `maxItems`.

### Output Overview

- **Database agent** (Instant Database mode) — a flat agent row served from our store: contacts (email/phone/WhatsApp), brokerage, license, ratings, deal stats, languages, nationality, plus a derived `country`.
- **Live-scraped property / agent / broker** — full PropertyFinder detail from the page's server-rendered data.

Free-tier users receive the first 2 database records in full as proof of quality; every record after that has its email/phone/WhatsApp replaced with an upgrade prompt. Paying users always receive full contacts.

### Output Samples

**Instant Database agent (shortened):**

```jsonc
{
  "id": "203954",
  "name": "Myles Bush",
  "email": "mb@phoenixhomes.ae",
  "phone": "+971509501897",
  "whatsapp_phone": "+971509501897",
  "position": "Director / Co-founder",
  "superagent": true,
  "verified": true,
  "total_properties": 1,
  "experience_since": 2007,
  "average_rating": 4.9,
  "review_count": 11,
  "nationality": "United Kingdom",
  "languages": "English",
  "broker_name": "Phoenix Homes Real Estate Brokers LLC",
  "broker_location": "Dubai",
  "profile_url": "https://www.propertyfinder.ae/en/broker/myles-bush",
  "country": "ae"
}
```

### Key Output Fields

| Group | Fields |
|---|---|
| **Identity & contact** | id, name, email, phone, whatsapp\_phone, position, profile\_url, photo\_url |
| **Performance** | superagent, verified, total\_properties, for\_sale\_count, for\_rent\_count, experience\_since, average\_rating, review\_count, transactions\_sale, transactions\_rent, deal\_volume |
| **Profile** | nationality, languages, license\_number, bio, ranking |
| **Brokerage** | broker\_name, broker\_location, broker\_total\_agents, broker\_url |
| **Geo** | country (ae / sa / qa / eg), broker\_location (city/emirate) |

### FAQ

#### What's the difference between Instant Database mode and live scraping?

Instant Database mode (`dbCountry` + optional filters) serves agents straight from our pre-collected store — no requests to PropertyFinder, results in seconds. Live scraping (`startUrls`) hits PropertyFinder directly for current listings, agents, or brokers.

#### Which countries are covered?

The **agent database** covers the UAE and Qatar (where PropertyFinder publishes an agent directory) — 8,500+ agents. **Live property scraping** works across all four PropertyFinder markets: UAE (`ae`), Saudi Arabia (`sa`), Qatar (`qa`) and Egypt (`eg`).

#### Do the agents include WhatsApp numbers?

Yes — WhatsApp is the primary contact channel in the Gulf, and the vast majority of agents carry one alongside email and phone.

#### Do I need a URL for Instant Database mode?

No — just set a country (and optionally city/brokerage/language/nationality) and leave `startUrls` empty.

#### Can it scrape properties too, not just agents?

Yes. Live-scrape mode handles search results, property detail pages, agent profiles, and broker/agency pages across all four countries.

#### Can I scrape content behind a login?

No. The actor only accesses publicly available PropertyFinder pages and pre-collected public agent-directory data.

#### JSON or CSV?

Both — export from your Apify dataset in whichever format you need.

### Support

Found a bug or want a field added? Open an issue on the actor's **Issues** tab and we'll take a look.

### Additional Services

Need a custom Gulf real-estate feed (bulk country exports, scheduled monitoring, a webhook/Sheets/DB push, or a tailored schema)? Reach out — custom scraping and data-pipeline work is available.

### Explore More Scrapers

- [Redfin Scraper — Listings + Agent Database](https://apify.com/memo23/apify-redfin-cheerio-ppe) — US agents, email + phone
- [Realtor.com Scraper — 200K+ Agent Database](https://apify.com/memo23/realtor-search-cheerio)
- [Zillow Agents & Leads Scraper](https://apify.com/memo23/zillow-agents-leads-scraper-ppe)
- [Bayut Scraper](https://apify.com/memo23) — UAE property portal

See the [full memo23 actor catalog →](https://apify.com/memo23)

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Property Finder Group (Property Finder FZ-LLC) or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available PropertyFinder pages and pre-collected public agent-directory data — no authenticated endpoints, paid features, or content behind the PropertyFinder login wall. Users are responsible for ensuring their use complies with PropertyFinder's Terms of Service, applicable data-protection law (GDPR, UAE PDPL, etc.), and any contractual obligations of their own organization.

### SEO Keywords

propertyfinder scraper, propertyfinder.ae scraper, propertyfinder.sa scraper, saudi propertyfinder scraper, property finder api, propertyfinder agent scraper, real estate agent emails, dubai real estate leads, uae property scraper, gulf real estate data, whatsapp agent leads, real estate lead generation, property listings scraper, dubai agents database, abu dhabi real estate scraper, saudi arabia property scraper, qatar real estate scraper, egypt property scraper, brokerage roster scraper, real estate crm data, propertyfinder json csv export, gcc property data

# Actor input Schema

## `instantDatabase` (type: `boolean`):

Serve matching agents from the pre-collected database instead of live-scraping. Auto-enabled if you set any of the filters below.

## `dbCountry` (type: `string`):

Which PropertyFinder market to serve agents from.

## `dbCity` (type: `string`):

Filter agents by their office city/emirate, e.g. Dubai, Abu Dhabi, Sharjah, Ajman, Riyadh.

## `dbBrokerage` (type: `string`):

Filter to a brokerage whose name contains this text, e.g. Betterhomes, Allsopp, fam Properties.

## `dbLanguage` (type: `string`):

Filter to agents who speak this language, e.g. Arabic, Russian, French, Hindi.

## `dbNationality` (type: `string`):

Filter by agent nationality, e.g. United Kingdom, India, Egypt.

## `dbHasEmail` (type: `boolean`):

Return only agents that have an email address on file.

## `dbHasPhone` (type: `boolean`):

Return only agents that have a phone number on file.

## `dbHasWhatsapp` (type: `boolean`):

Return only agents that have a WhatsApp number on file.

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

URLs to start with. Supports PropertyFinder search URLs (e.g. `https://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1`), property detail pages, agent profiles (`/en/agent/{slug}-{id}`), and broker/agent-directory pages (`/en/find-agent`). Works across ae / sa / qa / eg.

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

Maximum number of agents (database mode) or listings/agents (live scrape) to return.

## `monitoringMode` (type: `boolean`):

Live scrape only: scrape only listings that are new compared to previous runs.

## `maxConcurrency` (type: `integer`):

Maximum number of pages that can be processed at the same time.

## `minConcurrency` (type: `integer`):

Minimum number of pages that will be processed at the same time.

## `maxRequestRetries` (type: `integer`):

Number of times the crawler will retry a failed request before giving up.

## `proxy` (type: `object`):

Specifies proxy servers used for live scraping (not needed in Instant Database mode).

## Actor input object example

```json
{
  "instantDatabase": false,
  "dbHasEmail": false,
  "dbHasPhone": false,
  "dbHasWhatsapp": false,
  "startUrls": [
    "https://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1",
    "https://www.propertyfinder.sa/en/search?c=1&fu=0&ob=mr"
  ],
  "maxItems": 1000,
  "monitoringMode": false,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 100,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1",
        "https://www.propertyfinder.sa/en/search?c=1&fu=0&ob=mr"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/apify-propertyfinder-cheerio-ppe").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://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1",
        "https://www.propertyfinder.sa/en/search?c=1&fu=0&ob=mr",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/apify-propertyfinder-cheerio-ppe").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://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1",
    "https://www.propertyfinder.sa/en/search?c=1&fu=0&ob=mr"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/apify-propertyfinder-cheerio-ppe --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PropertyFinder Scraper — Agent Database (Email & Phone)",
        "description": "PropertyFinder scraper with an instant agent database — 8,500+ UAE & Qatar agents with email, phone, WhatsApp & deal stats, filterable by City / Brokerage / Language. Or live-scrape property listings, agents & brokers across UAE, Saudi, Qatar & Egypt. Pure HTTP. JSON/CSV.",
        "version": "0.0",
        "x-build-id": "zZwp52Q0djaPTluYA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~apify-propertyfinder-cheerio-ppe/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-apify-propertyfinder-cheerio-ppe",
                "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/memo23~apify-propertyfinder-cheerio-ppe/runs": {
            "post": {
                "operationId": "runs-sync-memo23-apify-propertyfinder-cheerio-ppe",
                "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/memo23~apify-propertyfinder-cheerio-ppe/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-apify-propertyfinder-cheerio-ppe",
                "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": {
                    "instantDatabase": {
                        "title": "Use Instant Database (no scraping)",
                        "type": "boolean",
                        "description": "Serve matching agents from the pre-collected database instead of live-scraping. Auto-enabled if you set any of the filters below.",
                        "default": false
                    },
                    "dbCountry": {
                        "title": "Country",
                        "enum": [
                            "ae",
                            "sa",
                            "qa",
                            "eg"
                        ],
                        "type": "string",
                        "description": "Which PropertyFinder market to serve agents from."
                    },
                    "dbCity": {
                        "title": "City / Emirate (optional)",
                        "type": "string",
                        "description": "Filter agents by their office city/emirate, e.g. Dubai, Abu Dhabi, Sharjah, Ajman, Riyadh."
                    },
                    "dbBrokerage": {
                        "title": "Brokerage contains (optional)",
                        "type": "string",
                        "description": "Filter to a brokerage whose name contains this text, e.g. Betterhomes, Allsopp, fam Properties."
                    },
                    "dbLanguage": {
                        "title": "Language (optional)",
                        "type": "string",
                        "description": "Filter to agents who speak this language, e.g. Arabic, Russian, French, Hindi."
                    },
                    "dbNationality": {
                        "title": "Nationality (optional)",
                        "type": "string",
                        "description": "Filter by agent nationality, e.g. United Kingdom, India, Egypt."
                    },
                    "dbHasEmail": {
                        "title": "Only agents with an email",
                        "type": "boolean",
                        "description": "Return only agents that have an email address on file.",
                        "default": false
                    },
                    "dbHasPhone": {
                        "title": "Only agents with a phone",
                        "type": "boolean",
                        "description": "Return only agents that have a phone number on file.",
                        "default": false
                    },
                    "dbHasWhatsapp": {
                        "title": "Only agents with WhatsApp",
                        "type": "boolean",
                        "description": "Return only agents that have a WhatsApp number on file.",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with. Supports PropertyFinder search URLs (e.g. `https://www.propertyfinder.ae/en/search?c=2&fu=0&ob=mr&page=1`), property detail pages, agent profiles (`/en/agent/{slug}-{id}`), and broker/agent-directory pages (`/en/find-agent`). Works across ae / sa / qa / eg.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "type": "integer",
                        "description": "Maximum number of agents (database mode) or listings/agents (live scrape) to return.",
                        "default": 1000
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only new listings)",
                        "type": "boolean",
                        "description": "Live scrape only: scrape only listings that are new compared to previous runs.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "type": "integer",
                        "description": "Maximum number of pages that can be processed at the same time.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min Concurrency",
                        "type": "integer",
                        "description": "Minimum number of pages that will be processed at the same time.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "type": "integer",
                        "description": "Number of times the crawler will retry a failed request before giving up.",
                        "default": 100
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Specifies proxy servers used for live scraping (not needed in Instant Database mode).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
