# Zumper Rental Scraper (`solidcode/zumper-scraper`) Actor

\[💰 $12 / 1K] Extract rental listings from Zumper by city/state or URL. Get prices, addresses, geo-coordinates, beds/baths, amenities, pet policies, ratings, agent phone and photos.

- **URL**: https://apify.com/solidcode/zumper-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $12.00 / 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.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

## Zumper Scraper

Pull rental listings from Zumper at scale across the United States and Canada — full addresses, geo coordinates, monthly rent ranges, bed/bath ranges, amenities, pet policies, listing-agent phone numbers, and high-res photo galleries for every apartment, house, condo, townhome, or room. Built for real-estate investors, relocation services, and rental-market analysts who need fresh, structured listing data without copying it off the map one pin at a time.

### Why This Scraper?

- **Every listing in a city, not just page one** — recursive map-area coverage walks the whole metro and harvests far past the visible map's pin limit, so a dense market like San Francisco or Toronto returns its full inventory instead of the first 50 results.
- **Five property types** — apartments, houses, condos, townhomes, and rooms, each as its own filtered search.
- **Geo coordinates and neighborhood on every row** — exact latitude/longitude plus neighborhood name, ready to plot on a map or join to demographic data.
- **Min/max rent and bed/bath ranges** — multi-floorplan buildings collapse into one clean row carrying `priceMin`/`priceMax`, `bedsMin`/`bedsMax`, and `bathsMin`/`bathsMax` instead of dozens of near-duplicate unit rows.
- **Listing-agent name and phone where published** — capture the listing agent's name and direct phone, plus the brokerage / property-management name, for every rental that publishes them.
- **Real high-res photo gallery URLs** — every listing's full set of 1280×960 image URLs plus a photo count, not opaque internal image IDs.
- **Airbnb-friendly sublet filter** — narrow to rentals that explicitly allow short-term / Airbnb subletting in a single toggle.
- **US + Canada coverage** — search any city in either country by typing "City, ST" or pasting a Zumper URL; no slug-building required.
- **No repeated listings** — overlapping map areas are de-duplicated automatically, so the same building never lands in your dataset twice.

### Use Cases

**Real Estate Investment & Analysis**
- Benchmark asking rents by neighborhood using min/max rent ranges
- Track inventory depth in a target metro over time
- Compare rent per bedroom across cities and property types
- Spot Airbnb-friendly buildings for short-term-rental underwriting

**Relocation & Rental Services**
- Build curated listing shortlists for clients moving to a new city
- Filter by monthly budget and bedroom count in one pass
- Surface move-in-ready units by availability date
- Mirror a saved Zumper search by pasting its URL

**Market Research**
- Map rental supply by neighborhood with exact coordinates
- Compare apartments vs. houses vs. condos across markets
- Measure how pet policies and amenities vary by area
- Analyze price spreads in multi-floorplan buildings

**Lead Generation**
- Build listing-agent contact lists with name, phone, and brokerage
- Target property managers in specific cities
- Identify newly available rentals for outreach
- Assemble brokerage-level coverage maps for a metro

### Getting Started

#### Search by Location

The simplest way to start — just a city and state or province:

```json
{
    "searchLocations": ["San Francisco, CA"],
    "maxResults": 50
}
````

#### Filtered Search

Narrow to two-bedroom houses within a monthly budget across several cities:

```json
{
    "searchLocations": ["Austin, TX", "Denver, CO"],
    "propertyType": "houses",
    "minPrice": 1500,
    "maxPrice": 3500,
    "minBeds": 2,
    "maxBeds": 3,
    "maxResults": 200
}
```

#### Using a Zumper URL

Paste any Zumper search URL — filters baked into the URL are applied automatically:

```json
{
    "startUrls": ["https://www.zumper.com/apartments-for-rent/san-francisco-ca/price-2000,4000"],
    "maxResults": 100
}
```

#### Full-Featured Example

```json
{
    "searchLocations": ["Toronto, ON", "Miami, FL"],
    "propertyType": "condos",
    "minPrice": 1800,
    "minBeds": 1,
    "airbnbFriendly": true,
    "maxResults": 500,
    "includeDetails": true,
    "includePhotos": true
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Zumper search or listing URLs directly. Any filters already in the URL (price, beds, property type) are applied automatically. The search filters below do **not** apply to URLs — everything comes from the URL itself. |
| `searchLocations` | string\[] | `["San Francisco, CA"]` | Search by typing a city and state or province (e.g. "San Francisco, CA" or "Toronto, ON"). No need to build URLs manually. The filters below apply to these searches. |

#### Search Filters

These apply to Search Locations only. When using URLs, all filters come from the URL itself.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `propertyType` | select | `Apartments` | What kind of rentals to find: Apartments, Houses, Condos, Townhomes, or Rooms. |
| `minPrice` | integer | — | Only return rentals at or above this monthly rent. Leave empty for no minimum. |
| `maxPrice` | integer | — | Only return rentals at or below this monthly rent. Leave empty for no maximum. |
| `minBeds` | integer | — | Fewest bedrooms (0 = studio). Leave empty for any. |
| `maxBeds` | integer | — | Most bedrooms (0 = studio). Leave empty for any. |
| `airbnbFriendly` | boolean | `false` | Only return rentals that allow short-term / Airbnb subletting. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited. You may get slightly more than this number — never fewer. Start with 10–50 to test, then increase. |
| `includeDetails` | boolean | `true` | Fetch each listing's full detail page to add amenities, pet policy, agent name and phone, description, exact square footage, and availability date. Turn off for a much faster, lighter run that still returns address, location, price, beds/baths, and photos. |
| `includePhotos` | boolean | `true` | Include the listing photo URLs and photo count for each rental. |

### Output

Each rental is one flat row. Here's a representative result with full details and photos enabled:

```json
{
    "source": "zumper.com",
    "scrapedAt": "2026-06-27T14:30:00Z",
    "listingId": "12345678",
    "url": "https://www.zumper.com/address/123-market-st-san-francisco-ca-94103",
    "name": "The Market Lofts",
    "address": "123 Market St, San Francisco, CA 94103",
    "street": "123 Market St",
    "city": "San Francisco",
    "state": "CA",
    "zipcode": "94103",
    "neighborhood": "SoMa",
    "latitude": 37.7929,
    "longitude": -122.3971,
    "priceMin": 2950,
    "priceMax": 4800,
    "bedsMin": 0,
    "bedsMax": 2,
    "bathsMin": 1,
    "bathsMax": 2,
    "squareFeet": 1100,
    "rating": 8.6,
    "propertyType": "apartments",
    "amenities": ["In-unit Laundry", "Dishwasher", "Roof Deck", "Fitness Center"],
    "petsAllowed": ["cats", "dogs"],
    "phone": "4155551234",
    "agentName": "Jane Doe",
    "brokerageName": "Bay Area Property Group",
    "feedName": "Listed by management",
    "dateAvailable": "2026-07-01",
    "description": "Bright SoMa lofts with floor-to-ceiling windows, in-unit laundry, and a shared roof deck...",
    "hasFees": false,
    "airbnbFriendly": false,
    "photos": [
        "https://img.zumpercdn.com/abc123/1280x960",
        "https://img.zumpercdn.com/def456/1280x960"
    ],
    "photoCount": 24
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `source` | string | Always "zumper.com" |
| `scrapedAt` | string | ISO timestamp of data extraction |
| `listingId` | string | Unique Zumper listing identifier |
| `url` | string | Direct Zumper listing URL |
| `name` | string | Building or listing name |
| `propertyType` | string | apartments, houses, condos, townhomes, or rooms |
| `description` | string | Full listing description (with details on) |
| `rating` | number | Property / landlord rating, 0–10 (when available) |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Full street address |
| `street` | string | Street line |
| `city` | string | City |
| `state` | string | State or province code |
| `zipcode` | string | Postal code |
| `neighborhood` | string | Neighborhood name |
| `latitude` | number | Geo latitude |
| `longitude` | number | Geo longitude |

#### Pricing, Beds, Baths & Size

| Field | Type | Description |
|-------|------|-------------|
| `priceMin` | integer | Lowest monthly rent in the building |
| `priceMax` | integer | Highest monthly rent in the building |
| `bedsMin` | integer | Fewest bedrooms (0 = studio) |
| `bedsMax` | integer | Most bedrooms |
| `bathsMin` | number | Fewest bathrooms |
| `bathsMax` | number | Most bathrooms |
| `squareFeet` | number | Living area in square feet (with details on) |

#### Amenities, Policies & Availability

| Field | Type | Description |
|-------|------|-------------|
| `amenities` | string\[] | Human-readable amenity tags (with details on) |
| `petsAllowed` | string\[] / string | Pet policy or allowed pet types |
| `dateAvailable` | string | Availability / move-in date (with details on) |
| `hasFees` | boolean | Whether application or broker fees apply |
| `airbnbFriendly` | boolean | Short-term / Airbnb subletting allowed |

#### Agent Contact & Photos

| Field | Type | Description |
|-------|------|-------------|
| `agentName` | string | Listing agent name (with details on) |
| `phone` | string | Contact phone number |
| `brokerageName` | string | Brokerage or property-management name |
| `feedName` | string | Listing feed source |
| `photos` | string\[] | High-res photo URLs (with photos on) |
| `photoCount` | integer | Number of photos |

### Tips for Best Results

- **Start small** — set `maxResults` to 10–50 on your first run to confirm the data matches your needs, then scale up to harvest the full market.
- **Harvest a whole metro** — pair a dense city with a high `maxResults` (or 0 for unlimited); the map-area coverage keeps subdividing until the entire city's inventory is pulled, well past the map's visible pin limit.
- **Toggle details for speed vs. depth** — turn off `includeDetails` for fast, lightweight runs that still return address, location, rent, beds/baths, and photos. Turn it on for amenities, pet policy, agent contacts, square footage, and availability dates.
- **Detail-rich fields are pulled where the listing provides them** — agent name and phone, amenities, description, square footage, and availability come from each listing's detail page, so coverage varies by market and by how complete the listing is; the densest metros may return these for a subset of listings while core fields (address, rent, beds/baths, photos) are always present.
- **Mirror a saved search with URL mode** — paste a Zumper search URL to reproduce filters exactly as they appear on the site; price, bed, and property-type filters in the URL path are read automatically.
- **Widen filters if a search comes back empty** — a tight price or bedroom range on a smaller market can return nothing; loosen the range or remove a filter and re-run.
- **Townhomes share the houses pool** — Zumper has no separate townhome listing source, so choosing Townhomes returns the same results as Houses (townhomes are a subset of houses).
- **Mix cities and URLs in one run** — combine several Search Locations with one or more Zumper URLs to cover multiple markets in a single dataset.

### Pricing

**From $12 per 1,000 results** — a flat pay-per-result rate that undercuts the going market rate for Zumper rental data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.44 | $1.36 | $1.28 | $1.20 |
| 1,000 | $14.40 | $13.55 | $12.75 | $12.00 |
| 10,000 | $144.00 | $135.50 | $127.50 | $120.00 |
| 100,000 | $1,440.00 | $1,355.00 | $1,275.00 | $1,200.00 |

A "result" is any rental listing row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### 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 services, and lead generation. Users are responsible for complying with applicable laws and Zumper's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose. Be mindful of fair housing regulations and personal-data rules when using listing and agent-contact data. </content> </invoke>

# Actor input Schema

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

Paste Zumper search or listing URLs directly (e.g. https://www.zumper.com/apartments-for-rent/san-francisco-ca). Any filters already in the URL (price, beds, property type) are applied automatically. The search filters below do NOT apply to URLs — everything comes from the URL itself.

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

Search by typing a city and state (e.g. 'San Francisco, CA' or 'Austin, TX'). No need to build URLs manually. The filters below apply to these searches.

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

What kind of rentals to find. Only applies to Search Locations — ignored when using URLs (the URL determines its own type). Note: Zumper has no separate townhome listing pool, so 'Townhomes' returns the same results as 'Houses' (townhomes are a subset of houses).

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

Only return rentals at or above this monthly rent. Leave empty for no minimum.

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

Only return rentals at or below this monthly rent. Leave empty for no maximum.

## `minBeds` (type: `integer`):

Fewest bedrooms (0 = studio). Leave empty for any.

## `maxBeds` (type: `integer`):

Most bedrooms (0 = studio). Leave empty for any.

## `airbnbFriendly` (type: `boolean`):

Only return rentals that allow short-term / Airbnb subletting.

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

Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (up to a 100,000-listing safety ceiling). The scraper finishes the page it is on when the cap is reached, so you may get slightly more than this number — never fewer. Tip: start with 10-50 to test, then increase.

## `includeDetails` (type: `boolean`):

Fetch the full detail page for each listing to add amenities, pet policy, agent name and phone, description, exact square footage and availability date. Turn OFF for a much faster, lighter run that still returns address, location, price, beds/baths and photos.

## `includePhotos` (type: `boolean`):

Include the listing photo URLs and photo count for each rental.

## Actor input object example

```json
{
  "startUrls": [],
  "searchLocations": [
    "San Francisco, CA"
  ],
  "propertyType": "apartments",
  "airbnbFriendly": false,
  "maxResults": 100,
  "includeDetails": true,
  "includePhotos": 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 = {
    "startUrls": [],
    "searchLocations": [
        "San Francisco, CA"
    ],
    "propertyType": "apartments",
    "maxResults": 100,
    "includeDetails": true,
    "includePhotos": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/zumper-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [],
    "searchLocations": ["San Francisco, CA"],
    "propertyType": "apartments",
    "maxResults": 100,
    "includeDetails": True,
    "includePhotos": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/zumper-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "searchLocations": [
    "San Francisco, CA"
  ],
  "propertyType": "apartments",
  "maxResults": 100,
  "includeDetails": true,
  "includePhotos": true
}' |
apify call solidcode/zumper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zumper Rental Scraper",
        "description": "[💰 $12 / 1K] Extract rental listings from Zumper by city/state or URL. Get prices, addresses, geo-coordinates, beds/baths, amenities, pet policies, ratings, agent phone and photos.",
        "version": "1.0",
        "x-build-id": "iEme28ha67dyyDibq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~zumper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-zumper-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~zumper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-zumper-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~zumper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-zumper-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Zumper URLs",
                        "type": "array",
                        "description": "Paste Zumper search or listing URLs directly (e.g. https://www.zumper.com/apartments-for-rent/san-francisco-ca). Any filters already in the URL (price, beds, property type) are applied automatically. The search filters below do NOT apply to URLs — everything comes from the URL itself.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "Search by typing a city and state (e.g. 'San Francisco, CA' or 'Austin, TX'). No need to build URLs manually. The filters below apply to these searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "apartments",
                            "houses",
                            "condos",
                            "townhomes",
                            "rooms"
                        ],
                        "type": "string",
                        "description": "What kind of rentals to find. Only applies to Search Locations — ignored when using URLs (the URL determines its own type). Note: Zumper has no separate townhome listing pool, so 'Townhomes' returns the same results as 'Houses' (townhomes are a subset of houses).",
                        "default": "apartments"
                    },
                    "minPrice": {
                        "title": "Minimum Price ($/month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return rentals at or above this monthly rent. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price ($/month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return rentals at or below this monthly rent. Leave empty for no maximum."
                    },
                    "minBeds": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Fewest bedrooms (0 = studio). Leave empty for any."
                    },
                    "maxBeds": {
                        "title": "Maximum Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Most bedrooms (0 = studio). Leave empty for any."
                    },
                    "airbnbFriendly": {
                        "title": "Airbnb-Friendly Only",
                        "type": "boolean",
                        "description": "Only return rentals that allow short-term / Airbnb subletting.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (up to a 100,000-listing safety ceiling). The scraper finishes the page it is on when the cap is reached, so you may get slightly more than this number — never fewer. Tip: start with 10-50 to test, then increase.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Details",
                        "type": "boolean",
                        "description": "Fetch the full detail page for each listing to add amenities, pet policy, agent name and phone, description, exact square footage and availability date. Turn OFF for a much faster, lighter run that still returns address, location, price, beds/baths and photos.",
                        "default": true
                    },
                    "includePhotos": {
                        "title": "Include Photos",
                        "type": "boolean",
                        "description": "Include the listing photo URLs and photo count for each rental.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
