# Redfin Sold Comps Scraper — ARV & Comp Analysis | $1.50/1K (`parsing_machine/redfin-sold-comps-tracker`) Actor

Pull only sold-listing comps from Redfin by city, ZIP, county, or URL — price, beds, baths, sqft, lot size, year built, and days-on-market for closed sales. Built for house-flippers, wholesalers, and appraisers doing ARV and comp analysis, not active listings.

- **URL**: https://apify.com/parsing\_machine/redfin-sold-comps-tracker.md
- **Developed by:** [Iakov Iudin](https://apify.com/parsing_machine) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 sold listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

This is the sold-comps-only edition of the Redfin scraper: statusFilter is locked to sold closed sales for after-repair value (ARV) and comparable-property analysis. It accepts the same locations and direct Redfin URLs as the base actor and is built for real-estate investors, house flippers, wholesalers, and appraisers analyzing recently sold comps.

## Redfin Sold Comps Scraper — ARV & Comp Analysis | $1.50/1K | No Proxy

For real-estate investors, house flippers, wholesalers, and appraisers who need Redfin's recently sold comps data for After-Repair-Value (ARV) and comparable-property analysis without spinning up proxies or parsing HTML.

Pay per property: **$1.50 per 1,000 properties** — charged only for results delivered.

Scrape Redfin recently sold listings by city, ZIP code, county, or neighborhood. Returns structured property data — closed price, beds, baths, square footage, lot size, year built, days on market, GPS coordinates, and more. Powered by Redfin's internal stingray JSON API for reliable, fast extraction.

### Why use this actor?

- **Built for ARV & Comps** — `statusFilter` is permanently locked to closed/sold sales; perfectly tuned for comparable-property analysis
- **No proxy required** for most US regions — the API returns JSON directly
- **Fast and reliable** — structured JSON endpoint, no HTML parsing fragility
- **Rich data** — 20+ fields per property including remarks, closing status, and coordinates
- **Flexible input** — city, ZIP, county, neighborhood, or full Redfin search URL
- **Pay per result** — only pay for properties you actually receive

### What data do you get?

| Field | Description |
|---|---|
| `property_id` | Redfin property ID (stable) |
| `address` | Street address |
| `city`, `state`, `zip` | Location |
| `price` | Closed/sold price in USD |
| `beds` | Bedrooms |
| `baths` | Bathrooms (supports half-baths) |
| `sqft` | Interior square footage |
| `lot_size` | Lot size in square feet |
| `year_built` | Year of construction |
| `property_type` | house / condo / townhouse / multi-family / land / other |
| `status` | sold |
| `days_on_market` | Days on market before closing |
| `latitude`, `longitude` | GPS coordinates |
| `url` | Direct Redfin listing URL |
| `parse_confidence` | Data quality score (1.0 = perfect) |

### How to use

1. Go to [redfin.com](https://www.redfin.com) and navigate to a city, ZIP code, county, or neighborhood (locations and direct Redfin URLs work the same as the base Redfin scraper)
2. Copy the URL from your browser's address bar
3. Paste it into the **Locations** input field

**Example URLs:**

```text
https://www.redfin.com/city/30818/TX/Austin
https://www.redfin.com/zipcode/78701
https://www.redfin.com/county/1361/TX/Travis-County
https://www.redfin.com/neighborhood/48430/CA/San-Francisco/Noe-Valley
```

You can scrape multiple locations in one run by adding multiple URLs.

### Output sample

```json
{
  "property_id": "55823410",
  "address": "2107 Nueces St",
  "city": "Austin",
  "state": "TX",
  "zip": "78705",
  "price": 625000,
  "beds": 3,
  "baths": 2.0,
  "sqft": 1850,
  "lot_size": 5400,
  "year_built": 1978,
  "property_type": "house",
  "status": "sold",
  "days_on_market": 12,
  "latitude": 30.2843,
  "longitude": -97.7407,
  "url": "https://www.redfin.com/TX/Austin/2107-Nueces-St-78705/home/55823410",
  "parse_confidence": 1.0,
  "warnings": []
}
```

### Pricing example

| Run size | Cost |
|---|---|
| 100 properties | ~$0.15 |
| 1,000 properties | ~$1.50 |
| 10,000 properties | ~$15.00 |

### FAQ

**Do I need a Redfin account or proxy?**
No account. No proxy required for most US regions — the stingray JSON API is open. Configure Apify proxy in Advanced options only if you hit blocks.

**What output formats are available?**
JSON, CSV, Excel, XML — all via Apify dataset download or API.

**Do I need to filter for sold properties manually?**
No — this actor is hardcoded to only pull closed/sold sales for ARV and comparable-property analysis. The `statusFilter` is permanently locked to `sold`.

**What if a location returns empty results?**
The actor logs the error, skips the location, and continues. Empty locations push no records and charge nothing.

### Why this actor vs. competitors

| Feature | This actor | epctex/redfin-scraper ($2/1K) | Typical Redfin HTML scraper |
|---|---|---|---|
| Internal stingray JSON API | Yes | No (HTML) | No |
| parse\_confidence | Yes | No | No |
| Days on market field | Yes | Rarely | No |
| Multiple locations per run | Yes | Single URL | Single URL |
| Dedicated to Sold comps | Yes | No | No |
| Proxy required | No (most regions) | Yes | Often yes |

Key differentiators: `lot_size`, `year_built`, and `days_on_market` on every property. Designed specifically for investors and appraisers doing ARV analysis, ensuring only closed-sale data is extracted without extra configuration.

### parse\_confidence

Every record includes `parse_confidence` (1.0 = all fields present). Records with `parse_confidence < 0.8` have degraded data — inspect the `warnings` array.

### Use with AI agents (MCP)

Tag: `MCP_SERVERS`. Returns flat JSON — plug directly into LangChain agents, n8n nodes, or Make scenarios without transformation.

```json
{
  "mcpServer": "https://mcp.apify.com/?tools=bovi/redfin-sold-comps-tracker"
}
```

### Proxy

No proxy required for most US regions. If you encounter blocks, configure an Apify proxy in the **Advanced options** section.

### Cost

Pay-Per-Event (PPE) pricing:

| Event | Price |
|---|---|
| `property-item` | **$1.50 / 1,000 properties** |

Default run fetches up to 500 properties.

### Integrations

Built for real-estate investors, house flippers, wholesalers, and appraisers pulling structured property comps by city, ZIP, and neighborhood — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Legal

This actor accesses publicly available real estate data from redfin.com. Use responsibly and in accordance with Redfin's Terms of Service. Do not use for mass harvesting or commercial redistribution of listing data.

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Dubai Property Scraper](https://apify.com/bovi/dubai-property-scraper)
- [Onthemarket Properties Scraper](https://apify.com/bovi/onthemarket-properties-scraper)
- [Realtor Scraper](https://apify.com/bovi/realtor-scraper)
- [Rightmove Listings](https://apify.com/bovi/rightmove-listings)
- [Zillow Scraper](https://apify.com/bovi/zillow-scraper)
- [Zoopla Properties Scraper](https://apify.com/bovi/zoopla-properties-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

# Actor input Schema

## `locations` (type: `array`):

Full Redfin search URLs to scrape — city, ZIP, county, or neighborhood. Go to redfin.com, navigate to any area, copy the URL. Examples: https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. Add multiple URLs to scrape several areas in one run.

## `maxResults` (type: `integer`):

Maximum number of property records to return across all locations. 0 = no limit (up to Redfin API maximum per region). Default 500.

## `propertyTypes` (type: `array`):

Filter by property type. Accepted values: house, condo, townhouse, multi-family, land, other. Leave empty to include all types.

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

Minimum listing price filter. 0 = no minimum.

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

Maximum listing price filter. 0 = no maximum.

## `minBeds` (type: `integer`):

Minimum number of bedrooms. 0 = no minimum.

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

Optional Apify proxy. Most Redfin regions do not require a proxy — the stingray API returns JSON directly. Use a proxy only if you encounter blocks in restricted regions.

## `statusFilter` (type: `string`):

Filter by listing status. active: for-sale only; sold: recently sold; all: both active and sold.

## `pageSize` (type: `integer`):

Number of listings fetched per API call (max 350). Reduce if you see errors. Default 350.

## Actor input object example

```json
{
  "locations": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "maxResults": 500,
  "propertyTypes": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "statusFilter": "sold",
  "pageSize": 350
}
```

# Actor output Schema

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

Dataset containing Redfin Scraper records (address, city, state, price, beds, baths, sqft, days\_on\_market, status, property\_type, url, parse\_confidence).

# 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 = {
    "locations": [
        "https://www.redfin.com/city/30818/TX/Austin"
    ],
    "maxResults": 500,
    "propertyTypes": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minBeds": 0,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "statusFilter": "sold",
    "pageSize": 350
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsing_machine/redfin-sold-comps-tracker").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 = {
    "locations": ["https://www.redfin.com/city/30818/TX/Austin"],
    "maxResults": 500,
    "propertyTypes": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minBeds": 0,
    "proxyConfiguration": { "useApifyProxy": False },
    "statusFilter": "sold",
    "pageSize": 350,
}

# Run the Actor and wait for it to finish
run = client.actor("parsing_machine/redfin-sold-comps-tracker").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 '{
  "locations": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "maxResults": 500,
  "propertyTypes": [],
  "minPrice": 0,
  "maxPrice": 0,
  "minBeds": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "statusFilter": "sold",
  "pageSize": 350
}' |
apify call parsing_machine/redfin-sold-comps-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsing_machine/redfin-sold-comps-tracker"
        }
    }
}

```

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/tF680cuFJ2EddX5WU/builds/bKftbLWV8O8WsrJeB/openapi.json