Lamudi PH Property Scraper

Slug: fatihtahta/lamudi-ph-property-scraper

Overview

Lamudi PH Property Scraper collects structured public property listing records from Lamudi Philippines, including listing identity, sale or rental mode, asking price, property attributes, location fields, media links, source context, and optional enriched detail fields when available. Lamudi Philippines is a public real estate marketplace for residential, commercial, land, rental, and sale listings across the Philippines, making it useful for monitoring visible inventory and researching market segments. The actor helps property researchers, investors, brokers, analysts, proptech teams, and operators turn public listing pages into repeatable JSON records. Users can start from a location-based query, filtered search criteria, direct Lamudi search URLs, or direct listing URLs. Results are delivered as structured dataset records suitable for review, export, ETL pipelines, BI dashboards, AI-agent workflows, and downstream processing. The actor is designed for dependable recurring public data acquisition and consistent output handling, while the exact fields and listing availability depend on what Lamudi publicly exposes at run time.

What Makes This Actor Different

• Pipeline-ready property records: Each dataset item is a grouped property_listing JSON record with stable top-level objects such as source_context, entity, listing, pricing, location, property, media, contact_details, relationships, and attributes.
• Deduplication-friendly identity: The output includes record_id, url, listing.listing_id, property.property_id, and source identifiers under source_context.external_ids when available, giving data teams several supported keys for upserts and repeated-run comparison.
• Structured search and direct URL modes: Users can build a Lamudi search from location, deal_type, property type, price, room count, area, amenities, foreclosure handling, freshness, and sort fields, or paste direct Lamudi search/listing URLs for repeatable known scopes.
• Optional richer listing details: enrich_data is available for runs that need fuller listing records, such as amenities, land area, agency/contact signals, source-specific detail fields, and enriched availability indicators when Lamudi exposes them.
• Run summary artifacts: Each run can produce RUN-SUMMARY and RUN-SUMMARY.html artifacts with saved listing counts, input summary, enrichment counts, coverage counts, representative records, map readiness, and stop reason.
• Map-ready review: Listings can include location.latitude and location.longitude, and the actor writes a stable results-map artifact for coordinate-capable runs so teams can inspect listing distribution visually.
• Agentic usability: The input schema, field reference, output example, stable identifiers, and run artifacts are designed to support AI agents, workflow automations, search indexes, vector stores, CRMs, and BI pipelines without private context.
• Field-preserving grouped contract: Meaningful schema-supported listing, property, pricing, location, media, contact, agency, and source values are grouped into documented public objects instead of being flattened into ambiguous columns.

Who Should Use This Actor

• Real estate investors and analysts: collect public asking prices, locations, property types, room counts, and visible availability signals for market research and comparable listing review.
• Brokerages, agencies, and property operations teams: monitor public listing inventory, refresh known listing URLs, and route structured records into CRM or operations workflows.
• Market research and analytics teams: build repeatable datasets for supply monitoring, price-band analysis, location coverage, category movement, and dashboard reporting.
• Proptech, data engineering, and product teams: ingest nested JSON records into warehouses, APIs, search indexes, enrichment services, or listing intelligence products.
• AI agents and workflow automations: run scoped property-data acquisition tasks, inspect run summaries, use stable identifiers, and hand records to downstream review or enrichment steps.
• Lead generation and enrichment teams: add current public listing context, source URLs, agency details, contact signals, amenities, and property attributes to internal records when available.
• Monitoring and operations teams: schedule recurring runs to compare public listing records across time and flag new, removed, repriced, or changed records in downstream systems.

Common Use Cases

• Market intelligence: monitor public property supply, asking prices, location distribution, property types, amenities, availability labels, and category movement.
• Comparable listing research: collect public listing attributes for a specific city, neighborhood, property type, room count, floor area, land area, or price segment.
• Competitive monitoring: track visible listing activity across agencies, locations, property categories, and recurring saved searches.
• Catalog and listing database building: populate internal property or listing tables with structured public records and stable source URLs.
• Data enrichment: append current Lamudi listing details to CRM, BI, underwriting, portfolio, lead-review, or analytics datasets.
• Recurring reporting: schedule periodic runs for market snapshots, inventory reports, alerts, dashboards, or analyst review queues.
• Agentic research workflows: let an internal agent collect a scoped dataset, read the run summary, summarize changes, and route records to the next workflow step.
• Map-based review: use coordinate-capable records and the results-map artifact to inspect where collected listings are distributed.

Real-World Questions This Data Can Answer

• Which public Lamudi listings match a specific location, listing mode, property type, price band, room count, area range, amenity set, or freshness filter?
• Which listings are visible for sale versus rent in a target market segment?
• Which properties have enough structured attributes to support enrichment, review, monitoring, or BI workflows?
• Which records have coordinates and can be reviewed on a map?
• Which listings appear new, removed, repriced, or changed when compared with a previous internal dataset?
• Which cities, regions, property types, room counts, or price ranges are most visible in the collected segment?
• Which runs need follow-up because they returned fewer records, fewer coordinates, fewer enriched details, or unexpected optional-field coverage?

Quick Start

1. Choose a location-based search, direct Lamudi search URL, or direct listing URL.
2. Set a small limit, such as 10 or 25, for the first validation run.
3. Choose deal_type and any filters that define the target property segment.
4. Run the actor in Apify Console.
5. Inspect the first dataset records and the run summary artifacts.
6. Increase the limit, add scheduling, export the dataset, or connect downstream workflows after the output shape is verified.

Input Parameters

The actor supports location/query-based collection, direct Lamudi URL collection, optional detail enrichment, result limits, and optional MCP summary delivery.

Parameter	Type	Description	Default
location	string	City, province, neighborhood, or market supported by Lamudi Philippines, such as Metro Manila, Quezon City, Cebu, or Pampanga. Use one focused market per run for cleaner comparison.	-
deal_type	string	Listing mode for structured searches. Allowed values: buy, rent.	buy
property_type	array of strings	One or more Lamudi property groups or types. Allowed values: gt-apartment, room, gt-commercial, building, offices, retail, service-office, warehouse, gt-condo, condotel, loft, penthouse, studio, gt-house, beach-house, single-family-house, townhouse, villas, gt-land, agricutural-lot, beach-lot, commercial-lot, residential-lot.	-
enrich_data	boolean	Collect richer listing details when available, such as amenities, agency/contact signals, land area, and detail-page context. Turn off for faster validation when standard fields are enough.	true
sort_by	string	Sort order for Lamudi search results. Allowed values: popularity, newest, price-low, price-high.	popularity
min_price	integer	Minimum asking price or rent in PHP. Use with max_price for a budget band.	-
max_price	integer	Maximum asking price or rent in PHP.	-
bed_count	array of strings	Bedroom counts to include. Allowed values: 1, 2, 3, 4, 5 where 5 represents 5+.	-
bathroom_count	array of strings	Bathroom counts to include. Allowed values: 1, 2, 3, 4, 5 where 5 represents 5+.	-
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. Useful for land, lots, warehouses, and larger commercial properties.	-
max_land_area	integer	Maximum land or plot area in square meters.	-
foreclosed_property	string	Foreclosure handling. Allowed values: included, excluded, yes where yes means only foreclosed properties.	included
amenities	array of strings	Amenities or property features that matching listings should include. Supported values include security, guardhouse, CCTV, concierge, alarm, 24-hour security, roof garden, swimming pool, gym, sauna, jacuzzi, tennis court, playground, multipurpose room, terrace, balcony, garden, garage, internet, WiFi, air conditioning, heating, fireplace, water, electricity, built-in wardrobe, lift, furnished, equipped kitchen, storage room, office, and other schema-listed options.	-
publication_date	string	Freshness window. Allowed values: 1 for last 24 hours, 7 for last 7 days, 30 for last 30 days.	-
url	array of strings	Direct Lamudi search, category, filtered results, listing, or supported source URLs. Use this when the target scope is already defined on Lamudi or when refreshing known property pages.	-
limit	integer	Maximum number of property listing records to save. Start small for validation, then increase for monitoring or export runs.	-
mcpConnectors	array	Optional user-authorized Apify MCP connectors for post-run delivery of a concise listing summary with dataset, report, and map links when available.	[]

Choosing Inputs

Use structured query fields when you want the actor to define a focused Lamudi search from location and filters. Start with location and deal_type, then add property type, price, bedrooms, bathrooms, area, amenities, foreclosure handling, freshness, or sort options only when those filters are part of your research question.

Use url when you already have Lamudi search pages, results pages, listing pages, or supported source URLs that represent the exact scope you want to refresh. This is useful for recurring monitoring and targeted property checks because the same saved URLs can be reused.

Narrower filters produce more targeted datasets and cleaner comparisons. Broader filters improve discovery but may require a higher limit and more careful downstream segmentation. For cleaner analysis, split broad work into separate runs by location, property type, listing mode, price band, or freshness window.

Use a small limit for the first run, then increase it after confirming the output fields, record count, and map/run-summary artifacts match your workflow.

Input Recipes

• Validation run: choose a single location such as Metro Manila, keep deal_type at buy, enable enrich_data, and set a small limit to inspect the grouped output shape.
• Targeted residential search: combine location, deal_type, property_type, min_price, max_price, bed_count, and bathroom_count to collect comparable residential listings.
• Commercial or land review: choose gt-commercial or gt-land in property_type, then use land or floor-area fields to keep the segment aligned with the operational question.
• Fresh inventory monitoring: use publication_date with sort_by set to newest, then repeat the same input on a schedule to compare new or changed public listings.
• Direct search refresh: paste one or more saved Lamudi result pages into url and set a limit that matches the expected review workload.
• Known listing enrichment: paste known property URLs into url, keep enrich_data enabled, and route the resulting grouped rows into a CRM, warehouse, or review queue.

Example Inputs

Example 1: Location-driven validation run

{
  "location": "Metro Manila",
  "deal_type": "buy",
  "property_type": ["gt-condo"],
  "enrich_data": true,
  "limit": 25
}

Example 2: Filtered rental monitoring run

{
  "location": "Quezon City",
  "deal_type": "rent",
  "sort_by": "newest",
  "min_price": 15000,
  "max_price": 60000,
  "bed_count": ["1", "2"],
  "publication_date": "7",
  "limit": 100
}

Example 3: Direct Lamudi URL run with summary handoff

{
  "url": [
    "https://www.lamudi.com.ph/buy/metro-manila/",
    "https://www.lamudi.com.ph/sample-property-listing-001.html"
  ],
  "enrich_data": true,
  "limit": 50,
  "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-level reports, maps, and summaries are saved as key-value-store artifacts, not as dataset rows.

Record envelope and stable identifiers

Each property row includes required fields record_type, record_id, url, source_context, and entity. The recommended idempotency key is record_id; if your system needs a public URL key, use url or source_context.canonical_url when present. For listing-scoped systems, listing.listing_id and property.property_id repeat the listing identifier inside domain-specific groups.

Use record_id for upserts, deduplication, and repeated-run comparison. Stable identifiers make records easier to merge, deduplicate, sync, and compare across recurring runs. source_context preserves source domain, source URL, seed type and value, loaded URL, page position, enrichment status, external IDs, search context, and timestamp-style provenance fields when available.

Examples

Example: property listing record

{
  "record_type": "property_listing",
  "record_id": "sample-lamudi-listing-001",
  "url": "https://www.lamudi.com.ph/sample-property-listing-001.html",
  "source_context": {
    "source_id": "lamudi_ph_property_scraper",
    "source_domain": "lamudi.com.ph",
    "source_url": "https://www.lamudi.com.ph/sample-property-listing-001.html",
    "seed_type": "location",
    "seed_value": "Metro Manila",
    "loaded_url": "https://www.lamudi.com.ph/buy/metro-manila/",
    "canonical_url": "https://www.lamudi.com.ph/sample-property-listing-001.html",
    "seed_url": "https://www.lamudi.com.ph/buy/metro-manila/",
    "page_number": 1,
    "position": 3,
    "scraped_at": "2026-07-09T10:00:00+00:00",
    "language": "en-PH",
    "country": "PH",
    "fingerprint": "sample-fingerprint-001",
    "enrichment_status": "enriched",
    "external_ids": {
      "listing_id": "sample-lamudi-listing-001",
      "reference_id": "SAMPLE-REF-001",
      "detail_page_id": "sample-proppit-001",
      "proppit_id": "sample-proppit-001"
    },
    "search": {
      "url": "https://www.lamudi.com.ph/buy/metro-manila/",
      "title": "Property For Sale in Metro Manila",
      "location": "Metro Manila",
      "deal_type": "buy"
    }
  },
  "entity": {
    "title": "Sample 2-Bedroom Condo for Sale in Metro Manila",
    "description": "Sample public listing description for a condominium unit near business districts and transit routes.",
    "category": "property"
  },
  "listing": {
    "listing_id": "sample-lamudi-listing-001",
    "listing_type": "property_listing",
    "deal_type": "sale",
    "transaction_type": "For Sale",
    "availability": "InStock"
  },
  "pricing": {
    "price": 6800000,
    "price_text": "PHP 6800000",
    "currency": "PHP",
    "availability": "InStock"
  },
  "location": {
    "address": "Sample Avenue, Metro Manila, Philippines",
    "city": "Makati",
    "region": "Metro Manila",
    "country": "PH",
    "latitude": 14.5547,
    "longitude": 121.0244,
    "coordinates": {
      "latitude": 14.5547,
      "longitude": 121.0244
    },
    "map_address": "Sample Avenue, Makati, Metro Manila"
  },
  "property": {
    "property_id": "sample-lamudi-listing-001",
    "property_type": "condo",
    "bedrooms": 2,
    "bathrooms": 1,
    "floor_area": 54,
    "land_area": 0,
    "area_unit": "sqm",
    "amenities": ["Swimming pool", "Gym", "24 hours security"],
    "features": ["Balcony", "Lift"]
  },
  "media": {
    "main_image_url": "https://www.lamudi.com.ph/sample-image-001.jpg",
    "image_urls": [
      "https://www.lamudi.com.ph/sample-image-001.jpg",
      "https://www.lamudi.com.ph/sample-image-002.jpg"
    ]
  },
  "contact_details": {
    "phones": ["+63 900 000 0000"],
    "websites": ["https://www.lamudi.com.ph/sample-agency-profile"],
    "contacts": [
      {
        "name": "Sample Property Team",
        "role": "Agency contact"
      }
    ]
  },
  "relationships": {
    "agency": {
      "name": "Sample Realty Group",
      "reference_id": "sample-agency-001"
    }
  },
  "attributes": {
    "source_specific": {
      "schema_org": {
        "listing_type": "RealEstateListing",
        "offer_type": "Offer",
        "address_type": "PostalAddress",
        "geo_type": "GeoCoordinates",
        "floor_size_type": "QuantitativeValue"
      },
      "measurement_sources": {
        "floor_area": {
          "schema_org_unit_code": "MTK"
        }
      },
      "listing_type_label": "For Sale",
      "detail_page": {
        "embedded_listing": {
          "id": "sample-proppit-001",
          "operation_type": "sale",
          "price": 6800000,
          "currency": "PHP"
        }
      }
    }
  }
}

Run Summary, Map, And Artifacts

The actor exposes stable run artifacts through Apify key-value-store links:

Artifact	Type	What it is useful for
RUN-SUMMARY	JSON	Machine-readable run receipt with generated time, input summary, saved record counts, record families, search modes, enrichment counts, field coverage, representative records, artifact keys, and map statistics.
RUN-SUMMARY.html	HTML	Human-readable run report for quick operator review before export or downstream ingestion.
results-map	HTML	Interactive listing map generated from records with usable location.latitude and location.longitude.
RUN-SUMMARY-ERROR	JSON	Public-safe artifact summary if post-save run artifacts cannot be created.

These artifacts help property teams and data teams verify completion, compare recurring runs, inspect enrichment and coordinate coverage, decide whether a retry or segmented run is needed, and attach a concise run receipt to tickets, reports, alerts, or AI-agent workflows. The artifacts are not dataset rows and should not replace the listing dataset as the primary output.

Field Reference

Record envelope

• record_type (string, required): normalized record family. Current listing rows use property_listing.
• record_id (string, required): stable record identifier recommended for deduplication and upserts.
• url (string, required): primary public Lamudi listing URL.

source_context

• source_context.source_id (string, optional): source identifier for the actor's Lamudi listing source.
• source_context.source_domain (string, optional): source domain, typically lamudi.com.ph.
• source_context.source_url (string, optional): primary source URL for the normalized listing.
• source_context.seed_type (string, optional): discovery or input mode such as location, search_url, or detail_url.
• source_context.seed_value (string, optional): concrete seed value used for the run, such as a resolved location or input URL.
• source_context.loaded_url (string, optional): search or detail page URL loaded while collecting the record.
• source_context.canonical_url (string, optional): canonical listing URL when available.
• source_context.seed_url (string, optional): search or source URL that led to the listing.
• source_context.page_number (integer, optional): result page number when available.
• source_context.position (integer, optional): listing position on the source page or direct detail result.
• source_context.scraped_at (string, optional): timestamp for when the record was normalized.
• source_context.language (string, optional): language or locale signal.
• source_context.country (string, optional): country code or country label.
• source_context.fingerprint (string, optional): additional fingerprint for audit and deduplication support.
• source_context.enrichment_status (string, optional): enrichment state such as standard, enriched, or finalized after detail recovery was exhausted.
• source_context.external_ids (object, optional): source identifiers such as listing_id, reference_id, detail_page_id, or proppit_id when available.
• source_context.search (object, optional): search context, resolved location, listing mode, URL, or breadcrumbs when available.

entity

• entity.title (string, optional): listing title.
• entity.description (string, optional): public listing description when available.
• entity.category (string, optional): broad entity category, typically property.

listing

• listing.listing_id (string, optional): listing identifier repeated inside the listing group.
• listing.listing_type (string, optional): normalized listing type.
• listing.deal_type (string, optional): normalized sale or rent mode.
• listing.transaction_type (string, optional): source-facing transaction label when available.
• listing.availability (string, optional): public availability signal when exposed by the source.

pricing

• pricing.price (number, optional): numeric asking price or rent as displayed by Lamudi.
• pricing.price_text (string, optional): human-readable displayed price.
• pricing.currency (string, optional): currency code, usually PHP.
• pricing.billing_period (string, optional): normalized rent billing period when available.
• pricing.billing_period_raw (string, optional): original billing-period value when it differs from the normalized value.
• pricing.availability (string, optional): source availability label associated with the offer.
• pricing.offer_url (string, optional): offer or listing URL associated with the displayed price when it is meaningfully different from the primary listing URL.

location

• location.address (string, optional): public address or location string.
• location.city (string, optional): city or municipality.
• location.region (string, optional): province or region.
• location.country (string, optional): country code or label.
• location.latitude (number, optional): latitude for coordinate-capable records.
• location.longitude (number, optional): longitude for coordinate-capable records.
• location.coordinates (object, optional): latitude and longitude repeated as an object for map and GIS-friendly consumers.
• location.map_address (string, optional): map address when it differs from the structured address.

property

• property.property_id (string, optional): property or listing identifier repeated in the property group.
• property.property_type (string, optional): property category or type.
• property.bedrooms (number, optional): bedroom count when available.
• property.bathrooms (number, optional): bathroom count when available.
• property.floor_area (number, optional): numeric floor area in square meters when available.
• property.land_area (number, optional): numeric land or plot area in square meters when available.
• property.area_unit (string, optional): area unit, commonly sqm.
• property.amenities (array of strings, optional): amenity labels exposed by the listing.
• property.features (array of strings, optional): additional property feature labels.

media

• media.main_image_url (string, optional): primary listing image URL.
• media.image_urls (array of strings, optional): listing image URLs in source-provided order when available.

contact_details

• contact_details.phones (array of strings, optional): phone numbers exposed by the detail page.
• contact_details.visible_phone_prefix (string, optional): partial phone prefix shown by Lamudi when a full number is not exposed.
• contact_details.websites (array of strings, optional): agency or contact profile URLs when available.
• contact_details.contacts (array of objects, optional): enriched agency or contact entries.

relationships

• relationships.agency (object, optional): agency information, such as name, profile/logo links, verification label, or reference ID when available.

attributes

• attributes (object, optional): additional source-specific details that do not fit a stronger public group, such as schema-style provenance, area text, listing labels, or detail-page summary values.

Data Model Notes

• Identity fields: use record_id as the primary idempotency key. Use url, source_context.canonical_url, listing.listing_id, or property.property_id as secondary matching fields when your downstream system requires listing-scoped identifiers.
• Source and provenance fields: source_context helps trace a record back to the public source, original search context, position, enrichment status, and external IDs when available.
• Property and listing attributes: entity, listing, property, pricing, location, and media carry the main user-facing listing value.
• Pricing and status fields: prices, availability labels, billing periods, and transaction labels are point-in-time public signals and should be verified before operational decisions.
• Nested objects: grouped objects keep related fields together for JSON-first systems, ETL pipelines, BI staging, and AI-agent review.
• Optional fields: fields such as contact details, agency relationships, coordinates, land area, amenities, and detailed media depend on what each public listing exposes.
• Repeated runs: compare records across runs by stable identifiers plus run metadata from Apify, and store the input configuration used for each recurring segment.

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 in downstream code, dashboards, and AI-agent prompts.
• Deduplication: use record_id as the recommended stable key, with url, source_context.canonical_url, listing.listing_id, and property.property_id as useful supporting identifiers.
• Freshness: results reflect the publicly available listing data at run time.
• Repeated runs: use the recommended idempotency key 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 and map artifacts to audit listing counts, enrichment status, coordinate coverage, stop reason, map readiness, and export readiness without treating them as replacement dataset records.

Tips For Best Results

• Start with a small limit to validate the output shape before scaling up.
• Use one city, neighborhood, property type, listing mode, or price band per run when you need clean comparison sets.
• 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 you need richer property, contact, agency, amenity, or land-area fields.
• Schedule recurring runs for monitoring workflows instead of relying on manual one-off exports.
• Use record_id for deduplication when storing results over time.
• Review RUN-SUMMARY, RUN-SUMMARY.html, and results-map 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 the available input fields for the target location, filters, direct search URLs, or listing URLs.
3. Set the maximum number of outputs with limit if you want a bounded run.
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 AI agent, data pipeline, or operations workflow needs a bounded Lamudi listing dataset, a clear field contract, and a run receipt that summarizes counts, enrichment, coordinate coverage, and artifact readiness.

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, enrichment state, coordinate coverage, stop reason, and export readiness.
6. Upsert records into the downstream system using record_id.
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 or 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 or alongside records 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

You can schedule runs to keep public Lamudi listing datasets refreshed for recurring research, reporting, monitoring, or enrichment workflows.

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

Integration Options

• CRM enrichment: sync public listing, location, price, agency, contact, and property attributes into account, lead, or portfolio records.
• BI dashboards: monitor asking prices, availability labels, property mix, geographic coverage, and coordinate availability over time.
• Warehouses and ETL pipelines: load grouped JSON records into analytics tables while preserving nested property, pricing, location, and source-context groups.
• Webhooks: trigger validation, deduplication, notifications, enrichment, or ingestion workflows after each completed run.
• Google Sheets or Airtable: review smaller scoped datasets, compare listing segments, and share lightweight research outputs with stakeholders.
• MCP connectors: authorize a connector in Apify, select it in mcpConnectors, and use the delivered listing summary, dataset link, report link, or map link in the destination tool.
• Search and vector indexes: index listing titles, descriptions, source URLs, locations, and attributes for discovery, semantic search, retrieval workflows, or agent context.

Export Formats And Downstream Use

• JSON: for APIs, applications, AI agents, and data pipelines that need nested objects and full field fidelity.
• CSV or Excel: for spreadsheet workflows, stakeholder review, lightweight analysis, and manual quality checks.
• API access: for automated ingestion into internal systems and recurring data products.
• BI and warehouses: for reporting, dashboards, historical analysis, monitoring, and segment comparison.
• Search or vector indexes: for discovery, semantic search, retrieval workflows, property knowledge bases, or AI-agent context.

Downstream Pipeline Guide

• Idempotency: use record_id for upserts; keep url, listing.listing_id, and property.property_id as secondary matching keys.
• Null handling: treat optional fields as nullable, especially contact details, agency relationships, coordinates, amenities, land area, and media arrays.
• 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, location, property type, listing mode, price band, and workflow name outside or alongside records for easier analysis.
• Change detection: compare repeated runs by record_id and selected business fields such as pricing.price, pricing.price_text, listing.availability, entity.title, property.property_type, bedrooms, bathrooms, and area fields.
• Quality checks: monitor record count, duplicate rate, required identifiers, price availability, coordinate availability, enrichment status, and important optional field fill rates.
• Human review: route records with missing critical fields, unusual prices, changed availability, high-value segments, or unexpected location values into a review queue when needed.
• Retention: decide how long to keep raw exports versus normalized warehouse tables based on the monitoring, research, or compliance needs of your workflow.

Performance And Coverage Expectations

Recent validation artifacts available for this actor are small test-style runs, not broad live-market benchmarks. Use the measured values below as evidence that the output and artifact surfaces were exercised, not as a promise about production speed.

Run type	Example scope	Listings	Duration	Coverage notes
Validation artifact	Sample location-driven run with a limit of 2	2	1 second	2 coordinate-capable records, 2 map markers, run stopped after the sample source was exhausted

Planning estimates for real Lamudi runs:

Run size	Estimated duration
Small runs under 1,000 outputs	About 3-5 minutes
Medium runs from 1,000 to 5,000 outputs	About 5-15 minutes
Large runs over 5,000 outputs	About 15-30 minutes

Execution time varies based on filters, result volume, target availability, target 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 claim complete market coverage, official listing completeness, or guaranteed listing availability.

Limitations

• Availability depends on what Lamudi Philippines publicly exposes at run time.
• Some optional fields may be missing on sparse listings or listings without detail-rich public information.
• Very broad searches may take longer or require a higher limit.
• Target-side changes can affect field availability, labels, or visible listing structure.
• Regional, account, visibility, listing status, or availability differences may change visible results.
• Listing prices, availability, status, descriptions, and contact signals are point-in-time public signals and should be verified before operational decisions.
• The actor provides structured public real estate listing data, not legal, financial, investment, valuation, appraisal, brokerage, or MLS advice.

Troubleshooting

• No results returned: check location spelling, filters, property category, direct URLs, and whether Lamudi currently has matching public records.
• Fewer results than expected: broaden filters, raise limit, split the search differently, or verify that Lamudi contains enough matching public records.
• Some fields are empty: optional fields depend on what each listing publicly provides.
• Duplicate-looking records: compare record_id, url, and listing identifiers to decide whether records represent variants, updated pages, or repeated source visibility.
• Run takes longer than expected: reduce scope, lower limit for validation, disable enrichment when standard fields are enough, or split broad collection into smaller segments.
• Output changed: compare the current output with the Field Reference and provide a small sample if support is needed.
• 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 Philippines property listing records, including listing identity, title, description, source URL, sale/rent mode, price, currency, location, property attributes, media, source context, and optional enriched detail fields.

Can I filter by location, property type, date, price, status, or other criteria?

Yes. The schema supports location, deal_type, property_type, sort_by, price range, bedroom counts, bathroom counts, floor area, land area, foreclosure handling, amenities, and publication_date.

Can I use direct Lamudi URLs?

Yes. Use url for known Lamudi search pages, results pages, direct listing pages, or supported source URLs.

Why did I receive fewer results than my limit?

The limit is a maximum, not a guarantee. A run may return fewer records if Lamudi exposes fewer matching public listings for the selected scope or if filters narrow the search strongly.

Where can I find the run summary and interactive map?

Open the actor run output links for RUN-SUMMARY, RUN-SUMMARY.html, and results-map when those artifacts are available. They are key-value-store artifacts, not dataset rows.

How should I choose a limit for my first run?

Start with a small limit such as 10, 25, or 50. Confirm the output shape and fields, then increase the limit for recurring monitoring, exports, or broad research.

Can I schedule recurring runs?

Yes. Use Apify schedules to run the same input daily, weekly, or on a custom cron schedule.

How do I avoid duplicates across runs?

Use record_id as the primary idempotency key. Keep url, source_context.canonical_url, listing.listing_id, and property.property_id as supporting keys where useful.

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

Yes. The grouped JSON records, field reference, stable identifiers, run summary, and map artifact are designed to support AI-agent workflows, automated review, ETL, BI, search indexing, and enrichment pipelines.

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

Yes. Apify datasets can be exported in JSON, CSV, Excel, and other supported formats. JSON preserves the nested record structure best.

Does this actor collect private data or provide official MLS or appraisal data?

No. It collects publicly available listing information from Lamudi Philippines. It does not provide MLS access, appraisal-grade valuation, ownership verification, legal advice, investment advice, or guaranteed availability.

Compliance & Ethics

Responsible Data Collection

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

• Real estate research and market analysis
• Public listing monitoring and operational reporting
• CRM, BI, ETL, and AI-agent workflow enrichment

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 run ID, expected versus actual behavior, a small output sample if relevant, and the downstream destination or export format if the issue is pipeline-related.