# Rent.com Scraper (`haketa/rent-com-scraper`) Actor

Scrape rental listings from Rent.com — apartments, houses, condos and townhouses across all US cities. Extract rent prices, floor plans, amenities, pet policies, parking, photos, phone numbers and availability. Filter by city, price range, bedrooms and property type.

- **URL**: https://apify.com/haketa/rent-com-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.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

## Rent.com Scraper

Scrape rental listings from **[Rent.com](https://www.rent.com)** and extract structured data on apartments, houses, condos and townhouses across all US cities. Get rent prices, floor plans, amenities, pet policies, parking info, photos and contact phone numbers — ready for analysis, dashboards or integration with your CRM, ATS or database.

### Why use Rent.com Scraper?

Rent.com is one of the largest US rental marketplaces with **28,000+ listings per major city**. This scraper gives you programmatic access to all that data without manual copy-paste or expensive third-party APIs.

- **No browser needed** — direct HTML parsing, fast and cost-efficient
- **Two scraping modes** — quick listing scan or deep detail extraction
- **Built-in filters** — narrow by city, price range, bedrooms and property type before scraping
- **Structured output** — clean JSON/CSV ready for Excel, Google Sheets, Python, SQL or any BI tool

### What data can you extract from Rent.com?

#### Listing mode (fast — ~30 listings per request)

Every listing includes: property name, full address, city, state, ZIP code, GPS coordinates, monthly rent range, bedroom and bathroom counts, square footage, availability status, available unit count, pet-friendly flag, contact phone number, photo count and direct listing URL.

#### Detail mode (rich — 1 extra request per listing)

Enable `scrapeDetails` to also get: floor plans with unit-level beds/baths/availability, full amenity list (20-30 items per property), pet policy with deposit and weight limits, parking type and fees, special deals and promotions, property description, up to 50 photo URLs, and neighborhood names.

### How much does Rent.com Scraper cost?

| Mode | Speed | Approximate cost |
|---|---|---|
| Listings only | ~30 listings/request | **~$1.50 per 1,000 listings** |
| With details | +1 request per listing | **~$5 per 1,000 listings** |

Platform usage (Apify compute units) is billed separately. Listing-only mode is extremely efficient — one page fetch returns ~30 properties.

### Example output

#### Listing mode

```json
{
  "propertyId": "lc5930006",
  "propertyName": "Hillside Creek",
  "address": "1730 E Oltorf St",
  "city": "Austin",
  "state": "TX",
  "zipCode": "78741",
  "latitude": 30.233092,
  "longitude": -97.73785,
  "propertyType": "APARTMENTS",
  "rentMin": 739,
  "rentMax": 1653,
  "bedsMin": 1,
  "bedsMax": 2,
  "bathsMin": 1,
  "bathsMax": 2,
  "sqftMin": 606,
  "sqftMax": 1042,
  "availabilityStatus": "10+ Units Available",
  "totalAvailable": 21,
  "petFriendly": true,
  "phoneNumber": "(737) 497-0381",
  "photoCount": 21,
  "listingUrl": "https://www.rent.com/apartment/hillside-creek-austin-tx-lc5930006"
}
````

#### Detail mode (additional fields)

```json
{
  "neighborhood": "East Riverside - Oltorf, Riverside",
  "specialDeals": [
    "$500 GIFT CARD + MOVE-IN SAVINGS Tour today and apply within 48 hours..."
  ],
  "amenities": [
    "Pool", "Fitness Center", "Club House", "Pet Friendly",
    "Walk-in Closet", "Dishwasher", "Patio", "Jogging Walking Trails"
  ],
  "floorPlans": [
    { "name": "1 Bd", "beds": 1, "baths": 1, "availableCount": 6 },
    { "name": "2 Bd", "beds": 2, "baths": 2, "availableCount": 2 }
  ],
  "petPolicy": "Dogs Allowed | Max 2 pets | Weight limit: 75 | Deposit: $250 | +$25/mo",
  "parkingInfo": "Covered Lot",
  "description": "Hillside Creek offers convenient living in the creative heart of Austin...",
  "photos": [
    "https://photos.rent.com/876f8112e12d5f5a43d25c6aef3b9ff2",
    "https://photos.rent.com/c761174462ca39aab0a95dccf9cce4f6"
  ]
}
```

### Input parameters

#### Quick start — just set a city and run

```json
{
  "cities": ["austin-texas"],
  "maxListings": 100
}
```

#### Full input reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | `[]` | Direct Rent.com search URLs — overrides city inputs |
| `cities` | array | `[]` | City-state slugs: `austin-texas`, `chicago-illinois` |
| `propertyType` | string | `apartments` | `apartments`, `houses_condos`, `luxury-apartments`, `apartments_townhouses_condos_houses`, `cheap-apartments` |
| `minPrice` | integer | `0` | Minimum monthly rent ($). 0 = no minimum |
| `maxPrice` | integer | `0` | Maximum monthly rent ($). 0 = no maximum |
| `minBeds` | integer | `0` | Minimum bedrooms. 0 = studio/any |
| `maxBeds` | integer | `0` | Maximum bedrooms. 0 = no limit |
| `scrapeDetails` | boolean | `false` | Fetch detail pages for amenities, floor plans, photos, phone |
| `maxListings` | integer | `200` | Total listing cap. 0 = unlimited |
| `maxPages` | integer | `25` | Pages per city (~30 listings/page) |
| `requestDelay` | integer | `800` | Delay between requests (ms) |
| `maxConcurrency` | integer | `1` | Parallel requests (keep 1-3) |

#### City slug format

Use `{city-name}-{state-name}` in lowercase with hyphens:

`austin-texas` · `los-angeles-california` · `new-york-city-new-york` · `chicago-illinois` · `miami-florida` · `seattle-washington` · `denver-colorado` · `san-francisco-california` · `nashville-tennessee` · `portland-oregon` · `dallas-texas` · `houston-texas` · `phoenix-arizona` · `atlanta-georgia` · `boston-massachusetts`

#### Advanced: direct URL input

Pass any valid Rent.com search URL for filters not exposed in the input schema:

```json
{
  "searchUrls": [
    "https://www.rent.com/california/los-angeles/luxury-apartments",
    "https://www.rent.com/texas/austin/houses_condos"
  ]
}
```

### How to scrape Rent.com rental listings

1. Click **Try for free** to open Rent.com Scraper in Apify Console
2. Enter one or more US cities (e.g. `austin-texas`)
3. Choose a property type and optional price/bedroom filters
4. Set `scrapeDetails` to `true` if you need amenities, floor plans and photos
5. Click **Start** and download results as JSON, CSV, Excel or via API

You can also run Rent.com Scraper programmatically via the [Apify API](https://docs.apify.com/api/v2), schedule recurring runs, or integrate with Zapier, Make, Google Sheets and 100+ other platforms.

### Use cases for Rent.com data

**Rental market analysis** — Track average rent by city, neighborhood and property type. Run weekly scheduled scrapes to monitor trends and seasonal fluctuations.

**Competitive intelligence** — Property management companies use Rent.com Scraper to monitor competitor pricing, vacancy rates and special deals across their markets.

**Investment research** — Compare rent-to-price ratios across cities. Identify neighborhoods with low vacancy and rising rents before making acquisition decisions.

**Relocation & HR** — Corporate relocation teams survey housing costs for employee transfers. Generate city-by-city rent reports with real listings data.

**Proptech & data products** — Power rent indices, affordability calculators, market dashboards and API services with structured Rent.com data.

**Lead generation** — Extract property manager phone numbers and listing details to build outreach lists for real estate services, moving companies or insurance providers.

### Output fields reference

| Field | Source | Description |
|---|---|---|
| `propertyId` | Listing | Rent.com listing ID |
| `propertyName` | Listing | Building or community name |
| `address` | Listing + LD+JSON | Street address |
| `city`, `state`, `zipCode` | Listing | Location |
| `neighborhood` | Detail | Neighborhood names |
| `latitude`, `longitude` | Listing | GPS coordinates |
| `propertyType` | Listing | APARTMENTS, HOUSES, CONDOS, etc. |
| `rentMin`, `rentMax` | Listing | Monthly rent range ($) |
| `bedsMin`, `bedsMax` | Listing | Bedroom count range |
| `bathsMin`, `bathsMax` | Listing | Bathroom count range |
| `sqftMin`, `sqftMax` | Listing | Square footage range |
| `availabilityStatus` | Listing | "10+ Units Available", "3 Units Available" |
| `totalAvailable` | Listing | Exact available unit count |
| `specialDeals` | Detail | Promotions and move-in deals |
| `petFriendly` | Listing | Pet-friendly flag |
| `phoneNumber` | Listing | Contact phone |
| `amenities` | Detail | Full amenity list (Pool, Gym, etc.) |
| `floorPlans` | Detail | Unit types with beds, baths, availability |
| `petPolicy` | Detail | Pet restrictions, deposits and fees |
| `parkingInfo` | Detail | Parking type and cost |
| `deposit` | Detail | Application or admin fee |
| `description` | Detail | Full property description |
| `photoCount` | Listing | Number of photos |
| `photos` | Detail | Photo URLs (up to 50) |
| `listingUrl` | Listing | Direct link to listing page |

### Tips for best results

- **Start with listing mode** — it's 5x cheaper and gives you rent, location, beds, phone and availability. Enable detail mode only when you need amenities and floor plans.
- **Use residential proxies** — Rent.com blocks datacenter IPs. The default proxy config uses Apify residential proxies.
- **Filter before scraping** — use `minPrice`, `maxPrice`, `minBeds` to reduce noise and save compute.
- **Schedule weekly runs** — set up a recurring schedule to track rent changes over time.

### Integrations

Rent.com Scraper works with the full Apify ecosystem:

- **API** — call programmatically from Python, Node.js, PHP or any language
- **Webhooks** — trigger actions when a run completes
- **Google Sheets** — export results directly to a spreadsheet
- **Zapier / Make** — connect to 5,000+ apps and automate workflows
- **Slack / Email** — get notifications on new listings or price changes

### Limitations

- US rental listings only (Rent.com covers the United States)
- Phone numbers and amenities require `scrapeDetails: true`
- Some listings may have incomplete data depending on what the property manager uploaded
- Rate limiting may occur with high concurrency — keep `maxConcurrency` at 1-3

# Actor input Schema

## `searchUrls` (type: `array`):

Direct Rent.com search URLs. If provided, city/state inputs are ignored. Examples: 'https://www.rent.com/texas/austin-apartments', 'https://www.rent.com/california/los-angeles/luxury-apartments'.

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

City names with state. Format: 'city-state' as URL slug. Examples: 'austin-texas', 'los-angeles-california', 'new-york-city-new-york', 'chicago-illinois'. Ignored if searchUrls is provided.

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

Type of property to search. Only used with cities input, ignored for searchUrls.

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

Minimum monthly rent filter. Leave 0 for no minimum.

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

Maximum monthly rent filter. Leave 0 for no maximum.

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

Minimum bedroom count. 0 = studio/any.

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

Maximum bedroom count. 0 = no limit.

## `scrapeDetails` (type: `boolean`):

Fetch each listing's detail page for floor plans, amenities, phone number, photos and full description. Increases run time and cost.

## `maxListings` (type: `integer`):

Maximum total listings to scrape across all searches. Set 0 for unlimited.

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

Maximum pages per city search. Each page returns ~20-30 listings.

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

Proxy settings. Residential proxies recommended for Rent.com.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds.

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

Parallel requests. Keep low (1-3) to avoid blocks.

## Actor input object example

```json
{
  "searchUrls": [],
  "cities": [
    "austin-texas",
    "los-angeles-california"
  ],
  "propertyType": "apartments",
  "minPrice": 0,
  "maxPrice": 0,
  "minBeds": 0,
  "maxBeds": 0,
  "scrapeDetails": false,
  "maxListings": 200,
  "maxPages": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 800,
  "maxConcurrency": 1
}
```

# Actor output Schema

## `propertyId` (type: `string`):

Rent.com listing ID

## `propertyName` (type: `string`):

Building or community name

## `address` (type: `string`):

Street address

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

City name

## `state` (type: `string`):

State abbreviation (TX, CA, NY etc.)

## `zipCode` (type: `string`):

ZIP / postal code

## `neighborhood` (type: `string`):

Neighborhood or area name

## `latitude` (type: `string`):

GPS latitude

## `longitude` (type: `string`):

GPS longitude

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

apartment / house / condo / townhouse

## `rentMin` (type: `string`):

Minimum monthly rent

## `rentMax` (type: `string`):

Maximum monthly rent

## `bedsMin` (type: `string`):

Minimum bedroom count (0 = studio)

## `bedsMax` (type: `string`):

Maximum bedroom count

## `bathsMin` (type: `string`):

Minimum bathroom count

## `bathsMax` (type: `string`):

Maximum bathroom count

## `sqftMin` (type: `string`):

Minimum square footage

## `sqftMax` (type: `string`):

Maximum square footage

## `availabilityStatus` (type: `string`):

Available / Waitlist / Contact

## `specialDeals` (type: `string`):

Promotions (comma separated)

## `petFriendly` (type: `string`):

Property allows pets

## `phoneNumber` (type: `string`):

Contact phone number (detail page only)

## `amenities` (type: `string`):

Property amenities (comma separated)

## `floorPlans` (type: `string`):

Floor plan details JSON (detail page only)

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

Pet restrictions and deposits

## `parkingInfo` (type: `string`):

Parking type and cost

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

Minimum lease duration

## `deposit` (type: `string`):

Security deposit amount

## `description` (type: `string`):

Full listing description (detail page only)

## `photoCount` (type: `string`):

Number of listing photos

## `photos` (type: `string`):

Photo URLs (detail page only, comma separated)

## `rating` (type: `string`):

User rating (1-5)

## `reviewCount` (type: `string`):

Number of reviews

## `listingUrl` (type: `string`):

Detail page URL on Rent.com

## `searchCity` (type: `string`):

City used in search query

## `searchState` (type: `string`):

State used in search query

## `scrapedAt` (type: `string`):

ISO timestamp when scraped

# 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 = {
    "searchUrls": [],
    "cities": [
        "austin-texas",
        "los-angeles-california"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/rent-com-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 = {
    "searchUrls": [],
    "cities": [
        "austin-texas",
        "los-angeles-california",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/rent-com-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 '{
  "searchUrls": [],
  "cities": [
    "austin-texas",
    "los-angeles-california"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call haketa/rent-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rent.com Scraper",
        "description": "Scrape rental listings from Rent.com — apartments, houses, condos and townhouses across all US cities. Extract rent prices, floor plans, amenities, pet policies, parking, photos, phone numbers and availability. Filter by city, price range, bedrooms and property type.",
        "version": "0.0",
        "x-build-id": "sfW8J64oxzppUVQ37"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~rent-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-rent-com-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/haketa~rent-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-rent-com-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/haketa~rent-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-rent-com-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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Direct Rent.com search URLs. If provided, city/state inputs are ignored. Examples: 'https://www.rent.com/texas/austin-apartments', 'https://www.rent.com/california/los-angeles/luxury-apartments'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names with state. Format: 'city-state' as URL slug. Examples: 'austin-texas', 'los-angeles-california', 'new-york-city-new-york', 'chicago-illinois'. Ignored if searchUrls is provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "apartments",
                            "houses_condos",
                            "luxury-apartments",
                            "apartments_townhouses_condos_houses",
                            "cheap-apartments"
                        ],
                        "type": "string",
                        "description": "Type of property to search. Only used with cities input, ignored for searchUrls.",
                        "default": "apartments"
                    },
                    "minPrice": {
                        "title": "Min Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum monthly rent filter. Leave 0 for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum monthly rent filter. Leave 0 for no maximum.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum bedroom count. 0 = studio/any.",
                        "default": 0
                    },
                    "maxBeds": {
                        "title": "Max Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum bedroom count. 0 = no limit.",
                        "default": 0
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page for floor plans, amenities, phone number, photos and full description. Increases run time and cost.",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Max Listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings to scrape across all searches. Set 0 for unlimited.",
                        "default": 200
                    },
                    "maxPages": {
                        "title": "Max Pages per Search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum pages per city search. Each page returns ~20-30 listings.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies recommended for Rent.com."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds.",
                        "default": 800
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel requests. Keep low (1-3) to avoid blocks.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
