# Propertyfinder Eg Scraper (`mo_khairy/propertyfinder-eg-scraper`) Actor

Property Finder Egypt Scraper extracts structured real estate listing data from `propertyfinder.eg` for both sale and rent searches

- **URL**: https://apify.com/mo\_khairy/propertyfinder-eg-scraper.md
- **Developed by:** [Mohamed Khairy](https://apify.com/mo_khairy) (community)
- **Categories:** Automation, Real estate, AI
- **Stats:** 9 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 properties

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Property Finder Egypt Scraper

Property Finder Egypt Scraper extracts structured real estate listing data from `propertyfinder.eg` for both sale and rent searches. It supports location-based discovery and direct URL seeding, crawls Property Finder search pages, normalizes records into a clean dataset, and can optionally track newly seen listings for monitoring workflows. The actor is designed for market research, lead generation, inventory snapshots, and repeat runs where you only want fresh listings.

### Use cases

- Build a normalized database of Property Finder Egypt listings
- Monitor a district, compound, or city for newly published listings
- Export sale or rent inventory for market research and pricing analysis
- Track apartments, villas, chalets, duplexes, and other property types
- Feed downstream CRM, analytics, enrichment, or alerting pipelines

### What this actor extracts

Each dataset item is normalized into a consistent property record and may include:

- Listing URL and provider-scoped IDs
- Offer type such as `sale` or `rent`
- Property type
- Price and currency
- Bedrooms, bathrooms, area, and area unit
- Governorate, city, district, compound, and street text
- Latitude and longitude when available
- Furnishing and finishing status
- Listed and updated timestamps when present
- Verification flags
- Listing images
- Optional raw provider payload for debugging or custom post-processing

### Features

- Scrapes Property Finder Egypt search result pages
- Accepts direct list URLs and direct property detail URLs
- Supports location-based seeds for Egypt
- Deduplicates normalized results before output
- Supports monitoring mode using a key-value tracking store
- Can enrich listings with unit numbers via a secondary actor
- Supports metric and imperial area normalization

### Input options

Provide at least one of the following:

- `location`
- `sourceUrls`
- `listUrls`
- `propertyUrls`

#### Example: location-based run

```json
{
  "location": {
    "country": "EG",
    "governorate": "Cairo",
    "city": "New Cairo",
    "district": "Fifth Settlement"
  },
  "offerTypes": ["sale", "rent"],
  "realEstateType": "Apartment",
  "maxResultsPerProvider": 100,
  "units": "metric",
  "deduplicateResults": true,
  "threads": 3,
  "monitoringMode": false,
  "retrieveUnitNumber": false,
  "enableDelistingTracker": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### Example: direct search URL run

```json
{
  "sourceUrls": [
    {
      "type": "list",
      "url": "https://www.propertyfinder.eg/en/search?l=2254&c=1&t=1&fu=0&ob=mr"
    }
  ],
  "maxResultsPerProvider": 100,
  "deduplicateResults": true,
  "threads": 3,
  "monitoringMode": false
}
```

#### Example: direct property URL run

```json
{
  "sourceUrls": [
    {
      "type": "detail",
      "url": "https://www.propertyfinder.eg/en/plp/buy/apartment-for-sale-cairo-new-cairo-city-example-12345678.html"
    }
  ],
  "includeRaw": true
}
```

### Output

Results are stored in the default Apify dataset. The actor emits normalized listing items, and when `monitoringMode` is enabled it only emits properties that have not been seen in the tracking store before.

Typical output fields include:

```json
{
  "canonicalId": "propertyfinder_eg:12345678",
  "offerType": "sale",
  "realEstateType": "Apartment",
  "price": 8500000,
  "priceCurrency": "EGP",
  "bedrooms": 3,
  "bathrooms": 2,
  "area": 180,
  "areaUnit": "sqm",
  "country": "Egypt",
  "governorate": "Cairo",
  "city": "New Cairo",
  "district": "Fifth Settlement",
  "street": "North 90 Street",
  "gps": {
    "lat": 30.01,
    "lng": 31.45
  },
  "images": [
    "https://..."
  ],
  "sourceType": "list"
}
```

### Notes

- `listUrls` and `propertyUrls` remain supported for backward compatibility.
- Detail-page enrichment is best-effort and is disabled automatically when no residential proxy hint is detected.
- If `retrieveUnitNumber` is enabled, the actor expects `APIFY_TOKEN` to be available so it can call the configured unit-number actor.
- If `monitoringMode` is enabled and a listing already exists in the tracker store, it will be skipped from the final dataset output.

# Actor input Schema

## `location` (type: `object`):

Egypt-only location filter. Supports governorate, city, district, compound, and queryText.

## `offerTypes` (type: `array`):

Choose whether to scrape sale listings, rent listings, or both.

## `realEstateType` (type: `string`):

Optional canonical property-type filter, for example Apartment, Villa, Chalet, Duplex.

## `listUrls` (type: `array`):

Optional direct Property Finder search/result URLs.

## `propertyUrls` (type: `array`):

Optional direct Property Finder detail URLs.

## `sourceUrls` (type: `array`):

Optional direct seed URLs. Accepts strings as list URLs or objects with { type, url }.

## `maxResultsPerProvider` (type: `integer`):

Maximum number of normalized listings to emit for this actor run.

## `units` (type: `string`):

Choose how area values should be normalized in the output dataset.

## `deduplicateResults` (type: `boolean`):

Merge likely duplicate Property Finder records before saving results.

## `threads` (type: `integer`):

Maximum number of concurrent crawler requests.

## `retrieveUnitNumber` (type: `boolean`):

Call the configured enrichment actor to try to extract a unit number for each property.

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

Only emit listings that have not been seen in the tracking store before.

## `enableDelistingTracker` (type: `boolean`):

Persist seen-state in a key-value store for monitoring and delisting workflows.

## `includeRaw` (type: `boolean`):

Include the original Property Finder payload in each output item.

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

Maximum time to wait for a single request before it is considered failed.

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

How many times to retry failed requests before marking them as failed.

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

Apify proxy or custom proxy configuration. Residential proxies are recommended for detail-page enrichment.

## Actor input object example

```json
{
  "location": {
    "country": "EG",
    "governorate": "Cairo",
    "city": "New Cairo",
    "district": "Fifth Settlement"
  },
  "offerTypes": [
    "sale",
    "rent"
  ],
  "maxResultsPerProvider": 100,
  "units": "metric",
  "deduplicateResults": true,
  "threads": 3,
  "retrieveUnitNumber": false,
  "monitoringMode": false,
  "enableDelistingTracker": false,
  "includeRaw": false,
  "requestTimeoutSecs": 90,
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

Dataset items emitted by the actor, with the overview dataset view selected by default.

# 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 = {
    "location": {
        "country": "EG",
        "governorate": "Cairo",
        "city": "New Cairo",
        "district": "Fifth Settlement"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mo_khairy/propertyfinder-eg-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 = { "location": {
        "country": "EG",
        "governorate": "Cairo",
        "city": "New Cairo",
        "district": "Fifth Settlement",
    } }

# Run the Actor and wait for it to finish
run = client.actor("mo_khairy/propertyfinder-eg-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 '{
  "location": {
    "country": "EG",
    "governorate": "Cairo",
    "city": "New Cairo",
    "district": "Fifth Settlement"
  }
}' |
apify call mo_khairy/propertyfinder-eg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KzrW9ADeKRGwDJBSp/builds/HTBurQvpPestqIp00/openapi.json