# Zumper Scraper \[$2💰] | Rental Listings | US Market Data (`ahmed_jasarevic/zumper-scraper`) Actor

Scrape US rental listings from Zumper: rent, beds/baths, sqft, amenities and availability across thousands of apartment listings. Built for rental price monitoring, rent comparables and rental market research. Structured JSON rows via API, schedule or webhook.

- **URL**: https://apify.com/ahmed_jasarevic/zumper-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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

## Zumper Scraper — Scrape US Zumper Rental Listings As JSON

Scrape US rental listings from [Zumper](https://www.zumper.com) into **48-field JSON rows** — rent range, beds/baths, square footage, address, neighborhood, ZIP, amenities, pet policy, photos, agent contact, ratings and availability dates — using Zumper's own internal JSON APIs instead of its bot-protected HTML, so no browser is required. Built for rent comparables, rental price monitoring and rental market analysis at US city level.

### Main Use Cases: Rental Price Monitoring, Rent Comparables And Market Data

- **Rental price monitoring** — schedule recurring runs on the same city slug and diff the exports to track rent prices over time.
- **Rent comparables** — every row carries address, lat/lng, rent range, beds/baths, square footage and `listedAt`: the raw ingredients of a comp set.
- **Rental market analysis** — export a city run to CSV and compute median rent, $/sqft and listing counts; two runs give you rental market trends.
- **Rental lead generation** — rows include agent/brokerage name and phone (and e-mail with `includeDetails`) whenever Zumper exposes them.
- **Budget-filtered searches** — price and bedroom filters narrow a run to apartments under $2000, studios or 1-bedroom comps.
- **City-by-city apartment data pulls** — the same input shape works for `new-york-ny`, `los-angeles-ca`, `chicago-il` and `san-francisco-ca`.

### How The Zumper Scraper Works

The actor runs as a plain **CheerioCrawler** — HTTP plus JSON parsing, no headless browser, 256 MB memory. For each target city it POSTs Zumper's search endpoint (50 results per page, `offset` pagination), enriches rows with one building-detail request per building (standalone listings fall back to listing detail), applies price and bedroom filters in-process, and writes one dataset row per listing. Photo URLs are rebuilt from image ids; `includeDetails` adds extra detail for a per-request charge.

### Zumper Scraper Input Parameters

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | One of\* | `https://www.zumper.com/apartments-for-rent/austin-tx` (prefill) | Zumper search page URLs — one US city per entry; entries are `{"url": "..."}` objects. |
| `location` | string | One of\* | `""` (empty) | Alternative to `startUrls`: a Zumper slug (`austin-tx`) or a city (`Austin, TX`). Merged with any start URLs. |
| `maxItems` | integer | No | `50` | Hard cap on listings per run (min 1, max 5000). |
| `maxConcurrency` | integer | No | `4` | Requests processed in parallel (min 1, max 20). |
| `minPrice` | integer | No | — | Keep listings whose cheapest unit is at least this rent; applied client-side because Zumper's API accepts but ignores price filters. |
| `maxPrice` | integer | No | — | Keep listings whose cheapest unit is at most this rent (also client-side). |
| `minBedrooms` | integer | No | — | Keep listings with at least this many bedrooms (0 = studio); client-side. |
| `maxBedrooms` | integer | No | — | Keep listings with at most this many bedrooms; client-side. |
| `includeDetails` | boolean | No | `false` | Also fetch extra listing details (pet policy, agent e-mail, photos). Billed per extra request via the `include-details` charge event. |
| `maxRequestsPerCrawl` | integer | No | `1000` | Safety cap on total HTTP requests — search plus detail (min 10, max 20000). |
| `proxy` | object | No | `{"useApifyProxy": false}` | Standard Apify proxy picker — recommended for large runs; the search API rate-limits ~10–15 req/min per IP. |

\* The schema marks no field as formally required, but a run needs a target: `startUrls` (prefilled with the Austin, TX page) or `location`.

**Geography:** US city-level slugs only (`austin-tx`, `new-york-ny`) — neighborhood slugs such as `austin-tx/chestnut` return 0 results; there is no ZIP-level or non-US input. Free users get a capped 10-listing preview; paying users get full runs.

### Rental Listings As Structured JSON: All 48 Output Fields

One dataset row per Zumper listing. The dataset ships an **Overview** view (`title`, `rentMin`, `rentMax`, `bedroomsMin`, `bathroomsMin`, `squareFeetMin`, `address`, `neighborhood`, `zip`, `brokerageName`, `dateAvailable`, `url`) and exports as JSON, CSV or Excel from the console or the Apify API.

**Identity & provenance (7)** — `source` (always `"zumper"`), `listingId` (the row key for diffs), `buildingId` (`null` for standalone homes), `url`, `feedName` (upstream syndication feed), `enrichedWithDetail` (`true` when extra details were merged in), `scrapedAt` (ISO 8601).

**Listing text (2)** — `title` (unit/floorplan title or building name), `description`.

**Pricing (3)** — `rentMin` / `rentMax` (cheapest and most expensive unit rent per month), `currencyCode` (`1` = USD).

**Unit size (7)** — `bedroomsMin` / `bedroomsMax`, `bathroomsMin` / `bathroomsMax`, `squareFeetMin` / `squareFeetMax` (min/max ranges across the listing's units), `floorplanCount`.

**Location (8)** — `address`, `neighborhood`, `buildingName`, `city`, `state`, `zip`, `latitude`, `longitude`.

**Amenities & pets (5)** — `amenities` (unit tags), `buildingAmenities`, `petPolicy` (structured per species — authoritative pet info), `petsAllowed`, `petCodes` (raw codes: `1` = cat, `2` = dog, `3` = bird).

**Photos (2)** — `photos` (absolute `img.zumpercdn.com` URLs, reconstructed as `https://img.zumpercdn.com/{image_id}/1280x960`), `photoCount`.

**Contacts (4)** — `agentName`, `agentPhone`, `agentEmail` (arrives with detail enrichment), `brokerageName`.

**Ratings & reviews (3)** — `rating` (Zumper score 0–10), `externalRating`, `reviewsSummary`.

**Key dates (4)** — `dateAvailable` (ISO 8601 `YYYY-MM-DD`; often `null` because Zumper only populates it for some listings), `listedAt`, `modifiedAt`, `createdAt` (ISO 8601).

**Classification codes (3)** — `propertyType`, `leaseType`, `listingStatus` (raw Zumper numeric codes).

### Example Input And Output: Zumper Rental Listings

Example input:

```json
{
  "startUrls": [
    { "url": "https://www.zumper.com/apartments-for-rent/austin-tx" },
    { "url": "https://www.zumper.com/apartments-for-rent/chicago-il" }
  ],
  "maxItems": 100,
  "maxConcurrency": 4,
  "minPrice": 1000,
  "maxPrice": 2000,
  "minBedrooms": 1,
  "maxBedrooms": 2,
  "includeDetails": true,
  "maxRequestsPerCrawl": 300,
  "proxy": { "useApifyProxy": true }
}
```

Example output (one dataset row, values illustrative):

```json
{
  "source": "zumper",
  "listingId": 3456789,
  "buildingId": 123456,
  "url": "https://www.zumper.com/apartments/austin-tx/123-main-st-3456789",
  "title": "2 bed, 2 bath - 123 Main St",
  "description": "Modern downtown 2-bedroom with in-unit washer/dryer.",
  "rentMin": 1645,
  "rentMax": 2410,
  "currencyCode": 1,
  "bedroomsMin": 2,
  "bedroomsMax": 2,
  "bathroomsMin": 2,
  "bathroomsMax": 2,
  "squareFeetMin": 950,
  "squareFeetMax": 1100,
  "floorplanCount": 4,
  "address": "123 Main St, Austin, TX 78701",
  "neighborhood": "Downtown",
  "buildingName": "Main Street Lofts",
  "city": "Austin",
  "state": "TX",
  "zip": "78701",
  "latitude": 30.2695,
  "longitude": -97.742,
  "amenities": ["in-unit washer/dryer", "dishwasher", "balcony"],
  "buildingAmenities": ["pool", "fitness center", "parking"],
  "petPolicy": [
    { "species": "dog", "allowed": true },
    { "species": "cat", "allowed": true }
  ],
  "petsAllowed": true,
  "petCodes": [1, 2],
  "photos": ["https://img.zumpercdn.com/1122334455/1280x960"],
  "photoCount": 18,
  "agentName": "Jordan Example",
  "agentPhone": "+1-512-555-0143",
  "agentEmail": "jordan@example.com",
  "brokerageName": "Example Realty",
  "rating": 4.2,
  "externalRating": null,
  "reviewsSummary": "Residents like the pool and staff.",
  "dateAvailable": null,
  "listedAt": "2026-09-14T10:15:00Z",
  "modifiedAt": "2026-10-01T08:02:00Z",
  "createdAt": "2025-06-02T12:00:00Z",
  "propertyType": 2,
  "leaseType": 1,
  "listingStatus": 1,
  "feedName": null,
  "enrichedWithDetail": true,
  "scrapedAt": "2026-10-07T09:30:00Z"
}
```

### Zumper API Access: Scrape Zumper Rentals Without A Browser

Zumper's public HTML pages are served behind a **Fastly client challenge** (`_fs_ch_st_*` cookie) that blocks plain HTTP clients. Instead of fighting that, this actor uses Zumper's **own internal JSON APIs**, served without any anti-bot protection:

1. **Search** — `POST https://www.zumper.com/api/svc/inventory/v1/listables/search`
   - Body: `{"url":"<slug>","limit":50,"offset":0,"external":true,"countListings":true,"descriptionLength":580}`
   - Returns `{ listables[], matching, listing_count }` — the same data the search page renders.
   - `limit` is capped at **50** by the API (51+ returns 422); paginate with `offset`.
   - `minPrice`/`maxPrice` are accepted but ignored server-side, so price and bedroom filters are applied client-side inside the actor.
   - Each listable carries listing/building ids, address, city/state/ZIP, lat/lng, neighborhood, rent and beds/baths/sqft ranges, `date_available`, photo ids, amenity tags, pet codes, agent/brokerage contact, ratings and timestamps.

2. **Building detail** — `GET https://www.zumper.com/api/t/1/pages/buildings/{building_id}`
   - One request per building; listings in the same building share it.
   - Adds full description, structured `pet_policy` per species, agent e-mail, `media` photo ids, `floorplan_listings`, `amenity_tags`, `brokerage_name` and `reviews_summary`.
   - Keys on `building_id`, **not** the `pb_id` used in Zumper URLs.

3. **Listing detail (fallback)** — `GET https://www.zumper.com/api/t/1/pages/listings/{listing_id}`
   - Used for standalone listings that have no building.

**Why this bypasses the anti-bot:** the challenge only protects the HTML document. The JSON APIs the site's own frontend calls are open — no cookies, no challenge, no browser required. The actor is therefore a plain CheerioCrawler: fast, cheap, testable without a browser.

#### Known limitations and troubleshooting

- The search API **rate-limits aggressively per IP (~10–15 req/min)** — enable the Apify proxy for large runs, or lower `maxConcurrency`.
- `dateAvailable` is often `null` — Zumper only populates it for some listings.
- Neighborhood slugs (e.g. `austin-tx/chestnut`) return 0 results — use city-level slugs.
- `petCodes` are raw (`1`=cat, `2`=dog, `3`=bird); the structured `petPolicy` array is authoritative.
- **Cost:** CheerioCrawler and JSON APIs only — no browser. Runs at 256 MB; a 50-listing run is roughly 1 search request plus ~40 detail requests.

### Rent Comparables, Rental Market Analysis And Rental Price Monitoring

#### Build rent comps from one city run

Run one city slug and filter the export: each row gives `address`, `latitude`/`longitude`, `rentMin`/`rentMax`, beds/baths, square footage and `listedAt` — the checklist the comp guides prescribe: same bedrooms, square footage within roughly 15–20%, within about half a mile to a mile, recent listings, and a **median rather than an average**. Be explicit about what these are: **asking rents from live listings, not signed leases**.

#### Rental market analysis and rent trends — what this data can (and can't) tell you

Export a run to CSV and compute median rent, rent per square foot and listing counts by neighborhood or ZIP; two runs months apart show month-over-month movement. One run cannot replace an official index or enterprise multifamily market data from the likes of CoStar or Yardi Matrix — it is a snapshot of Zumper's current asking-rent inventory. The same honesty applies to "average rent in \[city]": you get the listings to compute a median from, not an official average. Against rent estimate tools (Rentometer, RentCast, HomeUnion RENTestimate) the trade-off is a model estimate versus your own comp set.

#### Rental price monitoring with scheduled runs

Set a weekly or daily schedule on the same city slug, then diff two dataset exports on `listingId` using `rentMin`/`rentMax` plus `modifiedAt`/`scrapedAt` to see which rents moved. Honest caveat: this actor stores **no built-in monitor state** — competitor `benthepythondev/zumper-rental-scraper` exposes an `onlyChanges` mode; here change detection is a comparison between two exports.

#### Budget-filtered and multi-city pulls

An "apartments under $2000" search is just `maxPrice: 2000` (add `minPrice` or `maxBedrooms` to narrow further) — filters run client-side, so they hold even though Zumper's API ignores price parameters. Repeat the input for `new-york-ny`, `los-angeles-ca`, `chicago-il` and `san-francisco-ca` for a multi-market dataset. Contact rows carry agent/brokerage name and phone only when Zumper exposes them (`agentEmail` needs `includeDetails`), so lead-gen coverage is partial.

### Integrations & Automation

- **Apify API** — start runs remotely, poll run states and fetch dataset items as JSON; the output `results` field links to the default dataset items endpoint. Console exports: JSON, CSV, Excel.
- **Webhooks** — fire on run success or failure to push new rows into your pipeline or Slack channel.
- **Zapier and Make** — trigger workflows on new dataset items (append to Google Sheets, create CRM records, alert on new rentals).
- **Schedules** — for rental price monitoring, run **daily or weekly** against the same city slug and keep one dataset per period for diffs; spaced-out runs also respect Zumper's per-IP rate limits better than one huge crawl.

### Related Actors

- [automation-lab/zumper-rental-listings-scraper](https://apify.com/automation-lab/zumper-rental-listings-scraper) — city / ZIP / URL input with dedup by listing ID.
- [bujhmml/zumper-rentals-scraper](https://apify.com/bujhmml/zumper-rentals-scraper) — inline-JSON parsing with `curl_cffi` TLS fingerprinting.
- [benthepythondev/zumper-rental-scraper](https://apify.com/benthepythondev/zumper-rental-scraper) — price-change monitor with an `onlyChanges` state.
- [abotapi/zumper-scraper](https://apify.com/abotapi/zumper-scraper) — 60+ fields, incremental mode and MCP connectors.
- [housingfeed/zumper-scraper](https://apify.com/housingfeed/zumper-scraper) — a pre-built database (82,739 live listings claimed, measured 2026-09-14) sold as a listings API rather than live scraping.

### FAQ

#### Is there an official Zumper API?

No. Zumper publishes no official public API — which is why API-directory products fill the gap (HousingFeed's rental-data API, ReefAPI's Apartments.com-style wrapper). This actor calls the same internal JSON endpoints Zumper's own frontend uses, served without anti-bot protection.

#### Why use this actor instead of the official Zumper API?

No official one exists — the real comparison is building it yourself, and the actor already handles what you would reverse-engineer: the Fastly HTML challenge, the 50-item `limit` cap with `offset` pagination, filters Zumper's API ignores server-side, detail keyed on `building_id` (not `pb_id`) and photo-id URL reconstruction. You also get a fixed 48-field schema, scheduling, webhooks, API access and a free 10-listing preview.

#### Can you scrape Zumper without getting blocked?

Yes. Plain HTTP clients get the Fastly challenge (`_fs_ch_st_*` cookie) on Zumper's HTML, so the actor never touches HTML — it calls the JSON APIs the frontend uses, via CheerioCrawler with no browser. The constraint is rate, not blocks: ~10–15 search requests per minute per IP, so large runs should use the Apify proxy.

#### How do I find rental comps with this actor?

Run the city slug, then filter rows to comparables: same bedroom count, square footage within ~15–20%, within about 0.5–1 mile (use `latitude`/`longitude`), recent listings (`listedAt`). Take the median of `rentMin`/`rentMax`, not the mean — these are asking rents, not executed leases.

#### How do I track apartment rent prices over time?

Schedule recurring runs on the same city slug (daily or weekly), then diff two exports on `listingId`, comparing `rentMin`/`rentMax` and `modifiedAt`/`scrapedAt`. The actor keeps no built-in monitor state, so change detection is a diff between two exports; Apify webhooks can trigger each run.

#### What is the average rent in \[city]?

You get the individual listings, so you can compute a median or average for any city you scrape — but the actor publishes no official figure, and asking rents are not signed-lease rents. Published averages come from Apartment List, Zillow median-rent pages or HUD FMR tables.

#### What are the alternatives to this Zumper scraper?

On the Apify Store: `automation-lab/zumper-rental-listings-scraper`, `bujhmml/zumper-rentals-scraper`, `benthepythondev/zumper-rental-scraper`, `abotapi/zumper-scraper` and `housingfeed/zumper-scraper`, plus `azzouzana/zumper-scraper` and browser-based `shhh_lab/apify-zumper`. Beyond Zumper: Zillow (Rental Manager, Rent Zestimate), Apartments.com (official customer API) and RentCast. For market research the choice is live raw rows (this actor) or cleaned aggregate databases (HousingFeed, RentCast); this actor covers Zumper only.

### SEO Keywords

zumper scraper, scrape zumper, zumper rentals scraper, zumper api, rental listings api, apartment data, rental price monitoring, track rent prices over time, rent comparables, how to find rental comps, rental market analysis, rental market trends, multifamily market data, average rent in \[city], rent estimate tools, rental lead generation, rental listing data for market research, apartments under $2000, zumper scraper new york, zillow rental data, apartments.com rental data

### For AI Agents & LLM Apps

**Purpose:** fetch structured US rental listing data — one JSON object per Zumper listing, 48 fields — for a given US city slug, without a browser.

Minimal working input:

```json
{
  "startUrls": [
    { "url": "https://www.zumper.com/apartments-for-rent/austin-tx" }
  ]
}
```

Output fields (one dataset object per listing): `source`, `listingId`, `buildingId`, `url`, `title`, `description`, `rentMin`, `rentMax`, `currencyCode`, `bedroomsMin`, `bedroomsMax`, `bathroomsMin`, `bathroomsMax`, `squareFeetMin`, `squareFeetMax`, `floorplanCount`, `address`, `neighborhood`, `buildingName`, `city`, `state`, `zip`, `latitude`, `longitude`, `amenities`, `buildingAmenities`, `petPolicy`, `petsAllowed`, `petCodes`, `photos`, `photoCount`, `agentName`, `agentPhone`, `agentEmail`, `brokerageName`, `rating`, `externalRating`, `reviewsSummary`, `dateAvailable`, `listedAt`, `modifiedAt`, `createdAt`, `propertyType`, `leaseType`, `listingStatus`, `feedName`, `enrichedWithDetail`, `scrapedAt`.

Behaviors an agent should know:

- Locations are **US city-level Zumper slugs only** (`austin-tx`, `new-york-ny`); neighborhood slugs such as `austin-tx/chestnut` return 0 results. No ZIP-level or non-US input.
- The search endpoint serves at most 50 listings per request (`limit` > 50 returns HTTP 422); the actor paginates internally with `offset`.
- `minPrice`, `maxPrice`, `minBedrooms` and `maxBedrooms` are applied **client-side** because Zumper's API accepts but ignores them server-side.
- `includeDetails` defaults to `false`; set it only when you need pet policy, agent e-mail and photos — each extra detail request is charged via the `include-details` event, and enriched rows carry `enrichedWithDetail: true`.
- Building detail is fetched once per building (`building_id`, not the URL's `pb_id`); standalone listings use the listing-detail endpoint.
- Search rate-limits ~10–15 requests/minute per IP — enable `proxy` beyond quick tests; `maxConcurrency` caps at 20.
- Defaults: `maxItems` 50 (max 5000), `maxConcurrency` 4, `maxRequestsPerCrawl` 1000. Free accounts get a capped 10-listing preview; paying accounts get full runs.
- `dateAvailable` is frequently `null`; `petCodes` are raw — treat `petPolicy` as authoritative.
- No built-in monitor state: run twice and diff on `listingId` using `rentMin`/`rentMax` and `modifiedAt`/`scrapedAt`.

Billing: pay-per-event — the documented charge event is `include-details` (per extra detail request while `includeDetails` is true).

### Legal & Compliance Disclaimer

- This is an independent third-party tool. It is **not affiliated with, endorsed by, sponsored by or connected to Zumper**.
- The actor reads only publicly available rental listings — Zumper's public search pages and the JSON endpoints those pages call. It uses no user accounts or authentication bypass; it does not log in or defeat login walls.
- Zumper's Terms of Service may change. You are solely responsible for ensuring your runs and use of the output comply with Zumper's ToS and applicable data-protection and scraping law.
- Output can include listing-agent contact details (name, phone, and e-mail where Zumper publishes them). That contact data must not be used for unsolicited commercial outreach in violation of applicable law.
- Data is provided as-is with no warranty of completeness or accuracy; listings change constantly.

# Actor input Schema

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

Zumper search page URLs, e.g. https://www.zumper.com/apartments-for-rent/austin-tx — one location per entry.

## `location` (type: `string`):

Optional: a Zumper slug like "austin-tx" or a city like "Austin, TX". Merged with Start URLs.

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

Hard cap on listings scraped in one run.

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

Maximum number of requests processed in parallel.

## `minPrice` (type: `integer`):

Optional: keep only listings whose cheapest unit is at least this much.

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

Optional: keep only listings whose cheapest unit is at most this much.

## `minBedrooms` (type: `integer`):

Optional: keep only listings with at least this many bedrooms (0 = studio).

## `maxBedrooms` (type: `integer`):

Optional: keep only listings with at most this many bedrooms.

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

Also fetch extra listing details (pet policy, agent e-mail, photos). Billed per extra request via the include-details charge event.

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on total HTTP requests (search pages + detail requests).

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zumper.com/apartments-for-rent/austin-tx"
    }
  ],
  "maxItems": 50,
  "maxConcurrency": 4,
  "includeDetails": false,
  "maxRequestsPerCrawl": 1000,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.zumper.com/apartments-for-rent/austin-tx"
        }
    ],
    "location": "",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "startUrls": [{ "url": "https://www.zumper.com/apartments-for-rent/austin-tx" }],
    "location": "",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "startUrls": [
    {
      "url": "https://www.zumper.com/apartments-for-rent/austin-tx"
    }
  ],
  "location": "",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/zumper-scraper --silent --output-dataset

```

## MCP server setup

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