# HotPads Rental Scraper (`solidcode/hotpads-scraper`) Actor

\[💰 $2.5 / 1K] Scrape HotPads rental listings by city, ZIP, map area, or URL. Get rent, beds, baths, sqft, address, coordinates, amenities, photos, pet policy, and property-manager contacts for apartments, houses, condos & rooms.

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

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## HotPads Rental Scraper

Pull live rental listings from HotPads at scale — monthly rent, addresses, beds, baths, square footage, GPS coordinates, amenities, full photo galleries, pet policies, and property-manager contacts for apartments, houses, condos, townhomes, rooms, and multi-family buildings across the United States. Built for rental-market analysts, relocation services, and real-estate investors who need current, structured rental inventory without searching HotPads listing by listing.

### Why This Scraper?

- **Nationwide US rental coverage** — search apartments, houses, condos, townhomes, rooms, and multi-family buildings across all 50 states by city or ZIP code, or paste a HotPads map URL to target an exact neighborhood.
- **Seven property-type filters** — Any type, Apartment, House, Condo, Townhome, Room / Roommate, or Multi-family, so you pull only the inventory you care about.
- **Precise rent, bedroom, bathroom, and pet filters** — set a monthly-rent range, a bedroom range (studios included at 0), a minimum bathroom count that respects half-baths (e.g. 1.5), and Dogs / Cats / Dogs & cats pet policies.
- **GPS coordinates on every listing** — exact `latitude` and `longitude` for mapping, radius analysis, and geo-joins, not just a street address.
- **Multi-unit buildings collapse to one clean row** — a large apartment community returns a single row with `price` (lowest) and `priceMax` (highest) plus an embedded `units[]` array carrying per-unit rent, beds, baths, and square footage — no duplicate building spam.
- **Full photo galleries** — every listing carries a `photoCount`, a `coverPhoto` URL, and a `photos[]` array of image URLs, ready to power visual listing feeds.
- **Property-manager contacts** — the listing company / property-manager `company` name on each building (plus `phone` when the manager publishes one) for outreach lists.
- **Optional deep enrichment** — one switch adds square footage, assigned nearby schools (name, rating, distance), full amenity lists, and unit floorplans to every listing.
- **Four sort orders, one result cap** — order by Best match, Newest, Price low-to-high, or Price high-to-low, and cap the run with a single `maxResults` number instead of juggling page counts.

### Use Cases

**Rental Market Research & Analytics**
- Track live rent levels and availability across neighborhoods and ZIP codes
- Compare rent per square foot between property types and submarkets
- Map inventory density using the latitude/longitude on every listing
- Build a fresh, structured rental dataset instead of copying listings by hand

**Lead Generation**
- Build property-manager and listing-company outreach lists by city
- Surface newly listed buildings by sorting on Newest
- Target multi-family communities for services and vendor pitches
- Feed rental leads straight into a CRM

**Relocation & Housing Search**
- Assemble shortlists filtered by rent range, bedrooms, and pet policy
- Compare pet-friendly inventory (dogs, cats, or both) across candidate cities
- Package amenities, photos, and school data for relocating employees
- Pull listings for an exact target area by pasting a panned HotPads map URL

**Investment & Portfolio Analysis**
- Benchmark asking rents against your own units in the same market
- Model rent spreads across a multi-unit building from the embedded `units[]` array
- Identify submarkets by beds/baths mix and price band
- Monitor competitive supply around an existing property

**Price & Availability Monitoring**
- Re-run on a schedule to track rent changes over time
- Watch a saved search area for new inventory
- Alert on listings that enter your target rent range
- Compare price-low-to-high results week over week

### Getting Started

#### Search One Location

The simplest run — just type a city and state:

```json
{
    "searchLocations": ["Austin, TX"],
    "maxResults": 50
}
````

#### Search With Filters

Narrow to pet-friendly two-bedrooms in a rent range, newest first:

```json
{
    "searchLocations": ["Denver, CO", "80202"],
    "propertyType": "apartment",
    "minPrice": 1500,
    "maxPrice": 3000,
    "minBedrooms": 2,
    "maxBedrooms": 3,
    "minBathrooms": 1.5,
    "petPolicy": "dogs_and_cats",
    "sortBy": "newest",
    "maxResults": 200
}
```

#### Paste HotPads URLs With Full Details

Paste search-results pages or individual listing pages and turn on enrichment:

```json
{
    "startUrls": [
        "https://hotpads.com/austin-tx/apartments-for-rent",
        "https://hotpads.com/brooklyn-ny/condos-for-rent"
    ],
    "includeListingDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchLocations` | array | `["Austin, TX"]` | Cities or ZIP codes to search (e.g. "Austin, TX", "78701"). To target a specific neighborhood, paste a HotPads neighborhood/map URL under `startUrls` instead. The Filters below apply to these searches. |
| `startUrls` | array | `[]` | Paste HotPads URLs — search-results pages or individual listing pages. The location and property type built into the URL are honored; use Search Locations + Filters for price, bedroom, bathroom, and pet limits. |

#### Filters

Filters apply to Search Locations only. Leave any filter blank to ignore it.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `propertyType` | select | `Any type` | Any type, Apartment, House, Condo, Townhome, Room / Roommate, or Multi-family. |
| `minPrice` | integer | — | Minimum monthly rent in USD. Blank for no minimum. |
| `maxPrice` | integer | — | Maximum monthly rent in USD. Blank for no maximum. |
| `minBedrooms` | integer | — | Fewest bedrooms to include. Use 0 to include studios. |
| `maxBedrooms` | integer | — | Most bedrooms to include. |
| `minBathrooms` | number | — | Fewest bathrooms; half-baths allowed (e.g. 1.5). |
| `petPolicy` | select | `Any` | Any, Dogs allowed, Cats allowed, or Dogs & cats allowed. |
| `sortBy` | select | `Best match` | Best match, Newest, Price: low to high, or Price: high to low. Price sorting ranks up to ~3,000 listings per location. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings across all locations and URLs combined. Set to 0 to collect all available, up to 50,000 per run. Each location returns up to ~8,000 listings (split very large markets across ZIP codes or smaller pasted HotPads map areas); price sorting ranks up to ~3,000 per location. Start with 20–50 to test, then increase. |
| `includeListingDetails` | boolean | `true` | Open each listing for the full record: all photos, amenities, unit floorplans, nearby schools, and square footage. Slower but much richer. When off, only the data on search cards is returned. |

### Output

Each result is one flat row per building. Multi-unit buildings carry an embedded `units[]` array. Here is a representative row with full details enabled:

```json
{
    "listingId": "a1b2c3d4",
    "buildingId": "9f8e7d6c",
    "title": "The Ellison Apartments",
    "propertyType": "apartment",
    "price": 1495,
    "priceMax": 2650,
    "beds": 1,
    "bedsMax": 3,
    "baths": 1,
    "sqft": 712,
    "address": "1200 Barton Springs Rd",
    "city": "Austin",
    "state": "TX",
    "zipcode": "78704",
    "latitude": 30.2596,
    "longitude": -97.7684,
    "company": "Greystar Property Management",
    "phone": "5125550142",
    "petsAllowed": ["cats", "dogs"],
    "amenities": ["In-Unit Laundry", "Swimming Pool", "Covered Parking", "Fitness Center"],
    "availableDate": "2026-08-01",
    "photoCount": 34,
    "coverPhoto": "https://images.hotpads.com/example-cover-1200.jpg",
    "photos": [
        "https://images.hotpads.com/example-1-1200.jpg",
        "https://images.hotpads.com/example-2-1200.jpg"
    ],
    "units": [
        { "unit": "A1", "beds": 1, "baths": 1, "price": 1495, "sqft": 712, "availableDate": "2026-08-01" },
        { "unit": "C3", "beds": 3, "baths": 2, "price": 2650, "sqft": 1340, "availableDate": "2026-09-15" }
    ],
    "schools": [
        { "name": "Zilker Elementary", "rating": 8, "type": "Public", "grades": "PK-5", "distance": 0.4 }
    ],
    "listingUrl": "https://hotpads.com/the-ellison-austin-tx-a1b2c3d4/pad",
    "scrapedAt": "2026-07-18T14:30:00Z"
}
```

#### Core Listing

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | HotPads listing identifier |
| `buildingId` | string | Building identifier (shared across a multi-unit building) |
| `title` | string | Listing title or building name |
| `propertyType` | string | apartment, house, condo, townhome, room, or multifamily |
| `listingUrl` | string | Full HotPads listing URL |
| `scrapedAt` | string | ISO-8601 timestamp of collection |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Street address |
| `city` | string | City |
| `state` | string | Two-letter state code |
| `zipcode` | string | ZIP code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Pricing & Size

| Field | Type | Description |
|-------|------|-------------|
| `price` | integer | Monthly rent in USD (lowest unit for multi-unit buildings) |
| `priceMax` | integer | Highest monthly rent for multi-unit buildings (absent when a single price) |
| `beds` | number | Bedrooms (lowest for multi-unit; 0 = studio) |
| `bedsMax` | number | Highest bedroom count for multi-unit (absent when single) |
| `baths` | number | Bathrooms (half-baths preserved, e.g. 1.5) |
| `sqft` | integer | Square footage (best coverage with details enabled) |

#### Units & Media

| Field | Type | Description |
|-------|------|-------------|
| `units` | object\[] | Per-unit floorplans for multi-unit buildings: `unit`, `beds`, `baths`, `price`, `sqft`, `availableDate` |
| `photoCount` | integer | Number of photos |
| `coverPhoto` | string | Cover photo URL |
| `photos` | string\[] | All photo URLs |

#### Amenities, Contact & Details

Amenities and pet policy come from every search card; schools, availability, and description are filled when `includeListingDetails` is on and HotPads provides them.

| Field | Type | Description |
|-------|------|-------------|
| `company` | string | Listing company / property-manager name |
| `phone` | string | Contact phone, when the manager publishes one |
| `petsAllowed` | string\[] | Pets permitted, e.g. `["dogs", "cats"]` |
| `amenities` | string\[] | Amenity list (in-unit laundry, pool, parking, etc.) |
| `schools` | object\[] | Nearby schools: `name`, `rating`, `type`, `grades`, `distance` |
| `availableDate` | string | Move-in / availability date, when listed |
| `description` | string | Listing description text, when HotPads publishes one |

### Tips for Best Results

- **Start small, then scale** — set `maxResults` to 20–50 on your first run to confirm the data fits your needs, then raise it.
- **Turn on Include Full Listing Details for depth** — this is the power-user switch: it adds square footage, assigned nearby schools, full amenity lists, and per-unit floorplans. Leave it off for faster, lighter runs when search-card fields are enough.
- **Type locations rather than building URLs** — "Austin, TX" or "78701" is more reliable than hand-crafting search links, and the Filters section only applies to typed locations.
- **Paste a HotPads map URL for an exact area** — pan and zoom the HotPads map to your target neighborhood, then paste that URL into HotPads URLs to inherit the precise map bounds.
- **Read multi-unit buildings from `units[]`** — a big apartment community is one row; its per-unit rent, beds, baths, and square footage live in the embedded `units[]` array, not in separate rows.
- **Sort by Newest to catch fresh inventory** — pair Newest with a scheduled run to surface listings the moment they appear.
- **Combine locations and URLs** — mix several Search Locations and pasted URLs in a single run; `maxResults` caps the combined total.

### Pricing

**From $2.50 per 1,000 results** — a clean pay-per-result rate that undercuts comparable HotPads scrapers. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|--------:|------------:|-------:|-------:|-----:|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is any listing row in the output dataset. Platform fees are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate rental-market research, relocation support, and lead generation. You are responsible for complying with applicable laws and HotPads' Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and be mindful of fair housing regulations when working with rental and location data. </content> </invoke>

# Actor input Schema

## `searchLocations` (type: `array`):

Search for rentals by typing a city or ZIP code (e.g. 'Austin, TX' or '78701'). To target a specific neighborhood, pan/zoom the HotPads map to it and paste that URL under HotPads URLs instead. No need to build URLs manually. The filters below apply to these searches.

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

Paste HotPads URLs directly. Works with search-results pages (city, neighborhood, or property-type pages) and individual listing pages. The location and property type built into the URL are honored. Price, bedroom, bathroom, and pet filters are NOT read from the URL — if you need those, use a Search Location with the Filters section below instead of pasting a filtered URL.

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

Only return this kind of rental. Applies to Search Locations only — ignored for pasted URLs.

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

Only return listings at or above this monthly rent. Leave blank for no minimum.

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

Only return listings at or below this monthly rent. Leave blank for no maximum.

## `minBedrooms` (type: `integer`):

Fewest bedrooms to include. Use 0 to include studios. Leave blank for no minimum.

## `maxBedrooms` (type: `integer`):

Most bedrooms to include. Leave blank for no maximum.

## `minBathrooms` (type: `number`):

Fewest bathrooms to include (half-baths allowed, e.g. 1.5). Leave blank for no minimum.

## `petPolicy` (type: `string`):

Only return listings that allow the selected pets. Applies to Search Locations only.

## `sortBy` (type: `string`):

Order in which listings are collected. Applies to Search Locations only. Price sorting ranks up to about 3,000 listings per location before ordering — for markets larger than that, sort a smaller area (a ZIP code, or a pasted HotPads map URL) or add filters.

## `maxResults` (type: `integer`):

Maximum number of listings to return across all locations and URLs combined. Set to 0 to collect all available, up to 50,000 per run. Each location returns up to about 8,000 listings — split very large markets (e.g. New York) across ZIP codes or smaller pasted HotPads map areas to go beyond that. When sorting by price, up to about 3,000 listings per location are ranked. Tip: start with 20-50 to test, then increase.

## `includeListingDetails` (type: `boolean`):

Open each listing to collect the full record: all photos, amenities, unit floorplans, nearby schools, pet fees, and description. Slower but much richer. When off, only the data shown on search cards is returned.

## Actor input object example

```json
{
  "searchLocations": [
    "Austin, TX"
  ],
  "startUrls": [],
  "propertyType": "any",
  "petPolicy": "any",
  "sortBy": "best_match",
  "maxResults": 100,
  "includeListingDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped rental listings with key fields.

# 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 = {
    "searchLocations": [
        "Austin, TX"
    ],
    "startUrls": [],
    "propertyType": "any",
    "petPolicy": "any",
    "sortBy": "best_match",
    "maxResults": 100,
    "includeListingDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/hotpads-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 = {
    "searchLocations": ["Austin, TX"],
    "startUrls": [],
    "propertyType": "any",
    "petPolicy": "any",
    "sortBy": "best_match",
    "maxResults": 100,
    "includeListingDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/hotpads-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 '{
  "searchLocations": [
    "Austin, TX"
  ],
  "startUrls": [],
  "propertyType": "any",
  "petPolicy": "any",
  "sortBy": "best_match",
  "maxResults": 100,
  "includeListingDetails": true
}' |
apify call solidcode/hotpads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HotPads Rental Scraper",
        "description": "[💰 $2.5 / 1K] Scrape HotPads rental listings by city, ZIP, map area, or URL. Get rent, beds, baths, sqft, address, coordinates, amenities, photos, pet policy, and property-manager contacts for apartments, houses, condos & rooms.",
        "version": "1.0",
        "x-build-id": "Y075xSspGFSmTDjLV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~hotpads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-hotpads-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/solidcode~hotpads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-hotpads-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/solidcode~hotpads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-hotpads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "Search for rentals by typing a city or ZIP code (e.g. 'Austin, TX' or '78701'). To target a specific neighborhood, pan/zoom the HotPads map to it and paste that URL under HotPads URLs instead. No need to build URLs manually. The filters below apply to these searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "HotPads URLs",
                        "type": "array",
                        "description": "Paste HotPads URLs directly. Works with search-results pages (city, neighborhood, or property-type pages) and individual listing pages. The location and property type built into the URL are honored. Price, bedroom, bathroom, and pet filters are NOT read from the URL — if you need those, use a Search Location with the Filters section below instead of pasting a filtered URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "apartment",
                            "house",
                            "condo",
                            "townhome",
                            "room",
                            "multifamily"
                        ],
                        "type": "string",
                        "description": "Only return this kind of rental. Applies to Search Locations only — ignored for pasted URLs."
                    },
                    "minPrice": {
                        "title": "Minimum Rent (USD / month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings at or above this monthly rent. Leave blank for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Rent (USD / month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings at or below this monthly rent. Leave blank for no maximum."
                    },
                    "minBedrooms": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Fewest bedrooms to include. Use 0 to include studios. Leave blank for no minimum."
                    },
                    "maxBedrooms": {
                        "title": "Maximum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Most bedrooms to include. Leave blank for no maximum."
                    },
                    "minBathrooms": {
                        "title": "Minimum Bathrooms",
                        "minimum": 0,
                        "type": "number",
                        "description": "Fewest bathrooms to include (half-baths allowed, e.g. 1.5). Leave blank for no minimum."
                    },
                    "petPolicy": {
                        "title": "Pet Policy",
                        "enum": [
                            "any",
                            "dogs",
                            "cats",
                            "dogs_and_cats"
                        ],
                        "type": "string",
                        "description": "Only return listings that allow the selected pets. Applies to Search Locations only."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "best_match",
                            "newest",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Order in which listings are collected. Applies to Search Locations only. Price sorting ranks up to about 3,000 listings per location before ordering — for markets larger than that, sort a smaller area (a ZIP code, or a pasted HotPads map URL) or add filters."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all locations and URLs combined. Set to 0 to collect all available, up to 50,000 per run. Each location returns up to about 8,000 listings — split very large markets (e.g. New York) across ZIP codes or smaller pasted HotPads map areas to go beyond that. When sorting by price, up to about 3,000 listings per location are ranked. Tip: start with 20-50 to test, then increase."
                    },
                    "includeListingDetails": {
                        "title": "Include Full Listing Details",
                        "type": "boolean",
                        "description": "Open each listing to collect the full record: all photos, amenities, unit floorplans, nearby schools, pet fees, and description. Slower but much richer. When off, only the data shown on search cards is returned."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
