# Apartments.com Scraper (`haketa/apartments-com-scraper`) Actor

Scrape rental listings from Apartments.com — the largest US rental marketplace by CoStar Group. Extract rent prices, total monthly costs, floor plans, amenities, fees, pet policies, photos, phone numbers and availability. Filter by city, price range, bedrooms and property type.

- **URL**: https://apify.com/haketa/apartments-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 $3.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

## Apartments.com Scraper

Extract rental listings from **[Apartments.com](https://www.apartments.com)** — the largest US rental marketplace by CoStar Group with **37,000+ listings per major city**. Get rent prices, GPS coordinates, phone numbers, floor plans, amenities, fees, pet policies and photos without needing an API key.

### Why use Apartments.com Scraper?

Most rental scrapers give you just the advertised rent. Apartments.com Scraper captures **both base rent and total monthly cost** — including mandatory fees like trash ($57/mo), pest control ($3/mo) and package locker ($10-15/mo) that inflate the real price tenants pay.

No browser needed — pure HTTP requests with JSON-LD structured data extraction. Fast, lightweight and cost-efficient.

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

#### Listing mode (default — no detail pages needed)

Thanks to Apartments.com's rich JSON-LD structured data, the listing page alone provides: property name, full address, city/state/ZIP, **GPS coordinates (lat/lng)**, rent range, bedroom count, **phone number**, description, rent specials flag, and direct listing URL — all without visiting individual property pages.

#### Detail mode (enable `scrapeDetails`)

Fetch each listing's detail page for additional data: floor plans with unit-level pricing, full amenity list, pet policy with breed restrictions, parking type and cost, fees breakdown (application, admin, trash, pest control), total monthly cost, up to 50 photo URLs, rating and reviews, Walk/Transit/Bike scores, virtual tour link, year built, unit count, and management company.

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

| Mode | Speed | Approximate cost |
|---|---|---|
| Listings only | ~40 listings/page | **~$2 per 1,000 listings** |
| With details | +1 request per listing | **~$6 per 1,000 listings** |

### Example output

Every listing includes these fields from the listing page alone:

```json
{
  "propertyId": "4v6169l",
  "propertyName": "Ellwood at Lake Travis",
  "address": "7655 N Ranch Road 620",
  "city": "Austin",
  "state": "TX",
  "zipCode": "78726",
  "latitude": 30.40643,
  "longitude": -97.85038,
  "rentMin": 994,
  "rentMax": 1555,
  "bedsMin": 1,
  "bedsMax": 3,
  "phoneNumber": "737-237-9124",
  "description": "Ellwood at Lake Travis Apartments",
  "rentSpecials": true,
  "listingUrl": "https://www.apartments.com/ellwood-at-lake-travis-austin-tx/4v6169l/"
}
````

With `scrapeDetails` enabled, additional fields include:

```json
{
  "amenities": ["Resort Pool", "Fitness Center", "Yoga Studio", "Pet Spa"],
  "floorPlans": [
    { "name": "A1A", "beds": 1, "baths": 1, "sqft": 608, "rentMin": 1153, "rentMax": 1178 }
  ],
  "fees": {
    "application": "85",
    "admin": "250",
    "package_locker": "10-15/mo",
    "pest_control": "3/mo",
    "trash": "57/mo"
  },
  "petPolicy": "Dogs and cats welcome, 2 pet max, 50 lb limit",
  "petRestrictions": ["Akita", "Pit Bull", "Rottweiler"],
  "rating": 4.1,
  "reviewCount": 87,
  "walkScore": 42,
  "managementCompany": "Greystar"
}
```

### Input parameters

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

```json
{
  "cities": ["austin-tx"],
  "maxListings": 50
}
```

#### Full input reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | `[]` | Direct Apartments.com search URLs — overrides city inputs |
| `cities` | array | `[]` | City-state slugs: `austin-tx`, `new-york-ny`, `chicago-il` |
| `propertyType` | string | `all` | `all`, `apartments`, `houses`, `condos`, `townhomes` |
| `maxPrice` | integer | `0` | Max rent filter. Adds `/under-{price}/` to URL |
| `minBeds` | integer | `0` | Min bedrooms. 0 = studio/any |
| `rentSpecialsOnly` | boolean | `false` | Only listings with active promotions |
| `scrapeDetails` | boolean | `false` | Fetch detail pages for floor plans, amenities, fees |
| `maxListings` | integer | `100` | Total listing cap. 0 = unlimited |
| `maxPages` | integer | `20` | Pages per city (~40 listings/page) |
| `requestDelay` | integer | `1000` | Delay between requests (ms) |
| `maxConcurrency` | integer | `1` | Parallel requests (keep at 1) |

#### City slug format

Use the exact Apartments.com URL slug — `{city}-{state}` in lowercase:

`austin-tx` · `new-york-ny` · `los-angeles-ca` · `chicago-il` · `miami-fl` · `seattle-wa` · `denver-co` · `san-francisco-ca` · `nashville-tn` · `portland-or` · `dallas-tx` · `houston-tx` · `phoenix-az` · `atlanta-ga` · `boston-ma`

#### Advanced URL examples

```json
{
  "searchUrls": [
    "https://www.apartments.com/austin-tx/under-1000/",
    "https://www.apartments.com/austin-tx/rent-specials/",
    "https://www.apartments.com/onion-creek-austin-tx/",
    "https://www.apartments.com/off-campus-housing/tx/austin/university-of-texas-at-austin-austin-campus/"
  ]
}
```

### How to scrape Apartments.com listings

1. Click **Try for free** to open the scraper in Apify Console
2. Enter one or more US cities (e.g. `austin-tx`)
3. Set price and bedroom filters if needed
4. Enable `scrapeDetails` for floor plans, amenities, fees and photos
5. Click **Start** and download results as JSON, CSV or Excel

Run programmatically via [Apify API](https://docs.apify.com/api/v2), schedule recurring runs, or integrate with Zapier, Make, Google Sheets and 100+ platforms.

### Important: Rate limiting and proxy requirements

Apartments.com (CoStar Group) uses aggressive anti-bot protection. To get reliable results:

- **Residential proxies are required** — datacenter IPs are blocked immediately. The default input uses Apify's residential proxy group.
- **Keep `requestDelay` at 1500ms or higher** — lower values trigger 403 blocks after 1-2 pages. For large scrapes (200+ listings), use `requestDelay: 3000`.
- **Keep `maxConcurrency` at 1** — parallel requests almost always trigger rate limiting.
- **The scraper retries automatically** — if a page returns 403, it waits and retries up to 3 times with increasing delays. Occasional 403s on later pages are normal behavior.
- **For 100+ listings**, increase the delay to 2000-3000ms. The scraper will be slower but more reliable.

Recommended settings for large scrapes:

```json
{
  "cities": ["austin-tx"],
  "maxListings": 500,
  "maxPages": 15,
  "requestDelay": 3000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Use cases for Apartments.com data

**True cost analysis** — Compare base rent vs total monthly cost across properties. Identify complexes with high mandatory fees that inflate the real cost beyond advertised rent.

**Rental market intelligence** — Track rent trends by city, neighborhood and property type with scheduled weekly runs. Monitor 37,000+ listings per major metro.

**Competitive pricing** — Property managers monitor competitor rents, specials and vacancy signals across their markets.

**Investment due diligence** — Evaluate rent-to-price ratios, occupancy indicators and fee structures before acquisition decisions.

**Relocation planning** — HR teams generate city-by-city rent reports with real listing data, GPS coordinates and phone numbers for employee transfers.

**Proptech data feeds** — Power rent indices, affordability tools and market dashboards with structured Apartments.com data including coordinates for mapping.

**Pet-friendly housing** — Filter by pet policy, breed restrictions and pet fees for renters with animals.

**Campus housing** — Use campus proximity URLs to scrape off-campus housing near specific universities.

### Output fields reference

| Field | Source | Description |
|---|---|---|
| `propertyId` | Listing | Apartments.com listing ID |
| `propertyName` | Listing | Building or community name |
| `address` | Listing | Street address |
| `city`, `state`, `zipCode` | Listing | Location |
| `latitude`, `longitude` | Listing (JSON-LD) | GPS coordinates |
| `rentMin`, `rentMax` | Listing | Base monthly rent range ($) |
| `bedsMin`, `bedsMax` | Listing | Bedroom count range |
| `phoneNumber` | Listing (JSON-LD) | Contact phone number |
| `description` | Listing (JSON-LD) | Short property description |
| `rentSpecials` | Listing | Has active promotion |
| `listingUrl` | Listing | Direct link to property page |
| `amenities` | Detail | Full amenity list |
| `floorPlans` | Detail | Unit types with beds, baths, sqft, pricing |
| `fees` | Detail | Application, admin, recurring fees |
| `petPolicy` | Detail | Pet restrictions and fees |
| `petRestrictions` | Detail | Restricted breeds list |
| `parkingInfo` | Detail | Parking type and cost |
| `rating`, `reviewCount` | Detail | User rating and review count |
| `walkScore` | Detail | Walk Score (0-100) |
| `yearBuilt` | Detail | Construction year |
| `unitCount` | Detail | Total units in complex |
| `managementCompany` | Detail | Property management company |
| `photos` | Detail | Photo URLs (up to 50) |
| `virtualTour` | Detail | Virtual tour link |

### Integrations

Apartments.com Scraper works with the full Apify ecosystem: API access from Python/Node.js/PHP, webhooks, Google Sheets export, Zapier/Make automation, and Slack/email notifications.

### Limitations

- US listings only (Apartments.com covers the United States)
- Residential proxies required — datacenter IPs are blocked
- Floor plans, amenities and fees require `scrapeDetails: true`
- Rate limiting may slow down large scrapes — use higher request delays
- Some fee data is in HTML tables, not JSON-LD — coverage varies by listing

# Actor input Schema

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

Direct Apartments.com search URLs. If provided, city inputs are ignored. Examples: 'https://www.apartments.com/austin-tx/', 'https://www.apartments.com/austin-tx/under-1000/', 'https://www.apartments.com/austin-tx/rent-specials/'.

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

City-state slugs matching Apartments.com URL format. Examples: 'austin-tx', 'new-york-ny', 'los-angeles-ca', 'chicago-il', 'miami-fl'. Ignored if searchUrls is provided.

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

Type of property to search. Only used with cities input.

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

Maximum monthly rent. Adds '/under-{price}/' filter to URL. 0 = no limit. Common values: 700, 1000, 1500, 2000.

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

Minimum bedroom count. 0 = studio/any.

## `rentSpecialsOnly` (type: `boolean`):

Only scrape listings with active promotions/deals. Adds '/rent-specials/' filter.

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

Fetch each listing's detail page for JSON-LD data: floor plans, amenities, fees, pet policy, photos, coordinates, reviews. Increases run time and cost significantly.

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

Maximum total listings to scrape. Set 0 for unlimited.

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

Maximum pages per city search. Each page has ~20-25 listings.

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

Proxy settings. Residential proxies recommended — CoStar has anti-bot protection.

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

Delay between requests in milliseconds. Keep above 1500ms to avoid blocks.

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

Parallel requests. Keep at 1-2 — CoStar rate limits aggressively.

## Actor input object example

```json
{
  "searchUrls": [],
  "cities": [
    "austin-tx"
  ],
  "propertyType": "all",
  "maxPrice": 0,
  "minBeds": 0,
  "rentSpecialsOnly": false,
  "scrapeDetails": false,
  "maxListings": 10,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 1500,
  "maxConcurrency": 1
}
```

# Actor output Schema

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

Apartments.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

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

ZIP code

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

Neighborhood name

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

GPS latitude

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

GPS longitude

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

apartment / house / condo / townhouse

## `yearBuilt` (type: `string`):

Construction year

## `unitCount` (type: `string`):

Total units in complex

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

Base rent minimum

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

Base rent maximum

## `totalMonthlyMin` (type: `string`):

Total cost with mandatory fees

## `totalMonthlyMax` (type: `string`):

Total cost with mandatory fees

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

Minimum bedrooms (0=studio)

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

Maximum bedrooms

## `rentSpecials` (type: `string`):

Has active promotion

## `specialText` (type: `string`):

Promotion text

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

Allows pets

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

Pet restrictions and fees

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

Contact phone number

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

Property amenities

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

Unit types with specs

## `fees` (type: `string`):

Application, admin, recurring fees

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

Average rating (1-5)

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

Number of reviews

## `walkScore` (type: `string`):

Walk Score (0-100)

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

Detail page URL

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

ISO timestamp

# 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-tx"
    ],
    "maxListings": 10,
    "maxPages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "requestDelay": 1500
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/apartments-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-tx"],
    "maxListings": 10,
    "maxPages": 1,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "requestDelay": 1500,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/apartments-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-tx"
  ],
  "maxListings": 10,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 1500
}' |
apify call haketa/apartments-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apartments.com Scraper",
        "description": "Scrape rental listings from Apartments.com — the largest US rental marketplace by CoStar Group. Extract rent prices, total monthly costs, floor plans, amenities, fees, pet policies, photos, phone numbers and availability. Filter by city, price range, bedrooms and property type.",
        "version": "0.0",
        "x-build-id": "TQRuxsF2VUN2c8ptz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~apartments-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-apartments-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~apartments-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-apartments-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~apartments-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-apartments-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 Apartments.com search URLs. If provided, city inputs are ignored. Examples: 'https://www.apartments.com/austin-tx/', 'https://www.apartments.com/austin-tx/under-1000/', 'https://www.apartments.com/austin-tx/rent-specials/'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City-state slugs matching Apartments.com URL format. Examples: 'austin-tx', 'new-york-ny', 'los-angeles-ca', 'chicago-il', 'miami-fl'. Ignored if searchUrls is provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "all",
                            "apartments",
                            "houses",
                            "condos",
                            "townhomes"
                        ],
                        "type": "string",
                        "description": "Type of property to search. Only used with cities input.",
                        "default": "all"
                    },
                    "maxPrice": {
                        "title": "Max Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum monthly rent. Adds '/under-{price}/' filter to URL. 0 = no limit. Common values: 700, 1000, 1500, 2000.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum bedroom count. 0 = studio/any.",
                        "default": 0
                    },
                    "rentSpecialsOnly": {
                        "title": "Rent Specials Only",
                        "type": "boolean",
                        "description": "Only scrape listings with active promotions/deals. Adds '/rent-specials/' filter.",
                        "default": false
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page for JSON-LD data: floor plans, amenities, fees, pet policy, photos, coordinates, reviews. Increases run time and cost significantly.",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Max Listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings to scrape. Set 0 for unlimited.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Pages per Search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum pages per city search. Each page has ~20-25 listings.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies recommended — CoStar has anti-bot protection."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds. Keep above 1500ms to avoid blocks.",
                        "default": 1500
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel requests. Keep at 1-2 — CoStar rate limits aggressively.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
