# Aqarmap Egypt Property Listings Scraper (`automation-lab/aqarmap-egypt-property-listings-scraper`) Actor

🏠 Export public Aqarmap Egypt sale and rent listings with prices, property details, locations, photos, amenities, descriptions, and visible seller context.

- **URL**: https://apify.com/automation-lab/aqarmap-egypt-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Aqarmap Egypt Property Listings Scraper

Export public Egyptian real estate listings from Aqarmap into clean JSON, CSV, Excel, XML, or RSS.

Use **Aqarmap Egypt Property Listings Scraper** to collect sale and rental inventory, prices, price per square meter, property attributes, locations, coordinates, photos, amenities, descriptions, and seller context that is visible without signing in.

- 🏠 Start from an Aqarmap sale/rent search or an exact listing URL
- 💰 Capture EGP prices and price-per-square-meter values
- 📍 Export addresses, localities, and map coordinates
- 🖼️ Collect the main photo and complete image gallery
- 🔁 Schedule recurring inventory and price monitoring
- ⚡ Choose detailed enrichment or faster search-card extraction

### What does Aqarmap Egypt Property Listings Scraper do?

The Actor turns public pages on `aqarmap.com.eg` into one structured row per property listing.

For search URLs, it follows pagination until it reaches your listing limit, the page safety limit, or the end of results. It removes duplicate listing IDs across every input URL.

For listing URLs, it reads the property directly. Detail enrichment uses Aqarmap's structured listing data and visible page fields to return richer records.

The Actor supports public sale and rental URLs in English or Arabic paths. It does not require an Aqarmap account.

### Who is this Aqarmap property scraper for?

#### Real estate brokers and lead teams

Build prospecting lists from current inventory, segment by location and property attributes, and send selected records into a CRM.

#### Investors and acquisition analysts

Compare asking prices, price per square meter, unit size, finish, amenities, and location across neighborhoods.

#### Valuation and data teams

Create repeatable source datasets for Egyptian property market models, dashboards, and comparable-property analysis.

#### Property managers and agencies

Monitor new rental inventory or detect when a tracked listing changes availability.

#### Researchers and journalists

Export reproducible snapshots of publicly advertised real estate without manually copying pages.

### Why use this Aqarmap scraper?

- ✅ **Source-specific output:** fields map to Aqarmap's public property records.
- ✅ **Search and detail modes:** crawl a market segment or look up exact listings.
- ✅ **Global deduplication:** each listing ID is emitted once per run.
- ✅ **Useful partial fallback:** if one detail page fails, its search-card data can still be saved.
- ✅ **Fail-closed input validation:** unrelated domains and Aqarmap pages outside the listing scope are rejected.
- ✅ **Automation ready:** run through the Console, API, schedules, webhooks, or MCP.
- ✅ **No browser by default:** efficient HTTP extraction keeps runs fast and economical.

### What Aqarmap property data can you extract?

| Field | Description |
|---|---|
| `listingId` | Stable numeric Aqarmap listing identifier |
| `url` | Canonical property listing URL |
| `title` | Public listing headline |
| `transactionType` | `sale` or `rent` |
| `propertyType` | Apartment, villa, chalet, land, commercial unit, or another source type |
| `price` | Numeric asking price |
| `currency` | Usually `EGP` |
| `pricePerSquareMeter` | Numeric EGP/m² value when shown |
| `areaSquareMeters` | Property floor area |
| `bedrooms` / `bathrooms` | Room counts |
| `location` | Combined public location label |
| `streetAddress` / `locality` / `country` | Structured address fields |
| `latitude` / `longitude` | Public map coordinates when present |
| `imageUrl` | Main listing image |
| `imageUrls` | Full public image gallery on enriched records |
| `datePosted` | Source publication timestamp |
| `availability` | Structured availability such as `InStock` |
| `amenities` | Public feature labels such as balcony, security, or parking |
| `description` | Full visible listing description |
| `sellerType` | Visible role such as Developer, Broker, or Owner |
| `floor` / `view` / `yearBuilt` | Additional detail fields when shown |
| `hasWhatsApp` | Whether an anonymous WhatsApp action is visible |
| `isVerified` | Verification flag visible on a search card |
| `sourceSearchUrl` | Search URL that discovered the listing |
| `scrapedAt` | UTC extraction timestamp |

### How much does it cost to scrape Aqarmap Egypt listings?

The Actor uses pay-per-event pricing:

- **Actor start:** $0.005 per run
- **Property listing:** tiered by your Apify plan; the BRONZE reference price is $0.00045004 per saved row

At the BRONZE reference price, 100 listings cost about $0.050 and 1,000 listings about $0.455, including the run-start event.

The FREE-tier per-listing event is $0.00051754. Higher plans receive progressively lower prices: SILVER $0.00035103, GOLD $0.00027002, PLATINUM $0.00018001, and DIAMOND $0.00012601.

Keep `maxItems` small for a first run. Disable detail enrichment when search-card fields are sufficient and speed matters more than galleries or descriptions.

### How to scrape Aqarmap Egypt in 5 steps

1. Open the Actor input page.
2. Add one or more Aqarmap Egypt sale, rent, or listing URLs.
3. Choose the maximum number of property listings.
4. Keep **Enrich from property detail pages** enabled for rich records, or disable it for a fast inventory scan.
5. Start the run and download the dataset as JSON, CSV, Excel, XML, or RSS.

The prefilled example is intentionally small and suitable for a quick first run.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | required | Aqarmap sale/rent searches or property listing URLs |
| `maxItems` | integer | 20 | Global maximum unique listings |
| `maxPagesPerSearch` | integer | 20 | Pagination safety limit per search URL |
| `enrichDetails` | boolean | `true` | Fetch detail fields, gallery, amenities, and coordinates |
| `proxyConfiguration` | object | none | Optional Apify Proxy configuration |

#### Example search input

```json
{
  "startUrls": [
    {
      "url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 2,
  "enrichDetails": true
}
````

#### Example exact-listing input

```json
{
  "startUrls": [
    {
      "url": "https://aqarmap.com.eg/en/listing/6819977-for-sale-cairo-hadayek-el-ahram-lmntq-t/"
    }
  ],
  "maxItems": 1,
  "enrichDetails": true
}
```

### Output example

```json
{
  "listingId": "6819977",
  "url": "https://aqarmap.com.eg/en/listing/6819977-for-sale-cairo-hadayek-el-ahram-lmntq-t",
  "title": "zh 100m Fully finished apartment in pyramid gardens",
  "transactionType": "sale",
  "propertyType": "Apartment with Garden",
  "price": 1800000,
  "currency": "EGP",
  "pricePerSquareMeter": 18000,
  "areaSquareMeters": 100,
  "bedrooms": 2,
  "bathrooms": 2,
  "locality": "Area T",
  "country": "EG",
  "latitude": 29.967278421053,
  "longitude": 31.095728874207,
  "datePosted": "2026-07-19T12:21:23.000Z",
  "availability": "InStock",
  "sellerType": "Developer",
  "amenities": ["SECURITY", "BALCONY", "ELEVATOR"],
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Optional fields are omitted when Aqarmap does not display them. This keeps exports compact and avoids ambiguous `null` values.

### Search mode versus detail mode

#### Enriched search monitoring

Use a search URL with `enrichDetails: true` when you need descriptions, galleries, coordinates, amenities, and seller type for every discovered property.

#### Fast inventory monitoring

Use `enrichDetails: false` when listing ID, title, price, area, rooms, locality, and lead image are enough. This performs one request per search page rather than one request per property.

#### Exact property lookup

Supply listing URLs directly. Exact URLs always return detail records because the listing page is the requested source.

### Pagination and deduplication

`maxItems` applies across all start URLs. If two searches contain the same property, the Actor saves it only once.

`maxPagesPerSearch` prevents an unexpectedly broad category URL from crawling indefinitely. Pagination begins at the `page` value already present in each URL, or page 1 when no value is supplied.

The Actor stops a search when a page has no new listing cards.

### Tips for reliable Aqarmap extraction

- 🎯 Start with 5–20 rows and inspect the output before increasing limits.
- 🧭 Use a narrow Aqarmap neighborhood or property-type URL for focused comparable data.
- ⚡ Disable detail enrichment for frequent inventory snapshots.
- 🔁 Use Apify schedules to run the same search daily or weekly.
- 🆔 Compare snapshots by `listingId`, not by title.
- 🌐 Leave the proxy field empty unless direct requests encounter regional rate limiting.
- 📉 Keep page limits aligned with the number of records you actually need.

### Scheduled price and inventory monitoring

Create an Apify schedule for a stable Aqarmap search URL. Export each run to a named dataset or forward it through a webhook.

A downstream workflow can compare `listingId`, `price`, `availability`, and `datePosted` against the previous snapshot to identify:

- newly listed properties,
- removed inventory,
- price changes,
- newly available rentals,
- changes in neighborhood asking-price distributions.

A card-only schedule is usually sufficient for frequent monitoring. Run periodic enriched snapshots when you also need changed descriptions or image galleries.

### Integrations

#### Google Sheets and Airtable

Send dataset rows through Make, Zapier, or an Apify integration. Use `listingId` as the unique key to update existing records instead of creating duplicates.

#### CRM and lead routing

Filter for target neighborhoods, price ranges, seller types, or property attributes, then create CRM records with the canonical listing URL as source evidence.

#### BigQuery, Snowflake, and data warehouses

Load scheduled snapshots into partitioned tables. Keep `scrapedAt` and `sourceSearchUrl` for lineage and time-series analysis.

#### Slack, email, and webhooks

Trigger alerts only for records that are new or whose price differs from the last saved snapshot.

### Use the Actor with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/aqarmap-egypt-property-listings-scraper').call({
  startUrls: [{ url: 'https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1' }],
  maxItems: 20,
  enrichDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/aqarmap-egypt-property-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://aqarmap.com.eg/en/for-rent/property-type/cairo?page=1'}],
    'maxItems': 20,
    'enrichDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~aqarmap-egypt-property-listings-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1"}],
    "maxItems": 20,
    "enrichDetails": true
  }'
```

### Use Aqarmap property data through MCP

Connect the Actor to AI assistants through Apify's MCP server.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/aqarmap-egypt-property-listings-scraper"
```

#### Claude Desktop, Cursor, and VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/aqarmap-egypt-property-listings-scraper"
    }
  }
}
```

Example prompts:

- “Scrape 20 Aqarmap sale listings from this Dokki search and rank them by EGP per square meter.”
- “Extract this Aqarmap listing and summarize its amenities, location, price, and seller type.”
- “Run a card-only rental inventory snapshot and return IDs and prices as a table.”

### Proxy configuration

Direct anonymous HTTP is the default because Aqarmap currently serves useful search and detail pages without login or a proxy.

If your run is rate-limited, enable Apify Proxy in the standard proxy editor. Start with a datacenter proxy. Residential traffic should only be used when a cheaper route is demonstrably blocked.

The Actor retries failed requests up to three times with a short exponential delay.

### Data quality and limitations

Aqarmap controls the source data and may change its HTML or structured metadata.

- Some fields are optional and vary by advertiser or property type.
- Phone-number reveal can require authentication and is not promised by this Actor.
- Search cards contain fewer fields than enriched detail pages.
- Advertiser-provided descriptions may contain spelling differences or mixed languages.
- Search ordering can change between runs.
- Removed or unavailable listings may stop resolving.

The Actor extracts public source claims; it does not independently verify property ownership, price accuracy, or availability.

### Is it legal to scrape Aqarmap?

This Actor accesses public pages and does not bypass login controls. Web scraping legality depends on your jurisdiction, purpose, volume, and handling of personal data.

Use the data responsibly:

- follow applicable laws and contractual obligations,
- avoid collecting data you do not need,
- do not use contact data for spam or harassment,
- respect intellectual-property and database rights,
- apply suitable retention and access controls.

You are responsible for ensuring your use case is lawful.

### Troubleshooting

#### Why did the run reject my URL?

Only `aqarmap.com.eg` sale searches, rent searches, and numeric listing paths are accepted. Copy the full URL from Aqarmap and ensure it contains `/for-sale/`, `/for-rent/`, or `/listing/{id}`.

#### Why is a field missing?

Aqarmap does not show every attribute for every property. Enable detail enrichment for the richest public record. Optional unavailable fields are omitted rather than returned as misleading values.

#### Why did pagination stop early?

The Actor stops when it reaches `maxItems`, `maxPagesPerSearch`, or a page with no new cards. Increase the relevant limit only after confirming the source search contains more inventory.

#### Why am I seeing request failures?

First rerun with a small limit. If the issue is regional or rate-related, enable a datacenter Apify Proxy. Inspect run logs for the exact URL and HTTP response before increasing retries or scale.

### Frequently asked questions

#### Can I scrape both sale and rental listings?

Yes. Add any combination of supported Aqarmap Egypt sale and rent search URLs. The `transactionType` field distinguishes the records.

#### Can I scrape a list of exact properties?

Yes. Add multiple Aqarmap listing URLs to `startUrls`; the global listing limit and deduplication still apply.

#### Does the Actor extract phone numbers?

Only anonymously visible context is in scope. Aqarmap may gate phone-number reveal behind account actions, so phone numbers are not promised.

#### Can I export to Excel?

Yes. Open the default dataset after a run and select Excel, CSV, JSON, XML, or RSS.

#### Can I schedule the scraper?

Yes. Use an Apify schedule and keep the same search input for repeatable inventory snapshots.

#### Does it need a browser?

No. The Actor uses efficient HTTP requests and parses structured public page data.

### Related real estate scrapers

Explore other Automation Lab property-data tools:

- [Imovirtual Property Listings Scraper](https://apify.com/automation-lab/imovirtual-scraper) for Portugal
- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for United States property workflows
- [Idealista Scraper](https://apify.com/automation-lab/idealista-scraper) for Southern European listings

Choose a source-specific Actor when you need the portal's native identifiers, prices, and property attributes.

### Support

If a valid public Aqarmap sale, rent, or listing URL fails, open an issue from the Actor page.

Include:

- the input URL,
- the run ID,
- whether detail enrichment was enabled,
- the expected listing count or missing field,
- a short description of what you observed.

Do not include passwords, private account data, or unnecessary personal information.

# Actor input Schema

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

Add public aqarmap.com.eg sale/rent search URLs or individual listing URLs.

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

Stop after this many unique Aqarmap property records across all inputs.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for pagination of each Aqarmap search URL.

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

Fetch each detail page for descriptions, coordinates, full photos, amenities, and seller context.

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

Optional Apify Proxy settings. Direct anonymous HTTP is used when omitted.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1"
    }
  ],
  "maxItems": 5,
  "maxPagesPerSearch": 2,
  "enrichDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset table containing extracted Aqarmap property listings.

# 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": [
        {
            "url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1"
        }
    ],
    "maxItems": 5,
    "maxPagesPerSearch": 2,
    "enrichDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/aqarmap-egypt-property-listings-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 = {
    "startUrls": [{ "url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1" }],
    "maxItems": 5,
    "maxPagesPerSearch": 2,
    "enrichDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/aqarmap-egypt-property-listings-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 '{
  "startUrls": [
    {
      "url": "https://aqarmap.com.eg/en/for-sale/property-type/cairo/dokki/?page=1"
    }
  ],
  "maxItems": 5,
  "maxPagesPerSearch": 2,
  "enrichDetails": true
}' |
apify call automation-lab/aqarmap-egypt-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/aqarmap-egypt-property-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Aqarmap Egypt Property Listings Scraper",
        "description": "🏠 Export public Aqarmap Egypt sale and rent listings with prices, property details, locations, photos, amenities, descriptions, and visible seller context.",
        "version": "0.1",
        "x-build-id": "FoMnHQkee23bK168R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~aqarmap-egypt-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-aqarmap-egypt-property-listings-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/automation-lab~aqarmap-egypt-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-aqarmap-egypt-property-listings-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/automation-lab~aqarmap-egypt-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-aqarmap-egypt-property-listings-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏠 Aqarmap search or listing URLs",
                        "type": "array",
                        "description": "Add public aqarmap.com.eg sale/rent search URLs or individual listing URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum property listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique Aqarmap property records across all inputs.",
                        "default": 20
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for pagination of each Aqarmap search URL.",
                        "default": 20
                    },
                    "enrichDetails": {
                        "title": "Enrich from property detail pages",
                        "type": "boolean",
                        "description": "Fetch each detail page for descriptions, coordinates, full photos, amenities, and seller context.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct anonymous HTTP is used when omitted."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```