# Zumper Scraper (`crawlerbros/zumper-scraper`) Actor

Scrape Zumper - US and Canada's leading rental platform. Search apartments, rooms, houses, condos, and townhomes by city and state. Get price, address, bedrooms, bathrooms, amenities, pet policy, floor size, and more.

- **URL**: https://apify.com/crawlerbros/zumper-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Zumper Scraper

Scrape **Zumper** — one of the largest rental marketplaces in the US and Canada. Search apartments and rental buildings by city and state with an optional bedroom filter, or fetch detail for specific listing URLs, and get rent ranges, bedroom and bathroom counts, square footage, address with neighbourhood and ZIP, property and lease type, pet policy, unit and building amenities, agent and brokerage contact, geo-coordinates, ratings, and photos. HTTP-only against `zumper.com`. No auth, no proxy.

### What this actor does

- **Three modes:** `searchRentals` (city + state), `searchByCity` (city name, slug resolved automatically), `listingDetails` (specific listing URLs)
- **60 states and provinces** exposed as a dropdown, covering the US and Canada
- **Bedroom filter:** 0 (studio) through 5
- **Geo-ready output:** latitude and longitude on every listing that publishes them, so results map directly
- **Empty fields are omitted**

### Output per rental listing

- `listingId` — Zumper listing ID
- `name` — building or listing name
- `address` — street address
- `city`, `state`, `zipCode`
- `neighborhood`
- `minPrice`, `maxPrice` — monthly rent range; equal values mean a single fixed rent
- `minBedrooms`, `maxBedrooms` — bedroom range across available units
- `minBathrooms`, `maxBathrooms` — bathroom range
- `squareFeet` — unit size (mode=listingDetails)
- `propertyType` — e.g. apartment, condo, house
- `leaseType` — long-term, short-term, or similar
- `petsAllowed` — pet policy as advertised
- `amenities` — in-unit amenities
- `buildingAmenities` — shared building amenities
- `rating` — Zumper rating, where one exists
- `phone`, `agentName`, `brokerageName` — listing contact
- `latitude`, `longitude`
- `imageUrl` — primary listing photo
- `listingUrl` — listing page on Zumper
- `searchCity`, `searchState` — the search that produced the record
- `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchRentals` | `searchRentals` / `searchByCity` / `listingDetails` |
| `city` | string | `San Francisco` | City name (search modes) |
| `state` | string | `CA` | US state or Canadian province code (search modes) |
| `bedrooms` | int | – | Bedroom count filter, `0` for studio (0–5) |
| `listingUrls` | array | – | Zumper listing URLs to fetch (mode=listingDetails) |
| `maxItems` | int | `20` | Hard cap (1–1000) |

#### Example: rentals in a major city

```json
{
  "mode": "searchRentals",
  "city": "San Francisco",
  "state": "CA",
  "maxItems": 200
}
```

#### Example: two-bedroom units

```json
{
  "mode": "searchRentals",
  "city": "Austin",
  "state": "TX",
  "bedrooms": 2,
  "maxItems": 300
}
```

#### Example: studios in a Canadian city

```json
{
  "mode": "searchByCity",
  "city": "Toronto",
  "state": "ON",
  "bedrooms": 0,
  "maxItems": 150
}
```

#### Example: detail for specific listings

```json
{
  "mode": "listingDetails",
  "listingUrls": [
    "https://www.zumper.com/apartments-for-rent/listing/12345678"
  ]
}
```

### Use cases

- **Rental market analysis** — track asking rents by city, neighbourhood, and bedroom count
- **Relocation and HR tools** — surface available units within a budget near a workplace
- **Property investment** — benchmark comparable rents before acquiring a building
- **Proptech products** — feed live inventory with geo-coordinates into a map-based search
- **Brokerage intelligence** — see which agencies list most heavily in a submarket
- **Data journalism** — quantify affordability and amenity trends across US and Canadian cities

### FAQ

**What is Zumper?**  A large North American rental marketplace listing apartments, condos, and houses across the US and Canada. See [zumper.com](https://www.zumper.com).

**Is this affiliated with Zumper?**  No. This is a third-party actor reading their public listing data.

**Do I need an account?**  No. Only publicly visible listing data is collected.

**Why are prices a range rather than a single number?**  Many Zumper entries are whole buildings with several available units. `minPrice` and `maxPrice` bracket the units currently listed; for a single unit both values are the same. Bedrooms and bathrooms work the same way.

**What's the difference between `searchRentals` and `searchByCity`?**  Both resolve a city to Zumper's internal location slug. `searchRentals` expects a city and its state code; `searchByCity` is more forgiving about the city name and is useful when the exact spelling or slug is uncertain.

**Does it cover Canada?**  Yes. The state dropdown includes the Canadian provinces — pass `ON`, `BC`, `QC` and so on with the matching city.

**Why is `squareFeet` missing from search results?**  Search returns building-level summaries where unit sizes vary. Run `listingDetails` on a specific listing to get its square footage.

**What's the difference between `amenities` and `buildingAmenities`?**  `amenities` are in-unit features such as in-unit laundry or dishwasher. `buildingAmenities` are shared facilities such as a gym, roof deck, or parking garage.

**Are contact details always present?**  No. `phone`, `agentName`, and `brokerageName` appear when the advertiser publishes them; private landlords often route enquiries through Zumper instead.

**How fresh is the data?**  Live at run time. Rental inventory turns over quickly, so re-running gives current availability and pricing.

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

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

City name (e.g. San Francisco, New York, Chicago). Used in searchRentals and searchByCity modes.

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

US/Canada state or province code (e.g. CA, NY, TX, ON). Used in searchRentals mode.

## `bedrooms` (type: `integer`):

Number of bedrooms filter. 0 = studio.

## `listingUrls` (type: `array`):

List of Zumper listing URLs for detail scraping.

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

Maximum number of listings to return.

## Actor input object example

```json
{
  "mode": "searchRentals",
  "city": "San Francisco",
  "state": "CA",
  "listingUrls": [],
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped Zumper rental 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 = {
    "mode": "searchRentals",
    "city": "San Francisco",
    "state": "CA",
    "listingUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zumper-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 = {
    "mode": "searchRentals",
    "city": "San Francisco",
    "state": "CA",
    "listingUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zumper-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 '{
  "mode": "searchRentals",
  "city": "San Francisco",
  "state": "CA",
  "listingUrls": [],
  "maxItems": 20
}' |
apify call crawlerbros/zumper-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/zumper-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/favbRdm9UcjdmnzVE/builds/rUvmnB9BM0LcKK7IN/openapi.json