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 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

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

Example 2: Targeted house purchase search

{
  "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

{
  "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

{
  "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.