# ApartmentFinder Scraper (`crawlerbros/apartmentfinder-scraper`) Actor

Scrape ApartmentFinder.com - one of the largest US apartment rental platforms. Search rental apartments across 29 major US cities including Austin, New York, Los Angeles, Chicago, Miami, Seattle. Returns apartment name, price range, address, city, state, coordinates, phone, bed/price breakdown,

- **URL**: https://apify.com/crawlerbros/apartmentfinder-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Real estate, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## ApartmentFinder Scraper

Scrape apartment rental listings from **ApartmentFinder.com** — one of the largest US apartment search platforms. Search rental apartments across 29 major US cities and retrieve structured data including apartment name, price range, address, city, state, GPS coordinates, phone number, bed/price breakdown, and direct listing URLs.

### Features

- Search rental apartments across **29 major US cities**
- Covers all major metro areas: Texas, California, New York, Florida, and more
- Returns up to **500 listings** per run
- Full **address, city, and state** details
- **Price range** per apartment complex
- **Bed type and per-unit pricing** breakdown
- **GPS coordinates** (latitude/longitude) for mapping
- **Phone number** for direct contact
- **Property image** URL included

### Input

| Field | Type | Description |
|-------|------|-------------|
| `city` | String | US city to search (austin, new-york, los-angeles, etc.) |
| `maxItems` | Integer | Max number of results (1–500, default 20) |

#### Supported Cities

Austin, Dallas, Houston, San Antonio, New York, Los Angeles, Chicago, Phoenix, Philadelphia, San Diego, San Jose, Jacksonville, Fort Worth, Columbus, Charlotte, Indianapolis, San Francisco, Seattle, Denver, Nashville, Miami, Atlanta, Boston, Portland, Las Vegas, Minneapolis, Raleigh, Tampa, Orlando

#### Example Input

```json
{
  "city": "austin",
  "maxItems": 50
}
````

### Output

Each item in the dataset represents one apartment complex listing:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | String | Unique ApartmentFinder listing ID |
| `name` | String | Apartment complex name |
| `priceRange` | String | Price range for available units (e.g. $1,200 - $2,500) |
| `address` | String | Full street address |
| `city` | String | City name |
| `state` | String | State abbreviation (e.g. TX, CA, NY) |
| `phone` | String | Contact phone number |
| `latitude` | Float | GPS latitude |
| `longitude` | Float | GPS longitude |
| `imageUrl` | String | URL of the primary listing image |
| `listingUrl` | String | Direct link to ApartmentFinder listing |
| `bedPricing` | Array | Per bed-type pricing breakdown (see below) |
| `scrapedAt` | String | ISO timestamp of when data was scraped |

#### bedPricing Array

Each element in `bedPricing` contains:

| Field | Type | Description |
|-------|------|-------------|
| `bedType` | String | Unit type (Studio, 1 Bed, 2 Beds, 3 Beds) |
| `startingPrice` | String | Starting rent for that unit type |

#### Example Output

```json
{
  "listingId": "r3v5z9k2m",
  "name": "The Domain at Barton Creek",
  "priceRange": "$1,350 - $2,800",
  "address": "8400 Southwest Parkway",
  "city": "Austin",
  "state": "TX",
  "phone": "(512) 555-0142",
  "latitude": 30.2241,
  "longitude": -97.8132,
  "imageUrl": "https://image.apartmentfinder.com/listings/r3v5z9k2m/main.jpg",
  "listingUrl": "https://www.apartmentfinder.com/Texas/Austin-Apartments/The-Domain-at-Barton-Creek-A10000001",
  "bedPricing": [
    { "bedType": "Studio", "startingPrice": "$1,350" },
    { "bedType": "1 Bed", "startingPrice": "$1,575" },
    { "bedType": "2 Beds", "startingPrice": "$2,100" }
  ],
  "scrapedAt": "2026-06-02T10:30:00+00:00"
}
```

### FAQ

**Does it require proxies?**
No. ApartmentFinder listing pages are publicly accessible without authentication, cookies, or proxies.

**How many results can I get?**
Up to 500 listings per run. ApartmentFinder displays approximately 42 listings per page.

**Which cities are supported?**
29 major US cities across all major metro areas including the top Texas markets, New York, Los Angeles, Chicago, Miami, Seattle, Denver, Atlanta, Boston, and more.

**What does `priceRange` represent?**
The price range shows the lowest and highest rent across all available unit types within that apartment complex.

**What is `bedPricing`?**
`bedPricing` is an array with per-unit-type starting prices. For example, a complex may offer Studio units starting at $1,200 and 2-bedroom units starting at $1,900.

**Are listings for purchase included?**
No. ApartmentFinder is exclusively a rental platform. All listings are rental apartments.

**What's the data freshness?**
Listings are live from ApartmentFinder at the time of scraping.

# Actor input Schema

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

US city to search for apartments in.

## `maxItems` (type: `integer`):

Maximum number of listings to return (1–500).

## Actor input object example

```json
{
  "city": "austin",
  "maxItems": 20
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped ApartmentFinder apartment 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 = {
    "city": "austin",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/apartmentfinder-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 = {
    "city": "austin",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/apartmentfinder-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 '{
  "city": "austin",
  "maxItems": 20
}' |
apify call crawlerbros/apartmentfinder-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ApartmentFinder Scraper",
        "description": "Scrape ApartmentFinder.com - one of the largest US apartment rental platforms. Search rental apartments across 29 major US cities including Austin, New York, Los Angeles, Chicago, Miami, Seattle. Returns apartment name, price range, address, city, state, coordinates, phone, bed/price breakdown,",
        "version": "1.0",
        "x-build-id": "fG5LEwwKrU1FvLmxX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~apartmentfinder-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-apartmentfinder-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/crawlerbros~apartmentfinder-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-apartmentfinder-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/crawlerbros~apartmentfinder-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-apartmentfinder-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",
                "required": [
                    "city"
                ],
                "properties": {
                    "city": {
                        "title": "City",
                        "enum": [
                            "austin",
                            "dallas",
                            "houston",
                            "san-antonio",
                            "new-york",
                            "los-angeles",
                            "chicago",
                            "phoenix",
                            "philadelphia",
                            "san-diego",
                            "san-jose",
                            "jacksonville",
                            "fort-worth",
                            "columbus",
                            "charlotte",
                            "indianapolis",
                            "san-francisco",
                            "seattle",
                            "denver",
                            "nashville",
                            "miami",
                            "atlanta",
                            "boston",
                            "portland",
                            "las-vegas",
                            "minneapolis",
                            "raleigh",
                            "tampa",
                            "orlando"
                        ],
                        "type": "string",
                        "description": "US city to search for apartments in.",
                        "default": "austin"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of listings to return (1–500).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
