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

Apartments.com scraper & API: search US rental listings by city or area and export address, rent price, beds, baths, square feet, amenities, pet policy, photos, contact phone, coordinates and availability. Rental market data and real-estate lead generation — fast, no login.

- **URL**: https://apify.com/haketa/apartments-com-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 44 total users, 1 monthly users, 100.0% runs succeeded, 1 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Apartments.com Scraper — US Rental Listings, Rent Comps, Floor Plans & Multifamily Property Data Extractor

> **The most complete Apartments.com data extraction tool on Apify.** Pull live rental listings from the largest US apartment marketplace — operated by **CoStar Group** — with structured rent prices, total monthly costs, beds/baths/sqft, amenities, fees, pet policies, photos, phone numbers, ratings, and geocoordinates. Built for **multifamily investors, prop-tech teams, rent-comp analysts, lenders, brokerages, and relocation platforms** that need fresh, query-ready rental supply data without fighting CoStar's anti-bot stack.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com/haketa/apartments-com-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20at%20Run-orange)]()
[![Engine](https://img.shields.io/badge/Engine-HTTP%20%2B%20JSON--LD-green)]()
[![Coverage](https://img.shields.io/badge/Coverage-Nationwide%20USA-purple)]()
[![Pay Per Event](https://img.shields.io/badge/Pricing-Pay%20Per%20Event-yellow)]()
[![Region](https://img.shields.io/badge/Country-United%20States-red)]()
[![No Auth](https://img.shields.io/badge/Auth-None%20Required-success)]()
[![Property Types](https://img.shields.io/badge/Types-Apts%20%7C%20Houses%20%7C%20Condos%20%7C%20Townhomes-lightgrey)]()

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target Website** | [Apartments.com](https://www.apartments.com/) — US apartments, houses, condos & townhomes for rent |
| **Input Modes** | 41+ major US metro dropdown (`citySelect`), custom city slugs (`cities`), or direct `searchUrls` |
| **Core Data Extracted** | Property ID/name, address, ZIP, GPS coordinates, rent min/max, beds/baths/sqft, phone number, rent specials, floor plans, fees |
| **Pagination & Scale** | Automatic multi-page & multi-city traversal (`maxPages: 0` = auto) supporting **1,000+ unique rental listings** |
| **Authentication** | None required — public listing & structured JSON-LD data |
| **Export Formats** | JSON, CSV, Excel (XLSX), HTML, XML, RSS, JSONL, and direct Apify REST API / Webhooks |

***

### What This Actor Does

The **Apartments.com Scraper** is a production-ready Apify actor that extracts structured rental listings from **[Apartments.com](https://www.apartments.com/)** — the flagship US rental marketplace owned by **CoStar Group**, the same company behind LoopNet, Homes.com, and the CoStar Suite used by 90%+ of US commercial real-estate professionals. Apartments.com aggregates **multifamily complexes, condos, townhomes, and single-family rentals** across virtually every metro in the United States, making it the single largest public source of US rental supply data.

The actor fetches city or URL-scoped search results, parses each listing card from the HTML and from the embedded JSON-LD `CollectionPage` graph, and optionally dives into each property's detail page to pull floor plans, amenity tags, fees, pet policies, photos, ratings, walk scores, and management company info. It returns one normalized JSON record per property — ready to drop into Postgres, BigQuery, Snowflake, Power BI, a CRM, or an investment-research notebook.

Each record can include:

- **Property identity** — Apartments.com listing ID, property name, full street address, city, state, ZIP, neighborhood, latitude/longitude
- **Pricing** — base rent range (`rentMin`/`rentMax`), total monthly with fees (`totalMonthlyMin`/`totalMonthlyMax`), deposit
- **Unit specs** — bedroom range, bathroom range, sqft range, floor plans (when detail scrape is on)
- **Property metadata** — property type (apartment / house / condo / townhome), year built, unit count, management company
- **Lifestyle attributes** — pet friendly flag + full pet policy + breed/weight restrictions, parking, lease term
- **Marketing signals** — `rentSpecials` flag + free-text promo description, ratings, review count
- **Media** — photo URLs, photo count, virtual tour link
- **Walkability** — Walk Score, Transit Score, Bike Score
- **Contact** — leasing phone number, listing URL

If you've ever tried to build a rent-comp dataset by hand, you already know this is a multi-week engineering project. This actor does it in minutes.

***

### Why scrape Apartments.com yourself when this exists?

Apartments.com is a high-value target *because* it is hard to scrape. CoStar invests heavily in protecting its data — they license it commercially through the CoStar API at five-figure annual contracts. DIY scrapers typically hit the wall at one of these obstacles within the first week:

- Aggressive **Akamai / DataDome fingerprinting** that blocks vanilla `requests` / `axios` traffic on the first hit
- **HTTP 403 and 429 rate-limit walls** triggered by even mild concurrency
- **Markup churn** — Apartments.com ships A/B tests constantly, so CSS selectors break every few weeks
- **Two sources of truth per page** — the visible HTML cards and a separate JSON-LD `CollectionPage` graph that need to be merged and de-duplicated by property name
- **Pagination quirks** — `/2/`, `/3/` URL suffixes with no canonical "last page" hint; you have to detect partial pages
- **Detail-page JSON-LD nesting** — floor plans, fees, and pet rules live across multiple `@graph` nodes inside multiple `<script type="application/ld+json">` blocks
- **Total monthly vs. base rent confusion** — the headline price excludes mandatory fees that often add $100–$400/month
- **Phone numbers rendered as click-to-call tokens**, not raw text
- **Geocoordinates only available in JSON-LD**, not in the visible card
- **IP geofencing** — non-US IPs get throttled or shown a stripped layout, so residential US proxies are mandatory at scale

This actor handles all of it: realistic Chrome headers, retry-with-backoff on 403/429, Apify Residential Proxy integration, JSON-LD + HTML merge, deterministic dedupe by property ID, and a stable normalized output schema that survives Apartments.com's UI refreshes.

***

### Quick Start

#### One-Click Run

1. Open the actor page on the Apify Store and click **"Try for free"**
2. Pick one or more cities from the **Cities** dropdown (e.g. Austin TX, New York NY, Chicago IL). Need a city that isn't listed? Add its slug (e.g. `boise-id`) in **Other cities (advanced)**, or paste full Apartments.com search URLs into **Start URLs**
3. Optionally choose a **Property Type**, **Max Monthly Rent** or **Minimum Bedrooms**, toggle **Scrape Detail Pages** for floor plans/amenities/fees/photos, and set a **Max Listings** cap
4. Hit **Start** — your structured rental dataset appears in the Apify dataset view, downloadable as JSON, CSV, Excel, or HTML

#### API Run (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/apartments-com-scraper").call(run_input={
    "citySelect": ["austin-tx", "houston-tx", "dallas-tx"],
    "propertyType": "apartments",
    "maxPrice": "2500",
    "minBeds": "2",
    "scrapeDetails": True,
    "maxListings": 300,
    "maxPages": 15,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
})

for unit in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        unit["propertyName"],
        f"{unit['bedsMin']}–{unit['bedsMax']} bd",
        f"${unit['rentMin']:,}–${unit['rentMax']:,}/mo",
        unit["city"], unit["zipCode"],
    )
```

#### API Run (Node.js / TypeScript)

```typescript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/apartments-com-scraper').call({
    searchUrls: [
        'https://www.apartments.com/new-york-ny/',
        'https://www.apartments.com/brooklyn-ny/under-3500/',
    ],
    rentSpecialsOnly: false,
    scrapeDetails: true,
    maxListings: 500,
    proxyConfiguration: {
        useApifyProxy: true,
        apifyProxyGroups: ['RESIDENTIAL'],
    },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Pulled ${items.length} NYC + Brooklyn listings`);
```

#### API Run (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~apartments-com-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "citySelect": ["los-angeles-ca", "san-francisco-ca", "seattle-wa"],
    "propertyType": "all",
    "maxPrice": "3000",
    "scrapeDetails": false,
    "maxListings": 200
  }'
```

***

### How It Works

The actor builds a list of search URLs from your input, fetches each page over an optimized mobile HTTP profile (+ optional Apify Residential Proxy), parses the response, and merges two complementary data sources:

1. **HTML placard cards** — `<article class="placard">` elements expose listing ID, street address, headline rent range, beds, deal/special badge, and detail-page URL via `data-*` attributes.
2. **JSON-LD `CollectionPage` graph** — every search page embeds a `<script type="application/ld+json">` block containing an `@graph` with an `ItemList` of `ApartmentComplex` / `Product` / `Residence` entities. These supply geocoordinates, telephone, aggregate rating, review count, and a clean address object that backfills missing fields.

The actor matches the two sources by lowercased property name, dedupes by `propertyId`, and pushes one normalized record per property to the dataset.

If `scrapeDetails: true`, each property's detail page is fetched too. The detail parser pulls additional JSON-LD nodes covering floor plans (with per-floor-plan rent + sqft + bedrooms), amenity tags, fee schedule, pet policy + restrictions, parking notes, lease term, deposit, photo gallery URLs, virtual tour link, walk/transit/bike scores, and management company.

#### Source endpoints

| Source Pattern | Example | What's there |
|---|---|---|
| City landing | `apartments.com/{city-slug}/` | Default search — all property types |
| Price filter | `apartments.com/{city}/under-{price}/` | Adds price cap filter |
| Bed filter | `apartments.com/{city}/{n}-bedrooms/` | Adds bedroom minimum |
| Specials | `apartments.com/{city}/rent-specials/` | Promotions-only feed |
| Type filter | `apartments.com/houses/{city}/` etc. | Houses, condos, townhomes |
| Pagination | `apartments.com/{city}/{page}/` | `/2/`, `/3/`, … |
| Detail page | `apartments.com/{property-slug}-{city-slug}/{propertyId}/` | Full JSON-LD + amenity HTML |

#### Engineering details

- **Mobile Safari / iOS fingerprint** — aligned `User-Agent`, `Accept`, `Accept-Language` and `Referer`; the desktop fingerprint is served a stripped interstitial, so mobile is required for full pages
- **Retry-with-backoff on soft blocks, 403 and 429** — up to six attempts per URL, re-rotating the session (and proxy IP) each time; a response under 40 KB is treated as a soft block and retried
- **Optional Apify Residential Proxy** — strongly recommended; default config pre-selects `RESIDENTIAL` group
- **Configurable `requestDelay` (default 1500 ms) + `maxConcurrency` (default 1)** — tuned to stay under CoStar's per-IP rate-limit threshold
- **JSON-LD walker** — recursive scanner up to 8 levels deep, supports nested `@graph`, `ListItem`, and `mentions[]` structures
- **Dedupe by `propertyId`** with fallback to `listingUrl` then `propertyName`
- **Auto-stop on partial pages** — when a page returns fewer than 5 listings, the actor treats it as the last page and moves to the next task

***

### Input Parameters

Pick one or more cities from the **Cities** dropdown (or paste raw search URLs), then narrow the search with property type, price and bedroom filters. Leaving everything empty returns a ready-made sample of listings from popular US metros.

```json
{
  "citySelect": ["austin-tx", "houston-tx", "denver-co"],
  "cities": ["boise-id"],
  "propertyType": "apartments",
  "maxPrice": "2000",
  "minBeds": "1",
  "rentSpecialsOnly": false,
  "scrapeDetails": true,
  "maxListings": 250,
  "maxPages": 15,
  "requestDelay": 1500,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### Parameter reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `citySelect` | `array<string>` | `["austin-tx"]` | **Primary input.** Pick one or more US cities from the built-in dropdown of 41 major metros (e.g. `new-york-ny`, `los-angeles-ca`, `chicago-il`, `houston-tx`, `miami-fl`, `seattle-wa`, `washington-dc`, `san-francisco-ca`). Leave empty for a mixed sample from popular cities. |
| `cities` | `array<string>` | `[]` | **Other cities (advanced).** Free-text list for any US city not in the dropdown, using the Apartments.com slug format — e.g. `boise-id`, `madison-wi`, `ann-arbor-mi`. Combined with your dropdown selection. |
| `propertyType` | `string` | `"all"` | One of `all`, `apartments`, `houses`, `condos`, `townhomes`. Applied when cities are used (ignored for raw `searchUrls`). |
| `maxPrice` | `string` (enum) | `"0"` | Maximum monthly rent, selected from a dropdown. Appends `/under-{price}/` to search URLs. `"0"` = no cap. Available values: `"700"`, `"1000"`, `"1200"`, `"1500"`, `"2000"`, `"2500"`, `"3000"`. |
| `minBeds` | `string` (enum) | `"0"` | Minimum bedrooms, from a dropdown. `"0"` = studio or any. Values: `"0"`, `"1"`, `"2"`, `"3"`, `"4"`. |
| `rentSpecialsOnly` | `boolean` | `false` | Restrict to listings with active promotions (free month, discounted rent, etc.). |
| `scrapeDetails` | `boolean` | `false` | Visit each listing's detail page for JSON-LD enrichment (floor plans, amenities, fees, pet policy, photos, scores). **Significantly increases runtime and cost.** |
| `maxListings` | `integer` | `0` | Hard cap on total listings saved across all cities. `0` = unlimited. (Empty no-filter runs are auto-capped at ~100 for a fast, cheap sample.) |
| `maxPages` | `integer` | `0` | Pages crawled per city/search URL (`0` = automatic pagination governed by `maxListings`). Each page yields ~25–40 listings. |
| `requestDelay` | `integer` | `1500` | Delay between requests in ms. CoStar rate-limits aggressively — keep at or above `1500`. Max `15000`. |
| `maxConcurrency` | `integer` | `1` | Parallel requests. Keep at `1`–`2`. Higher values trigger 403/429 quickly. Max `5`. |
| `searchUrls` | `array<string>` | `[]` | **Start URLs (advanced).** Paste ready-made Apartments.com search URLs to scrape directly. When provided, the city and filter options above are ignored. Great for neighborhoods, ZIPs, and custom filter combos. |
| `proxyConfiguration` | `object` | Residential | Apify Proxy config. Residential proxies are strongly recommended — datacenter IPs are blocked within minutes. |

***

### Output Schema

Every dataset record uses a single flat JSON shape so warehouse loads, BI tools, and CRMs don't need per-record branching.

#### Identity & location

| Field | Type | Description |
|---|---|---|
| `propertyId` | `string` | Apartments.com canonical listing ID (e.g., `40n18nj`) |
| `propertyName` | `string` | Property name (e.g., `Edison Austin`, `The Hudson Yards`, `Pacific Plaza Apartments`) |
| `address` | `string` | Street address (e.g., `4711 E Riverside Dr`) |
| `city` | `string` | City (e.g., `Austin`, `New York`, `Los Angeles`) |
| `state` | `string` | Two-letter state code (`TX`, `NY`, `CA`, …) |
| `zipCode` | `string` | 5-digit ZIP code |
| `neighborhood` | `string` | Neighborhood / submarket when detected |
| `latitude` | `number` | Geocoordinate (decimal degrees) — from JSON-LD |
| `longitude` | `number` | Geocoordinate (decimal degrees) — from JSON-LD |
| `listingUrl` | `string` | Canonical Apartments.com property detail URL |
| `searchCity` | `string` | The city slug the listing was discovered under |

#### Property metadata

| Field | Type | Description |
|---|---|---|
| `propertyType` | `string` | Apartment, House, Condo, Townhome (when detected) |
| `yearBuilt` | `integer` | Construction year (detail page) |
| `unitCount` | `integer` | Total units in the property (detail page) |
| `managementCompany` | `string` | Property manager / owner name (detail page) |

#### Pricing & unit specs

| Field | Type | Description |
|---|---|---|
| `rentMin` | `number` | Lowest advertised monthly rent (base) |
| `rentMax` | `number` | Highest advertised monthly rent (base) |
| `totalMonthlyMin` | `number` | Lowest total monthly cost including mandatory fees |
| `totalMonthlyMax` | `number` | Highest total monthly cost including mandatory fees |
| `bedsMin` | `integer` | Minimum bedrooms (`0` = studio) |
| `bedsMax` | `integer` | Maximum bedrooms |
| `bathsMin` | `number` | Minimum bathrooms |
| `bathsMax` | `number` | Maximum bathrooms |
| `sqftMin` | `integer` | Minimum unit square footage |
| `sqftMax` | `integer` | Maximum unit square footage |
| `deposit` | `number` | Required security deposit (USD) |
| `leaseTerm` | `string` | Lease length(s) — e.g. `6, 9, 12 months` |
| `floorPlans` | `array<object>` | Per-floor-plan array (`name`, `beds`, `baths`, `sqft`, `rentMin`, `rentMax`, `available`) — detail page |
| `fees` | `object` | Free-text fee schedule (application, admin, amenity, etc.) — detail page |

#### Marketing, lifestyle & media

| Field | Type | Description |
|---|---|---|
| `availabilityStatus` | `string` | Now Available, Coming Soon, Waitlist, etc. |
| `rentSpecials` | `boolean` | `true` if a promo banner is detected |
| `specialText` | `string` | Free-text promo description (e.g., `1 month free on 13-month lease`) |
| `petFriendly` | `boolean` | `true` if dogs or cats are allowed |
| `petPolicy` | `string` | Free-text pet policy summary |
| `petRestrictions` | `array<string>` | Breed/weight restrictions when published |
| `parkingInfo` | `string` | Parking type + cost (e.g., `Garage, $150/mo`) |
| `amenities` | `array<string>` | Community + unit amenity tags (`Pool`, `Fitness Center`, `In-Unit Laundry`, `EV Charging`, …) |
| `description` | `string` | Full marketing description from detail page |
| `photoCount` | `integer` | Number of gallery images |
| `photos` | `array<string>` | Photo URLs |
| `virtualTour` | `string` | Virtual tour URL when offered |
| `rating` | `number` | Apartments.com aggregate rating (0–5) |
| `reviewCount` | `integer` | Number of resident reviews |
| `walkScore` | `integer` | 0–100 walkability score |
| `transitScore` | `integer` | 0–100 public transit score |
| `bikeScore` | `integer` | 0–100 bikeability score |
| `phoneNumber` | `string` | Leasing office phone — present for named communities (from JSON-LD) or via detail scrape |
| `scrapedAt` | `string` | ISO-8601 timestamp |

#### Example record — named apartment community (New York, NY)

Taken verbatim from a fresh verification run. Named communities also expose `latitude`, `longitude`, `phoneNumber` and a short `description` directly from the search page's JSON-LD graph:

```json
{
  "propertyId": "1j2c5h6",
  "propertyName": "10 Halletts Point",
  "address": "10, 20, 30 Halletts Pt",
  "city": "Astoria",
  "state": "NY",
  "zipCode": "11102",
  "neighborhood": null,
  "latitude": 40.7766,
  "longitude": -73.93585,
  "propertyType": null,
  "rentMin": 4228,
  "rentMax": 4228,
  "bedsMin": 2,
  "bedsMax": 2,
  "rentSpecials": true,
  "phoneNumber": "929-552-4252",
  "description": "10 Halletts Point Apartments",
  "listingUrl": "https://www.apartments.com/10-halletts-point-astoria-ny/1j2c5h6/",
  "searchCity": "new-york-ny",
  "scrapedAt": "2026-11-01T23:43:06.268Z"
}
```

#### Example record — individual unit listing (Brooklyn, NY)

Single-unit rentals don't carry a community name, so the actor stores the **street address** as `propertyName`. These still return address, rent range, beds and the detail URL; enable **Scrape Detail Pages** to add geo, phone, amenities and more:

```json
{
  "propertyId": "65t9ffv",
  "propertyName": "1515 Surf Ave",
  "address": "1515 Surf Ave",
  "city": "Brooklyn",
  "state": "NY",
  "zipCode": "11224",
  "rentMin": 2899,
  "rentMax": 3099,
  "bedsMin": 1,
  "bedsMax": 2,
  "rentSpecials": null,
  "listingUrl": "https://www.apartments.com/1515-surf-brooklyn-ny/65t9ffv/",
  "searchCity": "new-york-ny",
  "scrapedAt": "2026-11-01T23:43:06.268Z"
}
```

#### Example record — fully enriched with `scrapeDetails: true`

When detail scraping is on, each property's detail page backfills floor plans, amenities, fees, pet policy, photos, lease term, walk/transit/bike scores and management company. A representative enriched record looks like:

```json
{
  "propertyId": "40n18nj",
  "propertyName": "Edison Austin",
  "address": "4711 E Riverside Dr",
  "city": "Austin",
  "state": "TX",
  "zipCode": "78741",
  "latitude": 30.2389,
  "longitude": -97.7128,
  "propertyType": "Apartment",
  "yearBuilt": 2021,
  "unitCount": 312,
  "rentMin": 1295,
  "rentMax": 2840,
  "bedsMin": 0,
  "bedsMax": 3,
  "bathsMin": 1,
  "bathsMax": 2,
  "sqftMin": 512,
  "sqftMax": 1420,
  "rentSpecials": true,
  "specialText": "1 month free on 13-month lease",
  "petFriendly": true,
  "petPolicy": "Cats and dogs welcome. 2 pets max.",
  "petRestrictions": ["No aggressive breeds", "50 lb weight limit"],
  "phoneNumber": "(512) 555-0142",
  "amenities": ["Pool", "Fitness Center", "In-Unit Laundry", "EV Charging", "Rooftop Lounge"],
  "floorPlans": [
    { "name": "S1", "beds": 0, "baths": 1, "sqft": 512, "rentMin": 1295, "rentMax": 1295 },
    { "name": "A2", "beds": 1, "baths": 1, "sqft": 720, "rentMin": 1620, "rentMax": 1620 },
    { "name": "B1", "beds": 2, "baths": 2, "sqft": 1090, "rentMin": 2310, "rentMax": 2310 },
    { "name": "C1", "beds": 3, "baths": 2, "sqft": 1420, "rentMin": 2840, "rentMax": 2840 }
  ],
  "fees": { "application": "$60", "admin": "$200", "amenity": "$25/mo" },
  "parkingInfo": "Garage, $125/mo",
  "leaseTerm": "6, 9, 12, 13 months",
  "deposit": 500,
  "photoCount": 42,
  "photos": ["https://images1.apartments.com/.../photo01.jpg", "..."],
  "rating": 4.3,
  "reviewCount": 178,
  "walkScore": 64,
  "transitScore": 51,
  "bikeScore": 72,
  "managementCompany": "Greystar",
  "listingUrl": "https://www.apartments.com/edison-austin-austin-tx/40n18nj/",
  "searchCity": "austin-tx",
  "scrapedAt": "2026-11-01T14:32:18.000Z"
}
```

> **Field coverage note:** Every record always includes `propertyId`, `propertyName`, `address`, `city`, `state`, `zipCode`, `listingUrl`, `rentMin`/`rentMax` and `bedsMin`/`bedsMax`. Fields such as `latitude`, `longitude`, `phoneNumber` and `description` come from the search page's JSON-LD and are present for **named apartment communities** (a subset of each result page); detail-only fields (`floorPlans`, `amenities`, `fees`, `petPolicy`, `photos`, `walkScore`, `managementCompany`, `yearBuilt`, `unitCount`, …) populate when you set **`scrapeDetails: true`**. Null fields are kept in the schema so warehouse loads stay consistent.

***

### Property Type & Status Reference

#### Property type taxonomy

| `propertyType` value | Meaning |
|---|---|
| `Apartment` | Multifamily rental community (most common) |
| `House` | Single-family detached rental |
| `Condo` | Condominium unit rented by owner |
| `Townhome` | Attached townhouse rental |

Filter at the search level with the `propertyType` input parameter: `all`, `apartments`, `houses`, `condos`, `townhomes`.

#### Availability statuses

| `availabilityStatus` | Meaning |
|---|---|
| `Now Available` | Units available for immediate move-in |
| `Coming Soon` | Pre-leasing future units (often new construction) |
| `Waitlist` | Fully occupied; accepting waitlist applications |
| `Limited Availability` | Few units left |
| `Contact for Availability` | No live availability published |

#### Rent specials examples

When `rentSpecials: true`, the `specialText` field contains the promo verbatim. Common patterns:

- `1 month free on 13-month lease`
- `$500 off first month`
- `Look & Lease — $0 admin fee`
- `Reduced deposit for qualified applicants`
- `Free covered parking for 12 months`

***

### Use Cases

#### Multifamily Investment Research & Acquisitions

Multifamily syndicators, REITs, and value-add investors run this actor to:

- **Pull a full rent roll snapshot** for every comp within a 1–3 mile radius of a target acquisition
- **Compute price-per-sqft and price-per-bed comparables** across submarkets to underwrite offer prices
- **Track lease-up velocity** at new construction by re-running weekly and diffing `availabilityStatus`
- **Identify rent specials concentration** as a soft-market signal (markets with high `rentSpecials: true` share are typically over-supplied)
- **Benchmark target asset rent vs. market** by floor plan type using the `floorPlans` array
- **Source off-market opportunities** by spotting properties listed by smaller management companies that may signal owner fatigue

#### Rent Comp & Pricing Analytics (Prop-Tech)

Pricing platforms, revenue-management vendors, and prop-tech startups use the data to:

- **Train rent-prediction models** on millions of rows of `rentMin`/`bedsMin`/`sqftMin`/`zipCode`/`amenities`
- **Build rent index dashboards** by city, ZIP, neighborhood, or property class
- **Power automated comp reports** that property managers receive in their inbox each Monday
- **Monitor competitor pricing in real time** — alert when a comp drops rent by >5%
- **Feed AI underwriting copilots** with the freshest possible rent signal
- **Validate proprietary pricing recommendations** against live market evidence

#### Brokerage, Leasing & Tour Generation

Apartment locators, leasing brokerages, and corporate housing providers leverage Apartments.com data to:

- **Build searchable internal inventories** without licensing the CoStar Suite
- **Match client requirements** (budget, beds, pet policy, neighborhood) against current listings instantly
- **Stage tour itineraries** by pulling addresses, phone numbers, and availability in one query
- **Identify pet-friendly inventory** for clients with dogs over 50 lbs using `petRestrictions`
- **Spot rent specials** to lead with savings in client conversations
- **Track which buildings convert from "Now Available" to "Waitlist"** as a soft demand signal

#### Relocation & Corporate Housing

Relocation management companies, HR mobility teams, and corporate-housing providers use the actor to:

- **Pre-screen rentals** in destination metros before an employee accepts an offer
- **Build relocation packets** with shortlisted comparables across price tiers
- **Quote cost-of-living adjustments** with hard `totalMonthlyMin` data — not estimated medians
- **Compare neighborhoods** using `walkScore`/`transitScore`/`bikeScore`
- **Match commute zones** by geocoordinate to office addresses

#### Lender Underwriting, Insurance & Risk

Multifamily lenders (agency, CMBS, debt funds), property insurers, and tax appeal consultants use the dataset to:

- **Underwrite refi requests** by validating sponsor's stated rent against scraped market rent
- **Stress-test pro formas** with current vacancy + concession environment in the submarket
- **Identify mispriced insurance policies** when scraped rent is materially above premium-baseline rent
- **Support property-tax appeals** with hard comparable evidence
- **Monitor portfolio submarkets** quarterly for early signs of rent compression
- **Feed credit committees** with submarket performance briefs

#### Market Reports & Real-Estate Journalism

Brokerages, research desks, and real-estate journalists publish recurring market reports built on this data:

- **Quarterly metro rent index** — median `rentMin` by city/ZIP, year-over-year
- **Concession watch** — % of listings carrying `rentSpecials` by metro
- **New construction lease-up tracker** — units coming online filtered by `yearBuilt >= current_year - 2`
- **Pet-friendliness index** — share of inventory accepting cats/dogs by city
- **Amenity-of-the-month reports** — which amenities (EV charging, coworking, dog wash) are spreading fastest

#### Location Intelligence & Site Selection

Retailers, QSR chains, fitness operators, and mobility companies use rental density as a population/demand proxy:

- **Identify high-density rental ZIPs** for store/site selection (renter share correlates with foot traffic)
- **Spot emerging neighborhoods** by tracking new-construction inventory growth
- **Estimate household formation** by counting unique `propertyId` in lease-up status
- **Inform last-mile / delivery zone design** with apartment-cluster maps
- **Layer Walk/Transit scores** onto trade-area analyses

#### Academic & Public-Policy Research

Housing researchers, urban planners, and policy think tanks use the dataset to study:

- **Rent burden trends** by metro and submarket
- **Geographic patterns of affordable inventory** (filter `maxPrice` against AMI thresholds)
- **Concession patterns as market-softness indicators**
- **Pet-policy and source-of-income discrimination** signals across jurisdictions
- **Inventory mix shifts** — multifamily vs. SFR vs. condo — over time

#### CRM Enrichment, Lead Routing & Direct Outreach

B2B vendors selling to multifamily operators (property-management software, IoT, smart locks, payment platforms) enrich their pipelines with:

- **Building-level firmographics** — `managementCompany`, `unitCount`, `yearBuilt`, location
- **Targeted outbound lists** filtered by property size or vintage
- **Account-mapping** — group properties by `managementCompany` to estimate operator portfolio scale
- **Territory planning** — geographic clustering by ZIP / metro
- **Trigger-based plays** — new properties appearing for the first time = new construction = sales trigger

***

### Sample Queries & Recipes

#### Recipe 1: Full Manhattan inventory under $3,000/mo, all property types

```json
{
  "citySelect": ["new-york-ny"],
  "propertyType": "all",
  "maxPrice": "3000",
  "scrapeDetails": false,
  "maxListings": 0,
  "maxPages": 30
}
```

#### Recipe 2: 2-bedroom Austin apartments with full detail enrichment

```json
{
  "citySelect": ["austin-tx"],
  "propertyType": "apartments",
  "minBeds": "2",
  "maxPrice": "2500",
  "scrapeDetails": true,
  "maxListings": 200
}
```

#### Recipe 3: Houses for rent across Houston, Dallas, and San Antonio

```json
{
  "citySelect": ["houston-tx", "dallas-tx", "san-antonio-tx"],
  "propertyType": "houses",
  "minBeds": "3",
  "scrapeDetails": true,
  "maxListings": 300
}
```

#### Recipe 4: Rent-specials-only sweep across top tech metros (concession monitor)

```json
{
  "citySelect": ["san-francisco-ca", "seattle-wa", "austin-tx", "denver-co"],
  "rentSpecialsOnly": true,
  "scrapeDetails": false,
  "maxListings": 500,
  "maxPages": 20
}
```

#### Recipe 5: Hyper-targeted neighborhood comp pull via search URLs

```json
{
  "searchUrls": [
    "https://www.apartments.com/brooklyn-ny/williamsburg/",
    "https://www.apartments.com/chicago-il/west-loop/",
    "https://www.apartments.com/los-angeles-ca/silver-lake/"
  ],
  "scrapeDetails": true,
  "maxListings": 150
}
```

#### Recipe 6: Affordable inventory under $1,000 across Sun Belt secondary markets

Cities not in the dropdown go in the free-text `cities` (Other cities) field:

```json
{
  "cities": ["el-paso-tx", "lubbock-tx", "tulsa-ok", "memphis-tn", "birmingham-al"],
  "maxPrice": "1000",
  "scrapeDetails": false,
  "maxListings": 400
}
```

#### Recipe 7: Sample run — 20 listings to validate schema before a full scrape

```json
{
  "citySelect": ["miami-fl"],
  "maxListings": 20,
  "maxPages": 1,
  "scrapeDetails": true
}
```

***

### Integration Examples

#### Google Sheets

Configure an Apify schedule that runs this actor each morning. Add the **"Save to Google Sheets"** integration on the schedule's outputs tab — every run appends fresh rows. Use a pivot table for `medianRent BY city, bedsMin`.

#### Make.com / Zapier / n8n

Use the official **Apify** connector to trigger on `run.succeeded`. Common downstream flows:

- New listing in target ZIP → Slack alert to broker team
- `rentSpecials` flipped to `true` on a target comp → email digest
- Property dropped below `$X` price threshold → trigger CRM task
- Rent decreased vs. last week → push to internal pricing dashboard

#### Power BI / Tableau / Looker Studio

Connect Apify's REST dataset endpoint directly. Build dashboards covering:

- Median rent heatmap by ZIP
- Concession share by metro / submarket
- New construction lease-up funnel (`yearBuilt >= 2024` + `availabilityStatus`)
- Floor-plan-level price-per-sqft comparisons
- Pet-policy distribution by city

#### Postgres / Snowflake / BigQuery

Use the [Apify webhook integration](https://docs.apify.com/platform/integrations/webhooks) to POST run results to your warehouse ingestion endpoint after every scheduled run. Recommended schema: one table `listings`, one table `floor_plans` (one row per floor plan, joined on `propertyId`).

```sql
SELECT zip_code,
       AVG(rent_min) AS avg_rent_min,
       AVG(rent_max) AS avg_rent_max,
       COUNT(*)      AS active_listings,
       SUM(CASE WHEN rent_specials THEN 1 ELSE 0 END)::float / COUNT(*) AS concession_share
FROM   apartments_com_listings
WHERE  state = 'TX' AND scraped_at >= CURRENT_DATE - INTERVAL '7 days'
GROUP  BY zip_code
ORDER  BY active_listings DESC;
```

#### Salesforce / HubSpot CRM Enrichment

Nightly Apify run → match `managementCompany` to your Account records → upsert `unitCount`, `yearBuilt`, latest median rent. Trigger Tasks when an Account's portfolio shows new lease-up properties (sales opportunity for property-management software).

#### Webhooks & Custom Pipelines

Subscribe a webhook to `RUN.SUCCEEDED` and post the dataset URL to your ETL worker. The actor's deterministic schema makes downstream parsing trivial.

***

### Major US Rental Markets at a Glance

| Metro | City Slug | Why it matters |
|---|---|---|
| New York, NY | `new-york-ny` | Largest US rental market by unit count; highest median rent |
| Los Angeles, CA | `los-angeles-ca` | 2nd largest renter base; complex submarket geography |
| Chicago, IL | `chicago-il` | Top-5 multifamily transaction market; deep neighborhood data |
| Houston, TX | `houston-tx` | Energy-driven rental demand; broad price spectrum |
| Dallas-Fort Worth, TX | `dallas-tx`, `fort-worth-tx` | One of the hottest US lease-up markets |
| Austin, TX | `austin-tx` | Tech-driven; high concession environment in 2024–2026 cycle |
| Miami, FL | `miami-fl` | Migration-driven rent growth; luxury condo rental supply |
| Seattle, WA | `seattle-wa` | Tech-heavy; high transit-score inventory |
| Boston, MA | `boston-ma` | Higher-ed and biotech demand; September lease cycle |
| Washington, DC | `washington-dc` | Government employment base; stable rent |
| San Francisco, CA | `san-francisco-ca` | Most volatile rents post-COVID; rich concession data |
| Denver, CO | `denver-co` | High new-construction pipeline; lease-up rich |
| Atlanta, GA | `atlanta-ga` | Sun Belt magnet; large SFR rental share |
| Phoenix, AZ | `phoenix-az` | Build-to-rent capital of the US |
| San Diego, CA | `san-diego-ca` | Military + biotech demand; supply-constrained |
| Philadelphia, PA | `philadelphia-pa` | Affordable East Coast comp baseline |
| Minneapolis, MN | `minneapolis-mn` | Stable rust-belt-adjacent market |
| Portland, OR | `portland-or` | Walk-score-rich; renter-friendly regulations |
| Nashville, TN | `nashville-tn` | High in-migration; lease-up heavy |
| Charlotte, NC | `charlotte-nc` | Banking center; growing multifamily pipeline |

The actor works on **any** Apartments.com city slug — those above are simply the deepest by listing count.

***

### Cost & Performance

| Metric | Value |
|---|---|
| Engine | High-speed HTTP + structured JSON-LD parsing |
| Runtime (city, 100 listings, no detail) | ~1–3 minutes |
| Runtime (city, 100 listings, with detail) | ~10–20 minutes |
| Data freshness | Live at run time |
| Auth required | None |
| Proxy required | Yes — Apify Residential strongly recommended |
| Concurrency | `1`–`2` |
| Memory footprint | 256 MB minimum, 1 GB recommended for `scrapeDetails: true` |
| Pricing model | Pay-per-event — predictable per-record cost |
| Output formats | JSON, CSV, Excel (XLSX), HTML, XML, RSS, JSON Lines |

***

### Frequently Asked Questions

#### How fresh is the data?

Live at run time. Apartments.com is updated continuously by property managers, so every run pulls the current snapshot. Schedule the actor hourly, daily, or weekly to maintain a history.

#### How many listings will I get per run?

Depends entirely on inputs. In a fresh benchmark the actor pulled **400 unique New York, NY listings in ~126 seconds** (0 duplicates) before hitting the `maxListings` cap — roughly 18 result pages deep in a single metro. A single city with `maxPages: 20` typically returns 300–500 listings; major metros (NYC, LA, Chicago) can yield 1,000+ if you raise `maxPages` and `maxListings`. Set `maxListings: 0` for unlimited.

#### Do I need an Apartments.com login or API key?

No. The actor uses anonymous HTTP fetches against public search and detail pages. CoStar's commercial API is **not** required.

#### Why do I need residential proxies?

CoStar uses Akamai / DataDome anti-bot protection that fingerprints datacenter IP ranges within minutes. Apify Residential proxies present as real US consumer connections and are the most reliable option. Datacenter proxies will get blocked.

#### Will this work on the Apify Free plan?

Yes for small sample runs. Production-scale crawling (thousands of listings) typically requires a paid Apify plan because of residential proxy traffic costs.

#### How do I scrape only one neighborhood?

Use `searchUrls` and paste Apartments.com's neighborhood URL — e.g. `https://www.apartments.com/brooklyn-ny/williamsburg/`. The `cities`/`propertyType`/`maxPrice` inputs are ignored when `searchUrls` is set.

#### Can I scrape houses, condos, and townhomes — not just apartments?

Yes. Set `propertyType` to `houses`, `condos`, or `townhomes`. Apartments.com lists significant SFR and condo inventory in addition to multifamily.

#### What's the difference between `rentMin` and `totalMonthlyMin`?

`rentMin` is the headline base rent. `totalMonthlyMin` includes mandatory fees the property charges every month (amenity fee, trash fee, pest control, technology package, etc.). For underwriting and rent-comp accuracy, **use `totalMonthlyMin`/`totalMonthlyMax`**.

#### Does the actor return floor-plan-level pricing?

Yes when `scrapeDetails: true`. The `floorPlans` array contains one entry per published floor plan with `name`, `beds`, `baths`, `sqft`, and `rent`.

#### Why are latitude/longitude and phone empty on some records?

Those fields come from the JSON-LD `CollectionPage` graph that Apartments.com embeds for **named apartment communities**, so they populate for that subset of each result page (typically the larger, professionally managed buildings). **Individual-unit listings** — identified by their street address as `propertyName` — don't publish search-page geo/phone. To fill geo, phone, amenities, floor plans and more for *every* property, set **`scrapeDetails: true`**, which visits each detail page.

#### Are reviews and ratings included?

`rating` (0–5) and `reviewCount` are included when available (mostly with `scrapeDetails: true`). Individual review text is not extracted in the default schema to keep records flat — open a feature request if you need it.

#### Can I get historical rent data?

Not from a single run — Apartments.com only publishes current rents. To build history, **schedule this actor daily** and archive each dataset run; Apify stores all run datasets indefinitely on most plans.

#### Does the actor handle pagination automatically?

Yes. It walks `/2/`, `/3/`, … up to `maxPages` per task and auto-stops when it detects a partial / empty page.

#### Does it work for Canadian or international listings?

No — Apartments.com is US-only. For Canada use the [Realtor.ca Scraper](https://apify.com/haketa/realtor-ca-scraper) or [Kijiji Scraper](https://apify.com/haketa/kijiji-scraper); for Australia use [Domain.com.au Scraper](https://apify.com/haketa/domain-com-au-scraper); for Europe see the [Immoweb](https://apify.com/haketa/immoweb-scraper) and [Marktplaats](https://apify.com/haketa/marktplaats-scraper) actors.

#### What if I get blocked (403 / 429) during a run?

The actor retries up to 5 times with exponential backoff on 403/429. If persistent: raise `requestDelay` to `3000`+, drop `maxConcurrency` to `1`, and ensure residential proxies are enabled. Avoid running multiple parallel Apartments.com jobs.

#### Can I schedule the actor?

Yes — Apify's built-in Scheduler supports any cron expression. Pair with the Save-to-Sheets or webhook integration for a fully automated pipeline.

#### Can I export to Excel, CSV, or directly to my warehouse?

Yes — JSON, CSV, Excel (XLSX), HTML, XML, RSS, and JSON Lines from the dataset view, plus REST API access for any custom pipeline.

#### How does this compare to the CoStar / Apartments.com commercial API?

CoStar's commercial product offers contracted data licensing, broader historical coverage, and SLA support — but starts in the high five figures annually. This actor gives you **live public listing data** at a pay-per-event price point, perfect for ad-hoc research, prototyping, and many production workloads.

#### Are agent or owner contact emails included?

No. Apartments.com does not publish leasing emails on listings — only the **leasing-office phone number** (when present) is returned.

***

### Related Apify Actors by Haketa

If you need rental, real-estate, or marketplace data beyond Apartments.com, these sibling actors cover related sources:

- [Rent.com Scraper (US)](https://apify.com/haketa/rent-com-scraper) — sister rental marketplace with overlapping but distinct US inventory
- [Realtor.ca Scraper (Canada)](https://apify.com/haketa/realtor-ca-scraper) — Canadian residential listings (CREA MLS feed)
- [Domain.com.au Property Scraper (Australia)](https://apify.com/haketa/domain-com-au-scraper) — Australian sale & rental listings
- [Immoweb.be Belgium Property Scraper](https://apify.com/haketa/immoweb-scraper) — Belgian residential & commercial property
- [Zameen.com Pakistan Real Estate Scraper](https://apify.com/haketa/zameen-scraper) — Pakistan's largest property portal
- [VivaReal Brazil Real Estate Scraper](https://apify.com/haketa/vivareal-scraper) — Brazilian residential listings
- [ZAP Imóveis Brazil Scraper](https://apify.com/haketa/zapimoveis-scraper) — Brazilian sale & rental
- [Lamudi Philippines Real Estate Scraper](https://apify.com/haketa/lamudi-scraper) — Philippines property listings
- [Realestate.com.kh Cambodia Scraper](https://apify.com/haketa/realestate-com-kh-scraper) — Cambodian property
- [OfferUp Scraper (US)](https://apify.com/haketa/offerup-scraper) — adjacent US marketplace data
- [Kijiji.ca Scraper (Canada)](https://apify.com/haketa/kijiji-scraper) — Canadian classifieds incl. rentals
- [BBB Business Scraper](https://apify.com/haketa/bbb-scraper) — enrich property management company records

***

### Comparison vs. Alternatives

| Approach | Setup | Freshness | Cost (1,000 listings) | Schema normalization | Anti-bot handling |
|---|---|---|---|---|---|
| **This actor** | < 5 minutes | Live | Pennies–dollars (pay-per-event) | Built-in | Built-in (proxies + backoff) |
| Manual copy-paste | Hours per city | Live | Free (labor cost) | None | N/A — manual |
| Custom Python + residential proxies | 2–4 weeks dev | Live | Proxy + dev + infra | DIY (constantly breaks) | DIY |
| CoStar / Apartments.com commercial API | Weeks of contract negotiation | Live | $$$$ annual contract | Yes | Yes |
| Generic web-scraping SaaS | Days to configure | Live | $$ monthly subscription | Limited | Limited |
| Stale third-party rent reports | None | Monthly–quarterly | Subscription | Pre-aggregated only | N/A |

***

### Why Pay-Per-Event Pricing?

- You only pay when the actor actually runs and produces records
- Cost scales linearly with how much data you consume — no monthly minimums
- Transparent line-item billing inside the Apify console
- Free to evaluate — run a 20-listing sample for pennies before committing
- Far cheaper than a CoStar enterprise contract for most non-enterprise workloads
- Predictable for finance — no surprise overage bills based on Compute Units

***

### Keywords

Apartments.com scraper · scrape Apartments.com · Apartments.com data extractor · Apartments.com API · US rental listings API · US apartment data scraper · CoStar rental data alternative · rent comp data · multifamily property data · multifamily rent comp scraper · apartments listings scraper · apartment rental data extractor · Apartments.com rent scraper · NYC apartment scraper · Los Angeles apartment scraper · Chicago apartment scraper · Houston apartment scraper · Miami apartment scraper · Seattle apartment scraper · Austin apartment scraper · Boston apartment scraper · Washington DC apartment scraper · San Francisco apartment scraper · Denver rent comp scraper · Atlanta rent data · Phoenix rental scraper · floor plan rent data · apartment amenities scraper · pet policy rental data · single family rental scraper · SFR rental listings API · condo rental scraper · townhome rental scraper · build-to-rent data · rent specials tracker · concession monitor scraper · multifamily investor research data · prop-tech rental data feed · relocation cost-of-living data · lender multifamily underwriting data · REIT rent comp dataset · brokerage rental inventory API · B2B intelligence · 1,000+ results pagination · bulk export JSON CSV Excel API.

***

### Support

- **Bug reports:** Use the **Issues** tab on the Apify Store actor page
- **Feature requests:** Same place — please describe your use case and target metro
- **Direct contact:** Through the Apify developer profile

If this actor saves you time or unlocks a project that wasn't possible before, a **5-star rating** on the Apify Store helps other multifamily investors, prop-tech teams, brokerages, and researchers discover it. Thank you.

***

### 📋 Changelog

| Version | Date | Notes |
|---|---|---|
| **v1.2** | **2026-11** | Unlocked **1,000+ deep pagination** (`maxPages: 0` auto-pagination default + automatic multi-metro expansion when `maxListings >= 1000`), tuned prefill to 50 items for rapid execution, and cleaned up dataset/output schemas. |
| **v1.0.2** | **2026-11** | Fixed `propertyName` for individual-unit listings (street address now used instead of "Unknown"); verified 400 unique NYC listings in ~126 s with 0 duplicates / 0 value bugs; README output examples regenerated from the live sample. |
| **v1.0.1** | **2026-07** | Maintenance pass — verified selectors/JSON-LD endpoints against the live site, retested output quality, structure and freshness. |
| **v1.0.0** | **2026-05** | Initial public release — HTTP + JSON-LD scrape, city/URL inputs, optional detail-page enrichment, residential proxy support, pay-per-event pricing. |

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/apartments-com-scraper/changelog.md

# Actor input Schema

## `citySelect` (type: `array`):

Pick one or more US cities to scrape rental listings from. Leave empty to get a sample from popular cities across the country.

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

Optional. Add any US city not in the dropdown using the Apartments.com slug format, e.g. 'boise-id', 'madison-wi', 'ann-arbor-mi'. Combined with your dropdown selection.

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

Type of rental to search for.

## `maxPrice` (type: `string`):

Only show listings at or below this monthly rent. Choose 'No limit' to include every price.

## `minBeds` (type: `string`):

Smallest number of bedrooms to include.

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

Only include listings that currently advertise a promotion or move-in deal.

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

Also open each listing to collect floor plans, amenities, fees, pet policy and photos. Richer data, but slower and more expensive.

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

Maximum total listings to collect across all cities. Set 0 for unlimited.

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

Maximum result pages to read per city (each page has ~25-40 listings). Set 0 for automatic pagination governed by Max Listings.

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

Optional. Paste ready-made Apartments.com search URLs to scrape them directly. When provided, the city and filter options above are ignored.

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

Proxy settings. Residential proxies are recommended for reliable results.

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

Pause between requests, in milliseconds. Higher values are gentler and more reliable.

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

How many requests run in parallel. Keep low for the most reliable results.

## Actor input object example

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

# Actor output Schema

## `datasetItems` (type: `string`):

All extracted rental listings for this run.

## `overviewTable` (type: `string`):

A clean, human-readable table of the listings.

# 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 = {
    "citySelect": [
        "austin-tx"
    ],
    "cities": [],
    "maxListings": 50,
    "searchUrls": [],
    "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 = {
    "citySelect": ["austin-tx"],
    "cities": [],
    "maxListings": 50,
    "searchUrls": [],
    "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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

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

```

## CLI example

```bash
echo '{
  "citySelect": [
    "austin-tx"
  ],
  "cities": [],
  "maxListings": 50,
  "searchUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelay": 1500
}' |
apify call haketa/apartments-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/apartments-com-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jfeW77N2cQgl9TKKc/builds/WNCv6zbkabdL1leGL/openapi.json