# Madlan - Israel Real Estate Listings (`swerve/madlan-scraper`) Actor

Scrape Madlan.co.il property listings in Israel. Rent & buy across 127+ cities. Returns prices, rooms, area, photos, amenities, property type, and agent contact info.

- **URL**: https://apify.com/swerve/madlan-scraper.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 86 total users, 28 monthly users, 99.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Madlan.co.il Real Estate Scraper

Scrape real estate listings (rent & buy) from [Madlan.co.il](https://www.madlan.co.il), Israel's most data-rich property platform powered by Localize.city.

### Why This Scraper?

Madlan (Localize.city) is Israel's most analytics-heavy real estate platform. Unlike Yad2, Madlan enriches every listing with neighbourhood analytics, price trends, and property condition data. This scraper gives you:

- **Rich property data** - condition, parking spots count, floorplan images, and amenity flags that other platforms lack
- **Image CDN URLs** - direct image links that work without bot protection or cookies
- **127+ Israeli cities** - Hebrew or English names, multi-city in one run
- **Advanced filters** - price, rooms, neighbourhood, amenities, and agent exclusion
- **Agent detection** - each listing tagged with `hasAgent: true/false`
- **Contact info** - phone numbers and names when available

### Use Cases

- **Real estate investors** comparing Madlan listings against transaction history to spot underpriced apartments in Tel Aviv, Herzliya, and Givatayim
- **Property analysts** studying condition data (renovated, new, needs work) and floorplans at scale for flipping or value-add strategies
- **PropTech startups** building Hebrew-language property search apps with richer structured data than Yad2 alone provides
- **Buyer-side agents** sourcing off-Yad2 inventory and exclusive Madlan listings to pitch to client pipelines
- **Bank mortgage teams** validating borrower-stated property details (rooms, sqm, condition) against Madlan's dataset
- **Market researchers** tracking private vs. agent listing ratios and inventory churn across Israeli cities

### Input

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City name (Hebrew/English), comma-separated, or `"all"` |
| `dealType` | string | `"rent"` or `"buy"` |
| `maxItems` | integer | Max listings per city (1-500, default 200) |
| `minPrice` | integer | Min price in ILS (optional) |
| `maxPrice` | integer | Max price in ILS (optional) |
| `minRooms` | number | Min rooms (optional) |
| `maxRooms` | number | Max rooms (optional) |
| `neighbourhood` | string | Filter by neighbourhood or street name in Hebrew (optional) |
| `excludeAgents` | boolean | Only return private-owner listings |
| `requireParking` | boolean | Only listings with parking |
| `requireElevator` | boolean | Only listings with elevator |
| `requireBalcony` | boolean | Only listings with balcony |
| `requireSecureRoom` | boolean | Only listings with safe room (mamad) |

#### Example Input

```json
{
  "city": "Tel Aviv, Haifa",
  "dealType": "rent",
  "maxItems": 100,
  "maxPrice": 8000,
  "minRooms": 2,
  "requireBalcony": true
}
````

### Output

Results are sorted by most recent first. Each listing includes:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique Madlan listing ID |
| `url` | string | Direct link to the listing on Madlan |
| `dealType` | string | `"rent"` or `"buy"` |
| `city` | string | City name in English |
| `cityHebrew` | string | City name in Hebrew |
| `neighbourhood` | string | Neighbourhood name in Hebrew |
| `address` | string | Full address string |
| `streetName` | string | Street name |
| `streetNumber` | string | Street/house number |
| `price` | integer | Price in ILS |
| `currency` | string | Always `"ILS"` |
| `rooms` | number | Number of rooms |
| `floor` | string | Floor number/description |
| `areaSqm` | number | Area in square meters |
| `condition` | string | Property condition (e.g. renovated, new) |
| `parking` | integer | Number of parking spots |
| `hasElevator` | boolean | Whether building has elevator |
| `hasBalcony` | boolean | Whether unit has balcony |
| `hasSecureRoom` | boolean | Whether unit has safe room (mamad) |
| `images` | array | Image URLs (CDN links, no bot protection) |
| `floorplanImages` | array | Floorplan image URLs |
| `contactName` | string | Contact person name (agent or owner) |
| `contactPhone` | string | Contact phone number |
| `contactType` | string | Contact type (agent, private, etc.) |
| `hasAgent` | boolean | `true` if agent, `false` if private owner |
| `firstSeen` | string | When the listing first appeared on Madlan (ISO date) |
| `scrapedAt` | string | When this data was scraped (ISO date) |

#### Example Output

```json
{
  "id": "gd93kf2m",
  "url": "https://www.madlan.co.il/listings/gd93kf2m",
  "dealType": "rent",
  "city": "Tel Aviv",
  "cityHebrew": "תל אביב יפו",
  "neighbourhood": "הצפון הישן",
  "address": "דיזנגוף 204, תל אביב יפו",
  "streetName": "דיזנגוף",
  "streetNumber": "204",
  "price": 6500,
  "currency": "ILS",
  "rooms": 3,
  "floor": "4",
  "areaSqm": 72,
  "condition": "משופצת",
  "parking": 1,
  "hasElevator": true,
  "hasBalcony": true,
  "hasSecureRoom": false,
  "images": [
    "https://images2.madlan.co.il/t:nonce:v=2;resize:height=800;convert:type=webp/bulletin/gd93kf2m/img1.webp",
    "https://images2.madlan.co.il/t:nonce:v=2;resize:height=800;convert:type=webp/bulletin/gd93kf2m/img2.webp"
  ],
  "floorplanImages": [
    "https://images2.madlan.co.il/t:nonce:v=2;resize:height=800;convert:type=webp/bulletin/gd93kf2m/floorplan.webp"
  ],
  "contactName": "David",
  "contactPhone": "054-1234567",
  "contactType": "private",
  "hasAgent": false,
  "firstSeen": "2026-03-20T10:30:00.000Z",
  "scrapedAt": "2026-03-26T14:22:05.123Z"
}
```

### Also Available

- [Yad2.co.il Real Estate Scraper](https://apify.com/swerve/yad2-scraper) - Israel's #1 classifieds platform, 800+ listings per city
- [Yad2.co.il Vehicle Scraper](https://apify.com/swerve/yad2-vehicles) - scrape vehicle listings from Yad2
- [Yad2.co.il Products Scraper](https://apify.com/swerve/yad2-products) - scrape second-hand product listings from Yad2

### Supported Cities (127+)

Use English or Hebrew names. Partial names work too (e.g. "Pardes Hana" matches "Pardes Hana Karkur"). Use `"all"` to scrape every city.

**Major Cities:** Tel Aviv (תל אביב), Jerusalem (ירושלים), Haifa (חיפה), Beer Sheva (באר שבע), Rishon Lezion (ראשון לציון), Petah Tikva (פתח תקווה), Ashdod (אשדוד), Netanya (נתניה), Ashkelon (אשקלון), Holon (חולון), Ramat Gan (רמת גן), Bat Yam (בת ים), Rehovot (רחובות), Modiin (מודיעין), Bnei Brak (בני ברק)

**Sharon & Center:** Raanana (רעננה), Herzliya (הרצליה), Kfar Saba (כפר סבא), Hod Hasharon (הוד השרון), Ramat Hasharon (רמת השרון), Givatayim (גבעתיים), Nes Ziona (נס ציונה), Rosh Haayin (ראש העין), Givat Shmuel (גבעת שמואל), Kiryat Ono (קרית אונו), Or Yehuda (אור יהודה), Ganei Tikva (גני תקווה), Shoham (שוהם), Yehud Monosson (יהוד מונוסון), Lod (לוד), Ramla (רמלה), Yavne (יבנה), Gedera (גדרה), Beer Yaakov (באר יעקב), Gan Yavne (גן יבנה), Hadera (חדרה), Pardes Hana Karkur (פרדס חנה כרכור), Binyamina (בנימינה), Zichron Yaakov (זכרון יעקב), Kadima Tzoran (קדימה צורן), Even Yehuda (אבן יהודה), Kfar Yona (כפר יונה), Tel Mond (תל מונד)

**North:** Nazareth (נצרת), Nof Hagalil (נוף הגליל), Tiberias (טבריה), Akko (עכו), Nahariya (נהריה), Carmiel (כרמיאל), Afula (עפולה), Kiryat Ata (קרית אתא), Kiryat Bialik (קרית ביאליק), Kiryat Motzkin (קרית מוצקין), Kiryat Yam (קרית ים), Kiryat Shmona (קרית שמונה), Migdal Haemek (מגדל העמק), Yokneam Illit (יוקנעם עילית), Nesher (נשר), Tirat Carmel (טירת הכרמל), Or Akiva (אור עקיבא), Kiryat Tivon (קרית טבעון), Shfaram (שפרעם), Maalot Tarshiha (מעלות תרשיחא), Tzfat (צפת), Beit Shean (בית שאן)

**South:** Eilat (אילת), Kiryat Gat (קרית גת), Arad (ערד), Dimona (דימונה), Sderot (שדרות), Netivot (נתיבות), Ofakim (אופקים), Rahat (רהט), Kiryat Malachi (קרית מלאכי), Yeruham (ירוחם), Mitzpe Ramon (מצפה רמון), Meitar (מיתר), Lehavim (להבים), Omer (עומר)

**Jerusalem Area:** Beit Shemesh (בית שמש), Mevaseret Zion (מבשרת ציון), Maale Adumim (מעלה אדומים), Efrat (אפרת), Givat Zeev (גבעת זאב), Modiin Illit (מודיעין עילית), Beitar Illit (ביתר עילית), Kiryat Yearim (קרית יערים), Tzur Hadassah (צור הדסה)

**Other:** Ariel (אריאל), Harish (חריש), Elad (אלעד), Karnei Shomron (קרני שומרון), Alfei Menashe (אלפי מנשה), Oranit (אורנית), Katzrin (קצרין), and 20+ more

### Keywords

Madlan scraper, Madlan API, Localize.city API, Israeli real estate data, Tel Aviv apartment listings, Jerusalem property data, Israel property scraper, Hebrew real estate API, Israeli real estate market, floorplan data Israel, madlan.co.il scraper, Israel housing market data

# Actor input Schema

## `city` (type: `string`):

City name in Hebrew or English (e.g. 'Tel Aviv', 'תל אביב', 'Haifa', 'Jerusalem'). Comma-separated for multiple cities, or 'all' for all 127+ cities. Common cities: Tel Aviv, Jerusalem, Haifa, Beer Sheva, Raanana, Herzliya, Netanya, Ashdod, Rishon Lezion, Petah Tikva, Ramat Gan, Holon, Bat Yam, Rehovot, Modiin, Ashkelon, Kfar Saba, Hadera, Bnei Brak, Eilat

## `dealType` (type: `string`):

Type of listing to scrape

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

Maximum number of listings to scrape per city. Big cities like Tel Aviv can have 1,000+ listings.

## `minPrice` (type: `integer`):

Minimum price filter in ILS (optional)

## `maxPrice` (type: `integer`):

Maximum price filter in ILS (optional)

## `minRooms` (type: `number`):

Minimum number of rooms (optional)

## `maxRooms` (type: `number`):

Maximum number of rooms (optional)

## `publishedAfter` (type: `string`):

Only include listings first published on or after this date. Drastically reduces cost for daily monitoring. Accepts ISO (YYYY-MM-DD) or full ISO timestamps.

## `neighbourhood` (type: `string`):

Filter by neighbourhood or street name in Hebrew (e.g. נווה זמר, הצפון הישן). Matches against neighbourhood, street name, and address fields.

## `propertyType` (type: `string`):

Filter by property type. Leave empty for all types.

## `excludeAgents` (type: `boolean`):

Only return listings from private owners (exclude agent/broker listings)

## `requireParking` (type: `boolean`):

Only return listings that have parking

## `requireElevator` (type: `boolean`):

Only return listings with an elevator in the building

## `requireBalcony` (type: `boolean`):

Only return listings that have a balcony

## `requireSecureRoom` (type: `boolean`):

Only return listings that have a secure room (safe room / mamad)

## `enrichInsights` (type: `boolean`):

Adds a 'locationInsights' array to each listing with categorized neighborhood data (planning, safety, livability, transportation, prices) in Hebrew. Costs 1 extra GraphQL call per scan.

## Actor input object example

```json
{
  "city": "Tel Aviv",
  "dealType": "rent",
  "maxItems": 200,
  "excludeAgents": false,
  "requireParking": false,
  "requireElevator": false,
  "requireBalcony": false,
  "requireSecureRoom": false,
  "enrichInsights": false
}
```

# 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 = {
    "city": "Tel Aviv"
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/madlan-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 = { "city": "Tel Aviv" }

# Run the Actor and wait for it to finish
run = client.actor("swerve/madlan-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 '{
  "city": "Tel Aviv"
}' |
apify call swerve/madlan-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Madlan - Israel Real Estate Listings",
        "description": "Scrape Madlan.co.il property listings in Israel. Rent & buy across 127+ cities. Returns prices, rooms, area, photos, amenities, property type, and agent contact info.",
        "version": "1.0",
        "x-build-id": "RcAtbPVsSPAh2YyeG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swerve~madlan-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swerve-madlan-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/swerve~madlan-scraper/runs": {
            "post": {
                "operationId": "runs-sync-swerve-madlan-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/swerve~madlan-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-swerve-madlan-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",
                "required": [
                    "city",
                    "dealType"
                ],
                "properties": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name in Hebrew or English (e.g. 'Tel Aviv', 'תל אביב', 'Haifa', 'Jerusalem'). Comma-separated for multiple cities, or 'all' for all 127+ cities. Common cities: Tel Aviv, Jerusalem, Haifa, Beer Sheva, Raanana, Herzliya, Netanya, Ashdod, Rishon Lezion, Petah Tikva, Ramat Gan, Holon, Bat Yam, Rehovot, Modiin, Ashkelon, Kfar Saba, Hadera, Bnei Brak, Eilat"
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Type of listing to scrape",
                        "default": "rent"
                    },
                    "maxItems": {
                        "title": "Max Listings Per City",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape per city. Big cities like Tel Aviv can have 1,000+ listings.",
                        "default": 200
                    },
                    "minPrice": {
                        "title": "Min Price (₪)",
                        "type": "integer",
                        "description": "Minimum price filter in ILS (optional)"
                    },
                    "maxPrice": {
                        "title": "Max Price (₪)",
                        "type": "integer",
                        "description": "Maximum price filter in ILS (optional)"
                    },
                    "minRooms": {
                        "title": "Min Rooms",
                        "type": "number",
                        "description": "Minimum number of rooms (optional)"
                    },
                    "maxRooms": {
                        "title": "Max Rooms",
                        "type": "number",
                        "description": "Maximum number of rooms (optional)"
                    },
                    "publishedAfter": {
                        "title": "Published After",
                        "type": "string",
                        "description": "Only include listings first published on or after this date. Drastically reduces cost for daily monitoring. Accepts ISO (YYYY-MM-DD) or full ISO timestamps."
                    },
                    "neighbourhood": {
                        "title": "Neighbourhood / Street (שכונה / רחוב)",
                        "type": "string",
                        "description": "Filter by neighbourhood or street name in Hebrew (e.g. נווה זמר, הצפון הישן). Matches against neighbourhood, street name, and address fields."
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "flat",
                            "penthouseapp",
                            "roofflat",
                            "minipenthouse",
                            "gardenapartment",
                            "duplex",
                            "villa",
                            "cottage",
                            "dualcottage",
                            "studio"
                        ],
                        "type": "string",
                        "description": "Filter by property type. Leave empty for all types."
                    },
                    "excludeAgents": {
                        "title": "Exclude Agents",
                        "type": "boolean",
                        "description": "Only return listings from private owners (exclude agent/broker listings)",
                        "default": false
                    },
                    "requireParking": {
                        "title": "Require Parking",
                        "type": "boolean",
                        "description": "Only return listings that have parking",
                        "default": false
                    },
                    "requireElevator": {
                        "title": "Require Elevator",
                        "type": "boolean",
                        "description": "Only return listings with an elevator in the building",
                        "default": false
                    },
                    "requireBalcony": {
                        "title": "Require Balcony",
                        "type": "boolean",
                        "description": "Only return listings that have a balcony",
                        "default": false
                    },
                    "requireSecureRoom": {
                        "title": "Require Secure Room (ממ״ד)",
                        "type": "boolean",
                        "description": "Only return listings that have a secure room (safe room / mamad)",
                        "default": false
                    },
                    "enrichInsights": {
                        "title": "Include Neighborhood Insights",
                        "type": "boolean",
                        "description": "Adds a 'locationInsights' array to each listing with categorized neighborhood data (planning, safety, livability, transportation, prices) in Hebrew. Costs 1 extra GraphQL call per scan.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
