# Dot Property + Lamudi Scraper | PH Real Estate + Exact GPS Pin (`memo23/dotproperty-scraper`) Actor

Scrape dotproperty.com.ph AND lamudi.com.ph — Philippines real-estate listings with the EXACT map-pin coordinates (lat/lng), price, beds, baths, areas, facilities, photos, agent info. Houses, condos, land, offices — rent or sale. Monitoring mode returns only new listings. JSON/CSV out.

- **URL**: https://apify.com/memo23/dotproperty-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 18 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 property listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Dot Property + Lamudi Philippines Scraper — Real Estate Listings with Precise Map-Pin Coordinates 🏠📍

Scrape **dotproperty.com.ph AND lamudi.com.ph** — the Philippines' two largest property portals, in one actor — and get every listing as clean, structured data: price, bedrooms, bathrooms, floor areas, facilities, full photo galleries, agent details, and — unlike any competing scraper — the **exact map-pin latitude/longitude** for every listing, not just a vague "Metro Manila, Makati" text label.

![How Dot Property Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-dotproperty.png)

### Why use this scraper?

- 📍 **Precise coordinates on every row** — the exact map pin the listing shows on its map view (`14.5501056, 121.0221988`), so you can plot listings, compute distances to MRT stations/schools/offices, and run real geo analysis. Competing scrapers only return the coarse location text.
- 🏢 **Two portals, one dataset** — Dot Property and Lamudi in the same run; every row carries a `source` field. Cover the whole Philippine listing market with one schedule instead of stitching two actors together.
- 🏘️ **Complete listing data** — price with currency and rent period, property type, bedrooms, bathrooms, usable + land area, floors, 40+ facility tags, full description, and the complete photo gallery in full resolution.
- 🧭 **Three ways to start** — paste any listing URL, paste direct ad URLs, or just give it locations + rent/sale + property types and let the actor build the searches.
- 🔁 **Monitoring mode** — run it on a schedule and receive **only new listings** each time. Ideal for deal-alerting, price tracking, and lead generation.
- ⚡ **Fast, HTTP-only pipeline** — no headless browsers. Server-rendered HTML parsed directly; hundreds of listings per minute at low cost.
- 🌏 **Sister-site ready** — Dot Property runs the same platform across Asia; URLs from dotproperty.co.th, dotproperty.com.vn, and other country sites are accepted too (Philippines is the primary, fully-tested target).

### What data does it extract?

| Field group | Fields |
|---|---|
| Identity | `listingId`, `listingUrl`, `title`, `name`, `propertyType`, `operation` (rent/sale) |
| 💰 Price | `price.amount`, `price.currency`, `price.period`, `price.raw`, plus `rentPrice` / `salePrice` (both set on listings offered for rent AND sale at once) |
| 📍 Location | **`coordinates.latitude` / `coordinates.longitude` (exact map pin)**, `region`, `city`, `area`, `locationText`, `breadcrumbs` |
| 🛏️ Specs | `bedrooms`, `bathrooms`, `usableAreaSqm`, `landAreaSqm`, `floors`, `specsRaw` |
| 🏊 Facilities | `facilities[]` — Swimming pool, Gym, 24-hour security, Car park, … |
| 📝 Content | `description`, `descriptionHtml`, `images[]` (full-size gallery), `ogImage` |
| 👤 Agent | `agentName`, `agentLocation`, `agentListingCount`, `agentInfoText` |

### Use cases

- **Property investment analysis** — map every rental in a barangay with real coordinates, compare ₱/sqm across areas, find under-priced listings near transit.
- **OFW / relocation search tooling** — build a filtered feed of family-sized houses near a specific office or school using true distance, not location strings.
- **Market monitoring** — schedule with monitoring mode to get only newly posted listings; feed alerts to Slack/Telegram/email via Apify integrations.
- **Lead generation** — agent names + listing counts across any city; find the most active brokers per area.
- **Academic / urban research** — housing price distribution, supply density, amenity coverage across Philippine metros.

### Input configuration

Either paste URLs:

```json
{
    "startUrls": [
        "https://www.dotproperty.com.ph/houses-for-rent/metro-manila/makati",
        "https://www.dotproperty.com.ph/ads/3-bedroom-house-for-rent-in-san-lorenzo-metro-manila-near-mrt-3-ayala_dbd72c1aae6c-5acf-5082-3e68-b5efb089"
    ],
    "maxItems": 200
}
````

Or use the search builder:

```json
{
    "locations": ["Metro Manila", "Cebu"],
    "operation": "rent",
    "propertyTypes": ["houses", "condos"],
    "maxItems": 500
}
```

| Input | Type | Description |
|---|---|---|
| `startUrls` | array | Any dotproperty.com.ph or lamudi.com.ph listing/property URLs — auto-classified. Takes priority over the search builder. |
| `locations` | array | Location names or slugs ("Metro Manila", "makati", "cebu"). |
| `operation` | string | `rent` (default) or `sale`. |
| `propertyTypes` | array | `properties` (all), `houses`, `condos`, `apartments`, `townhouses`, `villas`, `land`, `offices`. |
| `sites` | array | Portals the search builder targets: `dotproperty`, `lamudi`. Default: both. |
| `monitoringMode` | boolean | Only return listings not delivered on previous runs. |
| `resetMonitoringState` | boolean | One-shot: clear the "already seen" record. |
| `maxItems` | integer | Hard cap on listings collected (default 1000). |
| `maxConcurrency` | integer | Parallel detail-page fetches (default 10). |
| `proxy` | object | Proxy settings; a small residential pool is plenty. |

### Output sample

```json
{
    "type": "property",
    "listingId": "019eab4e-13b6-7194-adf4-d3bff8d72cec",
    "listingUrl": "https://www.dotproperty.com.ph/ads/3-bedroom-house-for-rent-in-san-lorenzo-metro-manila-near-mrt-3-ayala_dbd72c1aae6c-5acf-5082-3e68-b5efb089",
    "title": "For Lease 3 Bedroom in San Lorenzo Village, Makati City",
    "operation": "rent",
    "propertyType": "House",
    "price": { "amount": 350000, "currency": "PHP", "period": "month", "raw": "Rent: ₱ 350,000 / month" },
    "coordinates": { "latitude": 14.5501056, "longitude": 121.0221988 },
    "region": "Metro Manila",
    "city": "Makati",
    "area": "San Lorenzo",
    "locationText": "San Lorenzo, Makati, Metro Manila",
    "bedrooms": 3,
    "bathrooms": 3,
    "usableAreaSqm": 400,
    "landAreaSqm": 456.5,
    "floors": 2,
    "facilities": ["Swimming pool", "Air conditioning", "Gym", "24-hour security", "Car park", "Garden"],
    "description": "San Lorenzo Village, Makati City …",
    "images": ["https://pix.dotproperty.co.th/…full-size…jpg"],
    "agentName": "Eva Marzan",
    "agentLocation": "Makati City",
    "agentListingCount": 435,
    "scrapedAt": "2026-07-07T20:29:56.136Z"
}
```

Export as **JSON, CSV, Excel, or XML** straight from the Apify dataset, or pull via API into your own pipeline.

### How it works

1. **Classify** every start URL: listing page vs direct ad URL.
2. **Walk pagination** on listing pages via `rel="next"` until `maxItems` is reached.
3. **Fetch each ad page once** and parse the JSON-LD `Product` block, the geo meta tags (the precise pin), the breadcrumb hierarchy, the spec grid, facilities, gallery, and agent block.
4. **Push one row per listing** — no padding rows, no duplicate charges.

### FAQ

**How are the coordinates different from other Dot Property scrapers?**
Other scrapers return only the location text ("Metro Manila, Makati, San Lorenzo"). This actor extracts the listing's own map-pin latitude/longitude — the same pin you see when you open the map on the listing page — precise enough to compute walking distance to an MRT station.

**Does it include the agent's phone number?**
No. Dot Property gates phone reveal behind a login wall, and this actor does not bypass authentication. On Dot Property you get the agent's name, city, and portfolio size (listing count); Lamudi does not expose agent identity in its public pages, so agent fields are `null` on Lamudi rows.

**How do Dot Property and Lamudi rows differ?**
Both share the same schema and both carry precise coordinates. Lamudi rows often include a street-level address in `locationText`; Dot Property rows add `landAreaSqm`, `floors`, an `area` (barangay/village) field, and agent info. The `source` field tells them apart.

**Can I only get new listings on repeat runs?**
Yes — enable `monitoringMode`. The first run seeds a private per-user baseline; every later run returns only listings you haven't received before, and skipped listings are never charged.

**Does it work for sale listings as well as rentals?**
Yes — both, across houses, condos, apartments, townhouses, villas, land, and offices.

**What about other Dot Property country sites?**
URLs from sister sites (e.g. dotproperty.co.th) are accepted and use the same parser, since Dot Property runs one platform across Asia. The Philippines site is the primary, fully-tested target.

**What about listings offered for rent AND sale at the same time?**
Some Lamudi listings carry two prices. Both are returned: `rentPrice` (with monthly period) and `salePrice`, while `price` reflects the operation context the listing was found under. Single-operation listings fill only the matching field.

**Are monitoring IDs kept separate per portal?**
Yes — delivered-listing IDs are namespaced by portal (`dp_…` / `lm_…`) in your private per-user store, so Dot Property and Lamudi IDs can never collide or cause a listing to be skipped incorrectly.

**How many listings can it handle?**
Broad searches match 50,000+ listings. Use `maxItems` to cap the run; the actor streams results as it goes.

### Support & feature requests

Found an issue or need an extra field? Open an issue in the **Issues** tab of this actor in the Apify Console — we typically respond within 24 hours.

### Additional services

Need a custom scraper, a private variant of this actor, delivery to your own database, or a different property portal covered? Reach out via the Apify contact form.

### Explore more scrapers

Check out our other actors on the [memo23 Apify profile](https://apify.com/memo23) — job boards, real estate, travel, e-commerce, and lead-generation scrapers.

### ⚠️ Disclaimer

This actor is not affiliated with, endorsed by, or sponsored by Dot Property, Lifull Connect, or any of their subsidiaries. It only accesses publicly available data that any visitor can see in a browser, and it does not bypass authentication or access controls. You are solely responsible for how you use the extracted data and for complying with applicable laws, the target website's terms of service, and data-protection regulations (including the Philippine Data Privacy Act) in your jurisdiction. Use reasonable request rates. If you plan to republish or commercialize scraped data, obtain independent legal advice first.

### SEO Keywords

dot property scraper, dotproperty.com.ph scraper, lamudi scraper, lamudi.com.ph scraper, lamudi philippines data, philippines real estate scraper, philippines property data, manila property listings scraper, makati condo rental data, cebu property scraper, philippines rental listings api, property listing coordinates latitude longitude, real estate data extraction philippines, philippines housing market data, condo for sale data philippines, house for rent scraper manila, property market monitoring philippines, real estate lead generation philippines

# Actor input Schema

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

Full dotproperty.com.ph or lamudi.com.ph URLs to crawl. Mix listing and property URLs from both portals in the same array if useful. Takes priority over the location builder below.

## `locations` (type: `array`):

Location names or slugs — e.g. "Metro Manila", "makati", "Cebu". Case and spaces don't matter; they're slugified automatically.

## `operation` (type: `string`):

Whether to search rental listings or listings for sale. Used with Locations.

## `propertyTypes` (type: `array`):

Which property types to search. `properties` means all types. Used with Locations. (Townhouses and villas exist only on Dot Property; offices map to Lamudi's `commercial` category.)

## `sites` (type: `array`):

Which Philippines property portals the location builder searches. Both by default — every row carries a `source` field so you can tell them apart.

## `monitoringMode` (type: `boolean`):

When enabled, listings whose ID has already been delivered to you are silently skipped (no detail page is fetched and no charge applies for them). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new listings. Combine with Apify's scheduler for a 'listings posted since last run' feed.

## `resetMonitoringState` (type: `boolean`):

One-shot toggle: clear the saved 'listings already seen' record at the start of this run. Use this when you change search URL, want to rebuild the baseline, or recover from a missed delivery. Has no effect when monitoring mode is off.

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

Hard cap on the number of listings collected. Broad searches on Dot Property can match 50,000+ listings; use this cap to limit billing.

## `maxConcurrency` (type: `integer`):

Maximum number of listing detail pages processed in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of listing detail pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed request is given up.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.dotproperty.com.ph/houses-for-rent/metro-manila/makati",
    "https://www.lamudi.com.ph/rent/metro-manila/makati/house/"
  ],
  "operation": "rent",
  "propertyTypes": [
    "properties"
  ],
  "sites": [
    "dotproperty",
    "lamudi"
  ],
  "monitoringMode": false,
  "resetMonitoringState": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5
}
```

# 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 = {
    "startUrls": [
        "https://www.dotproperty.com.ph/houses-for-rent/metro-manila/makati",
        "https://www.lamudi.com.ph/rent/metro-manila/makati/house/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/dotproperty-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [
        "https://www.dotproperty.com.ph/houses-for-rent/metro-manila/makati",
        "https://www.lamudi.com.ph/rent/metro-manila/makati/house/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/dotproperty-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.dotproperty.com.ph/houses-for-rent/metro-manila/makati",
    "https://www.lamudi.com.ph/rent/metro-manila/makati/house/"
  ]
}' |
apify call memo23/dotproperty-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dot Property + Lamudi Scraper | PH Real Estate + Exact GPS Pin",
        "description": "Scrape dotproperty.com.ph AND lamudi.com.ph — Philippines real-estate listings with the EXACT map-pin coordinates (lat/lng), price, beds, baths, areas, facilities, photos, agent info. Houses, condos, land, offices — rent or sale. Monitoring mode returns only new listings. JSON/CSV out.",
        "version": "0.0",
        "x-build-id": "AAZpRNlEE21tl6Jvq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~dotproperty-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-dotproperty-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~dotproperty-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-dotproperty-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~dotproperty-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-dotproperty-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Dot Property / Lamudi URLs",
                        "type": "array",
                        "description": "Full dotproperty.com.ph or lamudi.com.ph URLs to crawl. Mix listing and property URLs from both portals in the same array if useful. Takes priority over the location builder below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Location names or slugs — e.g. \"Metro Manila\", \"makati\", \"Cebu\". Case and spaces don't matter; they're slugified automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "operation": {
                        "title": "Rent or sale",
                        "enum": [
                            "rent",
                            "sale"
                        ],
                        "type": "string",
                        "description": "Whether to search rental listings or listings for sale. Used with Locations.",
                        "default": "rent"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Which property types to search. `properties` means all types. Used with Locations. (Townhouses and villas exist only on Dot Property; offices map to Lamudi's `commercial` category.)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "properties",
                                "houses",
                                "condos",
                                "apartments",
                                "townhouses",
                                "villas",
                                "land",
                                "offices"
                            ],
                            "enumTitles": [
                                "All properties",
                                "Houses",
                                "Condos",
                                "Apartments",
                                "Townhouses",
                                "Villas",
                                "Land",
                                "Offices"
                            ]
                        },
                        "default": [
                            "properties"
                        ]
                    },
                    "sites": {
                        "title": "Portals",
                        "type": "array",
                        "description": "Which Philippines property portals the location builder searches. Both by default — every row carries a `source` field so you can tell them apart.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "dotproperty",
                                "lamudi"
                            ],
                            "enumTitles": [
                                "Dot Property (dotproperty.com.ph)",
                                "Lamudi (lamudi.com.ph)"
                            ]
                        },
                        "default": [
                            "dotproperty",
                            "lamudi"
                        ]
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only return listings not seen on previous runs)",
                        "type": "boolean",
                        "description": "When enabled, listings whose ID has already been delivered to you are silently skipped (no detail page is fetched and no charge applies for them). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new listings. Combine with Apify's scheduler for a 'listings posted since last run' feed.",
                        "default": false
                    },
                    "resetMonitoringState": {
                        "title": "Reset monitoring state (one-shot)",
                        "type": "boolean",
                        "description": "One-shot toggle: clear the saved 'listings already seen' record at the start of this run. Use this when you change search URL, want to rebuild the baseline, or recover from a missed delivery. Has no effect when monitoring mode is off.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum items to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of listings collected. Broad searches on Dot Property can match 50,000+ listings; use this cap to limit billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listing detail pages processed in parallel.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of listing detail pages processed in parallel.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of retries before a failed request is given up.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
