# Zillow & Redfin Property Data Scraper (`scrapebench/zillow-redfin-property-scraper`) Actor
Look up any US home by street address and get consolidated property facts — beds, baths, sqft, year built, lot size, and property type — from Redfin and Zillow. Pay per match; misses are free.
- **URL**: https://apify.com/scrapebench/zillow-redfin-property-scraper.md
- **Developed by:** [ScrapeBench](https://apify.com/scrapebench) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
$0.004 / property lookup
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).
If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
## Zillow & Redfin Property Data Scraper
### Pain points
- You have a street address but need the property's facts — beds, baths, sqft, year built, lot size — as structured data, not a web page you have to read by hand.
- Redfin and Zillow block plain HTTP requests (TLS/browser fingerprinting + WAFs), so a simple `fetch` or a datacenter proxy just returns 403/429.
- Every listing site names and nests its fields differently, so consolidating one address into a single clean record means bespoke parsing per site.
### What we solve
- Give it one US street address and a source (Redfin or Zillow); it returns that property's consolidated facts as a single clean JSON record.
- Drives a real browser so it gets past the fingerprint/WAF blocks that stop plain HTTP scrapers, then reads each site's structured data directly.
- Normalizes every site into one schema (street line, city, state, ZIP, beds, baths, sqft, year built, lot size in sqft, property type, listing URL, and listing photo URLs) — unknown fields are omitted, never guessed.
- Charges only when it finds a real match (address + city + ZIP); a not-found or blocked lookup is free.
### Summary
Turn a street address into structured property facts. Give this actor a single US address and pick a source (Redfin or Zillow), and it returns that home's consolidated details — beds, baths, square footage, year built, lot size (in sqft), and property type — as one clean JSON record, plus the listing URL and the listing's photo gallery as full-size image URLs (empty when the home has no gallery). It drives a real browser so it gets past the browser-fingerprint and WAF blocks that defeat plain HTTP scrapers, then reads each site's own structured data and normalizes it to a single schema. Built for property-management onboarding, real-estate CRM enrichment, valuation/comp workflows, and any app that needs to auto-fill a property form (and its photos) from just an address. One address in, structured facts out — pay only for matches.
### Who it's for
- Property-management and PropTech teams auto-filling a property form from just an address
- Real-estate CRMs and marketplaces enriching listings/leads with structured home facts
- Analysts and investors building valuation, comp, and underwriting datasets
- Developers who need a simple address-to-property-facts API without maintaining browser scrapers
### How to use
Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:
```json
{
"address": "745 Garland Dr, Palo Alto, CA 94303",
"source": "redfin",
"useProxy": false
}
````
See **Inputs** below for every available field.
### What you get
One row per record:
| Field | Description |
|---|---|
| `found` | true when a property with address + city + ZIP was resolved; false when this source has no match or was blocked |
| `source` | Which site produced the record ('redfin' or 'zillow') — echoes the requested source |
| `data.address` | Street line only, e.g. '745 Garland Dr' |
| `data.city` | City |
| `data.state` | 2-letter state code, e.g. 'CA' |
| `data.zip` | ZIP code |
| `data.beds` | Number of bedrooms |
| `data.baths` | Number of bathrooms (may be fractional, e.g. 2.5) |
| `data.sqft` | Living area in square feet |
| `data.yearBuilt` | Year the home was built |
| `data.lotSizeSqft` | Lot size in square feet (acres are converted to sqft) |
| `data.propertyType` | Property type, e.g. 'Single Family Residential', 'Condo' |
| `data.sourceUrl` | Link to the source listing/record page |
| `data.images` | Listing photo gallery as an ordered array of { url, width, height } (url is the full-size CDN image; \[0] is the hero). Empty array when the listing has no gallery — e.g. many off-market/sold homes |
Sample:
```json
{
"found": true,
"source": "redfin",
"data": {
"address": "745 Garland Dr",
"city": "Palo Alto",
"state": "CA",
"zip": "94303",
"beds": 3,
"baths": 4,
"sqft": 3301,
"yearBuilt": 2012,
"lotSizeSqft": 12722,
"propertyType": "Single Family Residential",
"sourceUrl": "https://www.redfin.com/CA/Palo-Alto/745-Garland-Dr-94303/home/1210666",
"images": [
{
"url": "https://ssl.cdn-redfin.com/photo/163/bigphoto/105/1240105_0.jpg",
"width": 1024,
"height": 768
},
{
"url": "https://ssl.cdn-redfin.com/photo/163/bigphoto/105/1240105_1_0.jpg",
"width": 1024,
"height": 768
}
]
}
}
```
### Inputs
| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `address` | no | string | `"745 Garland Dr, Palo Alto, CA 94303"` | Full US property address, e.g. '745 Garland Dr, Palo Alto, CA 94303'. In Standby mode this is sent in the POST /scrape request body instead. |
| `source` | no | string | `"redfin"` | Which site to look the property up on. Redfin works without a proxy and is the reliable default; Zillow sits behind PerimeterX, so enable the residential proxy for it at volume. |
| `useProxy` | no | boolean | `false` | Route the browser through Apify residential proxy. Default off (direct). Turn on only for IP rate-limiting at volume or to help pass Zillow's PerimeterX. |
### Pricing (Pay Per Event)
You pay per result (`property-lookup`) — **no charge for empty runs**. Example: **100 matched property lookup** at *$0.004/result* ≈ **$0.40**.
Illustrative — 100 matched lookups at $0.004 each. Not-found/blocked lookups are free. Apify platform usage (compute) is billed separately per your plan.
### Use cases
- Auto-add property — type an address, prefill a property form with beds, baths, sqft, year built, lot size, and type.
- CRM / listing enrichment — turn an address into a structured property record for a database or marketplace.
- Valuation & comps — assemble per-address home facts for pricing, underwriting, or comparison workflows.
- Address-to-facts API — call it per address from your app instead of building and maintaining Redfin/Zillow scrapers.
### Why this actor
- Reads Redfin's and Zillow's own structured data, then normalizes to one clean schema — not a brittle screen-scrape of visible text.
- Drives a real browser, so it gets past the browser-fingerprint and WAF blocks that return 403/429 to plain HTTP scrapers and datacenter proxies.
- Honest output: only address+city+ZIP-complete matches count as found; unknown fields are omitted (never null/0/guessed); you pay only for matches.
- One address in, one structured record out — single-purpose and simple to call from any app or workflow.
### Limitations & updates
Single-source per call: it scrapes exactly the source you request (Redfin or Zillow) — it does not fall back across sites, so call it once per source if you want a fallback. Redfin is the reliable default and works without a proxy; Zillow sits behind PerimeterX and needs the residential proxy option (and can still be rate-limited at high volume). It returns the fields listed (physical property facts plus the listing's photo URLs); price history, tax, and agent data are out of scope. Photos come from the listing's own gallery, so a home with no gallery (e.g. many off-market/sold listings) returns an empty images array. A result missing address, city, or ZIP is reported as not-found rather than a partial record. It resolves one property per call from a full street address; it is not a bulk area/ZIP crawler.
### FAQ
**What do I give it and what do I get back?**
You give it a US street address and a source ('redfin' or 'zillow'). It returns one JSON record with the property's street line, city, state, ZIP, beds, baths, sqft, year built, lot size (sqft), property type, and the listing URL — or { "found": false } if that source has no match.
**Which sources are supported?**
Redfin (the reliable default) and Zillow. Redfin works without a proxy. Zillow sits behind PerimeterX, so at volume enable the residential proxy option to reach it consistently.
**How am I charged?**
Pay-per-event: one charge per successful lookup (a match with address, city, and ZIP). Not-found or blocked lookups are free, so you never pay for a miss.
**Why does it need a real browser?**
Redfin and Zillow block plain HTTP requests on TLS/browser fingerprint (not just IP), so curl, a bare fetch, and datacenter proxies all get 403/429. Driving a real browser gets past that and reads each site's own structured data.
**Do I need a proxy?**
No for Redfin (it works direct at low volume). For Zillow, or for higher volume, turn on the residential proxy option; there's a useProxy input for exactly this.
**Does it return listing photos?**
Yes — the data.images array gives the listing's photo gallery as full-size image URLs in order (the first is the hero), each with width and height. The URLs are public CDN links you can load directly in an ![]()
tag. A home with no gallery (many off-market/sold listings) returns an empty array; photos are supported on Redfin today.
**Is this personal data?**
No — it returns public property facts (physical attributes of a home as the listing sites publish them). It adds no owner/PII enrichment.
**How current is the data?**
It reflects each site's live data at run time, so the facts are as current as Redfin's/Zillow's own published records.
### Which actor to choose
Owning or managing a property usually means hiring the people who work on it — verify and find them:
- **Multi-State Contractor & Trade License Lookup** — You're hiring a contractor to work on the property — verify their license across states before you sign.
- **California Contractor Directory & Leads Scraper (CSLB)** — You need licensed contractors by trade and county for work on a California property.
### Guides & use cases
Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:
- **How-to:** [How to run Zillow & Redfin Property Data Scraper](https://scrapebench.dev/guides/how-to-zillow-redfin-property-scraper/)
- **Use case:** [Auto-fill a Property Form from Just an Address](https://scrapebench.dev/use-cases/auto-fill-property-form-from-address/)
More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**
# Actor input Schema
## `address` (type: `string`):
Full US property address, e.g. '745 Garland Dr, Palo Alto, CA 94303'. In Standby mode this is sent in the POST /scrape request body instead.
## `source` (type: `string`):
Which site to look the property up on. Redfin works without a proxy and is the reliable default; Zillow sits behind PerimeterX, so enable the residential proxy for it at volume.
## `useProxy` (type: `boolean`):
Route the browser through Apify residential proxy. Default off (direct). Turn on only for IP rate-limiting at volume or to help pass Zillow's PerimeterX.
## Actor input object example
```json
{
"address": "745 Garland Dr, Palo Alto, CA 94303",
"source": "redfin",
"useProxy": false
}
```
# Actor output Schema
## `property` (type: `string`):
Beds, baths, sqft, year built, lot size, and type for the looked-up address.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"address": "745 Garland Dr, Palo Alto, CA 94303",
"source": "redfin"
};
// Run the Actor and wait for it to finish
const run = await client.actor("scrapebench/zillow-redfin-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"address": "745 Garland Dr, Palo Alto, CA 94303",
"source": "redfin",
}
# Run the Actor and wait for it to finish
run = client.actor("scrapebench/zillow-redfin-property-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"address": "745 Garland Dr, Palo Alto, CA 94303",
"source": "redfin"
}' |
apify call scrapebench/zillow-redfin-property-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=scrapebench/zillow-redfin-property-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Zillow & Redfin Property Data Scraper",
"description": "Look up any US home by street address and get consolidated property facts — beds, baths, sqft, year built, lot size, and property type — from Redfin and Zillow. Pay per match; misses are free.",
"version": "0.0",
"x-build-id": "QPYDsno0a50atEyps"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/scrapebench~zillow-redfin-property-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-scrapebench-zillow-redfin-property-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/scrapebench~zillow-redfin-property-scraper/runs": {
"post": {
"operationId": "runs-sync-scrapebench-zillow-redfin-property-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/scrapebench~zillow-redfin-property-scraper/run-sync": {
"post": {
"operationId": "run-sync-scrapebench-zillow-redfin-property-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {
"address": {
"title": "Property address",
"type": "string",
"description": "Full US property address, e.g. '745 Garland Dr, Palo Alto, CA 94303'. In Standby mode this is sent in the POST /scrape request body instead."
},
"source": {
"title": "Listing source",
"enum": [
"redfin",
"zillow"
],
"type": "string",
"description": "Which site to look the property up on. Redfin works without a proxy and is the reliable default; Zillow sits behind PerimeterX, so enable the residential proxy for it at volume.",
"default": "redfin"
},
"useProxy": {
"title": "Use residential proxy",
"type": "boolean",
"description": "Route the browser through Apify residential proxy. Default off (direct). Turn on only for IP rate-limiting at volume or to help pass Zillow's PerimeterX.",
"default": false
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```