# Apartment List Scraper (`solidcode/apartmentlist-com-scraper`) Actor

\[💰 $2 / 1K] Extract US apartment and rental listings from ApartmentList.com — search any city or paste URLs. Get rent prices, floorplans and units (beds/baths/sqft/availability), amenities, pet policy, fees, photos, GPS, and nearby schools. Filter by price, bedrooms, move-in date, and pets.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Apartment List Scraper

Pull US apartment and rental listings from ApartmentList.com at scale — full floorplans, individual units with exact rent and availability, amenities, nearby schools, fees, GPS coordinates, and photos for every property. Search any US city by name or paste ApartmentList links, and get one clean row per property with its complete inventory nested inside. Built for real estate investors, proptech and relocation teams, and market researchers who need structured rental data across whole cities without copying it building-by-building.

### Why This Scraper?

- **Complete floorplans and live units, not just a price range** — every property returns its full unit list with exact monthly rent, bedrooms, bathrooms, square footage, lease length, availability status, and a per-unit move-in date (one sampled Austin community returned 51 available units across 14 floorplans).
- **Up to ~50 nearby schools with GreatSchools ratings** — each school includes its type (public or charter), grade range, a 1–10 rating, enrollment count, and distance in miles from the property.
- **Up to ~30 amenities per property** — pool, in-unit laundry, fitness center, garage parking, dishwasher, elevator, hardwood floors, dog park, and pet policies, all normalized into one flat list.
- **Six guided filters that map to real listing behavior** — bedrooms (Studio through 4+), monthly rent minimum and maximum, minimum bathrooms, earliest move-in date, pet policy (cats, dogs, or both), and an 11-option required-amenities multi-select.
- **Move-in date and bathroom filters verified unit-by-unit** — rather than trusting a listing summary, these two filters are checked against each property's actual units, so a "2+ bath, ready by March 1" search only keeps properties that genuinely qualify.
- **Exact GPS plus full mailing address** — latitude, longitude, street address, city, state, and ZIP on every property, ready to drop onto a map or feed a geocoder.
- **Leasing contacts, fees, and full media** — direct leasing phone number, management company, application and deposit fees, lease terms, parking and storage notes, and the complete photo set (17 images on a sample property) plus per-unit floorplan photos.
- **City-name search across the US or direct URLs** — type "Austin, TX" and it resolves to the correct ApartmentList page automatically, or paste search and property links copied from your browser; a single search pulls a city's entire ranked property set, so nothing is lost between pages.

### Use Cases

**Market Research & Rent Benchmarking**
- Map current rent-per-square-foot across a city's floorplans and unit types
- Compare studio, 1-, 2-, and 3-bedroom pricing block by block
- Track availability and move-in timing to gauge local demand
- Build rent indices from exact per-unit prices, not advertised ranges

**Investment & Acquisition Analysis**
- Pull every competing community around a target asset with full unit mixes
- Model achievable rents from live floorplan pricing and lease terms
- Flag concession activity via rent specials and fee structures
- Assess school ratings and amenity depth that drive resident demand

**Relocation & Concierge Services**
- Shortlist properties by budget, bedrooms, pets, and move-in date for a client
- Deliver curated options with photos, amenities, and leasing phone numbers
- Filter to pet-friendly communities allowing cats, dogs, or both
- Match families to properties near highly rated schools

**Lead Generation for Property Managers**
- Build competitor watch lists with management company and leasing contacts
- Monitor how rival communities price and position comparable floorplans
- Identify buildings running rent specials in your submarket

**Data Enrichment & Integration**
- Enrich a CRM or underwriting model with fresh unit-level rental data
- Feed dashboards with geocoded, structured listings by city
- Power rental comparison tools and relocation portals

### Getting Started

#### Simple City Search

Just name a city — filters are optional:

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

#### Filtered Search

Two-bedroom, pet-friendly, under $3,000, available by a target date:

```json
{
    "location": ["Denver, CO"],
    "bedrooms": ["2"],
    "priceMax": 3000,
    "bathroomsMin": 2,
    "petPolicy": "cats-and-dogs",
    "moveInDate": "2026-09-01",
    "amenities": ["in_unit_laundry", "parking"],
    "includeDetails": true,
    "maxResults": 200
}
```

#### Advanced — Paste ApartmentList URLs

Copy any city or property URL from your browser (after applying filters on the site) and let it override the guided fields:

```json
{
    "startUrls": [
        "https://www.apartmentlist.com/tx/austin",
        "https://www.apartmentlist.com/tx/austin/presidium-183"
    ],
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `location` | string\[] | `["Austin, TX"]` | Cities or areas to search, one per line (e.g. "Austin, TX", "New York, NY"). Each is searched separately and resolved to its ApartmentList page. Ignored when Start URLs are set. |
| `startUrls` | string\[] | `[]` | Power-user input. Paste ApartmentList search-result or individual property URLs copied from your browser. When provided, these override Locations and Filters. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `bedrooms` | select\[] | `[]` | Only include properties offering these bedroom counts. Options: Studio, 1 Bedroom, 2 Bedrooms, 3 Bedrooms, 4+ Bedrooms. Empty = any. |
| `bathroomsMin` | integer | `null` | Only include properties with a unit offering at least this many bathrooms (1–5). Works best with full property details on. |
| `priceMin` | integer | `null` | Only include listings at or above this monthly rent (USD). Empty = no minimum. |
| `priceMax` | integer | `null` | Only include listings at or below this monthly rent (USD). Empty = no maximum. |
| `moveInDate` | string | `null` | Only include properties with a unit ready on or before this date (YYYY-MM-DD). Works best with full property details on. |
| `petPolicy` | select | `Any` | Pet policy: Any, Cats allowed, Dogs allowed, or Cats & dogs allowed. |
| `amenities` | select\[] | `[]` | Only include properties offering all selected amenities: In-unit laundry, Laundry facilities, Air conditioning, Parking, Pool, Gym / fitness center, Dishwasher, Balcony / patio, Hardwood floors, Elevator, Wheelchair accessible. |

#### Output Detail & Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | Open each property's page to add its full unit and floorplan list, all amenities, nearby schools, fees, lease details, and the complete photo set. Turn off for faster, cheaper card-level runs. |
| `maxResults` | integer | `100` | Maximum number of properties to collect across all locations and URLs. Set to 0 for unlimited (an internal cap of 50,000 properties per run still applies). Counts properties, not individual units. |

### Output

Each row is one property, with its floorplans and units nested inside. Here is a representative result with full details enabled (units, schools, amenities, and photos trimmed for brevity):

```json
{
    "id": "p101471975",
    "url": "https://www.apartmentlist.com/tx/austin/presidium-183",
    "propertyName": "Presidium 183",
    "streetAddress": "9111 Research Boulevard",
    "formattedAddress": "9111 Research Boulevard, Austin, TX 78758",
    "city": "Austin",
    "state": "TX",
    "postalCode": "78758",
    "latitude": 30.375466,
    "longitude": -97.728449,
    "priceMin": 1030,
    "priceMax": 3024,
    "bedroomsAvailable": [0, 1, 2],
    "bathroomsAvailable": [1, 2],
    "unitsAvailable": 51,
    "soonestAvailable": "2025-08-25",
    "petPolicy": "Cats and dogs allowed",
    "amenities": ["Pool", "Gym", "In unit laundry", "Dishwasher", "Elevator", "Dog park", "Hardwood floors", "Parking"],
    "phone": "(934) 246-5800",
    "managementCompany": "presidium_re",
    "description": "Experience elevated urban living at Presidium 183 Apartments, North Austin's premier luxury community...",
    "applicationFee": null,
    "depositFee": null,
    "additionalFees": null,
    "leaseTerms": null,
    "parkingDetails": null,
    "storageDetails": null,
    "hasRentSpecial": null,
    "photos": [
        "https://cdn.apartmentlist.com/image/upload/f_auto,q_auto/a543abe0eb9ee374f8803a2d364be979.jpg"
    ],
    "schools": [
        { "name": "Hill Elementary School", "type": "public", "grades": "PK-5", "rating": 8, "numberOfStudents": 954, "distance": 1.2 }
    ],
    "units": [
        {
            "floorplan": "B41",
            "unitName": "2201",
            "bedrooms": 2,
            "bathrooms": 2,
            "sqft": 1274,
            "price": 2759,
            "priceMax": null,
            "totalPrice": 2759,
            "requiredFees": 0,
            "availability": "available",
            "availableOn": "2026-06-11",
            "leaseLength": 6,
            "applyUrl": "http://presidium183.securecafe.com/onlineleasing/...",
            "photos": ["https://cdn.apartmentlist.com/image/upload/f_auto,q_auto/d8443808ebe4d82cfb1e1e3004fd0e49.jpg"]
        }
    ],
    "availabilityLastChecked": null,
    "updatedAt": "2026-07-14T00:00:00Z",
    "searchLocation": "Austin, TX",
    "scrapedAt": "2026-07-16T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique ApartmentList property identifier |
| `url` | string | Direct property page URL |
| `propertyName` | string | Building or community name |
| `description` | string | Full property description text |
| `phone` | string | Leasing phone number |
| `managementCompany` | string | Managing company name |
| `hasRentSpecial` | boolean | Whether the property is running a rent special |
| `availabilityLastChecked` | string | When availability was last verified |
| `updatedAt` | string | Property last-updated timestamp |
| `searchLocation` | string | The input location that produced this row |
| `scrapedAt` | string | ISO timestamp of data collection |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `streetAddress` | string | Street address |
| `formattedAddress` | string | Full single-line address |
| `city` | string | City |
| `state` | string | Two-letter state code |
| `postalCode` | string | ZIP code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Pricing & Availability

| Field | Type | Description |
|-------|------|-------------|
| `priceMin` | number | Lowest current rent across units (USD) |
| `priceMax` | number | Highest current rent across units (USD) |
| `bedroomsAvailable` | number\[] | Distinct bedroom counts available (0 = studio) |
| `bathroomsAvailable` | number\[] | Distinct bathroom counts available |
| `unitsAvailable` | number | Count of currently available units |
| `soonestAvailable` | string | Earliest move-in date across units |
| `petPolicy` | string | Pet policy summary (cats and/or dogs) |

#### Fees & Lease

| Field | Type | Description |
|-------|------|-------------|
| `applicationFee` | string | Application fee, when published |
| `depositFee` | string | Security deposit, when published |
| `additionalFees` | string | Other fees, when published |
| `leaseTerms` | string | Lease term details |
| `parkingDetails` | string | Parking details |
| `storageDetails` | string | Storage details |

#### Units, Schools, Amenities & Media

| Field | Type | Description |
|-------|------|-------------|
| `units` | object\[] | Per-unit floorplan list (see fields below) |
| `schools` | object\[] | Nearby schools: `name`, `type`, `grades`, `rating` (1–10), `numberOfStudents`, `distance` (miles) |
| `amenities` | string\[] | Flat list of property amenities |
| `photos` | string\[] | Property photo URLs |

Each object in `units` contains:

| Field | Type | Description |
|-------|------|-------------|
| `floorplan` | string | Floorplan name |
| `unitName` | string | Unit or floorplan label |
| `bedrooms` | number | Bedrooms in the unit (0 = studio) |
| `bathrooms` | number | Bathrooms in the unit |
| `sqft` | number | Unit size in square feet |
| `price` | number | Monthly rent (USD); `null` when not disclosed |
| `priceMax` | number | Upper rent bound when the unit is priced as a range |
| `totalPrice` | number | Total monthly cost including required fees |
| `requiredFees` | number | Required recurring fees |
| `availability` | string | Availability status (e.g. "available") |
| `availableOn` | string | Date the unit is ready for move-in |
| `leaseLength` | number | Lease length in months |
| `applyUrl` | string | Direct online application link |
| `photos` | string\[] | Floorplan photo URLs |

### Tips for Best Results

- **Keep full details on for unit-level data** — `includeDetails` (on by default) is what adds the complete units, schools, fees, and full photo set. Turn it off only when you want a fast, city-wide sweep of property cards.
- **Bathroom and move-in filters need full details** — `bathroomsMin` and `moveInDate` are confirmed against each property's actual units, so leave `includeDetails` on for the most accurate matches; with it off they fall back to the property-level summary.
- **Start small, then scale** — run 25–50 results first to confirm the filters match your intent, then raise `maxResults`.
- **Remember one row equals one property** — `maxResults` counts properties, and each can carry dozens of units, so a 100-property run can yield thousands of unit records.
- **Studio is bedroom count 0** — select "Studio" in bedrooms, and read `bedrooms: 0` in the unit data.
- **Combine cities in one run** — list several locations together to benchmark rents across markets in a single dataset.
- **Paste filtered URLs for exact parity** — apply filters on ApartmentList, then paste the resulting URL into Start URLs to mirror precisely what you see on the site.

### Pricing

**From $2.00 per 1,000 results** — a flat pay-per-result rate that undercuts monthly-subscription rental scrapers, with no commitment for low-volume runs. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.24 | $0.23 | $0.22 | $0.20 |
| 1,000 | $2.40 | $2.25 | $2.15 | $2.00 |
| 10,000 | $24.00 | $22.50 | $21.50 | $20.00 |
| 100,000 | $240.00 | $225.00 | $215.00 | $200.00 |

A "result" is one property row in your dataset, no matter how many units it contains. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate real estate research, market analysis, and relocation services. You are responsible for complying with applicable laws and ApartmentList's Terms of Service. Collect only publicly available listing information, respect fair housing regulations when using property data, and do not use extracted data for spam, harassment, or any unlawful purpose. </content> </invoke>

# Actor input Schema

## `location` (type: `array`):

Cities or areas to search, one per line, e.g. 'Austin, TX', 'New York, NY', 'San Francisco, CA'. Each location is searched separately. Ignored when Start URLs are provided.

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

Power-user input. Paste ApartmentList city search-result URLs (e.g. https://www.apartmentlist.com/tx/austin) or individual property URLs, copied from your browser after applying filters. Neighborhood-only URLs (…/neighborhoods/…) are not supported — use the parent city URL instead. When provided, these override the Locations and Filters settings above.

## `bedrooms` (type: `array`):

Only include properties offering these bedroom counts. Select any combination. Leave empty for no bedroom filter.

## `bathroomsMin` (type: `integer`):

Only include properties offering a unit with at least this many bathrooms. The exact minimum is confirmed against each property's units, so this works best with Include Full Property Details turned on. Leave empty for no bathroom filter.

## `priceMin` (type: `integer`):

Only include listings at or above this monthly rent in US dollars. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only include listings at or below this monthly rent in US dollars. Leave empty for no maximum.

## `moveInDate` (type: `string`):

Only include properties with at least one unit ready to move into on or before this date (YYYY-MM-DD). Leave empty for any availability. Applied to each unit's availability, so it works best with Include Full Property Details turned on.

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

Only include properties allowing the selected pets.

## `amenities` (type: `array`):

Only include properties that offer all of these amenities. Leave empty for no amenity filter.

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

Open each property's own page to add the full unit/floorplan list (beds, baths, sqft, price, availability), all amenities, nearby schools, fee and lease details, and the complete photo set. Turn off for faster, cheaper runs that return only what's on the search card. Slower when on: it makes one extra request per property.

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

Maximum number of properties to collect across all locations and URLs combined. Set to 0 for unlimited (an internal upper limit of 50,000 properties per run still applies). Note: each property can contain many individual units — this cap counts properties, not units. Results are collected in full pages, so the final page may overshoot this cap by a few records.

## Actor input object example

```json
{
  "location": [
    "Austin, TX"
  ],
  "startUrls": [],
  "bedrooms": [],
  "petPolicy": "any",
  "amenities": [],
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped properties with key fields — name, city/state, rent range, bedrooms, pet policy, and URL.

## `details` (type: `string`):

Full per-property fields including address, GPS coordinates, amenities, fees, photos, nearby schools, and the nested units/floorplans array.

# 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 = {
    "location": [
        "Austin, TX"
    ],
    "startUrls": [],
    "bedrooms": [],
    "petPolicy": "any",
    "amenities": [],
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/apartmentlist-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 = {
    "location": ["Austin, TX"],
    "startUrls": [],
    "bedrooms": [],
    "petPolicy": "any",
    "amenities": [],
    "includeDetails": True,
    "maxResults": 100,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apartment List Scraper",
        "description": "[💰 $2 / 1K] Extract US apartment and rental listings from ApartmentList.com — search any city or paste URLs. Get rent prices, floorplans and units (beds/baths/sqft/availability), amenities, pet policy, fees, photos, GPS, and nearby schools. Filter by price, bedrooms, move-in date, and pets.",
        "version": "1.0",
        "x-build-id": "U3yde1vfIA3fudLkh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~apartmentlist-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-apartmentlist-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/solidcode~apartmentlist-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-apartmentlist-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/solidcode~apartmentlist-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-apartmentlist-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": {
                    "location": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities or areas to search, one per line, e.g. 'Austin, TX', 'New York, NY', 'San Francisco, CA'. Each location is searched separately. Ignored when Start URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste ApartmentList city search-result URLs (e.g. https://www.apartmentlist.com/tx/austin) or individual property URLs, copied from your browser after applying filters. Neighborhood-only URLs (…/neighborhoods/…) are not supported — use the parent city URL instead. When provided, these override the Locations and Filters settings above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "bedrooms": {
                        "title": "Bedrooms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include properties offering these bedroom counts. Select any combination. Leave empty for no bedroom filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "studio",
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "Studio",
                                "1 Bedroom",
                                "2 Bedrooms",
                                "3 Bedrooms",
                                "4+ Bedrooms"
                            ]
                        },
                        "default": []
                    },
                    "bathroomsMin": {
                        "title": "Minimum Bathrooms",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include properties offering a unit with at least this many bathrooms. The exact minimum is confirmed against each property's units, so this works best with Include Full Property Details turned on. Leave empty for no bathroom filter."
                    },
                    "priceMin": {
                        "title": "Minimum Rent (USD / month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this monthly rent in US dollars. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Rent (USD / month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this monthly rent in US dollars. Leave empty for no maximum."
                    },
                    "moveInDate": {
                        "title": "Move-in Date",
                        "type": "string",
                        "description": "Only include properties with at least one unit ready to move into on or before this date (YYYY-MM-DD). Leave empty for any availability. Applied to each unit's availability, so it works best with Include Full Property Details turned on."
                    },
                    "petPolicy": {
                        "title": "Pet Policy",
                        "enum": [
                            "any",
                            "cats",
                            "dogs",
                            "cats-and-dogs"
                        ],
                        "type": "string",
                        "description": "Only include properties allowing the selected pets.",
                        "default": "any"
                    },
                    "amenities": {
                        "title": "Required Amenities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include properties that offer all of these amenities. Leave empty for no amenity filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "in_unit_laundry",
                                "laundry_facilities",
                                "air_conditioning",
                                "parking",
                                "pool",
                                "gym",
                                "dishwasher",
                                "balcony",
                                "hardwood_floors",
                                "elevator",
                                "wheelchair_accessible"
                            ],
                            "enumTitles": [
                                "In-unit laundry",
                                "Laundry facilities",
                                "Air conditioning",
                                "Parking",
                                "Pool",
                                "Gym / fitness center",
                                "Dishwasher",
                                "Balcony / patio",
                                "Hardwood floors",
                                "Elevator",
                                "Wheelchair accessible"
                            ]
                        },
                        "default": []
                    },
                    "includeDetails": {
                        "title": "Include Full Property Details",
                        "type": "boolean",
                        "description": "Open each property's own page to add the full unit/floorplan list (beds, baths, sqft, price, availability), all amenities, nearby schools, fee and lease details, and the complete photo set. Turn off for faster, cheaper runs that return only what's on the search card. Slower when on: it makes one extra request per property.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to collect across all locations and URLs combined. Set to 0 for unlimited (an internal upper limit of 50,000 properties per run still applies). Note: each property can contain many individual units — this cap counts properties, not units. Results are collected in full pages, so the final page may overshoot this cap by a few records.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
