# Lamudi Indonesia Property Scraper (`solidcode/lamudi-co-id-scraper`) Actor

\[💰 $1.0 / 1K] Extract property listings from Lamudi Indonesia (lamudi.co.id) — houses, apartments, land, and commercial for sale or rent, with prices in IDR, beds, baths, area, photos, geolocation, and agent and agency details. Search by city and filters, or paste Lamudi URLs directly.

- **URL**: https://apify.com/solidcode/lamudi-co-id-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Lamudi Indonesia Property Scraper

Pull property listings from Lamudi Indonesia (lamudi.co.id) at scale — IDR prices, bedrooms and bathrooms, building and land area in m², map coordinates, full photo galleries, and agent contacts for every house, apartment, villa, land plot, and commercial space for sale or rent across Indonesia. Built for Indonesian real-estate investors, buyer's agents, and proptech teams who need clean, structured Lamudi data without copy-pasting listings by hand.

### Why This Scraper?

- **Guided search with no URL crafting** — pick Buy or Rent, type a city like Jakarta, Bandung, Surabaya, or Bali, choose a property type, and run. No need to hand-build a Lamudi search link.
- **Seven property categories** — House, Apartment, Villa, Land / Lot, Commercial, Office Space, or Any, mapped straight to Lamudi's own catalog.
- **Prices in IDR, both ways** — a parsed numeric `price` for sorting and math, plus the original `priceText` exactly as shown; "Contact agent" / hidden-price listings are kept with a null price instead of being dropped.
- **Map coordinates on every listing** — `latitude` and `longitude` ready to plot, so you can map inventory or run radius analysis without geocoding addresses yourself.
- **Agent and agency contacts** — `agentName`, `agencyName`, and the agent's WhatsApp/phone number where Lamudi exposes it, ideal for outreach lists.
- **Buy and rent in one actor** — flip a single Buy-or-Rent dropdown; no separate run or second tool for the rental market.
- **Precision price, bedroom, and bathroom filters** — set an exact IDR range and minimum beds/baths, applied to every result so tight criteria come back clean.
- **Full photo gallery on demand** — turn on Fetch Full Details to collect every image URL, the land area, and the agent's direct phone number for each property.
- **Direct Lamudi URLs or guided fields** — paste one or many filtered Lamudi search URLs as Start URLs when you already have the exact search ready in your browser.

### Use Cases

**Market Research**
- Map for-sale and for-rent inventory across Jakarta, Bandung, Surabaya, and Bali
- Compare asking prices per m² between districts and cities
- Track property-type mix (houses vs. apartments vs. land) by region
- Benchmark new developments and named projects with the keyword filter

**Investment Analysis**
- Pull every listing in a target IDR price band for underwriting
- Plot listings on a map using built-in latitude and longitude
- Compare building area vs. land area to spot value on land-heavy lots
- Monitor newest-first listings to catch fresh stock early

**Lead Generation for Agents**
- Build agent and agency contact lists with names and phone numbers
- Identify the most active agencies in a city or property type
- Source comparable listings to support a client pitch or valuation

**Proptech & App Data**
- Feed a property search app or dashboard with structured Indonesian listings
- Enrich an existing database with IDR pricing, geo, and photos
- Power alerting tools that watch for new listings in a target area

**Price Monitoring**
- Track rental and sale price ranges over time in a specific district
- Watch how a single development's pricing shifts across runs
- Compare lowest-price-first and highest-price-first views of a market

### Getting Started

#### Simple city search

```json
{
  "purpose": "for-sale",
  "location": "jakarta"
}
````

#### Filtered buy search with price and bedrooms

```json
{
  "purpose": "for-sale",
  "location": "bandung",
  "propertyType": "house",
  "priceMin": 1000000000,
  "priceMax": 5000000000,
  "bedroomsMin": 3,
  "bathroomsMin": 2,
  "maxResults": 200
}
```

#### For-rent search with sort and full details

```json
{
  "purpose": "for-rent",
  "location": "bali",
  "propertyType": "villa",
  "sort": "newest",
  "fetchDetails": true,
  "maxResults": 100
}
```

#### Power-user Start URLs

```json
{
  "startUrls": [
    "https://www.lamudi.co.id/en/for-sale/jakarta/apartment/",
    "https://www.lamudi.co.id/en/for-rent/surabaya/house/"
  ],
  "maxResults": 300
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `purpose` | string | `"for-sale"` | Buy or rent: `For Sale (Buy)` or `For Rent`. Ignored when Start URLs are provided. |
| `location` | string | `"jakarta"` | City or region to search, e.g. Jakarta, Bandung, Surabaya, Bali, Tangerang. Use `Indonesia` to search the whole country. |
| `propertyType` | string | `"any"` | Property category: `Any`, `House`, `Apartment`, `Villa`, `Land / Lot`, `Commercial`, or `Office Space`. |
| `searchQuery` | string | `""` | Optional keyword — area, project, or development name, e.g. "BSD City", "Kemang", "Pantai Indah Kapuk". |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | — | Only include listings at or above this price in IDR (e.g. 1000000000 for 1 billion). |
| `priceMax` | integer | — | Only include listings at or below this price in IDR. |
| `bedroomsMin` | integer | — | Minimum bedrooms (0 = studio). Ignored for Land and most Commercial searches. |
| `bathroomsMin` | integer | — | Minimum bathrooms. |
| `areaMin` | integer | — | Minimum floor or land area in m². |
| `areaMax` | integer | — | Maximum area in m². |
| `sort` | string | `"most-relevant"` | Result order: `Most relevant (default)`, `Newest first`, `Lowest price first`, or `Highest price first`. |

#### Advanced Search & Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Paste Lamudi search-result or single-property URLs. When provided, these override Buy/Rent, City, Property Type, Keyword, and Filters above. |
| `maxResults` | integer | `50` | Maximum number of properties to collect across all searches and URLs. Set 0 for unlimited. |
| `fetchDetails` | boolean | `false` | Open each listing's own page to collect the full photo gallery, land area, and the agent's phone number. Adds one extra page visit per property. |

### Output

Each property is returned as one flat record. Every field below is always present (null when Lamudi does not provide it).

```json
{
  "id": "rumah-mewah-di-pondok-indah-12345",
  "url": "https://www.lamudi.co.id/en/property/rumah-mewah-di-pondok-indah-12345",
  "title": "Rumah Mewah di Pondok Indah",
  "purpose": "for-sale",
  "propertyType": "house",
  "price": 39000000000,
  "priceText": "Rp 39 Miliar",
  "priceCurrency": "IDR",
  "bedrooms": 5,
  "bathrooms": 4,
  "carSpaces": 2,
  "area": 586,
  "areaText": "586 m²",
  "landArea": 720,
  "location": "Pondok Indah, Jakarta Selatan",
  "region": "DKI Jakarta",
  "city": "Jakarta Selatan",
  "area_district": "Pondok Indah",
  "latitude": -6.1937297,
  "longitude": 106.7831,
  "photoCount": 10,
  "coverPhotoUrl": "https://img.lamudi.com/.../cover.jpg",
  "imageUrls": ["https://img.lamudi.com/.../1.jpg", "https://img.lamudi.com/.../2.jpg"],
  "description": "Spacious family home in a prime South Jakarta neighborhood...",
  "agentName": "Andi Wijaya",
  "agentPhone": "+6281234567890",
  "agencyName": "Premier Property Indonesia",
  "tagLabels": ["Premium", "Featured"],
  "postedAt": null,
  "scrapedAt": "2026-06-11T08:30:00Z"
}
```

#### Listing Core

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Lamudi listing identifier |
| `url` | string | Full listing URL |
| `title` | string | Listing title |
| `purpose` | string | `for-sale` or `for-rent` |
| `propertyType` | string | Normalized category (house, apartment, villa, land, commercial, office) |
| `description` | string | Listing description text |
| `tagLabels` | array | Badges shown on the listing, e.g. Premium, Featured |
| `postedAt` | string | Listing date when available |
| `scrapedAt` | string | ISO timestamp of collection |

#### Pricing & Specs

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Numeric price in IDR (null for hidden / "contact agent" prices) |
| `priceText` | string | Original formatted price text as shown |
| `priceCurrency` | string | Currency code, always `IDR` |
| `bedrooms` | number | Bedroom count |
| `bathrooms` | number | Bathroom count |
| `carSpaces` | number | Car / garage spaces |
| `area` | number | Building / floor area in m² |
| `areaText` | string | Raw area text as shown |
| `landArea` | number | Land area in m² (filled when Fetch Full Details is on) |

#### Location & Geo

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Human-readable location string |
| `region` | string | Province / region |
| `city` | string | City |
| `area_district` | string | District or sub-area within the city |
| `latitude` | number | Latitude for mapping |
| `longitude` | number | Longitude for mapping |

#### Agent & Media

| Field | Type | Description |
|-------|------|-------------|
| `agentName` | string | Agent or agency display name |
| `agentPhone` | string | Agent phone number where Lamudi exposes it |
| `agencyName` | string | Agency name |
| `photoCount` | number | Number of photos on the listing |
| `coverPhotoUrl` | string | Cover image URL |
| `imageUrls` | array | All gallery image URLs (filled when Fetch Full Details is on) |

### Tips for Best Results

- Use Start URLs when you already have a filtered search open in your browser — copy the Lamudi URL straight in and it fully overrides the guided fields, so the exact result set is reproduced.
- Enable Fetch Full Details only when you need the complete photo gallery, land area, or the agent's direct phone — it visits one extra page per property, so leave it off for fast runs that still include the cover photo, price, beds, baths, area, location, and agency.
- Price filters are applied to every retrieved listing for precision (Lamudi has no price field in its URL), so for very tight IDR ranges raise Max Results to keep enough matches on each page.
- Set `location` to `Indonesia` to sweep the whole country, or name a specific city slug like `jakarta-selatan` for a tighter, faster search.
- Use `Newest first` sort to catch fresh stock and `Lowest price first` to build comps from the bottom of a market upward.
- Skip `bedroomsMin` / `bathroomsMin` for Land and Commercial searches — those listings rarely report rooms, and the minimums can thin out otherwise valid results.
- Keep `maxResults` at 0 for a full market sweep, but start with a small cap when dialing in a new city or filter combination to verify the result shape first.

### Pricing

**From $1.00 per 1,000 results** — pay only for the property listings you collect, with no charge for compute time or run duration. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.115 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.15 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.50 | $10.50 | $10.00 |
| 100,000 | $120.00 | $115.00 | $105.00 | $100.00 |

A "result" is one property listing record in your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Apify platform fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available property listing data for legitimate business purposes such as market research, investment analysis, and lead generation. You are responsible for using the collected data in compliance with Lamudi's terms of service, applicable data-protection laws, and any local regulations governing personal data and real-estate information. Do not use contact details for unsolicited spam, and respect the rights of listing owners and agents. </content> </invoke>

# Actor input Schema

## `purpose` (type: `string`):

Are you looking for properties for sale or for rent? Ignored when Start URLs are provided.

## `location` (type: `string`):

City or region to search, e.g. "Jakarta", "Bandung", "Surabaya", "Bali", "Tangerang". Leave as "Indonesia" to search the whole country. Ignored when Start URLs are provided.

## `propertyType` (type: `string`):

Filter by property category. Choose 'Any' to include all types.

## `searchQuery` (type: `string`):

Optional keyword — area, project, or development name, e.g. "BSD City", "Kemang", "Pantai Indah Kapuk". Leave empty for no keyword filter.

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

Power-user input. Paste Lamudi search-result URLs (e.g. https://www.lamudi.co.id/en/for-sale/jakarta/house/) or individual property URLs directly. When provided, these override the Buy/Rent, City, Property Type, Keyword, and Filters settings above.

## `priceMin` (type: `integer`):

Only include listings at or above this price in Indonesian Rupiah (e.g. 1000000000 for 1 billion IDR). Leave empty for no minimum. Note: the price range is applied after listings are retrieved (Lamudi has no price filter in the URL), so very tight price ranges may need a higher Max Results to fill a page.

## `priceMax` (type: `integer`):

Only include listings at or below this price in Indonesian Rupiah. Leave empty for no maximum. Applied after listings are retrieved (see Minimum Price note).

## `bedroomsMin` (type: `integer`):

Only include properties with at least this many bedrooms (0 = studio). Leave empty for any. Ignored for Land and most Commercial searches.

## `bathroomsMin` (type: `integer`):

Only include properties with at least this many bathrooms. Leave empty for any.

## `areaMin` (type: `integer`):

Only include properties at or above this floor or land area in square meters. Leave empty for no minimum.

## `areaMax` (type: `integer`):

Only include properties at or below this area in square meters. Leave empty for no maximum.

## `sort` (type: `string`):

How Lamudi orders results before we collect them.

## `maxResults` (type: `integer`):

Maximum number of properties to collect across all searches and URLs. Set 0 for unlimited. Results are collected in full pages, so the final page may overshoot this cap by a few records. Very large or unlimited runs are bounded by a built-in safety ceiling of roughly 60,000 properties per search, well above any normal search's inventory.

## `fetchDetails` (type: `boolean`):

Open each listing's own page to collect the full photo gallery, land area, and the agent's phone number. This visits one extra page per property, so runs take longer. Leave off for faster runs that still include the cover photo, price, beds, baths, area, location, and agency.

## Actor input object example

```json
{
  "purpose": "for-sale",
  "location": "jakarta",
  "propertyType": "any",
  "startUrls": [],
  "sort": "most-relevant",
  "maxResults": 50,
  "fetchDetails": false
}
```

# Actor output Schema

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

Table of scraped property listings with key fields — price, beds, baths, area, location, and URL.

## `details` (type: `string`):

Full per-listing fields including photos, geolocation, description, agent and agency details, and timestamps.

# 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 = {
    "purpose": "for-sale",
    "location": "jakarta",
    "propertyType": "any",
    "searchQuery": "",
    "startUrls": [],
    "sort": "most-relevant",
    "maxResults": 50,
    "fetchDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/lamudi-co-id-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 = {
    "purpose": "for-sale",
    "location": "jakarta",
    "propertyType": "any",
    "searchQuery": "",
    "startUrls": [],
    "sort": "most-relevant",
    "maxResults": 50,
    "fetchDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/lamudi-co-id-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 '{
  "purpose": "for-sale",
  "location": "jakarta",
  "propertyType": "any",
  "searchQuery": "",
  "startUrls": [],
  "sort": "most-relevant",
  "maxResults": 50,
  "fetchDetails": false
}' |
apify call solidcode/lamudi-co-id-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lamudi Indonesia Property Scraper",
        "description": "[💰 $1.0 / 1K] Extract property listings from Lamudi Indonesia (lamudi.co.id) — houses, apartments, land, and commercial for sale or rent, with prices in IDR, beds, baths, area, photos, geolocation, and agent and agency details. Search by city and filters, or paste Lamudi URLs directly.",
        "version": "1.0",
        "x-build-id": "MV0fit0dvMUbC36tm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~lamudi-co-id-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-lamudi-co-id-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/solidcode~lamudi-co-id-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-lamudi-co-id-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/solidcode~lamudi-co-id-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-lamudi-co-id-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": {
                    "purpose": {
                        "title": "Buy or Rent",
                        "enum": [
                            "for-sale",
                            "for-rent"
                        ],
                        "type": "string",
                        "description": "Are you looking for properties for sale or for rent? Ignored when Start URLs are provided.",
                        "default": "for-sale"
                    },
                    "location": {
                        "title": "City / Region",
                        "type": "string",
                        "description": "City or region to search, e.g. \"Jakarta\", \"Bandung\", \"Surabaya\", \"Bali\", \"Tangerang\". Leave as \"Indonesia\" to search the whole country. Ignored when Start URLs are provided.",
                        "default": "jakarta"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "house",
                            "apartment",
                            "villa",
                            "land",
                            "commercial",
                            "office"
                        ],
                        "type": "string",
                        "description": "Filter by property category. Choose 'Any' to include all types.",
                        "default": "any"
                    },
                    "searchQuery": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional keyword — area, project, or development name, e.g. \"BSD City\", \"Kemang\", \"Pantai Indah Kapuk\". Leave empty for no keyword filter."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Lamudi search-result URLs (e.g. https://www.lamudi.co.id/en/for-sale/jakarta/house/) or individual property URLs directly. When provided, these override the Buy/Rent, City, Property Type, Keyword, and Filters settings above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum Price (IDR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price in Indonesian Rupiah (e.g. 1000000000 for 1 billion IDR). Leave empty for no minimum. Note: the price range is applied after listings are retrieved (Lamudi has no price filter in the URL), so very tight price ranges may need a higher Max Results to fill a page."
                    },
                    "priceMax": {
                        "title": "Maximum Price (IDR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price in Indonesian Rupiah. Leave empty for no maximum. Applied after listings are retrieved (see Minimum Price note)."
                    },
                    "bedroomsMin": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at least this many bedrooms (0 = studio). Leave empty for any. Ignored for Land and most Commercial searches."
                    },
                    "bathroomsMin": {
                        "title": "Minimum Bathrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include properties with at least this many bathrooms. Leave empty for any."
                    },
                    "areaMin": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties at or above this floor or land area in square meters. Leave empty for no minimum."
                    },
                    "areaMax": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties at or below this area in square meters. Leave empty for no maximum."
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "most-relevant",
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "How Lamudi orders results before we collect them.",
                        "default": "most-relevant"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to collect across all searches and URLs. Set 0 for unlimited. Results are collected in full pages, so the final page may overshoot this cap by a few records. Very large or unlimited runs are bounded by a built-in safety ceiling of roughly 60,000 properties per search, well above any normal search's inventory.",
                        "default": 50
                    },
                    "fetchDetails": {
                        "title": "Fetch full details (slower)",
                        "type": "boolean",
                        "description": "Open each listing's own page to collect the full photo gallery, land area, and the agent's phone number. This visits one extra page per property, so runs take longer. Leave off for faster runs that still include the cover photo, price, beds, baths, area, location, and agency.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
