# MagicBricks Property Scraper — Price, BHK, Area (India) (`memo23/magicbricks-property-scraper`) Actor

Scrape MagicBricks property listings — price, BHK, carpet & covered area, locality, project, builder, amenities, images and lister. Paste any filtered search or property URL, or build a search from a city + filters. Optional detail-page enrichment. JSON, CSV, Excel out

- **URL**: https://apify.com/memo23/magicbricks-property-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## MagicBricks Property Scraper

Turn any [MagicBricks](https://www.magicbricks.com) search into clean, structured property data. Paste a **filtered search URL**, build a search from a **city + filters**, or drop **direct property URLs** — and get one flat row per listing with price, BHK, carpet & covered area, locality, project, builder, amenities, floor, facing, GPS, images and the lister.

Built for real-estate lead generation, price & inventory research and market mapping across **1,000+ Indian cities**, for both **buy and rent**.

#### How it works

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

#### ✨ Why use this scraper?

- **Rich rows out of the box** — ~45 fields per property from the listing page alone: price (numeric + display), BHK, carpet & covered area, furnishing, floor, facing, ownership, possession, project, builder, locality, GPS, images, lister and more.
- **Three ways in** — filtered search URLs, a city + filters builder, or direct property URLs. Mix them in one run.
- **Beats MagicBricks' block** — MagicBricks serves datacenter scrapers a 403 "Access Denied" (Akamai); this actor routes every request through India residential IPs with a browser fingerprint, so you get the real page.
- **Optional detail-page enrichment** — flip on *Scrape property detail pages* to add the full readable amenities list, full description and a spec overview per property.
- **No brittle DOM scraping** — reads MagicBricks' embedded JSON state, so the output stays stable when the page layout changes.
- **JSON, CSV, Excel or API** — pipe results straight into your CRM, sheet or data pipeline. Billed per property row.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Real-estate agency / broker | Build targeted listing & owner-lead lists for any city, locality or budget |
| Proptech / portal | Seed or refresh a property database with structured, deduplicated rows |
| Market researcher | Measure inventory, price-per-sqft and BHK mix by locality and project |
| Investor / developer | Track asking prices, possession status and new projects in target micro-markets |
| Data / analytics team | Feed live MagicBricks listings into pricing or comparison models |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Search / SRP URL | `https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs` | Paginates that search (apply any filters on the site first, then paste the URL) |
| City + filters | `city: "Bangalore"`, `transactionType: "sale"`, `bedrooms: [2,3]` | Builds and paginates the matching search |
| Property URL | `https://www.magicbricks.com/propertyDetails/…&id=…` | Scrapes that single property |

**Not supported:** owner/agent phone numbers (MagicBricks gates these behind an OTP/login — only publicly shown lister name and type are returned), MagicBricks projects-microsite-only data, and anything behind a login. The actor scrapes only public listing and property pages.

#### ⚙️ How it works

1. **Classify** every input — a city + filters is turned into a search URL; pasted URLs are sorted into searches vs property pages.
2. **Unlock** each MagicBricks page with a browser TLS fingerprint over an India residential IP, so the real page is returned instead of the Akamai 403 block.
3. **Parse** the page's embedded `SERVER_PRELOADED_STATE_` JSON — a search page yields ~30 properties; the `?page=2`, `?page=3` … sequence is followed automatically up to your limit.
4. **Enrich** each property from its detail page (when *Scrape property detail pages* is on): full readable amenities, full description and a spec overview.
5. **Emit** one flat, self-contained row per property to the dataset, deduplicated by property id.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | MagicBricks search-results URLs and/or property URLs. Auto-classified. |
| `city` | string | — | City for the builder, e.g. `Bangalore`, `Mumbai`, `Pune`. |
| `transactionType` | string | `sale` | `sale` (buy) or `rent`. Used by the city builder. |
| `propertyTypes` | array | — | Property-type slugs for the builder (`Multistorey-Apartment`, `Residential-House`, `Residential-Plot`, …). Friendly names like `apartment`, `house`, `plot` accepted. |
| `bedrooms` | array | — | BHK filter for the builder, e.g. `2`, `3`. |
| `minBudget` / `maxBudget` | integer | — | Price range for the builder, in rupees (e.g. `5000000` = ₹50 Lac). |
| `scrapeDetails` | boolean | `false` | Also fetch each property's detail page for full amenities, description and spec overview. ~2× the requests. |
| `maxItems` | integer | `1000` | Max property rows for the whole run. |
| `maxItemsPerSearch` | integer | `1000` | Max rows per search URL / city build. |
| `maxConcurrency` | integer | `5` | Parallel requests. Keep moderate — MagicBricks is Akamai-protected. |
| `maxRequestRetries` | integer | `12` | Retry budget per request on Akamai blocks (403), 429 and network errors. |
| `proxy` | object | Apify Residential IN | Applies to free-tier runs; paid runs use a built-in India residential pool. |

#### 📊 Output overview

Each dataset record is **one property**, with listing-level fields (price, BHK, areas, furnishing, floor, facing, ownership, possession, project, builder, locality, GPS, images, lister, RERA) — and, when *Scrape property detail pages* is on, additional detail-level fields (full readable amenities, full description and a spec overview). All money fields are in INR (₹).

#### 📦 Output sample

```json
{
  "rowType": "property",
  "propertyId": "5318727",
  "title": "3 BHK Multistorey Apartment for Sale in Ramky Fortuna, Whitefield",
  "propertyType": "Apartment",
  "transactionType": "Sale",
  "listingType": "Resale",
  "bedrooms": 3,
  "bathrooms": 3,
  "balconies": 2,
  "price": 16300000,
  "priceDisplay": "1.63 Cr",
  "pricePerSqft": 11241,
  "carpetArea": 1100,
  "carpetAreaUnit": "Sq-ft",
  "coveredArea": 1450,
  "coveredAreaUnit": "Sq-ft",
  "furnishing": "Semi-Furnished",
  "floor": "8 of 14 Floor",
  "facing": "East",
  "ownership": "Freehold",
  "possessionStatus": "Ready to Move",
  "ageOfConstruction": "New Construction",
  "parking": "1 Covered",
  "reraIds": ["PRM/KA/RERA/1251/308/PR/211008/004353"],
  "locality": "Whitefield",
  "address": "Whitefield, Bangalore",
  "city": "Bangalore",
  "latitude": 12.9698,
  "longitude": 77.7499,
  "project": "Ramky Fortuna",
  "builder": "Ramky Estates",
  "amenities": ["Lift", "Swimming Pool", "Gymnasium", "Power Back Up", "Club House"],
  "description": "Well-ventilated 3 BHK apartment in a gated community…",
  "images": ["https://img.staticmb.com/mbphoto/property/…/photo.jpg"],
  "listerName": "Properties 21",
  "listerType": "Agent",
  "postedDate": "Posted Today",
  "isPremium": true,
  "propertyUrl": "https://www.magicbricks.com/propertyDetails/3-BHK-…-in-Bangalore&id=…",
  "sourceUrl": "https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs",
  "sourceMode": "search",
  "scrapedAt": "2026-06-25T12:30:00.000Z"
}
````

#### 🗂 Key output fields

| Field | Type | Notes |
|---|---|---|
| `title` / `propertyType` | string | Listing headline + type (Apartment / House / Plot / …) |
| `transactionType` / `listingType` | string | Sale / Rent + Resale / New |
| `bedrooms` / `bathrooms` / `balconies` | number | Unit configuration |
| `price` / `priceDisplay` / `pricePerSqft` | number / string | Asking price in ₹, the "79 Lac"/"1.63 Cr" label, and ₹/sqft |
| `carpetArea` / `coveredArea` (+ units) | number / string | Both areas, with their unit |
| `furnishing` / `floor` / `facing` / `ownership` / `possessionStatus` | string | Core specs |
| `locality` / `address` / `city` | string | Where the property is |
| `latitude` / `longitude` | number | GPS coordinates |
| `project` / `builder` | string | Project / society + developer |
| `amenities` | string\[] | Listing amenities (full readable list with `scrapeDetails`) |
| `reraIds` | string\[] | RERA registration ids, when listed |
| `images` | string\[] | Property image URLs |
| `listerName` / `listerType` | string | Public lister name + Owner / Agent / Builder |
| `propertyUrl` / `propertyId` | string | Canonical property URL + MagicBricks id |
| `allAmenities` / `fullDescription` / `overview` | — | Present only when *Scrape property detail pages* is on |

#### ❓ FAQ

**Can I get the owner's / agent's phone number?** No. MagicBricks hides contact numbers behind an OTP/login wall. The actor returns the publicly displayed **lister name** and **type** (Owner / Agent / Builder), not the gated phone.

**How many properties can I get per search?** MagicBricks paginates roughly 30 properties per page. Use a tighter search (locality, BHK, budget) to get the most relevant listings, and `maxItemsPerSearch` to cap.

**Buy and rent both?** Yes — paste a rent search URL, or set `transactionType: "rent"` in the city builder.

**What does *Scrape property detail pages* add?** The listing row is already rich (~45 fields). Turning it on visits each property's page to add the **full readable amenities list, full description and a spec overview** — at roughly double the requests.

**Do I need to configure proxies or an unlocker?** No. India residential routing is built in (MagicBricks is India-only and Akamai-protected). Just give it a city or some URLs.

#### 💬 Support

Found a bug or need an extra field? Open an issue on the [actor's Issues tab](https://apify.com/memo23/magicbricks-property-scraper/issues) and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom field, another property portal (99acres, Housing.com, NoBroker), or a scheduled listings feed into your warehouse? Custom scraping and pipeline work is available on request.

#### 🔎 Explore more scrapers

Looking for more India / real-estate data sources? Check out the other directory, property and company scrapers in the same publisher's collection on the Apify Store.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by MagicBricks (Times Internet Limited) or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available MagicBricks property listing and detail pages — no authenticated endpoints, no login-only or OTP-gated contact data. Users are responsible for ensuring their use complies with MagicBricks' Terms of Service, applicable data-protection law (including India's DPDP Act, GDPR and CCPA where relevant) and any contractual obligations of their own organisation. Use scraped personal data (such as lister names) lawfully and honour opt-out / do-not-contact requirements.

***

### SEO Keywords

magicbricks scraper, scrape magicbricks, magicbricks property scraper, magicbricks data extraction, magicbricks api, real estate scraper india, indian property data, magicbricks listings extractor, property price scraper india, magicbricks rent scraper, magicbricks buy scraper, real estate lead generation india, property market data india, magicbricks bangalore mumbai pune, scrape indian real estate, property listing scraper, magicbricks crawler, real estate data feed india, apify magicbricks, magicbricks property search scraper

# Actor input Schema

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

MagicBricks search-results URLs (apply any filters on the site, then paste the URL — e.g. `https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs`) and/or direct property URLs (`https://www.magicbricks.com/propertyDetails/...&id=...`). Auto-classified.

## `city` (type: `string`):

City name, e.g. `Bangalore`, `Mumbai`, `Pune`, `Gurgaon`. Resolved by MagicBricks to its internal city.

## `transactionType` (type: `string`):

Whether to search properties for sale (buy) or for rent. Used by the city builder.

## `propertyTypes` (type: `array`):

MagicBricks property-type slugs for the city builder. Common values: `Multistorey-Apartment`, `Builder-Floor-Apartment`, `Residential-House`, `Villa`, `Penthouse`, `Studio-Apartment`, `Residential-Plot`, `Farm-House`, `Serviced-Apartments`. Friendly names like `apartment`, `house`, `plot` are accepted too. Leave empty for all.

## `bedrooms` (type: `array`):

BHK filter for the city builder, e.g. `2`, `3`. Leave empty for all.

## `minBudget` (type: `integer`):

Minimum price for the city builder, in rupees (e.g. 5000000 = ₹50 Lac).

## `maxBudget` (type: `integer`):

Maximum price for the city builder, in rupees (e.g. 10000000 = ₹1 Cr).

## `scrapeDetails` (type: `boolean`):

Also fetch each property's detail page to enrich the row with the full readable amenities list, full description and a spec overview. Richer rows, but ~2× the requests (slower). Off = listing-only (already ~45 fields per property).

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

Hard cap on property rows across the entire run. Each row is one paid `property` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerSearch` (type: `integer`):

Cap per search URL / city build. MagicBricks paginates ~30 properties per page. Default 1000.

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

Parallel HTTP requests. MagicBricks sits behind Akamai — keep this moderate (4–8). Default 5.

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

Per-request retry budget on Akamai blocks (403), 429 and network errors. Each retry rotates to a fresh India residential IP across two pools. Default 12.

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

MagicBricks is India-only and Akamai-protected. Paying runs use a built-in dual India residential pool automatically; this setting applies to free-tier runs (defaults to Apify Residential, India).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs"
  ],
  "city": "Bangalore",
  "transactionType": "sale",
  "propertyTypes": [],
  "bedrooms": [],
  "scrapeDetails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 1000,
  "maxConcurrency": 5,
  "maxRequestRetries": 12,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# 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.magicbricks.com/flats-in-bangalore-for-sale-pppfs"
    ],
    "propertyTypes": [],
    "bedrooms": [],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/magicbricks-property-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": ["https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs"],
    "propertyTypes": [],
    "bedrooms": [],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/magicbricks-property-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": [
    "https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs"
  ],
  "propertyTypes": [],
  "bedrooms": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call memo23/magicbricks-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MagicBricks Property Scraper — Price, BHK, Area (India)",
        "description": "Scrape MagicBricks property listings — price, BHK, carpet & covered area, locality, project, builder, amenities, images and lister. Paste any filtered search or property URL, or build a search from a city + filters. Optional detail-page enrichment. JSON, CSV, Excel out",
        "version": "0.1",
        "x-build-id": "dcuKXWevwVUyGMfwj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~magicbricks-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-magicbricks-property-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/memo23~magicbricks-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-magicbricks-property-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/memo23~magicbricks-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-magicbricks-property-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Search & property URLs",
                        "type": "array",
                        "description": "MagicBricks search-results URLs (apply any filters on the site, then paste the URL — e.g. `https://www.magicbricks.com/flats-in-bangalore-for-sale-pppfs`) and/or direct property URLs (`https://www.magicbricks.com/propertyDetails/...&id=...`). Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name, e.g. `Bangalore`, `Mumbai`, `Pune`, `Gurgaon`. Resolved by MagicBricks to its internal city."
                    },
                    "transactionType": {
                        "title": "Buy or Rent",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Whether to search properties for sale (buy) or for rent. Used by the city builder.",
                        "default": "sale"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "MagicBricks property-type slugs for the city builder. Common values: `Multistorey-Apartment`, `Builder-Floor-Apartment`, `Residential-House`, `Villa`, `Penthouse`, `Studio-Apartment`, `Residential-Plot`, `Farm-House`, `Serviced-Apartments`. Friendly names like `apartment`, `house`, `plot` are accepted too. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "bedrooms": {
                        "title": "Bedrooms (BHK)",
                        "type": "array",
                        "description": "BHK filter for the city builder, e.g. `2`, `3`. Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minBudget": {
                        "title": "Min budget (INR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price for the city builder, in rupees (e.g. 5000000 = ₹50 Lac)."
                    },
                    "maxBudget": {
                        "title": "Max budget (INR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price for the city builder, in rupees (e.g. 10000000 = ₹1 Cr)."
                    },
                    "scrapeDetails": {
                        "title": "Scrape property detail pages",
                        "type": "boolean",
                        "description": "Also fetch each property's detail page to enrich the row with the full readable amenities list, full description and a spec overview. Richer rows, but ~2× the requests (slower). Off = listing-only (already ~45 fields per property).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max properties (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on property rows across the entire run. Each row is one paid `property` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max properties per search URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per search URL / city build. MagicBricks paginates ~30 properties per page. Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. MagicBricks sits behind Akamai — keep this moderate (4–8). Default 5.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on Akamai blocks (403), 429 and network errors. Each retry rotates to a fresh India residential IP across two pools. Default 12.",
                        "default": 12
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "MagicBricks is India-only and Akamai-protected. Paying runs use a built-in dual India residential pool automatically; this setting applies to free-tier runs (defaults to Apify Residential, India).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
