# Zumper Scraper — Rentals, Buildings & Rent Data (`shhh_lab/apify-zumper`) Actor

Extract rental listings, building details, and rent-market data from Zumper — apartments, houses, condos, and rooms with prices, amenities, photos, floorplan units, and 24-month rent trends.

- **URL**: https://apify.com/shhh\_lab/apify-zumper.md
- **Developed by:** [ShhhLabs](https://apify.com/shhh_lab) (community)
- **Categories:** Real estate, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.95 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

<p align="center"><img src="icon.png" alt="Zumper Rental Scraper" width="128" height="128"></p>

## Zumper Rental Listings Scraper

Scrape rental listings, building details, and rent-market data from [Zumper.com](https://www.zumper.com) — one of the largest US rental platforms. Extract apartments, houses, condos, and rooms with prices, amenities, photos, neighborhood data, individual floorplan units, and historical rent trends.

### Features

- **Search mode** — Scrape city listing pages with full pagination (25 listings/page).
- **Detail mode** — Scrape individual building pages for the full description **and every rentable unit** (floorplan-level prices, beds, baths, sqft, availability).
- **Rent research mode** — Market data: median & average rent, 24-month history, and rent distribution by bedroom count (studio → 4+ bed).
- **Property types** — Apartments, houses, condos, rooms.
- **Neighborhood drill-down** — Optionally enumerate and scrape every neighborhood within each city.
- **Deduplication** — The same listing appearing in city + neighborhood views is pushed only once.
- **Anti-bot handling** — Runs a real browser to clear Zumper's JavaScript challenge automatically.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | `SEARCH` \| `DETAIL` \| `RENT_RESEARCH` | `SEARCH` | What to scrape (see below). |
| `startUrls` | `string[]` | `[]` | **DETAIL mode only** — Zumper building/listing page URLs. |
| `cities` | `string[]` | `["new-york-ny"]` | **SEARCH / RENT_RESEARCH** — city slugs (`{city}-{state}`, e.g. `los-angeles-ca`). |
| `propertyTypes` | `string[]` | `["apartments"]` | **SEARCH** — `apartments`, `houses`, `condos`, `rooms`. |
| `maxPages` | `integer` | `10` | Max search-result pages per city + property-type combo (25 listings/page). |
| `includeNeighborhoods` | `boolean` | `false` | Also scrape each neighborhood within each city. |
| `includeMarketData` | `boolean` | `false` | In SEARCH mode, also scrape rent-research data per city. |
| `maxConcurrency` | `integer` | `5` | Max parallel browser pages. |
| `proxy` | `object` | Apify Residential | Proxy configuration. |

#### Modes

- **`SEARCH`** — builds URLs from `cities` × `propertyTypes`, paginates, and emits one [listing record](#listing-output-search) per unit/building.
- **`DETAIL`** — visits each URL in `startUrls` and emits one [building record](#building-output-detail) (full description + all floorplan units).
- **`RENT_RESEARCH`** — emits one [market-data record](#market-data-output-rent_research) per city.

#### Example: NYC apartments

```json
{ "mode": "SEARCH", "cities": ["new-york-ny"], "propertyTypes": ["apartments"], "maxPages": 5 }
````

#### Example: Full building details

```json
{
  "mode": "DETAIL",
  "startUrls": [
    "https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
  ]
}
```

#### Example: SF rent trends

```json
{ "mode": "RENT_RESEARCH", "cities": ["san-francisco-ca"] }
```

#### City slug format

`{city-name-hyphenated}-{state-abbrev-lowercase}`

| City | Slug |
|---|---|
| New York, NY | `new-york-ny` |
| Los Angeles, CA | `los-angeles-ca` |
| San Francisco, CA | `san-francisco-ca` |
| Chicago, IL | `chicago-il` |
| Austin, TX | `austin-tx` |
| Miami, FL | `miami-fl` |

### Output

#### Listing output (SEARCH)

38 fields per listing. `sqftMin`/`sqftMax`/`leaseMinDays`/`leaseMaxDays` are `null` when Zumper doesn't publish them.

```json
{
  "listingId": 63457759,
  "buildingId": 2022915,
  "buildingName": "The Highland",
  "address": "2840 Atlantic Avenue",
  "city": "New York",
  "state": "NY",
  "zipcode": "11207",
  "neighborhood": "East New York",
  "lat": 40.6763085,
  "lng": -73.8890418,
  "priceMin": 2300,
  "priceMax": 3688,
  "previousPrice": null,
  "bedroomsMin": 0,
  "bedroomsMax": 2,
  "bathroomsMin": 0,
  "bathroomsMax": 2,
  "sqftMin": null,
  "sqftMax": null,
  "leaseMinDays": null,
  "leaseMaxDays": null,
  "floorplanCount": 9,
  "propertyType": "apartment",
  "dateAvailable": null,
  "listedOn": "2026-06-11",
  "modifiedOn": "2026-06-15",
  "rating": 9.4,
  "petsAllowed": [],
  "amenities": ["Granite Countertop", "Stainless Steel Appliances", "Floor-To-Ceiling Windows"],
  "buildingAmenities": ["Fitness Center", "Rooftop Lounge", "Co-working lounge"],
  "phone": "(516) 619-3153",
  "agentName": "Bushburg Properties",
  "brokerageName": null,
  "isFeatured": false,
  "hasFees": false,
  "images": ["https://img.zumpercdn.com/873992950/1280x960"],
  "url": "https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny",
  "description": null
}
```

#### Building output (DETAIL)

One record per building, with a nested `units` array (one entry per rentable floorplan).

```json
{
  "buildingId": 2022915,
  "name": "The Highland",
  "description": "Housed in what was formerly the Empire State Dairy Company, The Highland …",
  "address": "2840 Atlantic Avenue",
  "formattedAddress": "2840 Atlantic Avenue, New York, NY 11207, USA",
  "city": "New York",
  "state": "NY",
  "zipcode": "11207",
  "neighborhood": "East New York",
  "citySlug": "new-york-ny",
  "lat": 40.6763085,
  "lng": -73.8890418,
  "yearBuilt": null,
  "floors": null,
  "phone": "(516) 619-3153",
  "agentName": "Bushburg Properties",
  "brokerageName": null,
  "petsAllowed": ["Large Dogs", "Cats"],
  "amenities": ["Fitness Center", "Rooftop Lounge"],
  "hasFees": false,
  "images": ["https://img.zumpercdn.com/873992950/1280x960"],
  "unitCount": 9,
  "units": [
    {
      "listingId": 63457779,
      "title": "Unit 324",
      "priceMin": 2300,
      "priceMax": 2300,
      "bedrooms": 0,
      "bathrooms": 0,
      "halfBathrooms": 0,
      "sqft": null,
      "dateAvailable": null,
      "propertyType": "apartment",
      "amenities": ["Floor-To-Ceiling Windows", "Vinyl Plank Flooring"],
      "images": ["https://img.zumpercdn.com/873993321/1280x960"],
      "url": "https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
    }
  ],
  "url": "https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
}
```

#### Market data output (RENT\_RESEARCH)

```json
{
  "city": "New York",
  "state": "NY",
  "citySlug": "new-york-ny",
  "scrapedAt": "2026-06-15",
  "rentData": {
    "studio":      { "medianRent": 3895, "averageRent": 4048.12, "averageSqft": 412, "count": 1470, "rentRanges": [{ "label": "$0 - $1,500", "percent": 1.85 }], "monthlyHistory": [{ "date": "2024-06", "medianRent": 3800 }] },
    "oneBed":      { "medianRent": 4750, "averageRent": 4912.02, "averageSqft": 600, "count": 3147, "rentRanges": [], "monthlyHistory": [] },
    "twoBed":      { "medianRent": 5600, "averageRent": 6182.17, "averageSqft": 900, "count": 2381, "rentRanges": [], "monthlyHistory": [] },
    "threeBed":    { "medianRent": 6195, "averageRent": 7130.08, "averageSqft": 1200, "count": 1196, "rentRanges": [], "monthlyHistory": [] },
    "fourBedPlus": { "medianRent": 7300, "averageRent": 8839.63, "averageSqft": 1500, "count": 315, "rentRanges": [], "monthlyHistory": [] }
  }
}
```

Any bedroom type with no data is `null`.

### How it works

Zumper is a React app served behind a non-interactive JavaScript anti-bot challenge — a plain HTTP request only ever returns a small "Client Challenge" shell, never the real content. This actor therefore drives a **real headless browser** ([Playwright](https://playwright.dev) + Chromium):

1. Builds seed URLs from the input (or uses `startUrls` in DETAIL mode).
2. Loads each page in a browser, which automatically executes the challenge and reloads with the real content.
3. Reads the server-rendered `window.__PRELOADED_STATE__` JSON embedded in the page and parses it with a brace-matching scanner (robust to the ~400 KB blob and trailing scripts).
4. Normalizes records (deduplicating by ID, cleaning Zumper's sentinel "unknown" values), then paginates and optionally enqueues neighborhoods / rent research.

A JSON-LD extraction utility is included as a resilience aid if the embedded-state format ever changes.

### Pricing

Designed for **Pay Per Result** — e.g. $0.015 per listing, building, or market-data record (configure in the Apify console). Because each page runs a browser, residential proxy + compute costs are higher than a plain HTTP scraper; per-result pricing keeps that predictable for you.

### Limitations & notes

- 25 listings per search page (Zumper's pagination size); use `maxPages` to control depth.
- **Residential proxies are strongly recommended** — datacenter IPs are challenged far more aggressively.
- DETAIL expects building pages (`/apartment-buildings/p…`). The full description and per-unit prices live only on these pages, not in search results.
- Polite by default: capped concurrency and request rate.

### Development

```bash
npm install
npm run build
npm test          # 38 unit tests (extraction + normalization)
npm start         # runs locally against ./storage with an INPUT.json
```

The unit tests cover the pure extraction/normalization logic (no network). To smoke-test the browser pipeline locally, drop an `INPUT.json` into `storage/key_value_stores/default/` and run `npm start`.

# Actor input Schema

## `mode` (type: `string`):

What to scrape:

- **SEARCH** — city listing pages (apartments, houses, condos, rooms) with pagination.
- **DETAIL** — individual building pages (full description + every floorplan unit). Requires Start URLs.
- **RENT\_RESEARCH** — market rent data (median/average rent, 24-month trends, rent distribution).

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

Zumper building/listing page URLs to scrape in **DETAIL** mode, e.g. `https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny`. Ignored in SEARCH and RENT\_RESEARCH modes.

## `cities` (type: `array`):

City slugs to scrape in SEARCH and RENT\_RESEARCH modes. Format: `{city-name-hyphenated}-{state-abbrev-lowercase}` — e.g. `new-york-ny`, `los-angeles-ca`, `chicago-il`, `austin-tx`.

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

Property types to scrape in SEARCH mode.

## `maxPages` (type: `integer`):

Maximum number of search-result pages to scrape per city + property-type combination (25 listings per page). Zumper reports thousands of matches per city, so this is the main cost control.

## `includeNeighborhoods` (type: `boolean`):

Also enumerate and scrape every neighborhood within each city. Greatly increases coverage and request count. Duplicate listings (same unit appearing in the city and a neighborhood view) are pushed only once.

## `includeMarketData` (type: `boolean`):

In SEARCH mode, also scrape the rent-research page for each city (median rent, averages, 24-month history and rent distribution by bedroom count).

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

Maximum number of browser pages open in parallel. Higher is faster but uses more memory and is more likely to trigger rate limiting.

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

Proxy settings. Residential proxies are strongly recommended — datacenter IPs are challenged far more aggressively by Zumper's anti-bot layer.

## Actor input object example

```json
{
  "mode": "SEARCH",
  "startUrls": [
    "https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
  ],
  "cities": [
    "new-york-ny"
  ],
  "propertyTypes": [
    "apartments"
  ],
  "maxPages": 10,
  "includeNeighborhoods": false,
  "includeMarketData": false,
  "maxConcurrency": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Rental listings scraped in SEARCH mode.

## `buildings` (type: `string`):

Buildings and their floorplan units scraped in DETAIL mode.

## `marketData` (type: `string`):

Per-city median/average rent, distribution and 24-month history.

# 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.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("shhh_lab/apify-zumper").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.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"] }

# Run the Actor and wait for it to finish
run = client.actor("shhh_lab/apify-zumper").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.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny"
  ]
}' |
apify call shhh_lab/apify-zumper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zumper Scraper — Rentals, Buildings & Rent Data",
        "description": "Extract rental listings, building details, and rent-market data from Zumper — apartments, houses, condos, and rooms with prices, amenities, photos, floorplan units, and 24-month rent trends.",
        "version": "0.0",
        "x-build-id": "unSi5QuPgLclrAdqc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shhh_lab~apify-zumper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shhh_lab-apify-zumper",
                "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/shhh_lab~apify-zumper/runs": {
            "post": {
                "operationId": "runs-sync-shhh_lab-apify-zumper",
                "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/shhh_lab~apify-zumper/run-sync": {
            "post": {
                "operationId": "run-sync-shhh_lab-apify-zumper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "SEARCH",
                            "DETAIL",
                            "RENT_RESEARCH"
                        ],
                        "type": "string",
                        "description": "What to scrape:\n- **SEARCH** — city listing pages (apartments, houses, condos, rooms) with pagination.\n- **DETAIL** — individual building pages (full description + every floorplan unit). Requires Start URLs.\n- **RENT_RESEARCH** — market rent data (median/average rent, 24-month trends, rent distribution).",
                        "default": "SEARCH"
                    },
                    "startUrls": {
                        "title": "Start URLs (DETAIL mode)",
                        "type": "array",
                        "description": "Zumper building/listing page URLs to scrape in **DETAIL** mode, e.g. `https://www.zumper.com/apartment-buildings/p1528434/the-highland-east-new-york-new-york-ny`. Ignored in SEARCH and RENT_RESEARCH modes.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City slugs to scrape in SEARCH and RENT_RESEARCH modes. Format: `{city-name-hyphenated}-{state-abbrev-lowercase}` — e.g. `new-york-ny`, `los-angeles-ca`, `chicago-il`, `austin-tx`.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "new-york-ny"
                        ]
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Property types to scrape in SEARCH mode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartments",
                                "houses",
                                "condos",
                                "rooms"
                            ],
                            "enumTitles": [
                                "Apartments",
                                "Houses",
                                "Condos",
                                "Rooms"
                            ]
                        },
                        "default": [
                            "apartments"
                        ]
                    },
                    "maxPages": {
                        "title": "Max pages per city + property type",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of search-result pages to scrape per city + property-type combination (25 listings per page). Zumper reports thousands of matches per city, so this is the main cost control.",
                        "default": 10
                    },
                    "includeNeighborhoods": {
                        "title": "Include neighborhoods",
                        "type": "boolean",
                        "description": "Also enumerate and scrape every neighborhood within each city. Greatly increases coverage and request count. Duplicate listings (same unit appearing in the city and a neighborhood view) are pushed only once.",
                        "default": false
                    },
                    "includeMarketData": {
                        "title": "Include market data",
                        "type": "boolean",
                        "description": "In SEARCH mode, also scrape the rent-research page for each city (median rent, averages, 24-month history and rent distribution by bedroom count).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of browser pages open in parallel. Higher is faster but uses more memory and is more likely to trigger rate limiting.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are strongly recommended — datacenter IPs are challenged far more aggressively by Zumper's anti-bot layer.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
