# Lamudi Scraper | Philippines Real Estate + Exact GPS Pin (`memo23/lamudi-scraper`) Actor

Scrape lamudi.com.ph — Philippines real-estate listings with the EXACT map-pin coordinates (lat/lng), street-level address, price, beds, baths, floor area, amenities, and full photo gallery. Houses, condos, land — rent or sale. Monitoring mode returns only new listings

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

## Pricing

from $1.50 / 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

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

Scrape **lamudi.com.ph** — one of the Philippines' largest property portals — and get every listing as clean, structured data: price, bedrooms, bathrooms, floor area, amenities, full photo galleries, street-level addresses, and — unlike any other Lamudi scraper — the **exact map-pin latitude/longitude** for every listing, not just a vague "Metro Manila, Makati" text label.

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

### Why use this scraper?

- 📍 **Precise coordinates on every row** — the exact map pin from the listing's own map (`14.5732687, 121.0005171`), so you can plot listings, compute distances to MRT stations/schools/offices, and run real geo analysis. Competing Lamudi scrapers only return the coarse location text.
- 🏠 **Street-level addresses** — Lamudi listings expose the actual street in their structured data (`"Diamante, San Andres Bukid, Manila"`), and this actor captures it.
- 🏘️ **Complete listing data** — price with currency and rent period, property type, bedrooms, bathrooms, floor area, amenity tags, full description, and the photo gallery in full resolution.
- 🧭 **Three ways to start** — paste any listing URL, paste direct property 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.
- 🎁 **Bonus: Dot Property support** — add `dotproperty` to the `sites` input (or paste dotproperty.com.ph URLs) and sweep both major PH portals in one run; every row carries a `source` field.

### What data does it extract?

| Field group | Fields |
|---|---|
| Identity | `listingId`, `listingUrl`, `title`, `name`, `propertyType`, `operation` (rent/sale), `source` |
| 💰 Price | `price.amount`, `price.currency`, `price.period`, plus `rentPrice` / `salePrice` (both set on listings offered for rent AND sale at once) |
| 📍 Location | **`coordinates.latitude` / `coordinates.longitude` (exact map pin)**, `region`, `city`, `locationText` (street-level), `breadcrumbs` |
| 🛏️ Specs | `bedrooms`, `bathrooms`, `usableAreaSqm` |
| 🏊 Amenities | `facilities[]` — 24-hour security, Garage, Balcony, Concierge, … |
| 📝 Content | `description`, `images[]` (full-size gallery), `ogImage` |

### Use cases

- **Property investment analysis** — map every rental in a barangay with real coordinates, compare ₱/sqm across areas, find under-priced listings near transit.
- **Relocation / OFW 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.
- **Academic / urban research** — housing price distribution, supply density, amenity coverage across Philippine metros.

### Input configuration

Either paste URLs:

```json
{
    "startUrls": [
        "https://www.lamudi.com.ph/rent/metro-manila/makati/house/",
        "https://www.lamudi.com.ph/property/41032-73-3f893ff3e404-f4bc-19e5841-8dbd-73e3"
    ],
    "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 lamudi.com.ph listing or 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`, `land`, `offices`. |
| `sites` | array | Defaults to `["lamudi"]`; add `dotproperty` to sweep both portals. |
| `monitoringMode` | boolean | Only return listings not delivered on previous runs. |
| `maxItems` | integer | Hard cap on listings collected (default 1000). |
| `proxy` | object | Proxy settings; a small residential pool is plenty. |

### Output sample

```json
{
    "type": "property",
    "source": "lamudi",
    "listingId": "41032-73-3f893ff3e404-f4bc-19e5841-8dbd-73e3",
    "listingUrl": "https://www.lamudi.com.ph/property/41032-73-3f893ff3e404-f4bc-19e5841-8dbd-73e3",
    "title": "House For Rent in Central Manila",
    "operation": "rent",
    "propertyType": "House",
    "price": { "amount": 70000, "currency": "PHP", "period": "month" },
    "coordinates": { "latitude": 14.5732687, "longitude": 121.0005171 },
    "region": "Metro Manila",
    "city": "Manila",
    "locationText": "Diamante, San Andres Bukid, Manila, Kalakhang Maynila, Pilipinas",
    "bedrooms": 3,
    "bathrooms": 4,
    "usableAreaSqm": 210,
    "facilities": ["24 hours security", "Garage", "Balcony", "Concierge"],
    "description": "House for Rent — newly renovated house …",
    "images": ["https://img.lamudi.com/…full-size…jpg"],
    "scrapedAt": "2026-07-08T03:20:00.000Z"
}
```

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 property URL.
2. **Walk pagination** on listing pages (`?page=N`) until `maxItems` is reached.
3. **Fetch each property page once** and parse Lamudi's structured-data block: geo coordinates (the precise pin), price specification, address, specs, amenities, plus the photo gallery.
4. **Push one row per listing** — no padding rows, no duplicate charges.

### FAQ

**How are the coordinates different from other Lamudi scrapers?**
Other scrapers return only the location text. This actor extracts the listing's own map-pin latitude/longitude — the same pin you see on the listing's map — precise enough to compute walking distance to an MRT station.

**Does it include the agent's name or phone?**
No. Lamudi does not expose agent identity or contact details in its public pages, and this actor does not bypass authentication or lead forms. (Tip: Dot Property rows — via the `sites` input — do include agent name, city, and listing count.)

**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, land, and commercial.

**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 tens of thousands of 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 Lamudi, 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

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, lamudi api alternative

# Actor input Schema

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

Full lamudi.com.ph URLs to crawl. Mix listing and property URLs 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. (Lamudi routes: houses, condos, apartments, land, offices→commercial; townhouses/villas exist only on Dot Property.)

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

Which portals the location builder searches. Defaults to Lamudi in this actor; add `dotproperty` to also sweep dotproperty.com.ph in the same run (every row carries a `source` field).

## `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 Lamudi can match tens of thousands of 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`):

Apify proxy settings. Lamudi has no aggressive anti-bot, so a small residential pool works fine.

## Actor input object example

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

# 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.lamudi.com.ph/rent/metro-manila/makati/house/"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/lamudi-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.lamudi.com.ph/rent/metro-manila/makati/house/"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/lamudi-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.lamudi.com.ph/rent/metro-manila/makati/house/"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/lamudi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lamudi Scraper | Philippines Real Estate + Exact GPS Pin",
        "description": "Scrape lamudi.com.ph — Philippines real-estate listings with the EXACT map-pin coordinates (lat/lng), street-level address, price, beds, baths, floor area, amenities, and full photo gallery. Houses, condos, land — rent or sale. Monitoring mode returns only new listings",
        "version": "0.0",
        "x-build-id": "FfORE6ucwp0f6UWwB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~lamudi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-lamudi-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~lamudi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-lamudi-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~lamudi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-lamudi-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": "Lamudi URLs",
                        "type": "array",
                        "description": "Full lamudi.com.ph URLs to crawl. Mix listing and property URLs 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. (Lamudi routes: houses, condos, apartments, land, offices→commercial; townhouses/villas exist only on Dot Property.)",
                        "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 portals the location builder searches. Defaults to Lamudi in this actor; add `dotproperty` to also sweep dotproperty.com.ph in the same run (every row carries a `source` field).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "lamudi",
                                "dotproperty"
                            ],
                            "enumTitles": [
                                "Lamudi (lamudi.com.ph)",
                                "Dot Property (dotproperty.com.ph)"
                            ]
                        },
                        "default": [
                            "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 Lamudi can match tens of thousands of 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",
                        "type": "object",
                        "description": "Apify proxy settings. Lamudi has no aggressive anti-bot, so a small residential pool works fine.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```