Is There a StreetEasy API? Yes — How to Get NYC Listing Data

Sooner or later, every developer building for the New York market runs the same search: is there an API for StreetEasy? The results look promising. There's even a page at streeteasy.com/nyc/api/info sitting right there in Google. You click it. It loads nothing useful, and there's no developer portal anywhere on the site to fall back to. Welcome to one of real estate data's most-asked, worst-answered questions.

Here's the honest version of the answer, plus the part most articles skip: what you can actually run today.

The short answer

No. StreetEasy has no public API. There is no developer program, no key to request, no sandbox. The API info page that still ranks in search results is a leftover from an earlier era of the company, and everything the ecosystem has built since (scrapers, unofficial clients, alert tools) exists precisely because the official door is closed.

That leaves you with four realistic options in 2026, and they differ a lot in cost, effort, and how often they wake you up at night. One of them is a hosted REST API you can call this afternoon. We'll get to all four, but first it's worth understanding why the door is closed, because that context explains which workarounds are stable and which ones are living on borrowed time.

Why StreetEasy doesn't hand out API keys

StreetEasy is not a listings site that happens to be in New York. It is apartment hunting in New York. Zillow bought the company back in 2013 for $50 million, and research cited on the company's Wikipedia page found that roughly eighty percent of people searching for a home in New York City used StreetEasy or an affiliated Zillow Group site. In most cities the portal competes with the MLS. In New York, famously short on a unified MLS, the portal largely is the market.

Listing data is the moat, and portals guard the moat. StreetEasy charges brokers to post rental listings: $3 per listing per day when the fee launched in 2017, $6 by 2022. When you're charging six dollars a day per rental listing, giving developers a free firehose of those same listings would be setting fire to your own business model. Yeah… no. That API was never coming back.

What StreetEasy does publish is aggregate market data. Their Data Dashboard offers downloadable CSVs of median rents, inventory, and days on market by neighborhood. If your project needs trends rather than listings, start there, it's free and official. This walkthrough shows what pulling it looks like in practice:

But the dashboard won't tell you what's listed right now at what price with which amenities. For listing-level data, you need one of the four options below.

Your four real options in 2026

Every path to StreetEasy listing data is a trade between money, engineering time, and fragility. Here's the honest comparison:

Option	Pricing	Setup effort	Where it hurts
Official StreetEasy API	Doesn't exist	n/a	The API page in search results leads nowhere; there is no developer portal behind it.
DIY scraper (headless browser + proxies)	"Free," plus proxies and your time	Days to build, forever to maintain	Bot detection, layout changes, IP bans. Every scraper you write is a maintenance contract you signed with yourself.
Scraper marketplaces (e.g. Apify actors)	~$3 per 1,000 results	Hours	StreetEasy caps a search around 1,050 results, so full-market pulls need price-band workarounds. You still own schemas, dedup, and monitoring, and actors break when the site shifts underneath them.
Unofficial open-source clients (e.g. a TypeScript GraphQL client)	Free	Hours	Reverse-engineered from StreetEasy's internal GraphQL. The README's changelog is a diary of the server rejecting things that worked last month. No one to email when it stops.
Hosted REST endpoints (RealtyAPI)	Subscriptions from $20/month for 20,000 requests	Minutes	Covers StreetEasy's world only (NYC boroughs + North Jersey), and it lives on the paid plans rather than the free tier.

If you're weighing the build-it-yourself route seriously, we've written up the general trade-off in web scraping vs. using an API. Short version: scraping wins when the data has no API at any price and your volume is tiny. It loses the moment uptime matters.

Is scraping StreetEasy even legal?

The question everyone asks quietly. The unsatisfying answer: scraping publicly visible data is not automatically illegal in the US, but StreetEasy's terms of use prohibit it, and Zillow Group has lawyers with market-leading motivation. Courts have gone back and forth on public-data scraping for years, and none of it makes your Tuesday deploy more reliable when the bot wall tightens. We cover the landscape properly in is website scraping legal? The practical read: the legal risk is real but ambiguous, while the engineering pain is certain. Most teams don't quit scraping because of a lawyer. They quit because of maintenance.

What RealtyAPI's StreetEasy endpoints cover

RealtyAPI runs hosted StreetEasy endpoints as part of its real estate data platform: you call a normal REST endpoint with an API key, and the scraping, proxies, and anti-bot plumbing stop being your problem. Seven endpoints cover the StreetEasy surface:

Endpoint	What it returns
`GET /search/rent`	Rental listings for one or more locations, with the full filter set below
`GET /search/buy`	For-sale listings, including co-op specific filters like monthly maintenance and taxes
`GET /rental_detailsbyid`	Full details for one rental listing, by the id that search returns
`GET /sale_detailsbyid`	Full details for one sale listing, by id
`GET /all_locations`	Every borough and neighborhood StreetEasy recognizes, with ids
`GET /schools`	School list with the slugs the buy search accepts as a filter
`GET /` (upcheck)	Health check

Each request costs one credit, auth is a single x-realtyapi-key header, and responses are JSON. Coverage follows StreetEasy itself: all five boroughs, neighborhood by neighborhood, plus the North Jersey commuter belt (Hoboken, Jersey City, and company).

The filters that make it feel like StreetEasy

Generic national listing APIs treat New York like any other city, which is exactly how you end up unable to answer "one-bed near the L train, pet-friendly, guarantor OK." These search parameters are the StreetEasy-native ones that matter:

transit_lines: filter by nearby subway lines (1,6,A,L, plus PATH and HBLR for the Jersey side)
prewar: prewar only, or hide prewar entirely
amenities: includes very NYC values like guarantor_ok, doorman, pied_a_terre, and washer_dryer
maintenance and taxes: monthly caps on the buy side, because a co-op's sticker price is only half the story
income_restricted: show only, or hide, income-restricted sales
school: limit buy results to a school zone, using slugs from /schools
open_house: listings with an open house today, tomorrow, or this week

Infographic: one RealtyAPI key connects to seven StreetEasy endpoints — search rentals, search sales, rental details, sale details, locations, schools, and health check

Quick-start: NYC listings in three requests

Base URL: https://streeteasy.realtyapi.io. Auth: your key in the x-realtyapi-key header. One note before you start: StreetEasy sits in RealtyAPI's premium set, so it's available on the subscription plans (PRO, $20/month for 20,000 requests) rather than the free tier. The free tier is still useful for feeling out the request and response shapes on the standard APIs first, and the docs cover key setup in a couple of minutes.

1. Find your location slugs

curl "https://streeteasy.realtyapi.io/all_locations" \
  -H "x-realtyapi-key: YOUR_KEY"

Response (trimmed):

[
  { "id": 1,       "name": "NYC and NJ" },
  { "id": 100,     "name": "Manhattan" },
  { "id": 300,     "name": "Brooklyn" },
  { "id": 302,     "name": "Williamsburg" },
  { "id": 1004000, "name": "Hoboken" }
]

Search takes location names, comma-separated and lowercased, so this list is your source of truth for what StreetEasy will accept.

2. Search rentals (or sales)

curl "https://streeteasy.realtyapi.io/search/rent?location=williamsburg&beds=1&priceRange=2500-4500&transit_lines=L&amenities=washer_dryer" \
  -H "x-realtyapi-key: YOUR_KEY"

Listings come back nested under search_results.listings; each entry's node carries the listing, including the id you'll use for details. When hasNextPage is true, request the next page with &page=2. Each page is one credit.

3. Pull full details for one listing

curl "https://streeteasy.realtyapi.io/rental_detailsbyid?buildingid=LISTING_ID" \
  -H "x-realtyapi-key: YOUR_KEY"

Same pattern on the sale side: /search/buy into /sale_detailsbyid.

A production-ish Python loop

Here's the same flow with pagination and the error handling you actually want, since any API that fronts live web data will occasionally have a bad minute upstream:

import requests

BASE = "https://streeteasy.realtyapi.io"
HEADERS = {"x-realtyapi-key": "YOUR_KEY"}

def get(path, **params):
    r = requests.get(BASE + path, params=params, headers=HEADERS, timeout=60)
    r.raise_for_status()
    data = r.json()
    # Upstream hiccups surface as a "message" field with empty results
    if data.get("message") and not data.get("search_results"):
        raise RuntimeError(f"Upstream error: {data['message']}")
    return data

def search_rentals(**filters):
    page = 1
    while True:
        data = get("/search/rent", page=page, **filters)
        results = data.get("search_results") or {}
        for item in results.get("listings") or []:
            yield item.get("node") or item
        if not (data.get("hasNextPage") or results.get("hasNextPage")):
            break
        page += 1

for listing in search_rentals(location="williamsburg", beds="1",
                              priceRange="2500-4500", transit_lines="L"):
    print(listing.get("id"))

From here it's your product: pipe listings into Postgres and diff daily for a price-drop alert bot, join transit_lines filters against commute times for a relocation tool, or watch open_house for a weekend-planning app. The point of an API over a scraper is that this loop is the whole integration. There's no proxy pool behind it for you to babysit. Ask me how I know what babysitting one is like.

Diagram of the three-request flow: list locations, search listings, then pull details for one listing

What you still can't get

Honesty section. These endpoints return what's on StreetEasy now: active listings, their details, current filters. They are not a time machine. If you want price history across years, you either capture snapshots yourself on a schedule (the pagination loop above plus a cron job and a database gets you surprisingly far) or lean on the free Data Dashboard for aggregate history. And if your app needs national coverage, StreetEasy data alone won't do it; that's what pairing it with the other sources on the platform is for, the same way we approached getting Zillow data through an API the question of whether Redfin has an API, and what counts as a Realtor.com API.

Key takeaways

StreetEasy has no public API, and it's structural, not an oversight. Listings are the product they charge brokers daily fees for, so a free official firehose is never coming.
For aggregate trends, use StreetEasy's own Data Dashboard. It's free, official, and covers median rents and inventory by neighborhood. No engineering required.
DIY and marketplace scrapers trade money for maintenance. $3 per 1,000 results sounds cheap until you're the one reconciling schemas and re-running capped searches in price bands.
Hosted endpoints turn the problem into one HTTP call. Search, details, locations, and schools, with NYC-native filters like subway lines and co-op maintenance caps, from $20/month.
Whatever route you pick, keep your integration one layer thick. If a source changes, you want to swap one client file, not an application's worth of parsing assumptions.

If you're building something for the New York market, the fastest way to know whether this data fits your product is to run the three requests above against a PRO plan, point them at your own neighborhood, and see what comes back. Twenty dollars buys you 20,000 requests and your evenings back.