# StreetEasy Scraper: NYC Rentals, Sales & Property Listings (`hyperbach/streeteasy-scraper`) Actor

Scrape StreetEasy NYC property listings: rentals and sales by search link with your filters, listing link or neighborhood. Property data: price, net effective rent, beds, baths, sq ft, days on market, amenities, building, agents as shown, photos. No login. Misses free.

- **URL**: https://apify.com/hyperbach/streeteasy-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 listings

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

## StreetEasy Scraper: NYC Rentals, Sales & Property Listings

**StreetEasy listings in New York City, logged out: search links (rentals or sales, with every filter you set on the site), listing links, or boroughs and neighborhoods by name in, one row per listing out — the address and unit, the price and net effective rent, beds, baths, square feet, the building type, the broker, the photos and the URL, and with each listing's page the days on market, the listed date, the description, the amenities, the building (name, year built, floors, units), the agents as the page shows them and a sale's monthly charges.** One free row per input carries the site's count and a verdict: COMPLETE, TRUNCATED (StreetEasy shows about 1,400 listings of one search) or PARTIAL. No login, no API key, no browser, proxies handled for you.

**$3.00 per 1,000 `listing` rows on the Free plan, $2.55 on Starter.** A run start is $0.006. The default input returns about 40 rows for about $0.126. A value that names nothing is a free row that says why.

![A StreetEasy rental listing page in a browser: a one-bedroom apartment in Harbor Point with its monthly rent, one month free on a twelve-month lease, bedrooms, bathrooms, days on market. Beside it, the row this Actor returns for the listing, with net_effective_rent and months_free highlighted, then the price, lease term, beds, baths and days on market.](https://api.apify.com/v2/key-value-stores/dcLLNGq99686o2A4v/records/hero-streeteasy-scraper.webp)

### Why this StreetEasy scraper

- **Your own searches, as you see them.** Paste a StreetEasy search link from your browser (`/for-rent/brooklyn`, `/for-sale/upper-west-side`, with the price, beds, no-fee or any other filter and the sort in the link), or give boroughs and neighborhoods by name with rentals or sales. The rows are the ones StreetEasy lists for that search: 14 rentals or 38 sales a page, in its order.
- **The listing page's fields, on by default.** Each row reads the listing's own page too: days on market and the listed date, the description, the amenities and the unit's features, the building's name, year built, floors and units, the agents as the page shows them (name, license, brokerage, phone), a sale's monthly taxes and common charges, and the price changes. Turn `includeDetails` off for the search card alone, faster.
- **Every search ends with its count.** The free input row gives StreetEasy's own count, the pages read and the verdict. StreetEasy shows at most 100 pages of rentals or 37 pages of sales of one search (about 1,400 listings, measured 2026-11-06); a larger search ends TRUNCATED with the count, and a price band or a neighborhood in the link reads more of it.
- **Charged once, only for listings.** A listing met twice (a featured card, two searches of the run) is delivered and charged once; StreetEasy's sponsored cards for listings outside your search are left out; input rows are free.

### Who it's for

- **Renters, relocation agents and brokers** — the rentals of a borough or a neighborhood with your filters (price, beds, no fee), with net effective rent, months free, days on market and the building's amenities, read again every day for what is new.
- **Investors and analysts** — the sales of a neighborhood with price, square feet, a sale's monthly taxes and common charges, the building's year built and units, to compare price per square foot and carrying costs.
- **Brokerages and leasing teams** — who lists what in a neighborhood: the broker and the agents as the listing page shows them, the days on market and the price changes of the competition.

### Quick start

**The leader's default job: 100 Brooklyn rentals with their pages**

```json
{
  "startUrls": [
    "https://streeteasy.com/for-rent/brooklyn"
  ],
  "maxItems": 100
}
```

**Sales of two neighborhoods by name, search cards only**

```json
{
  "areas": [
    "Upper West Side",
    "Williamsburg"
  ],
  "listingType": "sale",
  "includeDetails": false,
  "maxItems": 200
}
```

**A filtered search link and one listing**

```json
{
  "startUrls": [
    "https://streeteasy.com/for-rent/brooklyn/price:-3000%7Cbeds:2",
    "https://streeteasy.com/rental/5196111"
  ],
  "maxItems": 50
}
```

### Switching from `memo23/streeteasy-ppr`?

Your input works as it is. Each name in the left column is read as this Actor's own field and the run log says so (`read <theirs> as <ours>`); a name marked *not read* is ignored with a note. A value in the other Actor's shape, an object list or its own date form, is read too.

| memo23/streeteasy-ppr | this Actor | what to know |
|---|---|---|
| `startUrls` | `startUrls` | The same: search links with their filters, and listing links; `{url: …}` objects or plain strings. |
| `maxItems` | `maxItems` | The same: the most listing rows of the run. |
| `addresses` | *not read* | Not read: a search by street address. Paste the listing's or the search's link in `startUrls`. |
| `moreResults` | *not read* | Not read: StreetEasy shows about 1,400 listings of one search; split a large search by price band or neighborhood in the link (the input row says TRUNCATED with the count). |
| `monitoringMode` | *not read* | Not read: every run reads the search as it is now. Sort the link by newest (`?sort_by=listed_desc`) and cap it to watch new listings. |
| `enrichEmails` | *not read* | Not read: no e-mail lookup on other sites; the agents' names, license, brokerage and phone come as the listing page shows them. |
| `flattenDatasetItems` | *not read* | Not read: the rows are flat already (the photos, amenities, agents and price changes are lists in their own columns). |
| `maxConcurrency` | *not read* | Not read: the actor sets its own speed. |
| `minConcurrency` | *not read* | Not read: the actor sets its own speed. |
| `maxRequestRetries` | *not read* | Not read: a refused page is asked again on up to six fresh connections. |
| `proxy` | *not read* | Not read: the actor brings its own connections. Give your own proxy as a URL in `proxyUrl` if you must. |
| `dbInstant` | *not read* | Not read, nor any other `db…` field: the leader's pre-collected agent database is not a scrape of StreetEasy's pages; the agents of each listing come in its row. |

**What differs:**

- `startUrls` takes the same links: searches (`/for-rent/…`, `/for-sale/…`) and listings (`/building/<building>/<unit>`, `/rental/<id>`, `/sale/<id>`, `/building/<building>/rental/<id>`); agent profiles, building pages and building directories are not read (a free invalid_input row says so).
- `maxItems` is the same cap of the whole run, default 100 as there; 0 = no cap.
- The listing page's fields come with every row by default (`includeDetails`), at the one listing price; there is no separate monitoring, duplicate or e-mail event.
- No agent database, no address search, no e-mail lookup and no monitoring mode: this actor reads StreetEasy's own pages for the searches and listings you give.

### Output

One row per listing (and one free row per input):

| field | meaning |
|---|---|
| `record_type` | `listing` on a listing row (charged); `input` on an input's free row. |
| `status` | `ok`, or why an input gave no row: `not_found`, `not_a_search`, `invalid_input`, `failed`, `not_read`. |
| `input` | The value you gave that this row answers. |
| `id` | StreetEasy's listing id. |
| `url` | The listing's page (on an input row: the search read, without its page number). |
| `listing_type` | `rental` or `sale`. |
| `listing_status` | StreetEasy's status of the listing (`active`, `in contract`, `rented`, …). |
| `address` | The street address. |
| `unit` | The unit as StreetEasy shows it (`#12N`). |
| `area` | The neighborhood. |
| `zip_code` | The ZIP code. |
| `latitude` | Latitude. |
| `longitude` | Longitude. |
| `price` | The asking rent a month or the asking price, in US dollars. |
| `net_effective_rent` | A rental's net effective rent a month with its free months counted (null when none). |
| `months_free` | A rental's free months (null when none). |
| `lease_term_months` | A rental's lease term in months, when given. |
| `beds` | Bedrooms (0 = a studio). |
| `baths` | Bathrooms, a half bath counted 0.5. |
| `full_baths` | Full bathrooms. |
| `half_baths` | Half bathrooms. |
| `rooms` | Rooms in all (from the listing's page). |
| `square_feet` | Interior square feet, when the listing gives them (null when not given). |
| `building_type` | The building type (`rental`, `condo`, `co-op`, `townhouse`, …). |
| `sale_type` | A sale's type (`resale`, `sponsor unit`, …). |
| `new_development` | True for a new development. |
| `furnished` | True when the listing is furnished. |
| `available_at` | The date the unit is available, when given. |
| `broker` | The listing's brokerage or source as StreetEasy names it. |
| `source_type` | How the listing came to StreetEasy (`partner`, `feed`, …). |
| `placement` | `organic` or `featured` (a paid place inside the search). |
| `photos` | The photo URLs, in the listing's order. |
| `photo_count` | How many photos. |
| `has_3d_tour` | True when the listing has a 3D tour. |
| `has_video` | True when the listing has a video. |
| `open_house_start` | The next open house's start (New York time with its offset), when one is set. |
| `open_house_end` | The next open house's end. |
| `details_status` | `read` (the listing's page was read), `not_asked` (`includeDetails` off) or `failed` / `not_found` (the page was not served: the search card's fields stay). |
| `days_on_market` | Days on market, as the listing's page shows it. |
| `listed_at` | The date the listing went on the market. |
| `description` | The listing's description. |
| `amenities` | The building's amenities and the unit's features (`doorman`, `elevator`, `gym`, `washer dryer`, …). |
| `building_id` | StreetEasy's building id. |
| `building_name` | The building's name, when it has one. |
| `building_year_built` | The year the building was built. |
| `building_floors` | The building's floors. |
| `building_units` | The building's residential units. |
| `agents` | The agents as the listing's page shows them: name, license type, brokerage, phone and profile link. |
| `brokerage_license` | The listing brokerage's licensed name. |
| `monthly_taxes` | A sale's monthly taxes, in US dollars. |
| `monthly_common_charges` | A condo's monthly common charges. |
| `monthly_maintenance` | A co-op's monthly maintenance. |
| `price_changes` | The listing's price changes (price and time). |
| `listings_found` | On an input row: StreetEasy's own count for the search. |
| `pages_read` | On an input row: the search pages read. |
| `verdict` | On an input row: COMPLETE (read to the end), TRUNCATED (StreetEasy's own page window ended under its count) or PARTIAL (stopped: `note` says why). |
| `rows_delivered` | On an input row: the listing rows it delivered. |
| `note` | Why an input row has the status or the verdict it has. |
| `scraped_at` | When this row was read (UTC). |

Example record:

```json
{
  "record_type": "listing",
  "status": "ok",
  "input": "https://streeteasy.com/for-rent/brooklyn",
  "id": "5168316",
  "url": "https://streeteasy.com/building/house-55/37e",
  "listing_type": "rental",
  "listing_status": "active",
  "address": "55 Willoughby Street",
  "unit": "#37E",
  "area": "Downtown Brooklyn",
  "zip_code": "11201",
  "latitude": 40.692432,
  "longitude": -73.98687,
  "price": 5255,
  "net_effective_rent": 4379,
  "months_free": 3,
  "lease_term_months": 18,
  "beds": 1,
  "baths": 1.0,
  "full_baths": 1,
  "half_baths": 0,
  "rooms": 1,
  "square_feet": null,
  "building_type": "rental",
  "sale_type": null,
  "new_development": true,
  "furnished": false,
  "available_at": "2026-09-26",
  "broker": "Nancy Packes Inc.",
  "source_type": "partner",
  "placement": "featured",
  "photos": [
    "https://photos.zillowstatic.com/fp/3eaa4d2ba253d4415af3d6cae734db6b-p_e.webp",
    "https://photos.zillowstatic.com/fp/d5d58b1569b3ad85462cc5fa375ea2b1-p_e.webp",
    "https://photos.zillowstatic.com/fp/a512c50da2cd5bb90e494b37b4dead2d-p_e.webp"
  ],
  "photo_count": 24,
  "has_3d_tour": false,
  "has_video": true,
  "open_house_start": "2026-11-06T11:00:00.000-05:00",
  "open_house_end": "2026-11-06T17:00:00.000-05:00",
  "details_status": "read",
  "days_on_market": 41,
  "listed_at": "2026-09-26",
  "description": "~ Security Deposit Reduced to $1,000 for income-qualified applicants with credit scores that exceed 700.\n\n~ $2,500 rent credit. \n\nRising above the energy of Brooklyn, the modern ho …(truncated for display)",
  "amenities": [
    "bike room",
    "concierge",
    "doorman",
    "elevator",
    "fios available",
    "gym",
    "laundry",
    "live in super",
    "media room",
    "package room",
    "shared outdoor space",
    "wheelchair access",
    "central ac",
    "dishwasher",
    "washer dryer"
  ],
  "building_id": "6584629",
  "building_name": "House 55",
  "building_year_built": 2026,
  "building_floors": 43,
  "building_units": 295,
  "agents": [
    {
      "name": "Leasing Team",
      "license_type": "Leasing/Sales Office",
      "brokerage": "Nancy Packes Inc.",
      "phone": "+12125550100",
      "profile_url": "https://streeteasy.com/profile/900000"
    }
  ],
  "brokerage_license": "Nancy Packes Inc",
  "monthly_taxes": null,
  "monthly_common_charges": null,
  "monthly_maintenance": null,
  "price_changes": [
    {
      "price": 5255,
      "changed_at": "2026-09-26T13:48:10.000-04:00"
    }
  ],
  "listings_found": null,
  "pages_read": null,
  "verdict": null,
  "rows_delivered": null,
  "note": null,
  "scraped_at": "2026-11-06T19:08:53Z"
}
```

### Pricing

**Pay for the listings a run delivers**, plus one run start; no platform usage is billed to you. The listing price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Listing (`listing`) | per 1,000 | $3.00 | $2.55 | $2.10 | $1.50 |
| Run start (`start`) | per run | $0.006 | $0.006 | $0.006 | $0.006 |

A listing is **$3.00 per 1,000** on the Free plan ($0.003 a listing), with the listing's page (days on market, the description, the amenities, the building, the agents as shown) and every photo URL included. Each run that delivers a charged listing also pays the **run start, $0.006 once**; a run that delivers no charged listing pays nothing at all. So one search of 100 listings costs $0.306 on the Free plan, and several searches in one run share one start. The free input row of every search or listing, a value that is not a StreetEasy link, an area or a listing StreetEasy does not have, and a refused input are never charged, and a listing met twice in one run is charged once. Set a charge limit on the run and it stops before it would pass it.

### Usage patterns

- **Searches, places and listings** — `startUrls` takes StreetEasy links as your browser shows them: searches (`https://streeteasy.com/for-rent/brooklyn`, `https://streeteasy.com/for-sale/manhattan`, with any filter and sort in the link: `/for-rent/brooklyn/price:-3000%7Cbeds:2`, `?sort_by=listed_desc`) and listings (`/building/<building>/<unit>`, `/rental/<id>`, `/sale/<id>`). `areas` takes boroughs and neighborhoods by name or by their link word (`Brooklyn`, `Upper West Side`, `long-island-city`, `nyc` for all of New York City), each read as one search of `listingType` (rent or sale). StreetEasy only.
- **What a row is** — `record_type` = `listing`: one listing, charged, with `details_status` read (its page was read), not_asked (`includeDetails` off) or failed (the page was not served after six tries: the search card's fields stay). `record_type` = `input`: the free row of one input — the site's count (`listings_found`), the `pages_read`, the `rows_delivered`, the `verdict` and the `status` with its `note`.
- **How far a search goes** — A search is read page by page until its last page, `maxItems` (default 100, 0 = no cap) or your charge limit. StreetEasy shows at most 100 pages of 14 rentals or 37 pages of 38 sales of one search (about 1,400 listings); a larger search ends TRUNCATED with the site's count. A price band, a bed count or a neighborhood in the link reads more of a large market. With `includeDetails` (default) each listing's page is read too: 100 listings in one to four minutes (measured 2026-11-06; StreetEasy's bot wall refuses a share of calls that moves by the hour, and the actor waits those out); off, a page of 14 or 38 listings in about a second.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `startUrls` | `array` | `[]` | Search links as you see them in your browser, filters and sort included (https://streeteasy.com/for-rent/brooklyn/price:-3000%7Cbeds:2, https://streeteasy.com/for-sale/manhattan), and listing links (https://streeteasy.com/building/<building>/<unit>, https://streeteasy.com/rental/<id>, https://streeteasy.com/sale/<id>). A search reads every page StreetEasy serves for it: about 1,400 listings at most. |
| `areas` | `array` | `[]` | Places by name or by their StreetEasy link word: Brooklyn, Manhattan, Queens, Upper West Side, Williamsburg, Astoria, nyc (all of New York City). Each is read as one search of the listing type below. |
| `listingType` | `rent` / `sale` | `"rent"` | Which listings an area search reads. A link in StreetEasy search or listing URLs keeps its own type. |
| `includeDetails` | `boolean` | `true` | On: each row adds what only the listing's page shows: days on market, the listed date, the description, the amenities, the building (name, year built, floors, units), the agents as shown (name, license, brokerage, phone), the monthly taxes and charges of a sale, the price changes. Off: the search card's fields only, faster. |
| `maxItems` | `integer` | `100` | The most listing rows of the whole run; 0 = no cap beyond your charge limit. |
| `proxyUrl` | `string` |  | Your own proxy (scheme://user:pass@host:port) for every call instead of ours. Leave empty: the Actor brings its own connections at no cost to you. |
| `feedback` | `string` |  | A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A value that is not a StreetEasy search or listing link (an agent's profile, a building page, another site) is not an error: it gets one free input row with `status` invalid_input that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

An input row's `status` is `ok` (listings served; see `verdict`), `not_found` (StreetEasy answers 404 for the area or the listing; checked on two connections), `invalid_input` (not a StreetEasy search or listing link), `failed` (the site refused every try; free) or `not_read` (left at `maxItems`, the charge limit or the run's time limit). A listing row's `status` is `ok`.

**Why does a large search stop at about 1,400 listings?**

StreetEasy itself shows at most 100 pages of rentals (14 a page) or 37 pages of sales (38 a page) for one search; the page after the last one shows page 1 again. The input row says TRUNCATED with the site's count. Split the search by price (`price:2000-3000`), beds or neighborhood in the link to read the rest.

**Is the price filter on the gross rent or the net effective rent?**

StreetEasy's own price filter reads the net effective rent where a lease has free months: a listing at $3,540 with $2,950 net shows under a $3,000 filter. Both are on the row (`price`, `net_effective_rent`, `months_free`, `lease_term_months`).

**Does it need a StreetEasy account or API key?**

No. Everything is read from streeteasy.com's public search and listing pages, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/streeteasy-scraper').call({"startUrls": ["https://streeteasy.com/for-rent/brooklyn"], "maxItems": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/streeteasy-scraper').call(run_input={'startUrls': ['https://streeteasy.com/for-rent/brooklyn'], 'maxItems': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/streeteasy-scraper --input '{"startUrls": ["https://streeteasy.com/for-rent/brooklyn"], "maxItems": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~streeteasy-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"startUrls": ["https://streeteasy.com/for-rent/brooklyn"], "maxItems": 100}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/streeteasy-scraper` and ask, for example: "Get 100 Brooklyn apartments for rent from StreetEasy with price, beds, baths, square feet, days on market, amenities and the listing agent". The agent fills the input from the table above and reads the rows from the run's dataset. A field under the name another Actor gives it is read as this Actor's own: `urls`, `url`, `links`, `searchUrls` as `startUrls`; `locations`, `location`, `neighborhoods`, `neighborhood` as `areas`; `type`, `listing_type`, `searchType`, `mode` as `listingType`; `maxResults`, `max_items`, `limit`, `maxListings` as `maxItems` (and more). An agent or a person can add `feedback` to any run and say what was needed and not delivered: a missing field, a wrong or empty result, the Actor switched from or to, and why. The run returns the same rows at the same price, and a person reads every note.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/streeteasy-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[Zillow Scraper](https://apify.com/hyperbach/zillow-scraper)** — Zillow listings for sale, for rent and sold, by ZIP, city or search URL, with the Zestimate, and a property's price history.
- **[Redfin Scraper](https://apify.com/hyperbach/redfin-scraper)** — Redfin homes for sale, sold and for rent by search URL, city or ZIP code, with the price, beds, baths, square feet, days on market and the MLS id.
- **[Immobiliare.it Scraper](https://apify.com/hyperbach/immobiliare-scraper)** — Immobiliare.it homes for sale and for rent by search URL or place name, with the price, surface, rooms, the address and coordinates, and the agency.
- **[Fotocasa Scraper](https://apify.com/hyperbach/fotocasa-scraper)** — Fotocasa.es homes for sale and for rent in Spain by place name or search URL, with the price, surface, rooms, the coordinates and the agency.
- **[Rightmove Scraper](https://apify.com/hyperbach/rightmove-scraper)** — Rightmove UK homes to buy or to rent by search link, listing link or place name, with the price, beds, baths, type, tenure, size, key features, floorplans and the agent branch.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Search links as you see them in your browser, filters and sort included (https://streeteasy.com/for-rent/brooklyn/price:-3000%7Cbeds:2, https://streeteasy.com/for-sale/manhattan), and listing links (https://streeteasy.com/building/<building>/<unit>, https://streeteasy.com/rental/<id>, https://streeteasy.com/sale/<id>). A search reads every page StreetEasy serves for it: about 1,400 listings at most.

## `areas` (type: `array`):

Places by name or by their StreetEasy link word: Brooklyn, Manhattan, Queens, Upper West Side, Williamsburg, Astoria, nyc (all of New York City). Each is read as one search of the listing type below.

## `listingType` (type: `string`):

Which listings an area search reads. A link in StreetEasy search or listing URLs keeps its own type.

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

On: each row adds what only the listing's page shows: days on market, the listed date, the description, the amenities, the building (name, year built, floors, units), the agents as shown (name, license, brokerage, phone), the monthly taxes and charges of a sale, the price changes. Off: the search card's fields only, faster.

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

The most listing rows of the whole run; 0 = no cap beyond your charge limit.

## `proxyUrl` (type: `string`):

Your own proxy (scheme://user:pass@host:port) for every call instead of ours. Leave empty: the Actor brings its own connections at no cost to you.

## `feedback` (type: `string`):

A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note.

## Actor input object example

```json
{
  "startUrls": [
    "https://streeteasy.com/for-rent/brooklyn"
  ],
  "areas": [],
  "listingType": "rent",
  "includeDetails": true,
  "maxItems": 40
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per listing (and one free row per input):

## `runSummary` (type: `string`):

How the run went: listing rows charged, free rows, inputs by status with the site's count and the pages read, the source counters (calls, served, refused, exits, rotations, bytes) and the memory watch.

# 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": [
        "https://streeteasy.com/for-rent/brooklyn"
    ],
    "maxItems": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/streeteasy-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": ["https://streeteasy.com/for-rent/brooklyn"],
    "maxItems": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/streeteasy-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": [
    "https://streeteasy.com/for-rent/brooklyn"
  ],
  "maxItems": 40
}' |
apify call hyperbach/streeteasy-scraper --silent --output-dataset

```

## MCP server setup

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