# Lamudi Property Listings Extractor (`kawsar/lamudi-property-listings-extractor`) Actor

Lamudi property scraper that extracts listings from any search URL, so you get prices, bedrooms, floor area, location, and images as clean, ready-to-export data.

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

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Property Listings Extractor

Scrape property listings from Lamudi at scale. Paste any Lamudi search or category URL and pull every listing on the results pages into clean, structured data: price, bedrooms, bathrooms, floor area, full address, map coordinates, and the cover image. The extractor works for both buy and rent listings and for every property type Lamudi lists, including houses, condominiums, apartments, land, and commercial space.

No copying and pasting, no browser extensions, no manual paging. Give it a URL and get a dataset back.

### What this actor does

Lamudi shows properties across search and category pages, 30 per page, spread over dozens of pages. Collecting that by hand is slow and error prone. This actor takes one or more Lamudi result URLs, reads every listing on each page, follows the pagination for you, and returns one clean record per property.

You get a structured dataset you can export to JSON, CSV, or Excel, or pull straight into your own stack through the Apify API. It fits price monitoring, lead generation, market research, competitor tracking, and any workflow that needs fresh property data on a schedule.

### Key features

- **Any Lamudi URL** works: search results, category pages, city or region filters, and point-of-interest searches.
- **Buy and rent** listings are both supported, including monthly rental pricing with a price unit.
- **Every property type**: houses, condominiums, apartments, townhouses, land, and commercial listings.
- **Automatic pagination** across all result pages, so you are not limited to the first page.
- **Multiple URLs per run** to combine several cities, price bands, or property types in a single job.
- **Full location data**: region, locality, street address, country, latitude, and longitude for mapping.
- **Automatic deduplication** across pages and URLs, so each property appears once.
- **Clean output**: fields that a listing does not have are left out instead of returned as empty values.
- **Configurable limit** with `maxItems`, so runs stay fast and cost stays predictable.
- **Works on any Lamudi country domain** by pasting a URL from that site.

### Use cases

- **Price monitoring**: track asking prices for a city or neighborhood over time.
- **Lead generation**: build lists of new listings that match a location and price range.
- **Market research**: compare average price per square meter across regions.
- **Real estate dashboards**: feed a live map or analytics view with coordinates and prices.
- **CRM enrichment**: append fresh listing details to your existing records.
- **Investment analysis**: spot underpriced properties and rental yield opportunities.

### Input

Configure the run with a list of URLs and an optional limit.

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `searchUrls` | array of strings | Yes | (none) | One or more Lamudi search or category page URLs. |
| `maxItems` | integer | No | 100 | Maximum number of listings to collect across all URLs. |
| `requestTimeoutSecs` | integer | No | 45 | Per-request timeout in seconds. |

#### Example input

```json
{
    "searchUrls": [
        "https://www.lamudi.com.ph/buy/house/",
        "https://www.lamudi.com.ph/rent/condominium/"
    ],
    "maxItems": 200,
    "requestTimeoutSecs": 45
}
```

### How to get a Lamudi search URL

1. Open Lamudi and search for a location.
2. Apply the filters you want: purpose (buy or rent), property type, price range, bedrooms, or a point of interest.
3. Copy the full URL from your browser address bar.
4. Paste it into the `searchUrls` field. Add more than one URL to run them together.

Example URLs:

- `https://www.lamudi.com.ph/buy/house/` for houses for sale
- `https://www.lamudi.com.ph/rent/condominium/` for condos for rent
- `https://www.lamudi.com.ph/buy/house/?sorting=popularity&poi=189607` for houses near a point of interest

### Output

Each property becomes one record in the dataset. A field is included only when the listing provides it, so records stay clean. For example, `priceUnit` appears on rentals (such as `MONTH`) and is omitted on one-time sale listings.

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Lamudi listing identifier. |
| `propertyUrl` | string | Direct link to the property detail page. |
| `listingTitle` | string | Listing headline. |
| `propertyType` | string | Property type from the URL, such as house or condominium. |
| `purpose` | string | Either buy or rent. |
| `price` | number | Listed price as a number. |
| `currency` | string | Currency code, such as PHP. |
| `priceUnit` | string | Rental period when present, such as MONTH. |
| `bedrooms` | number | Number of bedrooms. |
| `bathrooms` | number | Number of bathrooms. |
| `areaSize` | number | Floor area value. |
| `areaUnit` | string | Floor area unit, such as sqm. |
| `region` | string | Administrative region. |
| `locality` | string | City or locality. |
| `streetAddress` | string | Street level address when available. |
| `country` | string | Country code. |
| `latitude` | number | Map latitude. |
| `longitude` | number | Map longitude. |
| `coverImage` | string | URL of the main listing image. |
| `listingDescription` | string | Full listing description text. |
| `availability` | string | Availability status, such as InStock. |
| `sourceUrl` | string | The search URL this listing came from. |
| `scrapedAt` | string | UTC timestamp of when the record was collected. |

#### Example output (sale listing)

```json
{
    "listingId": "41032-73-8fe11eba4f3b-755f-19dce96-9821-7662",
    "propertyUrl": "https://www.lamudi.com.ph/property/41032-73-8fe11eba4f3b-755f-19dce96-9821-7662",
    "listingTitle": "House For Sale in Bagong Pag-Asa",
    "propertyType": "house",
    "purpose": "buy",
    "price": 40000000,
    "currency": "PHP",
    "bedrooms": 2,
    "bathrooms": 2,
    "areaSize": 102,
    "areaUnit": "sqm",
    "region": "Metro Manila",
    "locality": "Quezon City",
    "streetAddress": "Vertis North, North Avenue, Bago Bantay, Quezon City",
    "country": "PH",
    "latitude": 14.6521991,
    "longitude": 121.0358201,
    "coverImage": "https://img.lamudi.com/...",
    "availability": "InStock",
    "sourceUrl": "https://www.lamudi.com.ph/buy/house/",
    "scrapedAt": "2026-08-23T09:15:00+00:00"
}
```

#### Example output (rental listing)

```json
{
    "listingId": "41032-73-53013fa735a4-e59d-19dbd5a-ade9-72b9",
    "propertyUrl": "https://www.lamudi.com.ph/property/41032-73-53013fa735a4-e59d-19dbd5a-ade9-72b9",
    "listingTitle": "Condo For Rent in Taguig",
    "propertyType": "condominium",
    "purpose": "rent",
    "price": 38000,
    "currency": "PHP",
    "priceUnit": "MONTH",
    "bedrooms": 1,
    "bathrooms": 1,
    "areaSize": 22,
    "areaUnit": "sqm",
    "region": "Metro Manila",
    "locality": "Taguig",
    "country": "PH",
    "latitude": 14.5302322,
    "longitude": 121.06140427,
    "availability": "InStock",
    "sourceUrl": "https://www.lamudi.com.ph/rent/condominium/",
    "scrapedAt": "2026-08-23T09:15:00+00:00"
}
```

### How pagination and limits work

Lamudi returns 30 listings per page. The actor reads the first page of each URL, then keeps requesting the next page until it either runs out of listings or reaches your `maxItems` limit. If you pass a URL that already contains a page number, the actor strips it and starts from the beginning so nothing is skipped.

To collect a specific city fully, raise `maxItems`. To sample quickly, set it low.

### Exporting your data

From the Apify console you can download results as JSON, CSV, Excel, HTML, or RSS. For automation, call the Apify API or use the JavaScript and Python SDKs to fetch the dataset, schedule runs, and trigger the actor from your own application.

### Tips for best results

- Filter on Lamudi first, then copy the URL. The actor returns exactly what your filtered search shows.
- Combine related searches in one run by adding several URLs to `searchUrls`.
- Use the `latitude` and `longitude` fields to plot listings on a map or run distance queries.
- Schedule regular runs to catch new listings and price changes early.

### FAQ

**Which Lamudi sites are supported?**
Any Lamudi country domain. Paste a search URL from the site you want and the actor handles it.

**Does it work for rentals?**
Yes. Rental records include the price and a `priceUnit` such as MONTH.

**Why is a field missing from some records?**
Fields are included only when the listing actually provides them. A sale listing has no rental period, so `priceUnit` is left out rather than returned as an empty value.

**Can I control how many listings I collect?**
Yes. Set `maxItems` to any number and the run stops once it reaches that count.

**In what order are listings returned?**
They follow the order shown on the Lamudi result pages you provide, across pages.

**Do I need to log in to Lamudi?**
No. The actor reads public search and category pages.

### Disclaimer

This actor collects publicly available listing data from Lamudi search pages. Use the data in line with Lamudi's terms and any applicable laws in your region. It is intended for research, analysis, and legitimate business use.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more Lamudi search or category pages to extract listings from. Paste a full Lamudi results URL for any purpose (buy or rent), property type, city, region or point-of-interest filter. Pagination is handled automatically.

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

Maximum number of property listings to collect across all search URLs.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.lamudi.com.ph/buy/house/",
    "https://www.lamudi.com.ph/rent/condominium/"
  ],
  "maxItems": 30,
  "requestTimeoutSecs": 45
}
```

# Actor output Schema

## `properties` (type: `string`):

Extracted Lamudi property listings with prices, bedrooms, floor area, location, coordinates and images.

# 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 = {
    "searchUrls": [
        "https://www.lamudi.com.ph/buy/house/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/lamudi-property-listings-extractor").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 = { "searchUrls": ["https://www.lamudi.com.ph/buy/house/"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/lamudi-property-listings-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrls": [
    "https://www.lamudi.com.ph/buy/house/"
  ]
}' |
apify call kawsar/lamudi-property-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/lamudi-property-listings-extractor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bsIOWrQJCDZJWqX6I/builds/pDQlyLZnq9pgiTiDD/openapi.json