# PadMapper Scraper (`crawlerbros/padmapper-scraper`) Actor

Scrape PadMapper.com apartment and rental listings. Search by city, neighborhood, or zip code with price, bedroom, bathroom, property-type, and pet filters, or fetch full building details and floorplans by URL.

- **URL**: https://apify.com/crawlerbros/padmapper-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## PadMapper Scraper

Scrape **PadMapper.com** apartment and rental listings across the US and Canada. Search any city, neighborhood, or zip code with price, bedroom, bathroom, property-type, and pet filters, or pull full building details — description, amenities, photos, and every available floorplan — from a single listing URL. HTTP-only, no login, no cookies, no paid proxy required.

### What this actor does

- **Two modes:** `search` (city / neighborhood / zip) and `byBuildingUrl` (single building deep-dive)
- **Filters:** min/max price, bedroom count, min bathrooms, property type, pets allowed, zip code, min/max square feet, min/max price per bedroom, lease term (long-term vs short-term/sublet)
- **Real listing data:** address, coordinates, price range, bed/bath range, amenities, photos, availability date
- **Building detail mode:** full description, year built, floor count, every floorplan/unit with its own price and availability
- **Photo URLs** built from PadMapper's CDN, ready to use directly
- Empty fields are omitted — every returned field has a real value

### Output per listing (mode = `search`)

- `listingId`, `buildingId`
- `title`, `buildingName`, `address`, `city`, `state`, `zipcode`, `neighborhood`
- `lat`, `lng`
- `minPrice`, `maxPrice` — monthly rent range (USD)
- `minBedrooms`, `maxBedrooms`, `minBathrooms`, `maxBathrooms`
- `minSquareFeet`, `maxSquareFeet` (rarely returned by PadMapper's search API — the `minSquareFeet`/`maxSquareFeet` input filters still narrow results even when this field is absent)
- `minLeaseDays`, `maxLeaseDays` (when known)
- `propertyType` — e.g. `apartment`, `condo`, `townhouse`
- `petsAllowed[]` — e.g. `cats`, `smallDogs`, `largeDogs`
- `dateAvailable`
- `amenities[]`, `buildingAmenities[]`
- `rating` — PadMapper/Zumper listing score (0-10) when available
- `hasFees`
- `floorplanCount`
- `phone`, `listingAgent`
- `imageUrls[]`, `imageCount`
- `listingUrl` — canonical padmapper.com building URL
- `recordType: "listing"`, `scrapedAt`

### Output per building (mode = `byBuildingUrl`)

- `buildingId`, `name`, `description`, `shortDescription`
- `address`, `street`, `city`, `state`, `zipcode`, `country`, `neighborhood`
- `lat`, `lng`
- `yearBuilt`, `floors`
- `averagePrice`, `averageSquareFeet`
- `amenities[]`, `petsAllowed[]`
- `phone`, `listingAgent`
- `imageUrls[]`, `imageCount`
- `floorplans[]` — each with `listingId`, `title`, `bedrooms`, `bathrooms`, `minPrice`, `maxPrice`, `dateAvailable`
- `floorplanCount`
- `buildingUrl`
- `recordType: "building"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` (city/neighborhood/zip) or `byBuildingUrl` (single building) |
| `location` | string | `new-york-ny` | PadMapper location slug (mode=search), e.g. `new-york-ny` or `new-york-ny/williamsburg` |
| `buildingUrl` | string | — | Full padmapper.com building URL (mode=byBuildingUrl) |
| `minPrice` | integer | — | Minimum monthly rent (USD) |
| `maxPrice` | integer | — | Maximum monthly rent (USD) |
| `bedrooms` | array (select) | `[]` | Bedroom counts to include: Studio, 1-5+ |
| `minBathrooms` | integer | — | Minimum number of bathrooms |
| `propertyTypes` | array (select) | `[]` | Apartment, Condo, Townhouse, Co-op, Loft, and more |
| `petsAllowed` | array (select) | `[]` | Cats, Small dogs, Large dogs |
| `minSquareFeet` | integer | — | Minimum unit size (sq ft); narrows results server-side even though the field is rarely returned in output |
| `maxSquareFeet` | integer | — | Maximum unit size (sq ft) |
| `minPricePerBedroom` | integer | — | Minimum monthly rent per bedroom (USD) |
| `maxPricePerBedroom` | integer | — | Maximum monthly rent per bedroom (USD) |
| `leaseTerm` | select | `any` | `any` (PadMapper default = long-term), `longTerm`, or `shortTerm`/sublet |
| `zipcodes` | array of strings | `[]` | Restrict results to specific zip codes |
| `maxItems` | integer | `50` | Maximum records to return (1-1000) |
| `proxyConfiguration` | proxy | AUTO | Only used as an automatic retry if PadMapper ever rate-limits a request |

#### Example: search a city with price and bedroom filters

```json
{
  "mode": "search",
  "location": "new-york-ny",
  "minPrice": 2000,
  "maxPrice": 4000,
  "bedrooms": ["1", "2"],
  "maxItems": 50
}
````

#### Example: search a neighborhood, pet-friendly only

```json
{
  "mode": "search",
  "location": "new-york-ny/williamsburg",
  "petsAllowed": ["cats", "smallDogs"],
  "maxItems": 30
}
```

#### Example: search by zip code within a city

```json
{
  "mode": "search",
  "location": "new-york-ny",
  "zipcodes": ["10001", "10011"],
  "maxItems": 40
}
```

#### Example: single building lookup

```json
{
  "mode": "byBuildingUrl",
  "buildingUrl": "https://www.padmapper.com/buildings/p1528434/the-highland-apartments-at-2840-atlantic-avenue-new-york-ny-11207"
}
```

### Use cases

- Track rental price ranges across neighborhoods for market research
- Build a rental-listing aggregator or price-comparison tool
- Monitor availability and price changes for specific buildings over time
- Feed apartment listing photos and details into a relocation or real-estate app
- Analyze pet-friendly or amenity-specific inventory in a given city

### FAQ

**Does this actor require login or cookies?**
No. PadMapper's search results and building pages are fully public.

**Does this actor use a paid proxy?**
No. It runs without any proxy by default. `proxyConfiguration` is only used as a one-time automatic retry if PadMapper ever returns a rate-limit response, and defaults to Apify's free AUTO datacenter group.

**How do I find the `location` slug for my city?**
Visit `padmapper.com/apartments/<your-city>` in a browser — the URL path segment after `/apartments/` is the slug (e.g. `chicago-il`, `austin-tx`). Append `/neighborhood-slug` to search within a neighborhood.

**Why do some listings have a price/bed/bath *range* instead of one number?**
PadMapper groups multiple available units in the same building under one listing when they share a building. The range reflects the min/max across all currently available units. Use `mode=byBuildingUrl` to get every individual unit's exact price and bedroom count.

**Some listings are missing `imageUrls` or `rating` — is that a bug?**
No — only fields with real data from PadMapper are included in each record. Not every listing has photos, a rating, or every optional field populated.

**Can I search cities outside the US?**
PadMapper primarily covers US and Canadian metro areas. Use the same `city-state`/`city-province` slug format, e.g. `toronto-on`.

# Actor input Schema

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

What to fetch.

## `location` (type: `string`):

PadMapper location slug, e.g. `new-york-ny`, `los-angeles-ca`, or a neighborhood path `new-york-ny/williamsburg`. Find the slug in any padmapper.com/apartments/... URL.

## `buildingUrl` (type: `string`):

Full padmapper.com building URL or path, e.g. `https://www.padmapper.com/buildings/p1528434/the-highland-apartments-at-2840-atlantic-avenue-new-york-ny-11207`.

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

Only include listings with a monthly rent at or above this amount.

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

Only include listings with a monthly rent at or below this amount.

## `bedrooms` (type: `array`):

Filter to specific bedroom counts. Leave empty for all.

## `minBathrooms` (type: `integer`):

Only include listings with at least this many bathrooms.

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

Filter to specific property types. Leave empty for all.

## `petsAllowed` (type: `array`):

Filter to listings that allow these pets. Leave empty for all.

## `minSquareFeet` (type: `integer`):

Only include listings with a unit size at or above this square footage. Confirmed to narrow PadMapper's own result set server-side; PadMapper's search API does not return a per-listing square-footage value, so this filter narrows results but the corresponding output fields won't always be populated.

## `maxSquareFeet` (type: `integer`):

Only include listings with a unit size at or below this square footage. See note on `minSquareFeet` about output-field availability.

## `minPricePerBedroom` (type: `integer`):

Only include listings whose price-per-bedroom is at or above this amount. Server-side PadMapper filter.

## `maxPricePerBedroom` (type: `integer`):

Only include listings whose price-per-bedroom is at or below this amount. Server-side PadMapper filter.

## `leaseTerm` (type: `string`):

Restrict to long-term (12+ month) or short-term/sublet listings. PadMapper defaults to long-term only when this is left as `any`.

## `zipcodes` (type: `array`):

Restrict results to specific zip codes within the searched city.

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

Optional. Used only as a one-time automatic retry if PadMapper ever returns 403/429 for a request. Defaults to Apify's free AUTO datacenter group.

## Actor input object example

```json
{
  "mode": "search",
  "location": "new-york-ny",
  "bedrooms": [],
  "propertyTypes": [],
  "petsAllowed": [],
  "leaseTerm": "any",
  "zipcodes": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped PadMapper listings and building records.

# 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 = {
    "mode": "search",
    "location": "new-york-ny",
    "bedrooms": [],
    "propertyTypes": [],
    "petsAllowed": [],
    "leaseTerm": "any",
    "zipcodes": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/padmapper-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 = {
    "mode": "search",
    "location": "new-york-ny",
    "bedrooms": [],
    "propertyTypes": [],
    "petsAllowed": [],
    "leaseTerm": "any",
    "zipcodes": [],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/padmapper-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 '{
  "mode": "search",
  "location": "new-york-ny",
  "bedrooms": [],
  "propertyTypes": [],
  "petsAllowed": [],
  "leaseTerm": "any",
  "zipcodes": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/padmapper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PadMapper Scraper",
        "description": "Scrape PadMapper.com apartment and rental listings. Search by city, neighborhood, or zip code with price, bedroom, bathroom, property-type, and pet filters, or fetch full building details and floorplans by URL.",
        "version": "1.0",
        "x-build-id": "O0XF8HuakQbk72iOE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~padmapper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-padmapper-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/crawlerbros~padmapper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-padmapper-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/crawlerbros~padmapper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-padmapper-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byBuildingUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "location": {
                        "title": "City or neighborhood (mode=search)",
                        "type": "string",
                        "description": "PadMapper location slug, e.g. `new-york-ny`, `los-angeles-ca`, or a neighborhood path `new-york-ny/williamsburg`. Find the slug in any padmapper.com/apartments/... URL.",
                        "default": "new-york-ny"
                    },
                    "buildingUrl": {
                        "title": "Building URL (mode=byBuildingUrl)",
                        "type": "string",
                        "description": "Full padmapper.com building URL or path, e.g. `https://www.padmapper.com/buildings/p1528434/the-highland-apartments-at-2840-atlantic-avenue-new-york-ny-11207`."
                    },
                    "minPrice": {
                        "title": "Min price ($/month)",
                        "minimum": 0,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Only include listings with a monthly rent at or above this amount."
                    },
                    "maxPrice": {
                        "title": "Max price ($/month)",
                        "minimum": 0,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Only include listings with a monthly rent at or below this amount."
                    },
                    "bedrooms": {
                        "title": "Bedrooms",
                        "type": "array",
                        "description": "Filter to specific bedroom counts. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0",
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "Studio",
                                "1 Bedroom",
                                "2 Bedrooms",
                                "3 Bedrooms",
                                "4 Bedrooms",
                                "5+ Bedrooms"
                            ]
                        },
                        "default": []
                    },
                    "minBathrooms": {
                        "title": "Min bathrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include listings with at least this many bathrooms."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Filter to specific property types. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartment",
                                "condo",
                                "townhouse",
                                "coop",
                                "loft",
                                "tic",
                                "mobileManufactured",
                                "farmRanch",
                                "multiFamily",
                                "incomeInvestment",
                                "houseboat",
                                "lotLand",
                                "singleFamilyHome",
                                "apartmentCondoTownhouse",
                                "floorPlan",
                                "room",
                                "sharedRoom"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "Condo",
                                "Townhouse",
                                "Co-op",
                                "Loft",
                                "TIC",
                                "Mobile / Manufactured",
                                "Farm / Ranch",
                                "Multi-family",
                                "Income / Investment",
                                "Houseboat",
                                "Lot / Land",
                                "Single-family home",
                                "Apartment/Condo/Townhouse",
                                "Floor plan",
                                "Room",
                                "Shared room"
                            ]
                        },
                        "default": []
                    },
                    "petsAllowed": {
                        "title": "Pets allowed",
                        "type": "array",
                        "description": "Filter to listings that allow these pets. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cats",
                                "smallDogs",
                                "largeDogs"
                            ],
                            "enumTitles": [
                                "Cats",
                                "Small dogs",
                                "Large dogs"
                            ]
                        },
                        "default": []
                    },
                    "minSquareFeet": {
                        "title": "Min square feet",
                        "minimum": 0,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Only include listings with a unit size at or above this square footage. Confirmed to narrow PadMapper's own result set server-side; PadMapper's search API does not return a per-listing square-footage value, so this filter narrows results but the corresponding output fields won't always be populated."
                    },
                    "maxSquareFeet": {
                        "title": "Max square feet",
                        "minimum": 0,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Only include listings with a unit size at or below this square footage. See note on `minSquareFeet` about output-field availability."
                    },
                    "minPricePerBedroom": {
                        "title": "Min price per bedroom ($/month)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Only include listings whose price-per-bedroom is at or above this amount. Server-side PadMapper filter."
                    },
                    "maxPricePerBedroom": {
                        "title": "Max price per bedroom ($/month)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Only include listings whose price-per-bedroom is at or below this amount. Server-side PadMapper filter."
                    },
                    "leaseTerm": {
                        "title": "Lease term",
                        "enum": [
                            "any",
                            "longTerm",
                            "shortTerm"
                        ],
                        "type": "string",
                        "description": "Restrict to long-term (12+ month) or short-term/sublet listings. PadMapper defaults to long-term only when this is left as `any`.",
                        "default": "any"
                    },
                    "zipcodes": {
                        "title": "Zip codes",
                        "type": "array",
                        "description": "Restrict results to specific zip codes within the searched city.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Used only as a one-time automatic retry if PadMapper ever returns 403/429 for a request. Defaults to Apify's free AUTO datacenter group.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
