Skip to content
    ↑↓ to choose · Enter to open

    · 13 min read

    Redfin Real Estate Scraper: Up to 2,500 Free Results a Month (2026)

    By CrawlerBros Engineering Team

    Active for-sale listings and rental properties return with 38 output fields per property, covering price, beds, baths, coordinates, and listing remarks. A thousand dataset results cost $2.00 on Apify's free plan, while an initial test run capping maxItems at 3 costs at most $0.01 in result charges. Historical sold listings are excluded completely because Redfin loads sold data via client-side JavaScript that requires a full browser session. This Actor is built for real estate analysts and software teams storing housing market metrics, but not for anyone who needs complete photo galleries or listing agent contact details.

    Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 2,500 results at $0.002 each before platform usage. Open Redfin Real Estate Scraper on Apify and run the prefilled example.

    How reliable is Redfin Real Estate Scraper in production?

    Across the last 30 days of public runs on the Apify platform, Redfin Real Estate Scraper recorded 78 runs with the following outcomes.

    Outcome Runs Share
    Succeeded 73 93.6%
    Failed 4 5.1%
    Aborted by the user 1 1.3%
    Timed out 0 0.0%
    Total 78 100.0%

    You should expect about 5 in a hundred runs to fail or time out in production schedules. Building retries and failure alerts around your scheduled jobs handles these occurrences, while user-aborted runs represent manual cancellations rather than system errors.

    What does it cost to run Redfin Real Estate Scraper?

    Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

    Apify plan Per result Per 1,000 results
    FREE $0.002 $2.00
    BRONZE $0.00167 $1.67
    SILVER $0.00133 $1.33
    GOLD $0.001 $1.00
    PLATINUM $0.001 $1.00
    DIAMOND $0.001 $1.00

    Worked example: collecting 10,000 results costs $20.00 in result charges before run-start fees and platform usage. With 5.1% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

    Result charges depend on dataset size, so setting maxItems controls the maximum result charges for a run. Starting with maxItems set to 3 costs at most $0.01 in result charges to test your configuration before scaling up. Providing additional links in startUrls collects more items until your configured item limit is reached.

    How do you run Redfin Real Estate Scraper from the API?

    None of its 4 controls is strictly required, so the defaults below produce a valid run on their own. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

    Call the synchronous endpoint to start a run and receive dataset items in one request:

    curl -X POST "https://api.apify.com/v2/acts/crawlerbros~redfin-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["https://www.redfin.com/city/11203/CA/Los-Angeles"],"searchMode":"SALE","maxItems":3}'

    The same run from Python, using the official client:

    from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "startUrls": [
    "https://www.redfin.com/city/11203/CA/Los-Angeles"
  ],
  "searchMode": "SALE",
  "maxItems": 3
}

run = client.actor("crawlerbros~redfin-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

    And from Node.js:

    import { ApifyClient } from 'apify-client'

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

const input = {
  "startUrls": [
    "https://www.redfin.com/city/11203/CA/Los-Angeles"
  ],
  "searchMode": "SALE",
  "maxItems": 3
}

const run = await client.actor('crawlerbros~redfin-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

    That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

    Which Redfin Real Estate Scraper inputs matter, and which can you skip?

    The main controls are startUrls, search, searchMode, and maxItems. Providing region links directly in startUrls is recommended because the search parameter calls Redfin's autocomplete API, which can encounter rate limits. Set searchMode to SALE for purchasing market listings or RENT for active rental inventory.

    • startUrls (array): Redfin city/region URLs (e.g., https://www.redfin.com/city/11203/CA/Los-Angeles, https://www.redfin.com/zipcode/90210).
    • searchMode (string): For sale or for rent listings. SOLD is not supported - Redfin loads sold data via client-side JS that requires a browser. Default: "SALE".
    • search (string): Alternative to startUrls - a city/ZIP query (e.g., 'Los Angeles, CA'). Note: may fail if Redfin autocomplete is rate-limited; startUrls is more reliable.
    • maxItems (integer): Maximum number of properties to return. Default: 50.

    Fixed-choice controls: searchMode accepts SALE (For Sale), RENT (For Rent).

    What does Redfin Real Estate Scraper return?

    Returned property records carry key market attributes like price, pricePerSqFt, sqFt, beds, baths, coordinates, and listingRemarks. The datasets do not include historical sold records, agent email addresses, or full photo galleries beyond the primary cover photo.

    Example Output

    • propertyId (e.g. 7066577)
    • mlsId (e.g. BB26074621)
    • mlsStatus (e.g. Active)
    • url (e.g. https://www.redfin.com/CA/Los-Angeles/2621-Si...)
    • address (e.g. 2621 Silver Ridge Ave)
    • city (e.g. Los Angeles)
    • state (e.g. CA)
    • zip (e.g. 90039)
    • latitude (e.g. 34.1035752)
    • longitude (e.g. -118.25645)
    • price (e.g. 999000)
    • pricePerSqFt (e.g. 959)
    • beds (e.g. 2)
    • baths (e.g. 1)
    • sqFt (e.g. 1042)
    • lotSize (e.g. 3622)
    • yearBuilt (e.g. 1925)
    • propertyType (e.g. Single Family)
    • daysOnRedfin (e.g. 1)
    • location (e.g. 671 - Silver Lake)
    • listingRemarks
    • scrapedAt (e.g. 2026-04-10T12:00:00+00:00)

    Address

    • address: String - Street address
    • unitNumber: String - Unit number
    • city: String - City
    • state: String - State code
    • zip: String - ZIP code
    • countryCode: String - Country code
    • latitude: Number - Latitude
    • longitude: Number - Longitude
    • location: String - Neighborhood

    Pricing & Specs

    • price: Integer - List / sale price
    • pricePerSqFt: Integer - Price per square foot
    • beds: Number - Number of bedrooms
    • baths: Number - Total bathrooms
    • fullBaths: Integer - Full bathrooms
    • sqFt: Integer - Square footage
    • lotSize: Integer - Lot size (sq ft)
    • stories: Number - Number of stories
    • yearBuilt: Integer - Year built
    • propertyType: String - Single Family / Condo / etc.
    • hoaFee: Integer - HOA fee
    • garageSpaces: Integer - Garage spaces
    • parkingSpaces: Integer - Parking spaces
    • poolType: String - Pool type

    Listing Info

    • listingStatus: String - Active/Pending/Sold
    • daysOnRedfin: Integer - Days on market
    • listingRemarks: String - Full listing description
    • numPictures: Integer - Number of photos
    • coverPhoto: String - Primary photo URL
    • isNewConstruction: Boolean - New construction
    • has3DTour: Boolean - 3D tour available
    • hasVideoTour: Boolean - Video tour available
    • hasVirtualTour: Boolean - Virtual tour available
    • scrapedAt: String - ISO 8601 scrape timestamp

    These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

    How do you build the workflow end to end?

    Open Redfin Real Estate Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

    1. Navigate to Redfin.com, copy a target city or ZIP URL, and add it to startUrls.
    2. Set searchMode to SALE or RENT to choose between purchasing or rental inventory.
    3. Set maxItems to 3 for your initial run to verify returned fields at minimal cost.
    4. Execute the Actor and confirm that the dataset is created using the hardcoded US RESIDENTIAL proxy.
    5. Inspect the resulting dataset to ensure fields like propertyId, price, address, and coordinates are populated.
    6. Add more target region links to startUrls if you need to fetch data across multiple geographic locations.
    7. Adjust maxItems up to the allowed maximum of 500 properties to complete your full data collection.

    How do you apply it? Three worked playbooks

    These are Redfin Real Estate Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

    Use case 1: Real estate research

    Outcome: Track prices and inventory in specific markets

    Configure: Set startUrls to ["https://www.redfin.com/city/11203/CA/Los-Angeles"], searchMode to "SALE", and maxItems to 50.

    Working method: Execute a run with a single city URL, then review price and daysOnRedfin across the returned dataset before scheduling periodic monitoring.

    Deliverable: A dataset of property records containing active listing prices and days on market for the selected region.

    Stop condition: The dataset contains zero records for a region known to have active listings on Redfin.

    Use case 2: Investment analysis

    Outcome: Find undervalued properties in target ZIP codes

    Configure: Set startUrls to ["https://www.redfin.com/zipcode/90210"], searchMode to "SALE", and maxItems to 100.

    Working method: Pass target ZIP code URLs into startUrls, execute the run, and filter results by comparing pricePerSqFt and listingRemarks across the records.

    Deliverable: A ZIP-code dataset with price per square foot figures and listing remarks.

    Stop condition: Returned items missing valid pricePerSqFt or propertyId values.

    Use case 3: Market trends

    Outcome: Aggregate data across cities for analysis

    Configure: Set startUrls to ["https://www.redfin.com/city/11203/CA/Los-Angeles", "https://www.redfin.com/zipcode/90210"], searchMode to "SALE", and maxItems to 500.

    Working method: Supply a list of target city and ZIP URLs into startUrls, run the Actor, and group output items by propertyType and zip to compare regional metrics.

    Deliverable: A multi-region dataset formatted for comparative real estate inventory analysis.

    Stop condition: Output items fail to contain key location fields like city, state, or zip.

    What breaks, and how do you design around it?

    • Over the last 30 days, 5.1% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

    Each execution limits output to a maximum of 500 property records. To analyze broader geographic areas, split your target markets across multiple distinct city or ZIP code URLs in startUrls. If you require historical property sales data, you must source that data elsewhere.

    When should you not use Redfin Real Estate Scraper?

    Do not use this Actor if your project requires historical sold listings, because Redfin loads sold data via client-side JavaScript. If you need commercial real estate or business listings, use LoopNet.com Commercial Real Estate Scraper instead.

    What should you check before trusting the output?

    • Verify that propertyId is populated as an integer on every record.
    • Check that latitude and longitude return numeric decimal values rather than nulls.
    • Confirm that price is populated with an integer value when searchMode is SALE.
    • Ensure scrapedAt contains a valid ISO 8601 timestamp string.
    • Stop scheduled runs if consecutive executions return empty dataset arrays for a valid startUrls link.

    None of this proves a record is correct. It gives a scheduled Redfin Real Estate Scraper run defined points where it should stop instead of quietly passing bad data downstream.

    Frequently asked questions

    What is the recent reliability of this Redfin scraper?

    In the last 30 days, 73 of 78 public runs succeeded, which represents a 93.6% success rate and a 5.1% failure rate.

    Can I scrape historical sold property listings?

    No. Redfin loads sold listings via client-side JavaScript requiring a browser session. This Actor uses Redfin's internal GIS API, which supports only active SALE and RENT listings.

    Why should I use startUrls over the search text field?

    The search parameter relies on Redfin's autocomplete API, which can be rate-limited. Passing direct city or ZIP URLs in startUrls bypasses autocomplete for higher reliability.

    Are detail page photos included in the output?

    Only the cover photo is included in the output. Full photo galleries require additional detail-page scraping that is rate-limited.

    Do I need to configure proxies for Redfin?

    No configuration is needed. Redfin restricts requests to US IP addresses, so the Actor uses built-in US RESIDENTIAL proxies automatically.

    Where to go next

    When you are ready to run it, open Redfin Real Estate Scraper on Apify; the free plan covers up to 2,500 results a month.

    Start with the Redfin Real Estate Scraper Actor page for the current input schema, pricing tier, and run history.

    It is part of the Real Estate Scrapers, which puts every related Actor on one page with its price and run history.

    If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

    Other Actors we maintain for related data:

    Related guides:

    Resources

    • Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-25.

    • Actor last updated by its maintainers on 2026-08-05.

    • Run outcome figures cover the 30 day public window ending 2026-09-25.

    • Redfin Real Estate Scraper on Apify

    Featured actors

    Redfin Real Estate Scraper

    Extract property listings from Redfin including price, beds, baths, sqft, address, coordinates, photos, listing remarks, and more. Uses Redfin's internal GIS API for reliable structured data.

    Run on Apify ↗