# StreetEasy Updated Scraper (`confidential_gnat/streeteasy-property-scraper`) Actor

Scrapes New York City apartment listings from StreetEasy (streeteasy.com), including address, neighborhood, price, bedrooms, bathrooms, square footage, amenities, availability and photos, for both rentals and sales.

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

## Pricing

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

## StreetEasy NYC Real Estate Scraper

**Scrape New York City apartment listings from StreetEasy (streeteasy.com)** — both **rentals and sales**. This **StreetEasy scraper** extracts the address, unit, neighborhood, price, bedrooms, bathrooms, square footage, amenities, availability date, concessions and photos for every listing in a search, and exports them to JSON, CSV or Excel — or straight into your code through the **Apify API**. Paste any StreetEasy search URL, press Start.

**Target website:** [streeteasy.com](https://streeteasy.com)

### ✨ Features of this StreetEasy real estate scraper

- **Rental and sales listings** — works with `/for-rent` and `/for-sale` searches alike
- **Full listing data** — address, unit, neighborhood, ZIP, price, beds, baths, square footage, building type
- **Rental concessions** — net effective price and months free, where the listing offers them
- **Amenities and features** — collected from each unit page
- **Keeps your search filters** — paste a filtered StreetEasy search URL and every filter is preserved
- **Pagination support** — walks through result pages until your item limit is reached
- **Fast mode** — skip unit pages to scrape roughly twice as fast from search results alone
- **Monitor mode** — set a project name and later runs skip listings you already scraped, returning only new ones — ideal for monitoring and saving money
- **Proxy support** — configurable, with US residential recommended for larger runs
- **No browser required** — runs on plain HTTP requests, which makes it fast and cheap

### 🚀 How to scrape StreetEasy listings in 5 steps

1. [Sign up](https://apify.com/sign-up) for a free Apify account — includes **$5 monthly credit**.
2. Open the actor page and click **Try for free**.
3. Paste a StreetEasy search URL into **Start URLs**.
4. Click **Start** and wait for the run to complete.
5. Download results from the **Output** tab in JSON, CSV, or Excel format.

You can also run this actor via the [Apify API](https://docs.apify.com/api/v2) or integrate it directly into your workflows using [Zapier](https://zapier.com/apps/apify), [Make](https://www.make.com/), or [n8n](https://n8n.io/).

### 💰 Pricing

This actor uses **pay-per-result** billing based on the compute units a run consumes.

- New Apify accounts include **$5 of free monthly credit**.
- It runs on plain HTTP requests rather than a headless browser, so it costs significantly less to run than browser-based real estate scrapers.
- Turning off **Visit each listing page** roughly halves the requests per listing when you only need the headline fields.

### 🔧 Input configuration

| Field                | Type    | Required | Default                               | Description                                                                      |
| -------------------- | ------- | -------- | ------------------------------------- | -------------------------------------------------------------------------------- |
| `startUrls`          | array   | —        | `https://streeteasy.com/for-rent/nyc` | StreetEasy search URLs or unit URLs. Page type is detected automatically.        |
| `maxItems`           | integer | —        | `5`                                   | Maximum listings to scrape **per start URL**. Set to `0` for no limit.           |
| `scrapeDetails`      | boolean | —        | `true`                                | Visit each unit page for description, amenities and features.                    |
| `cacheProjectName`   | string  | —        | —                                     | Project name. When set, the actor runs in **monitor mode**: listings scraped in earlier runs under this name are skipped. |
| `proxyConfiguration` | object  | —        | Apify Proxy, `RESIDENTIAL`, `US`      | **Required.** StreetEasy refuses most IPs; US residential proxies are what make a run succeed. |

![StreetEasy scraper input form with numbered labels](https://i.postimg.cc/K4SmvxG4/image.png)

1. **Start URLs** — the StreetEasy search URLs (or single unit URLs) to scrape, e.g. `https://streeteasy.com/for-rent/nyc`. Add as many as you like; filters in the URL are kept.
2. **Max listings per search** (`maxItems`) — the most listings to collect for each start URL. The default of `5` is a quick test; raise it for real runs, or set `0` for no limit.
3. **Visit each listing page** (`scrapeDetails`) — when ticked, the actor opens every unit page to add the description, amenities and features. Untick it for a faster, cheaper run with search-result fields only.
4. **Cache project name** (`cacheProjectName`) — leave empty for a normal run. Enter a name to turn on monitor mode (below).

The **Proxy configuration** section below the form is already set to US-friendly residential proxies; leave it on, as StreetEasy refuses most other IPs.

**Monitor mode:** give `cacheProjectName` a name (for example `nyc-2br-rentals`) and the actor remembers every listing it has scraped under that name. On the next run, previously scraped listings are skipped and only new ones are returned and charged. This makes it ideal for monitoring a search on a schedule and saves money, since you only pay for new results. Leave it empty for a normal full run, and use a different name for each search you want to track separately.

**Supported URL types:**

- Rental search — `https://streeteasy.com/for-rent/nyc`
- Sale search — `https://streeteasy.com/for-sale/nyc`
- Filtered search — `https://streeteasy.com/for-rent/nyc/price:-4000%7Cbeds:2`
- Single unit — `https://streeteasy.com/building/51-hamilton-terrace-new_york/1`

### 📦 StreetEasy scraper output data

Each result is a JSON object with the keys `url`, `listingId`, `listingType`, `address`, `unit`, `neighborhood`, `zipCode`, `state`, `price`, `totalMonthlyPrice`, `netEffectivePrice`, `monthsFree`, `bedrooms`, `bathrooms`, `livingAreaSize`, `buildingType`, `furnished`, `status`, `availableAt`, `leaseTermMonths`, `isNewDevelopment`, `hasVideos`, `hasTour3d`, `source` and `photos`. When unit pages are visited, these are added: the full `description`, `roomCount`, `amenities`, `features`, `fullAddress`, the listing agent (`agentName`, `agentPhone`, `agentCompany` and an `agents` list), `daysOnMarket`, `onMarketAt`, `attributes`, `aboutBuilding`, `propertyHistory` and `neighborhoodInfo` (described below). The dataset ships with two views: **Overview**, a compact table of address, neighborhood, price and room counts; and **Full listing details**, which adds amenities, agent contact, building facts, price history and neighborhood info.

**Sample output:**

```json
[
    {
        "url": "https://streeteasy.com/building/180-franklin-avenue-brooklyn/103",
        "listingId": "5025137",
        "listingType": "rental",
        "address": "180 Franklin Avenue",
        "unit": "#103",
        "neighborhood": "Bedford-Stuyvesant",
        "zipCode": "11205",
        "state": "NY",
        "price": 5188,
        "totalMonthlyPrice": null,
        "netEffectivePrice": null,
        "monthsFree": null,
        "bedrooms": 1,
        "bathrooms": 1.5,
        "livingAreaSize": 1075,
        "buildingType": "RENTAL",
        "furnished": false,
        "status": "ACTIVE",
        "availableAt": "2026-08-14",
        "leaseTermMonths": null,
        "isNewDevelopment": false,
        "hasVideos": false,
        "hasTour3d": false,
        "source": "Brown Harris Stevens Development Marketing",
        "photos": [
            "https://photos.zillowstatic.com/fp/f3cba8497bf26291ec44f9f02360b5c7-full.webp",
            "https://photos.zillowstatic.com/fp/9363b7a7965e595d4dd2363bceee23fd-full.webp",
            "https://photos.zillowstatic.com/fp/fe1f0570ae58855067420ae24a40f496-full.webp"
        ],
        "description": "AVAILABLE 8.15     This massive 1 Bedroom + 1.5 Bathroom Duplex with private patio is perfect! Unit 103 features a modern k...\u2026",
        "roomCount": 3,
        "amenities": [
            "BIKE_ROOM",
            "DOORMAN",
            "ELEVATOR",
            "FIOS_AVAILABLE",
            "PARKING",
            "GYM",
            "LAUNDRY",
            "SHARED_OUTDOOR_SPACE",
            "STORAGE_SPACE",
            "WHEELCHAIR_ACCESS"
        ],
        "features": [
            "DISHWASHER",
            "PRIVATE_OUTDOOR_SPACE",
            "WASHER_DRYER"
        ],
        "fullAddress": {
            "state": "NY",
            "street": "180 Franklin Avenue",
            "city": "BROOKLYN",
            "zipCode": "11205",
            "displayUnit": "#103"
        }
    }
]
```

**Extra detail fields** (added when unit pages are visited):

- `attributes` — policies, amenities and features as `{ "name", "value" }` pairs, e.g. `{ "name": "policies", "value": ["PETS_ALLOWED"] }`. Other names appear when present: `petPolicy`, `doormanTypes`, `parkingTypes`, `sharedOutdoorSpaceTypes`, `storageSpaceTypes`, `fireplaceTypes`, `privateOutdoorSpaceTypes`, `views`. Empty ones are left out.
- `agentName`, `agentPhone`, `agentCompany` — the first listed agent or company, plus `agents`, the full list with `licenseType`.
- `aboutBuilding` — building name, type, status, year built, floors, residential units, address, coordinates and documents link.
- `propertyHistory` — the unit's listing history, one row per event (`date`, `event` such as `ACTIVE`, `PRICE_CHANGE` or `DELISTED`, `price`, `priceChangePercent`, `listedBy`).
- `neighborhoodInfo` — the "About" and "Explore" blocks of the page: neighborhood `description`, `medianAskingRent` and `medianAskingSalePrice` for `medianBedrooms`, and nearby `transit`, `colleges`, `parks`, `museums` and `schools` with distances in miles.

```json
{
    "agentName": "The Lotus NYC",
    "agentPhone": "+16467761267",
    "agentCompany": "Rose Associates, Inc.",
    "attributes": [
        { "name": "policies", "value": ["PETS_ALLOWED"] },
        { "name": "doormanTypes", "value": ["FULL_TIME"] }
    ],
    "aboutBuilding": { "name": "The Lotus NYC Midtown East", "buildingType": "Rental building", "yearBuilt": 2026, "floors": 20, "residentialUnits": 157 },
    "propertyHistory": [
        { "date": "2026-10-07", "event": "PRICE_CHANGE", "price": 13039, "priceChangePercent": -4.48, "listedBy": "Rose Associates, Inc." },
        { "date": "2026-09-16", "event": "ACTIVE", "price": 13650, "priceChangePercent": null, "listedBy": "Rose Associates, Inc." }
    ],
    "neighborhoodInfo": {
        "name": "Murray Hill",
        "medianAskingRent": 7447,
        "medianAskingSalePrice": 1295000,
        "medianBedrooms": 2,
        "transit": [{ "name": "Grand Central–42nd St", "routes": ["S", "4", "5", "6", "7"], "distanceMiles": 0.2 }],
        "parks": [{ "name": "St. Vartan Park", "distanceMiles": 0.18 }]
    }
}
```

> Captured from a real run on 2026-09-12. The `photos` array is trimmed to three entries here; a live listing typically carries 7 to 15.

### 🐍 How to scrape StreetEasy with Python, JavaScript or the API

Run the actor programmatically with the official Apify clients. Replace `<YOUR_API_TOKEN>` with the token from your [Apify Console](https://console.apify.com/account/integrations).

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("<username>/streeteasy-property-scraper").call(run_input={
    "startUrls": [{"url": "https://streeteasy.com/for-rent/nyc"}],
    "maxItems": 25,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["address"], item["price"], item["bedrooms"])
```

**JavaScript** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('<username>/streeteasy-property-scraper').call({
    startUrls: [{ url: 'https://streeteasy.com/for-rent/nyc' }],
    maxItems: 25,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'] },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**cURL** — start a run and wait for the dataset:

```bash
curl -X POST "https://api.apify.com/v2/acts/<username>~streeteasy-property-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://streeteasy.com/for-rent/nyc"}], "maxItems": 25}'
```

### 💡 What you can use StreetEasy listing data for

- **Rental market analysis** — track asking rents by neighborhood over time
- **Investment research** — compare sale prices and price per square foot across areas
- **Concession tracking** — monitor how often landlords offer months free and how that moves
- **Comparable analysis** — pull comps for a specific building or block
- **Inventory monitoring** — watch how long listings stay on the market
- **Relocation research** — shortlist apartments matching a budget and bedroom count

Real estate agents, investors, appraisers, property managers, market analysts and relocation services use this data across residential real estate, proptech and financial research.

### ⚠️ Limitations & known issues

- **New York City only** — StreetEasy covers the five boroughs, so there is no data for other cities.
- **Listing URL forms** — `/building/{slug}/{unit}`, `/rental/{id}` and `/sale/{id}` unit pages are all accepted as start URLs.
- **Contact details** — the agent or company name and phone number shown on the listing are collected; agent email addresses are not.
- **Missing sections** — some listings have no policies, no neighborhood description or no price history, in which case that field is empty or `null`.

### ❓ Frequently asked questions

#### Can I scrape StreetEasy legally?

This actor only collects data that is already publicly visible on StreetEasy — no login, paywall, or private content is accessed. Scraping publicly available data is generally considered lawful (see *hiQ Labs v. LinkedIn* as precedent). You remain responsible for complying with StreetEasy's Terms of Service and for how you use listing content, which may be copyrighted by the listing broker.

#### Why did my run return no results?

Almost always the proxy setting. StreetEasy refuses roughly five out of six IP addresses with an HTTP 403, so a run without US residential proxies returns nothing at all. Leave `proxyConfiguration` on its default. Seeing several `403` lines in the log is normal and expected — the scraper simply retries from a different address until one is accepted.

#### Does this scrape both rentals and sales?

Yes. Paste a `/for-rent` or `/for-sale` search URL and the actor labels every row with `listingType` so you can tell them apart in a mixed dataset.

#### How many listings can I scrape from one search?

`maxItems` limits results **per start URL**, so three searches with `maxItems: 100` returns up to 300 listings. Set it to `0` to follow the search to its end.

#### Do I need a proxy to scrape streeteasy.com?

For a handful of listings, often not. For anything larger, yes — US residential proxies are strongly recommended, because StreetEasy blocks aggressively by IP.

#### How do I scrape StreetEasy with Python?

Install `apify-client`, then call the actor with your search URL and iterate the dataset — see the Python example above. Each listing comes back as flat JSON ready for pandas.

#### Can I run this StreetEasy scraper on a schedule?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run it daily, and set `cacheProjectName` to enable monitor mode, so each run skips previously scraped listings and returns only new ones — exactly what you want for market monitoring, and it keeps costs down.

#### Is this the cheapest streeteasy scraper in Apify?

Possibly yes, as this streeteasy scraper has caching feature which might save you money across multiple runs.

#### What output formats are supported?

JSON, CSV, Excel, XML and RSS, either from the **Output** tab or through the Apify API.

### 🔗 Other actors you may find useful - Student Housing and Rent Website Scrapers

| Actor | Description |
| ----- | ----------- |
| [HousingAnywhere Property Scraper](https://apify.com/confidential_gnat/housinganywhere-property-scraper) | Scrapes rental listings from HousingAnywhere across every city and room type it lists. |
| [Spotahome Property Scraper](https://apify.com/confidential_gnat/spotahome-property-scraper) | Scrapes mid- and long-term rental listings from Spotahome across European cities. |
| [Casita Student Accommodation Scraper](https://apify.com/confidential_gnat/casita-property-scraper) | Scrapes student accommodation listings from Casita, including pricing, room types and facilities. |
| [University Living Housing Scraper](https://apify.com/confidential_gnat/universityliving-housing-scraper) | Scrapes student housing listings and property details from University Living. |
| [AmberStudent Accommodation Scraper](https://apify.com/confidential_gnat/amberstudent-accomodation-scraper) | Scrapes AmberStudent student accommodation listings — pricing, availability, photos, amenities, location and reviews. |
| [Student.com Accommodation Scraper](https://apify.com/confidential_gnat/student-com-property-scraper) | Scrapes student accommodation listings from Student.com by city or university page. |
| [Rightmove Listing Availability Checker](https://apify.com/confidential_gnat/rightmove-listing-availability-checker) | Checks whether Rightmove listing URLs are still active or have been removed. |

### 💬 Support & contact

If you encounter any issues or have questions, please [open an issue](https://apify.com/confidential_gnat/streeteasy-property-scraper/issues/open).

You can also find more of our actors on the [Apify Store](https://apify.com/confidential_gnat).

# Actor input Schema

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

StreetEasy URLs to scrape. Accepts rental searches (https://streeteasy.com/for-rent/nyc), sale searches (https://streeteasy.com/for-sale/nyc) — including any filters you set in the site's own search — and single listing URLs. Page type is detected automatically.

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

Maximum number of listings to scrape per start URL. Set to 0 for no limit.

## `scrapeDetails` (type: `boolean`):

Open every listing page to collect the description, amenities and features. Turn this off to scrape roughly twice as fast using only the data on the search results page.

## `cacheProjectName` (type: `string`):

Optional. Name a project to remember which listings have already been scraped across runs, so repeated runs only return new listings.

## `proxyConfiguration` (type: `object`):

REQUIRED. StreetEasy blocks a large share of IPs — measured at roughly five in six — so runs need US residential proxies. The scraper retries each blocked request from a fresh IP, which is what makes runs succeed; without proxies every request returns 403.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://streeteasy.com/for-rent/nyc"
    }
  ],
  "maxItems": 5,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (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://streeteasy.com/for-rent/nyc"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("confidential_gnat/streeteasy-property-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://streeteasy.com/for-rent/nyc" }] }

# Run the Actor and wait for it to finish
run = client.actor("confidential_gnat/streeteasy-property-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://streeteasy.com/for-rent/nyc"
    }
  ]
}' |
apify call confidential_gnat/streeteasy-property-scraper --silent --output-dataset

```

## MCP server setup

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