# Lamudi Indonesia Scraper with Contacts & Features (`fatihtahta/lamudi-id-property-scraper`) Actor

Collect structured public property listing records from Lamudi Indonesia. Start from locations, search pages, or direct listing URLs when supported, then save CleanedWeb records to the default dataset for market research, monitoring, CRM, BI, ETL, and property workflows.

- **URL**: https://apify.com/fatihtahta/lamudi-id-property-scraper.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** Real estate, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 property listings

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.co.id Property Scraper

**Slug:** `fatihtahta/lamudi-id-property-scraper`

### Overview

Lamudi.co.id Property Scraper collects structured public property listing records from Lamudi Indonesia, including listing identity, source URLs, location details, asking prices, property facts, media, enrichment status, and source context when available. [Lamudi Indonesia](https://www.lamudi.co.id/) is a public real estate portal used to discover residential, commercial, rental, sale, and land listings across Indonesian markets. This actor helps property researchers, brokers, analysts, operators, proptech teams, and data teams turn public listing pages into repeatable JSON records. Users can start from direct Lamudi URLs, build searches from structured fields, or combine both approaches in the same run. Results are delivered as structured Apify dataset records suitable for review, export, ETL pipelines, BI dashboards, AI-agent workflows, and downstream processing. The actor is designed for recurring public property-data acquisition with stable field groups and run artifacts, without claiming complete market coverage, guaranteed listing availability, or valuation-grade accuracy.

### What Makes This Actor Different

- **Pipeline-ready property records:** Output records use grouped JSON objects such as `source_context`, `entity`, `listing`, `pricing`, `location`, `property`, `media`, `contact_details`, `relationships`, and `attributes`, which makes them easier to map into warehouses, search indexes, CRMs, and BI models.
- **Two supported start paths:** Users can provide direct Lamudi URLs for saved searches or known listings, build a location-driven search from public filters, or use both paths together while keeping URL seeds independent from query-builder filters.
- **Property-specific filters:** The input schema supports sale/rent mode, route language, property categories, sort order, price range, bedroom and bathroom counts, subsidized housing, foreclosure handling, floor area, land area, rental billing period, amenities, certificate types, and listing freshness windows.
- **Enrichment-aware records:** `enrich_data` can collect richer listing details when available, including additional property attributes, contact details, agency relationships, media, and source context. Enriched rows are identified through `source_context.enrichment_status`.
- **Run summary artifacts:** Each successful run writes `RUN-SUMMARY` and `RUN-SUMMARY.html` artifacts that help operators review saved listing counts, seed modes, selected public inputs, enrichment status, location coverage, pricing coverage, property breakdowns, media counts, representative records, and artifact keys.
- **Map-ready review:** Coordinate-capable runs write a `results-map` HTML artifact. If no valid coordinates are present, the map report still opens and clearly shows zero mapped listings rather than adding placeholder rows to the dataset.
- **MCP summary handoff:** Optional `mcpConnectors` can send a concise post-run summary to user-authorized Apify MCP connectors after dataset and key-value-store artifacts are saved. The actor does not send the full listing dataset through MCP by default.
- **Schema-aware public contract:** The dataset schema documents required and optional fields, realistic examples, nested objects, nullable values, and the recommended deduplication key so downstream systems can handle sparse listings without guessing.

### Who Should Use This Actor

- **Real estate investors and analysts:** collect comparable public listings by geography, property type, asking price, rental period, floor area, and availability signals for market review.
- **Brokerages and agencies:** monitor visible inventory, property categories, source listing URLs, contact details, media, and agency relationships for operational reporting.
- **Market research teams:** build repeatable listing snapshots for supply analysis, price-band review, property mix comparison, and recurring market intelligence.
- **Proptech and data engineering teams:** ingest normalized listing records into databases, APIs, search indexes, vector stores, and internal property-data products.
- **AI agents and workflow automations:** use documented inputs, field references, run summaries, and map artifacts to collect scoped public property records and route follow-up actions.
- **CRM and enrichment teams:** enrich internal accounts, leads, or opportunity records with public listing context, asking price, location, property facts, and source audit links.
- **Operations and monitoring teams:** schedule recurring runs for dashboards, alerts, review queues, and structured acquisition of public listing records.

### Common Use Cases

- **Market intelligence:** monitor public supply, asking prices, rental periods, property types, amenities, media coverage, and location distribution across Indonesian markets.
- **Comparable listing research:** collect public listing attributes for a specific city, province, property type, price segment, or rental category.
- **Competitive monitoring:** track visible listing activity by agency, property category, location, enrichment status, or source listing URL over repeated runs.
- **Inventory snapshots:** create dated exports of matching Lamudi listings for operational reports, executive dashboards, and internal market memos.
- **Data enrichment:** attach public location, price, property facts, media URLs, and source links to existing CRM, underwriting, or analytics datasets.
- **Recurring reporting:** schedule the same input configuration to refresh dashboards, detect changes, and compare listing counts over time.
- **Agentic research workflows:** let an internal agent run a scoped collection, read the run summary, inspect representative records, and hand off records to a review or enrichment workflow.

### Real-World Questions This Data Can Answer

- Which public Lamudi listings match a specific Indonesian location, transaction mode, property category, price range, room count, area range, amenity, or certificate filter?
- Which saved-search URL or direct listing URL produced each record?
- Which listings have enough structured location, price, media, and property facts to support enrichment, review, or monitoring workflows?
- Which cities, regions, property types, billing periods, or agencies are most visible in a selected result set?
- How many records were enriched, mapped, skipped for missing coordinates, or saved for a selected input configuration?
- Which listings can be matched across runs using `record_id`, `listing.listing_id`, `property.property_id`, `url`, `source_context.canonical_url`, or `source_context.fingerprint`?
- Which records need human review because optional fields such as price, coordinates, contact details, amenities, or media are missing?

### Quick Start

1. Choose a starting path: enter a Lamudi URL in `url`, provide a `location` for query mode, or use both.
2. Select `deal_type`, `property_type`, price, area, room, amenity, freshness, or certificate filters when you need a narrower listing slice.
3. Keep `limit` small for the first validation run so you can inspect the record shape quickly.
4. Run the actor in Apify Console and open the dataset after completion.
5. Review `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map` when present before increasing limits, scheduling the run, or importing records downstream.

### Input Parameters

Configure one or more public Lamudi source URLs, a structured query, optional enrichment, collection limits, and optional post-run connector delivery.

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `location` | string | City, regency, province, neighborhood, or market for query-built searches, such as `Jakarta`, `Jawa Tengah`, `Semarang`, `Solo`, or `Bali`. | – |
| `deal_type` | string | Listing mode for query-built searches. Allowed values: `buy`, `rent`. | `rent` |
| `language` | string | Lamudi route language for query-built searches. Allowed values: `id`, `en`. Direct URLs keep their own language path. | `id` |
| `property_type` | array of strings | One or more property groups or types. Values include apartment, condo, room, commercial, warehouse, shop/commercial, office, retail, hotel, house, townhouse, villa, land, and related Lamudi type codes. | – |
| `sort_by` | string | Sort order before collection. Allowed values: `popularity`, `newest`, `price-low`, `price-high`. | – |
| `min_price` | integer | Minimum asking price or rent in IDR. | – |
| `max_price` | integer | Maximum asking price or rent in IDR. | – |
| `bed_count` | array of strings | Bedroom counts to include. Allowed values: `1`, `2`, `3`, `4`, `5` where `5` represents 5 or more in the public form. | – |
| `bathroom_count` | array of strings | Bathroom counts to include. Allowed values: `1`, `2`, `3`, `4`, `5` where `5` represents 5 or more in the public form. | – |
| `subsidized_housing` | string | Subsidized housing handling. Allowed values: `included`, `excluded`, `yes`. | – |
| `foreclosed_property` | string | Foreclosure handling. Allowed values: `included`, `excluded`, `yes`. | – |
| `min_floor_area` | integer | Minimum floor area in square meters. | – |
| `max_floor_area` | integer | Maximum floor area in square meters. | – |
| `min_land_area` | integer | Minimum land or plot area in square meters. | – |
| `max_land_area` | integer | Maximum land or plot area in square meters. | – |
| `rent_price_periodicity` | array of strings | Rental billing periods to include for rental searches. Allowed values: `daily`, `monthly`, `yearly`. | – |
| `amenities` | array of strings | Lamudi amenity or feature filters such as `security`, `cctv`, `swimming_pool`, `gym`, `garage`, `internet`, `air-conditioning`, `furnished`, `equipped-kitchen`, `storage-room`, and more. | – |
| `certificate` | array of strings | Indonesian property certificate types. Allowed values: `shm`, `hgb`, `hak_pakai`, `hak_sewa`, `hgu`, `strata`, `ppjb`. | – |
| `publication_date` | string | Listing freshness window. Allowed values: `1`, `7`, `30` for last 24 hours, last 7 days, or last 30 days. | – |
| `url` | array of strings | One Lamudi URL per line. Supports search pages, filtered results, category pages, and individual listing pages. Each URL is an independent seed. | – |
| `enrich_data` | boolean | Collect richer listing details when available, including additional property details, contact details, media, source context, and agency relationships. | `true` |
| `limit` | integer | Maximum number of listing records to save. Start small for validation and increase after confirming output quality. | – |
| `mcpConnectors` | array of connector IDs | Optional Apify MCP connectors for post-run summary delivery. The actor sends a concise summary and links when compatible connector tools are available. | `[]` |

### Choosing Inputs

Use `url` when you already have a Lamudi search page, filtered result page, category page, or individual listing URL. Each URL is collected as its own seed, which makes URL input useful for repeatable saved-search monitoring and known-listing review.

Use `location` plus query-builder filters when you want the actor to create a structured Lamudi search. A focused `location`, `deal_type`, and small set of property filters usually produces cleaner comparison groups for price analysis, CRM enrichment, or recurring reporting.

Leave optional filters empty when your goal is broader discovery. Add filters gradually when you need a tighter segment, such as rental houses in a province, commercial spaces in a price band, listings with specific amenities, or recently posted records.

Use `limit` as a practical control. A small limit is useful for validating output shape and field availability; a higher limit is better for scheduled monitoring, dashboards, or exports after the input configuration is proven.

Keep segmented workflows separate when you need clean downstream comparisons. For example, run separate jobs by city, transaction mode, property type, price band, or rental billing period rather than mixing unrelated segments in one large export.

Enable `enrich_data` when downstream users need richer property details, contact details, media, or agency context. Turn it off for faster exploratory checks when search-result fields are enough.

### Input Recipes

- **Validation run:** use one `url` or one `location`, keep `limit` between 1 and 10, and inspect the first dataset records plus the run summary before scaling.
- **Targeted rental market slice:** set `location`, `deal_type` as `rent`, add one or more `property_type` values, choose a price band with `min_price` and `max_price`, then set a practical `limit`.
- **Commercial property review:** choose a city or province in `location`, select commercial-oriented property types, optionally add floor or land area bounds, and keep `enrich_data` enabled for richer listing context.
- **Recently listed monitoring:** use the same `location` and filters each run, set `publication_date` to `1`, `7`, or `30`, and compare records by stable identifiers across scheduled runs.
- **Known listing enrichment:** provide individual listing URLs in `url`, keep `enrich_data` enabled, and use the output to enrich CRM, review, or property-research records.
- **Segmented analysis:** create separate runs for each city, property type, price band, or transaction mode so downstream dashboards can compare like-for-like result sets.

### Example Inputs

#### Example 1: Small rental validation run

```json
{
  "location": "Jawa Tengah",
  "deal_type": "rent",
  "language": "id",
  "limit": 5,
  "enrich_data": true
}
````

#### Example 2: Targeted house purchase search

```json
{
  "location": "Jakarta",
  "deal_type": "buy",
  "property_type": ["gt-house"],
  "min_price": 500000000,
  "max_price": 2500000000,
  "bed_count": ["2", "3"],
  "limit": 25
}
```

#### Example 3: Direct URL monitoring run

```json
{
  "url": [
    "https://www.lamudi.co.id/sewa/jawa-tengah/"
  ],
  "limit": 20,
  "enrich_data": true,
  "mcpConnectors": []
}
```

### Output

#### Output destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, AI agents, and downstream APIs with minimal post-processing.

The current dataset contract contains one primary record shape: `property_listing`. Run summaries, reports, and maps are saved as key-value-store artifacts, not as dataset rows.

#### Record envelope and stable identifiers

The recommended idempotency key is `record_id` when present. For stricter upserts, combine `record_id` with `source_context.source_domain`; if `record_id` is missing, use `url`, `source_context.canonical_url`, `source_context.external_ids.listing_id`, `property.property_id`, or `source_context.fingerprint` in that order.

Use these identifiers to merge, deduplicate, sync, and compare listings across repeated runs. `source_context` records source provenance, seed type, seed value, URL context, position, language, enrichment status, and source-provided external IDs where available.

#### Example: property listing record

```json
{
  "record_type": "property_listing",
  "record_id": "sample-lamudi-listing-001",
  "url": "https://www.lamudi.co.id/properti/sample-lamudi-listing-001",
  "source_context": {
    "source_id": "lamudi_id_property_scraper",
    "source_domain": "lamudi.co.id",
    "source_url": "https://www.lamudi.co.id/properti/sample-lamudi-listing-001",
    "seed_type": "search_url",
    "seed_value": "https://www.lamudi.co.id/sewa/jawa-tengah/",
    "loaded_url": "https://www.lamudi.co.id/properti/sample-lamudi-listing-001",
    "canonical_url": "https://www.lamudi.co.id/properti/sample-lamudi-listing-001",
    "seed_url": "https://www.lamudi.co.id/sewa/jawa-tengah/",
    "page_number": 1,
    "position": 1,
    "scraped_at": "2026-07-09T17:33:52+00:00",
    "language": "id",
    "country": "ID",
    "fingerprint": "sample-fingerprint-001",
    "enrichment_status": "enriched",
    "external_ids": {
      "listing_id": "sample-lamudi-listing-001",
      "proppit_id": "sample-proppit-001"
    },
    "search": {
      "url": "https://www.lamudi.co.id/sewa/jawa-tengah/",
      "title": "Properti Disewakan di Jawa Tengah",
      "deal_type": "rent",
      "location_slug": "jawa-tengah"
    }
  },
  "entity": {
    "title": "Sample Shop House For Rent in Solo",
    "description": "Sample public listing description with floor area, land area, bathroom count, and nearby amenities.",
    "category": "property"
  },
  "listing": {
    "listing_id": "sample-lamudi-listing-001",
    "listing_type": "property_listing",
    "deal_type": "rent",
    "transaction_type": "Sewa",
    "availability": "InStock"
  },
  "pricing": {
    "price": 150000000,
    "price_text": "IDR 150000000 / month",
    "currency": "IDR",
    "billing_period": "month",
    "billing_period_raw": "MONTH",
    "availability": "InStock"
  },
  "location": {
    "address": "Sample Street, Solo, Central Java, Indonesia",
    "city": "Solo",
    "region": "Jawa Tengah",
    "country": "ID",
    "latitude": -7.39064103,
    "longitude": 109.35552668,
    "coordinates": {
      "latitude": -7.39064103,
      "longitude": 109.35552668
    },
    "map_address": "Solo, Jawa Tengah"
  },
  "property": {
    "property_id": "sample-lamudi-listing-001",
    "property_type": "Ruang Usaha",
    "bathrooms": 3,
    "floor_area": 138,
    "land_area": 138,
    "floor_area_text": "138 sqm",
    "floor_area_sqm": {
      "value": 138,
      "unit": "sqm"
    },
    "land_area_text": "138 sqm",
    "land_area_sqm": {
      "value": 138,
      "unit": "sqm"
    },
    "area_unit": "sqm",
    "amenities": ["Air", "Listrik", "Tanpa perabotan"],
    "features": ["Air", "Tanpa perabotan", "Listrik"]
  },
  "media": {
    "main_image_url": "https://img.lamudi.com/sample-listing-image.jpg",
    "image_urls": [
      "https://img.lamudi.com/sample-listing-image.jpg"
    ]
  },
  "contact_details": {
    "phones": ["+620000000000"],
    "visible_phone_prefix": "+620000",
    "contacts": [
      {
        "type": "agency",
        "name": "Sample Agency",
        "phone_numbers": ["+620000000000"]
      }
    ]
  },
  "relationships": {
    "agency": {
      "name": "Sample Agency",
      "url": "https://www.lamudi.co.id/sample-agency/"
    }
  },
  "attributes": {
    "source_specific": {
      "measurement_sources": {
        "floor_area": {
          "schema_org_unit_code": "MTK"
        },
        "land_area": {
          "raw_text": "138 m²"
        }
      }
    }
  }
}
```

#### Run Summary, Map, And Artifacts

The actor writes stable run artifacts to the Apify key-value store:

- `RUN-SUMMARY`: machine-readable JSON with generated time, start and finish time, duration, public input summary, requested limit, saved listing count, chunk count, stop reason, seed modes, URL/query counts, selected filters, location breakdowns, coordinate coverage, enrichment counts, pricing counts, property counts, media counts, representative records, and artifact keys.
- `RUN-SUMMARY.html`: a human-readable report for operators, analysts, and workflow owners who want a compact run receipt without opening every dataset row.
- `results-map`: a standalone HTML map report for records with valid coordinates. In a recent enriched validation run with 2 saved listings, 1 listing had valid coordinates and 1 listing was skipped from the map for missing coordinates.
- `RUN-SUMMARY-ERROR`: a compact diagnostic artifact written only if summary or map generation cannot be completed after listing records are saved.

Use these artifacts to confirm saved counts, enrichment state, coordinate readiness, mapped listing count, skipped coordinate count, and export readiness before importing data into production workflows.

### Field Reference

#### Record envelope

- **record\_type** *(string, required)*: row family; currently `property_listing`.
- **record\_id** *(string or null, optional)*: preferred stable listing key for deduplication and upserts.
- **url** *(string or null, optional)*: primary public Lamudi listing URL.

#### Source context

- **source\_context.source\_id** *(string or null, optional)*: source identifier for Lamudi Indonesia records.
- **source\_context.source\_domain** *(string or null, optional)*: source domain, usually `lamudi.co.id`.
- **source\_context.source\_url** *(string or null, optional)*: source URL associated with the listing record.
- **source\_context.seed\_type** *(string or null, optional)*: seed mode such as `location`, `search_url`, or `detail_url`.
- **source\_context.seed\_value** *(string or null, optional)*: public location, search URL, or listing URL that led to the record.
- **source\_context.loaded\_url** *(string or null, optional)*: public page URL associated with the saved row.
- **source\_context.canonical\_url** *(string or null, optional)*: canonical Lamudi listing URL when available.
- **source\_context.seed\_url** *(string or null, optional)*: URL seed that produced the row.
- **source\_context.page\_number** *(integer, number, or null, optional)*: result page number when available.
- **source\_context.position** *(integer, number, or null, optional)*: listing position within the page or result batch.
- **source\_context.scraped\_at** *(string or null, optional)*: ISO collection timestamp.
- **source\_context.language** *(string or null, optional)*: Lamudi route or page language.
- **source\_context.country** *(string or null, optional)*: country code or source country context.
- **source\_context.fingerprint** *(string or null, optional)*: source-derived fingerprint observed in saved rows.
- **source\_context.enrichment\_status** *(string or null, optional)*: status such as `standard` or `enriched`.
- **source\_context.external\_ids** *(object or null, optional)*: source-provided listing, detail page, or property identifiers.
- **source\_context.search** *(object or null, optional)*: search URL, page title, deal type, location slug, and breadcrumbs when available.

#### Listing identity

- **entity.title** *(string or null, optional)*: displayed listing headline.
- **entity.description** *(string or null, optional)*: public listing description text when available.
- **entity.category** *(string or null, optional)*: broad entity category, typically `property`.

#### Listing details

- **listing.listing\_id** *(string or null, optional)*: source listing identifier when present.
- **listing.listing\_type** *(string or null, optional)*: listing family, usually `property_listing`.
- **listing.deal\_type** *(string or null, optional)*: normalized transaction mode such as `rent` or `buy`.
- **listing.transaction\_type** *(string or null, optional)*: source transaction label.
- **listing.availability** *(string or null, optional)*: source availability signal when present.

#### Pricing

- **pricing.price** *(number, integer, or null, optional)*: numeric asking price or rent amount.
- **pricing.price\_text** *(string or null, optional)*: displayed source price text.
- **pricing.currency** *(string or null, optional)*: currency code, commonly `IDR`.
- **pricing.billing\_period** *(string or null, optional)*: normalized rental billing period such as `month`, `day`, or `year`.
- **pricing.billing\_period\_raw** *(string or null, optional)*: source billing-period text when preserved separately.
- **pricing.availability** *(string or null, optional)*: source availability signal.
- **pricing.offer\_url** *(string or null, optional)*: offer URL from source structured data when it differs from the main listing URL.

#### Location

- **location.address** *(string or null, optional)*: public address or location text; may be partial.
- **location.city** *(string or null, optional)*: city or locality.
- **location.region** *(string or null, optional)*: province, state, or region.
- **location.country** *(string or null, optional)*: country code or country label.
- **location.latitude** *(number or null, optional)*: latitude when available.
- **location.longitude** *(number or null, optional)*: longitude when available.
- **location.coordinates.latitude** *(number or null, optional)*: nested latitude for map and geospatial pipelines.
- **location.coordinates.longitude** *(number or null, optional)*: nested longitude for map and geospatial pipelines.
- **location.map\_address** *(string or null, optional)*: map or place label when available.

#### Property facts

- **property.property\_id** *(string or null, optional)*: source property or listing identifier repeated in the property group.
- **property.property\_type** *(string or null, optional)*: source property category, such as house, apartment, commercial space, shop, or land.
- **property.bedrooms** *(integer, number, or null, optional)*: bedroom count when shown.
- **property.bathrooms** *(integer, number, or null, optional)*: bathroom count when shown.
- **property.floor\_area** *(number, integer, or null, optional)*: numeric building or floor area.
- **property.land\_area** *(number, integer, or null, optional)*: numeric land or plot area.
- **property.floor\_area\_text** *(string or null, optional)*: displayed floor area text.
- **property.land\_area\_text** *(string or null, optional)*: displayed land area text.
- **property.floor\_area\_sqm.value** *(number or integer, optional)*: floor area value in square meters when available.
- **property.floor\_area\_sqm.unit** *(string, optional)*: floor area unit, usually `sqm`.
- **property.land\_area\_sqm.value** *(number or integer, optional)*: land area value in square meters when available.
- **property.land\_area\_sqm.unit** *(string, optional)*: land area unit, usually `sqm`.
- **property.area\_unit** *(string or null, optional)*: normalized area unit.
- **property.amenities** *(array of strings or null, optional)*: amenity labels shown for the listing.
- **property.features** *(array of strings or null, optional)*: feature labels shown for the listing.

#### Media

- **media.main\_image\_url** *(string or null, optional)*: primary listing image URL.
- **media.image\_urls** *(array of strings or null, optional)*: listing image URLs in source order when available.

#### Contact and relationships

- **contact\_details** *(object, optional)*: public contact and communication details exposed by enriched records, such as phone, WhatsApp, website, or contact payload fields.
- **relationships.agency** *(object, optional)*: agency details shown on enriched listing records.

#### Source-specific attributes

- **attributes.source\_specific** *(object, optional)*: Lamudi-specific values that do not fit a stronger public group.
- **attributes.source\_specific.measurement\_sources** *(object, optional)*: source metadata for floor area, land area, or other measurements.

### Data Model Notes

- **Identity fields:** use `record_id` as the primary upsert key when present; fall back to `url`, `source_context.canonical_url`, `source_context.external_ids.listing_id`, `property.property_id`, or `source_context.fingerprint`.
- **Source provenance:** `source_context` explains where the record came from, which seed produced it, and whether the row is standard or enriched.
- **Property and listing value:** `entity`, `listing`, `pricing`, `location`, `property`, and `media` carry the main review and analytics fields.
- **Point-in-time values:** prices, availability, descriptions, agency information, media, and contact details reflect public data visible at run time.
- **Nested objects:** related values are grouped to preserve structure for JSON-first systems and make flattening decisions explicit.
- **Optional fields:** null-check fields that depend on listing type, geography, source availability, enrichment, or direct URL versus query mode.
- **Repeated runs:** store run ID, input configuration, run date, and export metadata alongside records when comparing listing changes over time.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Field preservation:** meaningful schema-supported listing and property values should be kept in stable public fields or grouped objects instead of being silently discarded; optional source values may still be absent when Lamudi does not expose them for a specific record.
- **Best-effort extraction:** fields may vary by region, availability, account visibility, listing type, UI experiments, or source-side changes.
- **Optional fields:** null-check optional values in downstream code, dashboards, and AI-agent prompts.
- **Deduplication:** use `record_id` first, then `url`, `source_context.canonical_url`, `source_context.external_ids.listing_id`, `property.property_id`, or `source_context.fingerprint`.
- **Freshness:** results reflect publicly available listing data at run time.
- **Repeated runs:** use stable identifiers when syncing data into warehouses, CRMs, search indexes, vector stores, or monitoring systems.
- **Schema awareness:** downstream systems should rely on documented fields and handle newly missing optional fields gracefully.
- **Run receipts:** use `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map` to audit listing counts, enrichment status, coordinate readiness, skipped map outcomes, and export readiness without treating artifacts as replacement dataset records.

### Tips For Best Results

- Start with a small `limit` to validate the output shape before scaling up.
- Use one city, province, property type, price band, or transaction mode per run when you need cleaner comparisons.
- Leave optional filters empty when the goal is broad discovery.
- Add filters gradually to understand how each field changes the resulting dataset.
- Keep `enrich_data` enabled when contact details, agency context, richer property facts, or media matter.
- Use stable identifiers for deduplication when storing results over time.
- Keep a saved copy of the input configuration used for each recurring workflow.
- Review run summary and map artifacts before importing listings into production pipelines, dashboards, CRMs, or research workflows.

### How to Run on Apify

1. Open the Actor in Apify Console.
2. Configure a `url`, a `location`, query-builder filters, or a combination of URL and query inputs.
3. Set `limit` to control the maximum number of listing records saved.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and inspect the first records.
6. Download results in JSON, CSV, Excel, or another supported Apify dataset format.

### Agentic And API-First Usage

This actor can be used as a structured public property-data acquisition step inside larger automated workflows. It is useful when an agent, workflow builder, or data pipeline needs repeatable input configuration, stable JSON records, a documented idempotency key, and run artifacts that summarize completion and coverage.

Agent workflow pattern:

1. Generate or select a scoped input from the supported schema.
2. Run the actor manually, on a schedule, or through Apify platform automation.
3. Wait for completion and read the dataset records.
4. Validate records against the field reference.
5. Read `RUN-SUMMARY`, `RUN-SUMMARY.html`, or `results-map` to verify counts, limit behavior, enrichment status, skipped outcomes, coordinates, and export readiness.
6. Upsert records into the downstream system using `record_id` or the documented fallback key order.
7. Trigger market analysis, enrichment, alerts, BI refreshes, vector/search indexing, lead review, or human verification.

Practical notes for agentic use:

- Keep prompts and automations grounded in the documented input parameters.
- Start with small validation runs before allowing broad automated collection.
- Feed the Field Reference and one output sample to downstream AI steps.
- Feed run summary and map artifacts to downstream agents so they can reason about completion, record counts, location distribution, and follow-up actions.
- Treat optional property and listing fields as nullable instead of asking agents to infer missing values.
- Store run ID, input configuration, and dataset export metadata outside the record when building audit trails.
- For tools such as Claude, Codex, internal copilots, or property workflow agents, pass the input schema, Field Reference, idempotency key, and one representative output example rather than the full README when context is limited.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Schedule recurring runs to keep a Lamudi listing dataset current for monitoring, reporting, and downstream enrichment. Use stable input configurations so repeated runs can be compared by segment.

- Navigate to **Schedules** in Apify Console.
- Create a new schedule, such as daily, weekly, or a custom cron.
- Configure input parameters.
- Enable notifications for run completion.
- Add webhooks for automated processing.

#### Integration Options

- **CRM enrichment:** sync public listing, location, asking price, media, contact, and agency context into account, lead, or opportunity records.
- **BI dashboards:** monitor asking prices, property mix, city and region counts, mapped coordinates, enrichment status, and media availability over time.
- **Warehouses and ETL pipelines:** load grouped JSON records into analytics tables while preserving nested objects for full-fidelity review.
- **Google Sheets or Airtable:** review smaller exports, compare saved-search results, and share listing snapshots with non-technical stakeholders.
- **Webhooks:** trigger validation, notification, ingestion, or change-detection workflows after each completed run.
- **MCP connectors:** authorize a connector in Apify, select it in `mcpConnectors`, and receive a concise run summary with dataset, report, and map links when compatible connector tools are available.
- **Search and vector indexes:** index listing titles, descriptions, locations, property facts, and source URLs for discovery or AI-agent retrieval workflows.

### Export Formats And Downstream Use

- **JSON:** best for APIs, applications, AI agents, and data pipelines that preserve nested objects.
- **CSV or Excel:** useful for spreadsheet workflows, stakeholder review, and lightweight analysis after deliberate flattening.
- **API access:** suitable for automated ingestion into internal systems.
- **BI and warehouses:** supports reporting, dashboards, historical analysis, and monitoring when records are partitioned by run or segment.
- **Search or vector indexes:** useful for listing discovery, semantic search, retrieval workflows, and agent context.

### Downstream Pipeline Guide

- **Idempotency:** use `record_id` for upserts when present, with `url`, `source_context.canonical_url`, `source_context.external_ids.listing_id`, `property.property_id`, or `source_context.fingerprint` as fallback keys.
- **Null handling:** treat optional fields as nullable, especially contact details, agency relationships, coordinates, bedrooms, bathrooms, amenities, media, and enrichment-only values.
- **Type handling:** preserve numbers, booleans, arrays, and nested objects when exporting to JSON-first systems.
- **Flattening:** if exporting to CSV or Excel, flatten nested objects deliberately and keep the original JSON export for full fidelity.
- **Partitioning:** store run date, input segment, geography, property type, transaction mode, and workflow name alongside records for easier analysis.
- **Change detection:** compare repeated runs by stable key and selected business fields such as price, availability, location, property type, area, media count, or enrichment status.
- **Quality checks:** monitor record count, duplicate rate, required envelope fields, price availability, coordinate coverage, media availability, and important optional field fill rates.
- **Human review:** route records with missing critical fields, unusual prices, changed availability, high-value segments, or coordinate gaps into a review queue when needed.
- **Retention:** decide how long to keep raw exports versus normalized warehouse tables based on your monitoring, compliance, and research needs.

### Performance And Coverage Expectations

Recent local validation artifacts provide example metrics, not guarantees:

| Run type | Example scope | Listings | Duration | Coverage notes |
| --- | --- | --- | --- | --- |
| Enriched URL-seeded validation | `https://www.lamudi.co.id/sewa/jawa-tengah/`, `limit = 2`, `enrich_data = true` | 2 | 7 seconds | 2 enriched records, 2 priced records, 1 mapped coordinate record, 1 skipped from map for missing coordinates. |
| No-connector mock validation | One URL seed, `limit = 1`, `enrich_data = false` | 1 | About 1 second | Dataset, run summary, HTML summary, and map artifact were written; no MCP delivery was attempted. |

Execution time varies based on filters, result volume, public target availability, response size, enrichment depth, coordinate/map artifact creation, and how much information is returned per listing. Highly filtered runs can finish faster, while broad discovery, enrichment, or detail-rich listing records may take longer. The actor does not expose a `maximize_coverage` input.

### Limitations

- Availability depends on what Lamudi Indonesia publicly exposes at run time.
- Some optional fields may be missing on sparse records or non-enriched rows.
- Very broad searches may take longer or require higher limits.
- Target-side changes can affect field availability, labels, or optional groups.
- Regional, account, visibility, listing status, or availability differences may change visible results.
- Listing prices, availability, status, and descriptions are point-in-time public signals and should be verified before operational decisions.
- This actor provides structured public real estate data, not legal, financial, investment, valuation, appraisal, brokerage, or official MLS advice.

### Troubleshooting

- **No results returned:** check location spelling, filters, property category, direct URLs, and whether Lamudi has matching public records.
- **Fewer results than expected:** broaden filters, raise `limit`, or verify that the selected scope contains enough matching records.
- **Some fields are empty:** optional fields depend on what each listing publicly provides and whether enrichment is enabled.
- **Duplicate-looking records:** compare `record_id`, `url`, `source_context.canonical_url`, external IDs, and listing context to decide whether records represent variants, units, updates, or repeated visibility.
- **Run takes longer than expected:** reduce scope, lower `limit` for validation, or split broad collection into smaller segments.
- **Output changed:** compare current records with the Field Reference and include a small sample when reporting the issue.
- **Downstream import failed:** check JSON validity, nullable fields, nested objects, and whether your destination expects flattened columns.

### FAQ

#### What data does this actor collect?

It collects public Lamudi Indonesia property listing records, including listing identity, URLs, price, location, property facts, media, source context, enrichment status, and optional contact or agency details when available.

#### Can I filter by location, property type, price, area, rooms, amenities, certificate type, or freshness?

Yes. The input schema supports `location`, `property_type`, `min_price`, `max_price`, floor and land area bounds, bedroom and bathroom counts, amenities, certificate types, and `publication_date`.

#### Can I provide direct Lamudi URLs?

Yes. Use `url` for search pages, filtered result pages, category pages, or individual listing pages. Each URL is handled as an independent seed.

#### Why did I receive fewer results than my limit?

The selected scope may contain fewer visible matching listings, filters may be restrictive, or some records may not be available at run time. `limit` is a cap, not a guarantee.

#### Where can I find the run summary or interactive map?

Open the run outputs in Apify. The dataset contains listing records, while `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map` are key-value-store artifacts linked from the actor output.

#### How should I choose a limit for my first run?

Start with a small limit, such as 5 or 10, inspect the dataset shape and run summary, then increase the limit for monitoring, exports, or ETL ingestion.

#### Can I schedule recurring runs?

Yes. Use Apify schedules with the same input configuration to create repeatable listing snapshots for monitoring and reporting.

#### How do I avoid duplicates across runs?

Use `record_id` as the preferred stable key. If it is missing, fall back to `url`, `source_context.canonical_url`, `source_context.external_ids.listing_id`, `property.property_id`, or `source_context.fingerprint`.

#### Can I use the output with AI agents or automated workflows?

Yes. The actor produces structured JSON records and run artifacts that can be used by AI agents, ETL workflows, dashboards, alerts, and downstream APIs.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Apify datasets can be downloaded in common formats. JSON is best for preserving nested objects; CSV and Excel are useful after deliberate flattening.

#### Does this actor collect private data or provide official valuation data?

No. It collects publicly available listing information and does not provide private records, official MLS completeness, legal conclusions, appraisal-grade valuation, or investment advice.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available property listing information from Lamudi Indonesia for legitimate business purposes, including:

- Real estate research and market analysis
- Listing monitoring, CRM enrichment, and operational reporting
- Public property-data acquisition for dashboards, pipelines, and workflow automation

This section is informational and not legal advice.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site’s terms.
- Respect individual privacy and personal information.
- Use data responsibly and avoid disruptive or excessive collection.
- Do not use this actor for spamming, harassment, discrimination, unlawful housing practices, or other harmful purposes.
- Follow relevant data protection, fair housing, consumer protection, and sector-specific requirements where applicable.
- Review your own retention, access control, and data-sharing policies before operationalizing the dataset.

### Support

For help, use the Issues tab or the actor page support channel. Include the input used with sensitive values redacted, the Apify run ID, expected versus actual behavior, a small output sample if useful, and the downstream destination or export format when the issue is pipeline-related.

# Actor input Schema

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

Enter one city, regency, province, neighborhood, or market supported by Lamudi Indonesia, such as Jakarta, Jawa Tengah, Semarang, Solo, or Bali. Use one focused market per run when you want cleaner price comparisons, recurring monitoring, downstream deduplication, or CRM-ready listing slices.

## `deal_type` (type: `string`):

Select whether the structured search should collect Lamudi Indonesia properties listed for sale or for rent. Pair this with location and optional filters when you need comparable market slices for monitoring, CRM enrichment, reporting, or ETL ingestion.

## `language` (type: `string`):

Choose the Lamudi route language used for query-built searches. Indonesian routes use paths such as /jual/ and /sewa/; English routes use /en/for-sale/ and /en/for-rent/. Direct URL entries keep their own language and path.

## `property_type` (type: `array`):

Choose one or more broad Lamudi property groups or specific property types, such as apartments, houses, commercial spaces, or land. Leave empty to include all property types that match the selected location and listing mode.

## `sort_by` (type: `string`):

Choose how Lamudi should order matching listings before collection. Use newest for monitoring recent inventory, or price ordering when reviewing market ranges.

## `min_price` (type: `integer`):

Set the lowest listing price to include, in IDR. Use with a maximum price when you need a clean budget band for monitoring, dashboards, CRM imports, or market analysis.

## `max_price` (type: `integer`):

Set the highest listing price to include, in IDR. Leave empty if you only need a lower bound or want Lamudi to return all matching prices above the minimum.

## `bed_count` (type: `array`):

Select one or more bedroom counts to include. Leave empty when bedroom count should not narrow the property search, such as broad commercial or land monitoring.

## `bathroom_count` (type: `array`):

Select one or more bathroom counts to include. This is most useful for residential searches where room configuration is part of the downstream comparison.

## `subsidized_housing` (type: `string`):

Choose whether subsidized housing listings should be included, excluded, or collected exclusively. Leave empty when subsidized status should not narrow the search.

## `foreclosed_property` (type: `string`):

Choose whether foreclosed Lamudi listings should be included with normal listings, excluded from the search, or collected exclusively. Use this when foreclosure status matters for sourcing, risk review, or investment-screening workflows.

## `min_floor_area` (type: `integer`):

Set the smallest floor area to include, in square meters. Use area filters for more consistent comparison sets in ETL, reporting, or property-review workflows.

## `max_floor_area` (type: `integer`):

Set the largest floor area to include, in square meters. Pair this with minimum floor area when you need a precise size band.

## `min_land_area` (type: `integer`):

Set the smallest land or plot area to include, in square meters. This is useful for lots, warehouses, commercial properties, and land-focused monitoring.

## `max_land_area` (type: `integer`):

Set the largest land or plot area to include, in square meters. Leave empty when larger lots should remain eligible.

## `rent_price_periodicity` (type: `array`):

Select one or more rent billing periods when a rental search should include only daily, monthly, or yearly price listings. Leave empty when rent period should not narrow the search.

## `amenities` (type: `array`):

Select Lamudi amenities or features that matching listings should include. Leave empty for broader discovery; add amenities when your downstream workflow needs a targeted property profile.

## `certificate` (type: `array`):

Select one or more Indonesian property certificate types when ownership or legal-status filtering matters for the search. Leave empty when certificate type should not narrow matching listings.

## `publication_date` (type: `string`):

Choose a recent publication window when you want newly listed properties for monitoring, alerting, lead review, or recurring inventory refreshes. Leave empty when older matching listings should remain eligible.

## `url` (type: `array`):

Paste one supported Lamudi Indonesia URL per line, such as https://www.lamudi.co.id/sewa/jawa-tengah/ or an individual listing page. Use URLs when you need precise repeatability for saved searches, listing monitoring, dashboards, CRM enrichment, or ETL refreshes.

## `enrich_data` (type: `boolean`):

Turn this on for CRM enrichment, BI reporting, listing review, data-quality checks, and ETL workflows that benefit from richer property details. Leave it off for faster validation runs, small monitoring checks, or cases where standard search-result fields are enough.

## `limit` (type: `integer`):

Choose the maximum number of Lamudi property records to save for this run. Leave empty to collect as many results as the selected URL seeds or location search return within the actor run, or set a smaller number for faster validation and predictable ETL batch sizes.

## `mcpConnectors` (type: `array`):

Choose user-authorized MCP connectors for optional post-run summary delivery, listing-summary notifications, or workflow handoff. The actor sends saved listing counts, runtime, search and location summaries, enrichment status, and dataset/report/map links when available. It does not send the full Lamudi dataset through MCP by default. Leave empty to only save listings to the Apify dataset and key-value store.

## Actor input object example

```json
{
  "deal_type": "rent",
  "language": "id",
  "enrich_data": true,
  "mcpConnectors": []
}
```

# Actor output Schema

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

Structured Lamudi Indonesia property listing records saved by this run.

## `runSummaryJson` (type: `string`):

Machine-readable end-of-run summary with totals, seed modes, filters, enrichment, location, pricing, property, media, and artifact breakdowns.

## `runSummaryHtml` (type: `string`):

Human-readable end-of-run report with listing totals, coverage, enrichment, map, pricing, property, and representative-listing sections.

## `resultsMap` (type: `string`):

Standalone HTML map report for listing records with valid coordinates. Runs with no valid coordinates still save a report showing zero mapped 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/lamudi-id-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/lamudi-id-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 '{}' |
apify call fatihtahta/lamudi-id-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lamudi Indonesia Scraper with Contacts & Features",
        "description": "Collect structured public property listing records from Lamudi Indonesia. Start from locations, search pages, or direct listing URLs when supported, then save CleanedWeb records to the default dataset for market research, monitoring, CRM, BI, ETL, and property workflows.",
        "version": "0.1",
        "x-build-id": "eAuuetnEBflwAY0Bh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihtahta~lamudi-id-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihtahta-lamudi-id-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/fatihtahta~lamudi-id-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihtahta-lamudi-id-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/fatihtahta~lamudi-id-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihtahta-lamudi-id-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": {
                    "location": {
                        "title": "Set the Lamudi Indonesia Location or Market",
                        "type": "string",
                        "description": "Enter one city, regency, province, neighborhood, or market supported by Lamudi Indonesia, such as Jakarta, Jawa Tengah, Semarang, Solo, or Bali. Use one focused market per run when you want cleaner price comparisons, recurring monitoring, downstream deduplication, or CRM-ready listing slices."
                    },
                    "deal_type": {
                        "title": "Choose Sale or Rental Listing Mode",
                        "enum": [
                            "buy",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Select whether the structured search should collect Lamudi Indonesia properties listed for sale or for rent. Pair this with location and optional filters when you need comparable market slices for monitoring, CRM enrichment, reporting, or ETL ingestion.",
                        "default": "rent"
                    },
                    "language": {
                        "title": "Choose the Lamudi Search Page Language",
                        "enum": [
                            "id",
                            "en"
                        ],
                        "type": "string",
                        "description": "Choose the Lamudi route language used for query-built searches. Indonesian routes use paths such as /jual/ and /sewa/; English routes use /en/for-sale/ and /en/for-rent/. Direct URL entries keep their own language and path.",
                        "default": "id"
                    },
                    "property_type": {
                        "title": "Choose Property Categories and Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more broad Lamudi property groups or specific property types, such as apartments, houses, commercial spaces, or land. Leave empty to include all property types that match the selected location and listing mode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "gt-apartment",
                                "apartments",
                                "condo",
                                "room",
                                "gt-commercial",
                                "commercial-space",
                                "industrial-unit",
                                "warehouse",
                                "shop-commercial",
                                "office",
                                "retail",
                                "hotel",
                                "gt-house",
                                "single-family-house",
                                "townhouse",
                                "villa",
                                "gt-land",
                                "land"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "Apartments",
                                "Condo",
                                "Room",
                                "Commercial Space",
                                "Commercial Space Type",
                                "Industrial Unit",
                                "Warehouse",
                                "Shop or Commercial",
                                "Office",
                                "Retail",
                                "Hotel",
                                "House",
                                "Single Family House",
                                "Townhouse",
                                "Villa",
                                "Land",
                                "Land Type"
                            ]
                        }
                    },
                    "sort_by": {
                        "title": "Choose How Lamudi Orders Matching Listings",
                        "enum": [
                            "popularity",
                            "newest",
                            "price-low",
                            "price-high"
                        ],
                        "type": "string",
                        "description": "Choose how Lamudi should order matching listings before collection. Use newest for monitoring recent inventory, or price ordering when reviewing market ranges."
                    },
                    "min_price": {
                        "title": "Set a Minimum Asking Price or Rent",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the lowest listing price to include, in IDR. Use with a maximum price when you need a clean budget band for monitoring, dashboards, CRM imports, or market analysis."
                    },
                    "max_price": {
                        "title": "Set a Maximum Asking Price or Rent",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the highest listing price to include, in IDR. Leave empty if you only need a lower bound or want Lamudi to return all matching prices above the minimum."
                    },
                    "bed_count": {
                        "title": "Select Bedroom Counts to Include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more bedroom counts to include. Leave empty when bedroom count should not narrow the property search, such as broad commercial or land monitoring.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5+"
                            ]
                        }
                    },
                    "bathroom_count": {
                        "title": "Select Bathroom Counts to Include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more bathroom counts to include. This is most useful for residential searches where room configuration is part of the downstream comparison.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5+"
                            ]
                        }
                    },
                    "subsidized_housing": {
                        "title": "Choose How to Handle Subsidized Housing",
                        "enum": [
                            "included",
                            "excluded",
                            "yes"
                        ],
                        "type": "string",
                        "description": "Choose whether subsidized housing listings should be included, excluded, or collected exclusively. Leave empty when subsidized status should not narrow the search."
                    },
                    "foreclosed_property": {
                        "title": "Choose How to Handle Foreclosed Properties",
                        "enum": [
                            "included",
                            "excluded",
                            "yes"
                        ],
                        "type": "string",
                        "description": "Choose whether foreclosed Lamudi listings should be included with normal listings, excluded from the search, or collected exclusively. Use this when foreclosure status matters for sourcing, risk review, or investment-screening workflows."
                    },
                    "min_floor_area": {
                        "title": "Set a Minimum Floor Area",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the smallest floor area to include, in square meters. Use area filters for more consistent comparison sets in ETL, reporting, or property-review workflows."
                    },
                    "max_floor_area": {
                        "title": "Set a Maximum Floor Area",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the largest floor area to include, in square meters. Pair this with minimum floor area when you need a precise size band."
                    },
                    "min_land_area": {
                        "title": "Set a Minimum Land or Plot Area",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the smallest land or plot area to include, in square meters. This is useful for lots, warehouses, commercial properties, and land-focused monitoring."
                    },
                    "max_land_area": {
                        "title": "Set a Maximum Land or Plot Area",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the largest land or plot area to include, in square meters. Leave empty when larger lots should remain eligible."
                    },
                    "rent_price_periodicity": {
                        "title": "Select Rental Billing Periods",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more rent billing periods when a rental search should include only daily, monthly, or yearly price listings. Leave empty when rent period should not narrow the search.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "daily",
                                "monthly",
                                "yearly"
                            ],
                            "enumTitles": [
                                "Daily rent",
                                "Monthly rent",
                                "Yearly rent"
                            ]
                        }
                    },
                    "amenities": {
                        "title": "Require Specific Amenities or Property Features",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select Lamudi amenities or features that matching listings should include. Leave empty for broader discovery; add amenities when your downstream workflow needs a targeted property profile.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "security",
                                "guardhouse",
                                "cctv",
                                "concierge",
                                "security-door",
                                "alarm",
                                "fully-fenced",
                                "24-hour-security",
                                "roof-garden",
                                "swimming_pool",
                                "gym",
                                "sauna",
                                "jacuzzi",
                                "tennis-court",
                                "multiuse-room",
                                "outdoor-entertaining-area",
                                "deck",
                                "balcony",
                                "garden",
                                "grill",
                                "green-area",
                                "courtyard",
                                "garage",
                                "secure-parking",
                                "internet",
                                "wi-fi",
                                "video-cable",
                                "air-conditioning",
                                "heating",
                                "fireplace",
                                "natural-gas",
                                "intercom",
                                "water-tank",
                                "water",
                                "hot-water",
                                "electricity",
                                "tv",
                                "telephone",
                                "built-in-wardrobe",
                                "library",
                                "panoramic-view",
                                "lift",
                                "disabled-access",
                                "furnished",
                                "equipped-kitchen",
                                "integral-kitchen",
                                "ensuite",
                                "cleaning-room",
                                "cellar",
                                "storage-room",
                                "office"
                            ],
                            "enumTitles": [
                                "Security",
                                "Guardhouse",
                                "CCTV",
                                "Concierge",
                                "Security door",
                                "Alarm",
                                "Fully fenced",
                                "24 hours security",
                                "Roof garden",
                                "Swimming pool",
                                "Gym",
                                "Sauna",
                                "Jacuzzi",
                                "Tennis court",
                                "Playground",
                                "Multipurpose room",
                                "Outdoor entertaining area",
                                "Terrace",
                                "Balcony",
                                "Garden",
                                "Grill",
                                "Green area",
                                "Yard",
                                "Garage",
                                "Secure parking",
                                "Internet",
                                "WiFi",
                                "Video cable",
                                "Air conditioning",
                                "Heating",
                                "Fireplace",
                                "Natural gas",
                                "Intercom",
                                "Water tank",
                                "Water",
                                "Hot water",
                                "Electricity",
                                "TV",
                                "Telephone",
                                "Built-in wardrobe",
                                "Library",
                                "Panoramic view",
                                "Lift",
                                "Access for people with disabilities",
                                "Furnished",
                                "Equipped kitchen",
                                "Integral kitchen",
                                "Service room",
                                "Laundry room",
                                "Cellar",
                                "Storage room",
                                "Office room"
                            ]
                        }
                    },
                    "certificate": {
                        "title": "Select Indonesian Certificate Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more Indonesian property certificate types when ownership or legal-status filtering matters for the search. Leave empty when certificate type should not narrow matching listings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "shm",
                                "hgb",
                                "hak_pakai",
                                "hak_sewa",
                                "hgu",
                                "strata",
                                "ppjb"
                            ],
                            "enumTitles": [
                                "SHM",
                                "HGB",
                                "Hak Pakai",
                                "Hak Sewa",
                                "HGU",
                                "Strata",
                                "PPJB"
                            ]
                        }
                    },
                    "publication_date": {
                        "title": "Choose a Listing Freshness Window",
                        "enum": [
                            "1",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Choose a recent publication window when you want newly listed properties for monitoring, alerting, lead review, or recurring inventory refreshes. Leave empty when older matching listings should remain eligible."
                    },
                    "url": {
                        "title": "Add Direct Lamudi.co.id URLs (search pages, filtered results, categories, or listings)",
                        "type": "array",
                        "description": "Paste one supported Lamudi Indonesia URL per line, such as https://www.lamudi.co.id/sewa/jawa-tengah/ or an individual listing page. Use URLs when you need precise repeatability for saved searches, listing monitoring, dashboards, CRM enrichment, or ETL refreshes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrich_data": {
                        "title": "Collect Richer Details from Listing Pages",
                        "type": "boolean",
                        "description": "Turn this on for CRM enrichment, BI reporting, listing review, data-quality checks, and ETL workflows that benefit from richer property details. Leave it off for faster validation runs, small monitoring checks, or cases where standard search-result fields are enough.",
                        "default": true
                    },
                    "limit": {
                        "title": "Set the Maximum Number of Listings to Save",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Choose the maximum number of Lamudi property records to save for this run. Leave empty to collect as many results as the selected URL seeds or location search return within the actor run, or set a smaller number for faster validation and predictable ETL batch sizes."
                    },
                    "mcpConnectors": {
                        "title": "Select Optional MCP Connectors for Listing Handoff",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose user-authorized MCP connectors for optional post-run summary delivery, listing-summary notifications, or workflow handoff. The actor sends saved listing counts, runtime, search and location summaries, enrichment status, and dataset/report/map links when available. It does not send the full Lamudi dataset through MCP by default. Leave empty to only save listings to the Apify dataset and key-value store.",
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
