Så skrapar du Redfin med Python (utan att bli blockerad)

Redfin uppdaterar 70 % av nya MLS-listningar i USA inom fem minuter efter att de publicerats. Så pass färsk data är rena drömmen för alla som bygger en pipeline för fastighetsdata — och just därför riktar så många scraperlösningar in sig på Redfin och blir blockerade inom bara några minuter.

Jag har lagt flera år på att bygga verktyg för datautvinning på Thunderbit, och en sak kan jag säga med säkerhet: glappet mellan att "skrapa Redfin" och att "skrapa Redfin utan att bli blockerad" är där de flesta guider faller isär. De visar BeautifulSoup-koden, hoppar över delen där Cloudflare slår tillbaka mot dina förfrågningar, och lämnar dig att stirra på en 403-sida och undra vad som gick fel. Den här guiden är annorlunda. Jag går igenom tre verkliga metoder — HTML-parsing, Redfins dolda API och en no-code-väg med Thunderbit — och lägger ordentligt med tid på de anti-bot-skydd som faktiskt spelar roll. När du är klar vet du exakt vilken metod som passar din kunskapsnivå, din skala och din tolerans för underhållsjobb.

Testa Thunderbit för Redfin-skrapning

Vad är Redfin, och varför är deras data så viktig?

Redfin är en teknikdriven fastighetsmäklare med anställda agenter som hämtar objekt direkt från MLS-flöden. Tjänsten täcker över 100 storstadsområden i USA och Kanada i 42 delstater och har nästan 50 miljoner besökare per månad. Till skillnad från portaler som bara samlar in data från andra källor är Redfins information verifierad av mäklare, och deras egen Redfin Estimate AVM täcker över 95 miljoner fastigheter med ett medianfel på bara 1,96 % för bostäder som ligger ute på marknaden.

Den kombinationen — MLS-hastighet i form av färska uppdateringar, mäklarverifierad kvalitet och en stark AVM — är skälet till att fastighetsinvesterare, mäklare, proptech-startups och dataanalytiker alla vill ha programmatisk åtkomst till Redfin-data. Python är det naturliga valet: ekosystemet för skrapning är moget (requests, BeautifulSoup, Selenium, Playwright), community-stödet är stort och det passar direkt in i pandas och Jupyter för analys.

Varför skrapa Redfin med Python?

Användningsområdena är nästan lika många som användarna som behöver datan. Så här brukar olika målgrupper använda skrapad Redfin-data:

Målgrupp	Huvudsyfte med skrapningen	Exempel på användning
Fastighetsmäklare	Leadgenerering, marknadsinsikt	Nya objekt och utgångna annonser i serviceområdet; agentkatalog för konkurrensanalys
Fastighetsinvesterare	Affärsflöde, cap rate-analys	Filter för hyresavkastning, upptäckt av undervärderade objekt, dagliga larm om nya listningar
Proptech-startups	Produktdata-pipelines	Träningsdata för AVM, marknadsdashboards, förvärvsmotorer för iBuyer
Dataanalytiker	Marknadsanalys, BI	Trender för medianpris på ZIP-kodsnivå, tidsserier för dagar på marknaden, förhållanden mellan försäljningspris och listpris
Grossister / flippare	Spårning av stressade objekt	Upptäckt av prissänkningar, tvångsförsäljningar, jämförbara objekt utanför marknaden

Den bredare utvecklingen bekräftar detta: över 72 % av fastighetsbolagen använder nu prediktiv analys för att hitta möjligheter och hantera risk. PropTech-marknaden väntas nå $47 miljarder 2025 med en CAGR på 16,4 %. Strukturerad fastighetsdata är inte längre ett trevligt plus — det är en självklar basnivå.

Alla Redfin-fält du kan skrapa (fullständig referens)

Innan du skriver en enda rad kod behöver du veta vad som faktiskt går att hämta. Jag har granskat Redfins resultatsidor, objektsidor och agentprofiler — och korscheckat mot open source-wrappers för Stingray API, som projekten reteps/redfin och RedfinPlus. Totalt landar det på 117 olika fält över olika sidtyper.

Den här tabellen är värd att bokmärka. Att känna till dataschemat innan du börjar koda sparar timmar av letande efter rätt selektorer.

Fält på resultatsidor

Det här är de lätta fälten som finns på listkort — ofta möjliga att hämta utan full JS-rendering:

Fält	Datatyp	Kommentar
Objekt-ID	Nummer	Redfins interna heltal, parsas från `/home/{id}` i href
Listpris	Nummer
Fullständig adress	Text
Sovrum / Badrum / Kvm	Nummer	Tre värden i följd
Bostadstyp	Single Select	SFH, Condo, Townhouse, Multi
Status	Text	Active, Pending, Contingent
Dagar på marknaden	Nummer
Indikator för prissänkning	Nummer	Skillnad från ursprungligt listpris
Huvudfoto	Bild-URL	Ett foto per kort
Hot Home-märke	Boolean
Datum/tid för visning	Text
Mäklartillhörighet	Text

Fält på objektsidor

Det är på objektsidan som djupet finns. Många av dessa fält kräver JavaScript-rendering eller Stingray API:

Fält	Datatyp	Kommentar
Redfin Estimate (på marknaden)	Nummer	Via `/stingray/api/home/details/avm`
Redfin Estimate (utanför marknaden)	Nummer	Via `/stingray/api/home/details/owner-estimate`; medianfel 7,52 %
Byggår / renoverat år	Nummer
Tomtstorlek	Nummer
HOA-avgifter	Nummer	Per månad, om tillämpligt
Fastighetsskatt (årlig)	Nummer
Taxeringsvärde	Nummer
Tabell över försäljningshistorik	Tabell	Pris, datum, händelsetyp
Objektbeskrivning	Text	Marknadsföringstext
Foto-URL:er (karusell)	Bild-URL:er	20+ per listning
Namn, telefon, e-post för listande agent	Text / Telefon / E-post	Telefonnummer är ofta maskerat
Skolbetyg (låg/mellan/hög)	Nummer	Plus distriktsnamn
Walk / Transit / Bike Score	Nummer
Klimatriskpoäng	Nummer	Översvämning, brand, värme, vind
Liknande aktiva / sålda / närliggande hem	URL:er	Karuselldata
Parkering, garage, uppvärmning, kyla	Text	Bekvämlighetsgrupper

Fält på agentprofiler

Fält	Datatyp	Kommentar
Agentnamn, foto, mäklarfirma, bio	Text / Bild
Telefon, kontaktformulär	Telefon / Text	Klicka för att visa
Antal aktiva listningar	Nummer
Försäljning senaste 12 månaderna / total volym	Nummer
Genomsnittligt förhållande mellan listpris och försäljningspris	Nummer
Stjärnbetyg / antal recensioner	Nummer
Erfarenhetsår / licensnummer	Text / Nummer

När du använder Thunderbits AI Suggest Fields på en Redfin-sida identifierar den automatiskt de flesta av de här kolumnerna och sätter rätt datatyper — utan att du behöver mappa CSS-selektorer manuellt. Mer om det strax.

Så fungerar Redfins anti-bot-skydd egentligen — inte bara "använd en proxy"

Här vill jag vara tydlig, för de flesta guider hoppar över blockeringsproblemet och går rakt till "köp proxies från vår sponsor". Det hjälper inte. Om du inte förstår vad Redfin gör för att känna igen scrapers, bränner du proxykrediter och blir ändå blockerad. ScrapeOps ger Redfins anti-bot-svårighet 7,5 av 10, och Scraperly klassar den som medelhög (3/5) — "mindre aggressiv än Zillows enterprise-WAF och bygger på egen rate limiting och JavaScript-utmaningar."

Redfin använder en lösning i flera lager: Cloudflare i kanten (JS-utmaning, Turnstile, TLS/JA3-fingeravtryck) plus en Redfin-specifik rate limiter på applikationsnivå. Det finns ingen Crawl-delay i deras robots.txt, eftersom kontrollen sker på WAF-nivå.

Varför enkla `requests` + BeautifulSoup misslyckas på Redfin

Om du skickar en vanlig requests.get() till en Redfin-objektsida med standardheaders händer oftast detta:

HTTP 403 — Cloudflares JS-utmaning klarades inte, så du får utmaningssidan istället för listningen.
En mellanliggande challenge-sida — HTML-kroppen innehåller Cloudflares Turnstile-widget, inte objektdata.
HTTP 200 med delvis HTML — Du får ett skal med ett stort inbäddat JSON-block under root.__reactServerState.InitialContext, men inga för-renderade listkort, ingen prishistorik och inga skolbetyg.

Redfin använder sitt eget React SSR-ramverk (inte Next.js), och hydratiseringsnyckeln är Redfin-specifik — root.__reactServerState.InitialContext med listdata inbäddad under ReactServerAgent.cache.dataCache. Det här är inte __NEXT_DATA__ eller window.__INITIAL_STATE__.

Den absolut vanligaste orsaken till tysta 403:or? Saknade Sec-Fetch-*-headers. Redfin/Cloudflare validerar uttryckligen Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-Dest och Sec-Fetch-User. Om de saknas flaggas du direkt.

Spelplanen för att minska blockeringar: fördröjningar, headers, proxies och sessioner

Här är en fullständig genomgång, skydd för skydd, med konkreta åtgärder för varje del:

Redfins skydd	Vad det gör	Signal för upptäckt	Strategi för att minska blockering
Cloudflare JS-utmaning	Mellansida som sätter cookien `cf_clearance`	403 + Cloudflare-HTML i kroppen	`curl_cffi` med `impersonate="chrome120"`; värm sessionen via startsidan; amerikansk residential proxy
Cloudflare Turnstile	Interaktiv CAPTCHA vid riskfyllda sessioner	403 + Turnstile-widget	Headless browser med stealth + residential proxy
Cloudflare Error 1020 (ASN-blockering)	Blockerar flaggade IP:er/ASN:er i WAF	403 med "Error 1020 Access Denied"	Byt till residential- eller mobilproxy; använd aldrig datacenter-ASN
TLS/JA3-fingeravtryck	Upptäcker TLS-stackar som inte liknar en webbläsare	Tyst 403 även med perfekta headers	`curl_cffi`-impersonering eller riktig webbläsare
HTTP/2-fingeravtryck	Kontrollerar HTTP/2 SETTINGS och HPACK-ordning	Tyst blockering	`curl_cffi` pratar HTTP/2 som Chrome
Header-validering (UA, Sec-Fetch-*)	Webbläsarliknande headeruppsättning	403 på första begäran	Komplett Chrome-headeruppsättning inklusive `Sec-Fetch-Site/Mode/Dest/User`, realistisk `Referer`
Cookie-/sessionskontinuitet	Spårar `cf_clearance`, `RF_BROWSER_ID`	Utmaningar vid kalla djupa URL-hämtningar	Ihållande session; värm på startsidan först
Rate limit på app-nivå	Begränsning per IP-adress	429	Fördröj 2–5 sekunder med jitter; exponentiell backoff
Dåligt rykte för datacenter-IP	Blockerar kända DC-ASN:er	Omedelbar 1020/403	Använd endast residential- eller mobilproxy
Detektion av samtidighet	Flera parallella förfrågningar från samma IP	Plötslig Turnstile-eskalering	Högst 2 samtidiga per IP

Praktiska gränsvärden från tester i communityn:

Säker takt: 1 begäran var 2–3 sekund per IP
Ihållande mer än 20–30 begäranden/minut från en enda datacenter-IP triggar en utmaning inom några minuter
Mjuka rate limits släpper efter 5–15 minuter om trafiken upphör
Blockeringar av datacenter-IP (AWS, GCP, Azure, OVH) kan ligga kvar i timmar till dagar

Vanliga Python-requests (urllib3 + OpenSSL) ger ett JA3-fingeravtryck som inte matchar någon webbläsare — och blir tyst blockerade även med perfekta headers. Branschens lösning är curl_cffi med impersonate="chrome120", som talar Chrome-lik TLS + HTTP/2.

Tre sätt att skrapa Redfin med Python (och vilket du ska välja)

Jag har inte hittat en enda konkurrerande guide som jämför alla tre metoder sida vid sida. Här är beslutsmatrisen:

Kriterium	HTML-parsing (BS4 + Selenium)	Dold Stingray API	Thunderbit (no-code)
Svårighetsgrad för uppsättning	Medel (Python-miljö + webbläsardrivrutin)	Hög (reverse engineering av endpoints)	Låg (installera Chrome-tillägg)
Risk för blockering	Hög (DOM-förfrågningar syns tydligast)	Medel (API-liknande anrop ser renare ut)	Lägst (använder din riktiga webbläsarsession)
Kvalitet på datastrukturen	Medel (ostrukturerad HTML → manuell parsing)	Utmärkt (förstrukturerad JSON)	Hög (AI identifierar fält och datatyper automatiskt)
Underhållsbehov	Högt — en layoutändring kan bryta selektorer	Medel — endpoints kan ändras utan förvarning	Lägst — AI anpassar sig till layoutändringar
Skala	Låg–medel (hundratals med proxies)	Medel–hög (tusentals, renare förfrågningar)	Medel (50 sidor per batch via molnskrapning)
Bäst för	Utvecklare som vill ha full kontroll	Utvecklare som behöver ren JSON	Icke-utvecklare, snabba projekt, löpande data utan utvecklingsresurser

Underhållsaspekten är värd att betona. Redfin har släppt två generationer av listkort-DOM — äldre (homecardV2Price) och nuvarande (span.bp-Homecard__Price--value). Historiken i GitHub-ärenden visar att CSS-selektorer brukar gå sönder ungefär var 6–12:e månad. När det händer faller en BeautifulSoup-scraper ofta över en natt. En AI-baserad fältdetektor anpassar sig.

Innan du börjar

Svårighetsgrad: Medel (Metod 1 & 2), Nybörjare (Metod 3)
Tidsåtgång: ~30 minuter för Metod 1 eller 2; ~5 minuter för Metod 3
Du behöver:
- Python 3.8+ med pip (Metod 1 & 2)
- Chrome-webbläsare (alla metoder)
- Thunderbit Chrome Extension (Metod 3)
- Amerikanska residential proxies för skrapning i större skala (Metod 1 & 2)

Skrapa Redfin-data med AI Get Started Free

Metod 1: Skrapa Redfin med Python via HTML-parsing (BeautifulSoup + Selenium)

Det här är vägen med full kontroll. Du skriver selektorerna, du hanterar webbläsaren, du tar hand om felen.

Det är den mest lärorika metoden. Den är också den mest sköra.

Steg 1: Sätt upp din Python-miljö

Skapa en virtuell miljö och installera de bibliotek som behövs:

python -m venv redfin-scraper
source redfin-scraper/bin/activate  # På Windows: redfin-scraper\Scripts\activate
pip install requests beautifulsoup4 selenium webdriver-manager pandas curl_cffi

curl_cffi är avgörande här — det är det som låter dina HTTP-begäranden efterlikna ett riktigt Chrome-TLS-fingeravtryck istället för det standardfingeravtryck som Python-requests använder och som Cloudflare blockerar direkt.

Steg 2: Konfigurera webbläsarheaders och session

Det är här de flesta nybörjare kör fast. Du behöver hela Chrome-headeruppsättningen, inklusive Sec-Fetch-*-headers som Redfin/Cloudflare uttryckligen validerar:

from curl_cffi import requests as curl_requests

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Sec-Fetch-Site": "none",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-User": "?1",
}

session = curl_requests.Session(impersonate="chrome120")
session.headers.update(HEADERS)

# Värm sessionen — hämta cf_clearance- och RF_BROWSER_ID-cookies
session.get("https://www.redfin.com/")

Steget att värma sessionen är kritiskt — att träffa en djup objekts-URL kallt (utan tidigare cookies, utan Referer) ger lägre poäng hos Cloudflare.

Börja alltid med startsidan.

Steg 3: Skrapa Redfin-resultatsidor

När sessionen är varm kan du hämta en söksida för en stad och läsa ut listkorten. Aktuella selektorer (2024–2026):

import time
import random
from bs4 import BeautifulSoup

base_url = "https://www.redfin.com/city/17151/CA/San-Francisco"
listings = []

for page_num in range(1, 6):  # Sidor 1-5
    url = f"{base_url}/page-{page_num}" if page_num > 1 else base_url
    resp = session.get(url)

    if resp.status_code != 200:
        print(f"Blockerad på sida {page_num}: HTTP {resp.status_code}")
        break

    soup = BeautifulSoup(resp.text, "html.parser")
    cards = soup.select("[data-rf-test-id='property-card'], a.bp-Homecard")

    for card in cards:
        price_el = card.select_one("span.bp-Homecard__Price--value")
        addr_el = card.select_one("a.bp-Homecard__Address")
        stats = card.select("span.bp-Homecard__LockedStat--value")

        listing = {
            "price": price_el.text.strip() if price_el else None,
            "address": addr_el.text.strip() if addr_el else None,
            "beds": stats[0].text.strip() if len(stats) > 0 else None,
            "baths": stats[1].text.strip() if len(stats) > 1 else None,
            "sqft": stats[2].text.strip() if len(stats) > 2 else None,
            "url": "https://www.redfin.com" + addr_el["href"] if addr_el else None,
        }
        listings.append(listing)

    # Slumpmässig fördröjning mellan 2–5 sekunder
    time.sleep(random.uniform(2, 5))

print(f"Skrapade {len(listings)} listningar")

Du bör se en växande lista med dictionaries, där varje post innehåller pris, adress, sovrum/badrum/kvm och en länk till objektsidan för en San Francisco-listning. Om du får 0 kort, kontrollera HTTP-statuskoden — en 403 betyder att Cloudflare har stoppat dig, och då behöver du troligen residential proxies.

Steg 4: Skrapa enskilda objektsidor

Resultatsidorna ger grunderna. Objektsidorna ger Redfin Estimate, byggår, HOA, försäljningshistorik, agentinfo och bilder. De här sidorna kräver JavaScript-rendering, så byt till Selenium:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By
import time

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_argument("user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                     "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)

for listing in listings[:10]:  # Berika de första 10
    driver.get(listing["url"])
    time.sleep(random.uniform(3, 6))  # Vänta på JS-rendering

    try:
        estimate_el = driver.find_element(By.CSS_SELECTOR, "[data-rf-test-name='avmLdpPrice']")
        listing["redfin_estimate"] = estimate_el.text.strip()
    except:
        listing["redfin_estimate"] = None

    try:
        year_built = driver.find_element(By.XPATH, "//span[contains(text(),'Year Built')]/following-sibling::span")
        listing["year_built"] = year_built.text.strip()
    except:
        listing["year_built"] = None

driver.quit()

Efter det här steget bör dina första 10 listningar vara kompletterade med Redfin Estimate och byggår. XPath-selektorerna är lite robustare än CSS för de här nästlade bekvämlighetsfälten, men de är fortfarande sköra — alla DOM-ändringar kan bryta dem.

Steg 5: Hantera blockeringar och fel

Implementera omförsök med exponentiell backoff:

import time

def fetch_with_retry(session, url, max_retries=3):
    for attempt in range(max_retries):
        resp = session.get(url)
        if resp.status_code == 200:
            return resp
        elif resp.status_code in (403, 429, 503):
            wait = (2 ** attempt) + random.uniform(1, 3)
            print(f"Blockerad ({resp.status_code}). Försöker igen om {wait:.1f}s...")
            time.sleep(wait)
        else:
            print(f"Oväntad status: {resp.status_code}")
            break
    return None

Tecken på att du blivit blockerad: HTTP 403 med Cloudflare-HTML i kroppen, HTTP 429 (uttalad rate limit), tomt svarsbody eller "Error 1020 Access Denied" i sidinnehållet. Om du stöter på detta konsekvent är det dags att lägga till residential proxies eller byta till API-metoden.

Metod 2: Skrapa Redfin med Python via det dolda Stingray API:t

Det här är min favoritmetod. Redfins frontend pratar med ett internt JSON-API på /stingray/api/home/details/*, och svaren kommer tillbaka som ren, typad JSON — ingen HTML-parsing behövs.

Så hittar du Redfins dolda API-endpoints

Öppna Chrome DevTools → fliken Network → filtrera på Fetch/XHR → gå till valfri Redfin-objektsida. Du ser förfrågningar till endpoints som:

api/home/details/initialInfo — mappar URL → propertyId, listingId
api/home/details/aboveTheFold — pris, sovrum, badrum, kvm, bilder, status, agent, MLS#
api/home/details/belowTheFold — bekvämligheter, HOA, skatter, parkering, byggår, tomt, historik
api/home/details/avm — Redfin Estimate för objekt på marknaden
api/home/details/owner-estimate — Redfin Estimate för objekt utanför marknaden
api/home/details/descriptiveParagraph — marknadsföringsbeskrivning

För hyressidor extraheras rentalId (en UUID på 36 tecken) från URL:en i taggen <meta property="og:image">.

Skrapa objektdatan via Stingray API

Det finns en viktig egenhet: Stingray-svar är prefixade med den bokstavliga strängen {}&& som en anti-CSRF-åtgärd. Du måste ta bort den innan du parsar:

import json
from curl_cffi import requests as curl_requests

session = curl_requests.Session(impersonate="chrome120")
session.headers.update(HEADERS)

# Värm sessionen
session.get("https://www.redfin.com/")

# Hämta en objektsida för att få cookies och property ID
property_url = "https://www.redfin.com/CA/San-Francisco/123-Main-St-94102/home/12345678"
page_resp = session.get(property_url)

# Anropa nu Stingray API
api_url = "https://www.redfin.com/stingray/api/home/details/aboveTheFold?propertyId=12345678"
api_resp = session.get(api_url, headers={"Referer": property_url})

# Ta bort anti-CSRF-prefixet
payload = json.loads(api_resp.text.replace("{}&&", "", 1))

# Extrahera strukturerad data
listing_data = payload.get("payload", {})
print(json.dumps(listing_data, indent=2))

Svaret innehåller typade fält: pris som heltal, sovrum/badrum som nummer, foto-URL:er som arrayer och agentinfo som nästlade objekt. Ingen BeautifulSoup-parsing, inga CSS-selektorer, inga gissningar.

Fördelar och begränsningar med den dolda API-metoden

Fördelar:

Förstrukturerad JSON — betydligt renare än HTML-parsing
Snabbare per begäran (mindre payloads, ingen rendering)
Lägre risk för blockering (API-liknande anrop med rätt headers ser mer naturliga ut)

Begränsningar:

Endpoints kan ändras utan förvarning — det finns ingen officiell dokumentation
robots.txt förbjuder uttryckligen /stingray/ för wildcard-user-agenten
Kräver reverse engineering för att hitta nya endpoints
Kräver fortfarande varm session och rätt headers för att undvika Cloudflare

No-code-alternativet: skrapa Redfin med Thunderbit

Om du behöver Redfin-data men inte vill underhålla Python-script — eller bara vill ha resultat på fem minuter — börja här. Vi byggde Thunderbit exakt för detta: strukturerad datautvinning från vilken webbplats som helst, utan kod.

Steg 1: Installera Thunderbit och gå till Redfin

Installera Thunderbit Chrome Extension från Chrome Web Store. Öppna Redfin och gå till en resultatsida — till exempel bostäder till salu i San Francisco.

Steg 2: Klicka på "AI Suggest Fields"

Klicka på Thunderbit-ikonen i webbläsarens verktygsfält och välj sedan "AI Suggest Fields." AI:n läser Redfin-sidan och föreslår automatiskt kolumner som "Address", "Price", "Beds", "Baths", "SqFt", "Property Type" och "Listing Photo" — med rätt datatyper redan satta.

Du kan ta bort kolumner du inte behöver eller lägga till egna genom att klicka på "+ Add Column" och beskriva vad du vill ha i vanlig text, till exempel "listing agent name" eller "days on market".

Du bör nu se en tabellförhandsvisning med de kolumner du ställt in, redo att fyllas med data.

Steg 3: Klicka på "Scrape" och se datan rulla in

Klicka på "Scrape". Thunderbit bearbetar de synliga listningarna och fyller tabellen. För paginerade resultat hanteras sidbläddringen automatiskt — ingen loopkod behövs.

I mina tester fylldes en tabell med 50 rader på ungefär 45 sekunder. Strukturerad data, redo att exporteras.

Så hanterar Thunderbit Redfins anti-bot-skydd

Eftersom Thunderbit kör i din egen webbläsare ärver den dina befintliga Redfin-cookies, din session och ditt webbläsarfingeravtryck. För Cloudflare ser det ut som att en vanlig användare surfar på Redfin — för tekniskt sett är det precis vad som händer. Ingen headless browser, ingen datacenter-IP, inget TLS-fingeravtryck som inte matchar. För offentligt tillgängliga sidor kan Thunderbits molnskrapning bearbeta 50 sidor åt gången.

Det är en helt annan utgångspunkt än att köra requests från ett Python-script på en server.

Din webbläsarsession är redan betrodd.

Skrapa undersidor på Redfin med Thunderbit

Efter att du har skrapat resultatsidorna kan du klicka på "Scrape Subpages" för att låta AI:n besöka varje objektsida och berika tabellen med fler fält — Redfin Estimate, byggår, HOA-avgifter, agentinfo, fastighetsbilder och försäljningshistorik.

Det motsvarar den 40-raders Selenium-loopen i Metod 1 — men kräver ett klick och noll underhåll.

När Redfin ändrar sin DOM från homecardV2Price till span.bp-Homecard__Price--value anpassar sig AI:n. Dina Python-selektorer gör det inte.

Skrapa Redfin-undersidor med AI Get Started Free

Mer än CSV: exportera Redfin-data till Google Sheets, Airtable och Notion

De flesta guider stannar vid df.to_csv(). Det fungerar för en engångsanalys. Men om du jobbar i ett fastighetsteam behöver du samarbetsvänlig, levande data — inte statiska filer som samlar damm på någons skrivbord.

Export med Python (gspread + Airtable API)

Google Sheets via gspread:

import gspread
import pandas as pd
from gspread_dataframe import set_with_dataframe

df = pd.DataFrame(listings)
gc = gspread.service_account(filename="service_account.json")
sh = gc.open("Redfin Listings")
ws = sh.worksheet("Sheet1")
ws.clear()
set_with_dataframe(ws, df, include_index=False, resize=True)

# Visa fastighetsbilder inline via IMAGE()-formel
image_col = df.columns.get_loc("image_url") + 1
for row_idx, url in enumerate(df["image_url"], start=2):
    ws.update_cell(row_idx, image_col, f'=IMAGE("{url}")')

Tänk på att Sheets har en hård gräns på 10 miljoner celler per kalkylark, och API:t tillåter 300 läs- + 300 skrivbegäranden per minut per projekt. Använd ws.batch_update() i stället för att loopa cell för cell om du hanterar mer än några dussin rader.

Airtable via pyairtable:

Viktig ändring 2024: Airtable avvecklade de gamla API-nycklarna den 1 februari 2024. Du måste använda Personal Access Tokens (PAT) nu — alla guider som fortfarande visar api_key=... är föråldrade.

from pyairtable import Api

api = Api("patXXXXXXXXXXXXXX.yyyyyyyyyyyyyyyyyyyy")
table = api.table("appBaseId123", "Redfin Listings")

records = [
    {
        "Address": row["address"],
        "Price": row["price"],
        "Beds": row["beds"],
        "Photo": [{"url": row["image_url"]}],  # Airtable hämtar och hostar om
    }
    for row in listings
]
created = table.batch_create(records, typecast=True)

Airtables rate limit är 5 begäranden per sekund per base, med en spärr på 30 sekunder vid överträdelse. Bilagefältet accepterar payloads i formatet [{"url": ...}] — Airtables servrar hämtar då URL:en, lagrar om den på sitt CDN och skapar miniatyrbilder automatiskt.

Export med Thunderbit (1 klick till Sheets, Airtable, Notion)

Thunderbit har inbyggd export med ett klick till Google Sheets, Airtable och Notion — och här kommer delen jag verkligen är stolt över: fastighetsbilder laddas upp och visas som inline-bilder i Notion och Airtable. Ingen =IMAGE()-hackning, inga trasiga CDN-länkar. Du klickar på "Export to Airtable", och ditt team får en visuell fastighetsdatabas med miniatyrer som går att bläddra i från mobilen.

För fastighetsteam som arbetar med visuell gallring av listningar är det här skillnaden mellan ett användbart verktyg och en hög med CSV-rader.

Är det lagligt att skrapa Redfin? Vad ToS, robots.txt och rättsfall säger

Jag är inte jurist, och detta är inte juridisk rådgivning. Men efter många år inom datautvinning kan jag säga att "är det lagligt?" är frågan alla ställer och som de flesta guider duckar för.

Redfins robots.txt

Redfins robots.txt är detaljerad. Viktiga punkter:

Helt blockerade bots: peer39_crawler/1.0, AmazonAdBot, FireCrawlAgent — Redfin namnger uttryckligen den populära scraping-tjänsten från LLM-eran
Wildcard User-agent: * med Disallow gäller bland annat: /stingray/ (hela det interna API-namnområdet), /myredfin/, /api/v1/rentals/, /api/v1/properties/, /owner-estimate/
Ingen Crawl-delay:-direktiv för någon user agent
Över 50 sitemaps deklarerade — sitemaps är det renaste och minst WAF-tunga sättet att lista URL:er

Redfins användarvillkor

Avsnitt 2.3.5 säger: "You may not automatedly crawl or query the Services for any purpose or by any means... unless you have received prior express written permission."

Det här är ett browsewrap-avtal — acceptans genom fortsatt användning, inte genom aktivt klick. Amerikanska domstolar har historiskt varit skeptiska till att driva igenom browsewrap mot användare som inte faktiskt kände till villkoren (se Nguyen v. Barnes & Noble, 9th Cir. 2014).

Relevant praxis i korthet

Van Buren v. United States (Högsta domstolen, 2021): CFAA:s "exceeds authorized access"-del använder ett test där frågan är om grinden är uppe eller nere. Att använda en öppen dörr för ett ovälkommet syfte är inte federal hacking.
hiQ Labs v. LinkedIn (9th Cir., 2022): Skrapning av offentligt tillgänglig data är inte ett CFAA-brott. Men hiQ betalade till slut 500 000 dollar i förlikning på avtalsbrottssidan — eftersom hiQ hade registrerat LinkedIn-konton och klickat "I agree."
Meta Platforms v. Bright Data (N.D. Cal., jan. 2024): Domstolen gav Bright Data summary judgment — utloggad skrapning av offentlig data gjorde inte Bright Data till en "user" bunden av Metas användarvillkor.
X Corp. v. Bright Data (N.D. Cal., maj 2024): Domare Alsup avvisade X:s anspråk och slog fast att delstatsrättsliga krav som försökte kontrollera kopiering av offentligt innehåll var preempted av Copyright Act.

Praktiska råd

Skrapa bara offentligt tillgänglig data — registrera aldrig ett konto och skrapa sedan (det skapar avtalsrisk via clickwrap)
Respektera rate limits — aggressiva volymer stärker krav om trespass to chattels
Återpublicera inte rådata eller bilder i stor skala — CoStar v. Zillow-tvisten (inlämnad juli 2025, potentiella skadestånd över 1 miljard dollar) är en påminnelse om att upphovsrätt till bilder är allvarligt
Thunderbits webbläsarbaserade metod — som körs i din egen autentiserade session — ligger närmare "manuell surfning i maskinhastighet" än en headless datacenterbot, vilket är det mest försvarbara upplägget utanför ett licensierat API

Tips och vanliga fallgropar

Några hårt förvärvade lärdomar från att bygga extraktionsverktyg och se tusentals användare skrapa fastighetssajter:

Värm alltid upp sessionen. Hämta redfin.com/ innan någon djup URL. Kalla djup-URL-träffar är den vanligaste utlösaren för Cloudflare-utmaningar.
Rotera User-Agent på ett realistiskt sätt. Använd inte bara en — rotera mellan 5–10 aktuella Chrome-/Firefox-UAs. Men rotera inte för aggressivt (olika UA för varje begäran ser misstänkt ut).
Deduplicera med objekt-ID. Redfins paginering överlappar ibland. Läs ut /home/{id} från varje listnings-URL och deduplicera innan du berikar datan.
Undvik högtrafiktider om du kan. Sen natt / tidig morgon i amerikansk tid brukar enligt min erfarenhet innebära mindre WAF-granskning.
Om du får en 429, backa exponentiellt. Försök inte direkt igen — då riskerar du att gå från en mjuk rate limit till ett hårt IP-förbud.
För stora projekt (1 000+ sidor), räkna med residential proxies. Datacenter-IP:er (AWS, GCP, Azure, OVH) svartlistas av Cloudflares ASN-ryktesystem. Du träffar Error 1020 nästan direkt.

Välj rätt sätt att skrapa Redfin

Så vilken metod ska du välja? Det beror på vem du är och vad du behöver.

HTML-parsing (BeautifulSoup + Selenium): Bäst för utvecklare som vill ha full kontroll, är bekväma med att underhålla CSS-selektorer och inte har något emot att bygga om när Redfin ändrar sin DOM. Räkna med att behöva se över koden var 6–12:e månad.

Doldt Stingray API: Bäst för utvecklare som behöver ren, strukturerad JSON och kan hantera reverse engineering av odokumenterade endpoints. Mindre underhåll än HTML-parsing, men endpoints kan ändras utan förvarning. Tänk på att /stingray/ uttryckligen är förbjudet i robots.txt.

Thunderbit (no-code): Bäst för icke-utvecklare, snabba projekt och team som behöver löpande Redfin-data utan utvecklarresurser. AI:n anpassar sig till layoutändringar, skrapning av undersidor berikar datan med ett klick, och export till Google Sheets, Airtable eller Notion är inbyggt. Om du är ett fastighetsteam som behöver en levande fastighetsdatabas — inte ett engångsdumpat CSV — är det här den mest smidiga vägen.

Oavsett vilken väg du väljer: förstå Redfins anti-bot-skydd innan du börjar, veta vilka fält du behöver, välj ett exportformat som passar teamets arbetsflöde och håll dig på rätt sida om juridiska riktlinjer.

Redo att prova no-code-vägen? Thunderbits gratisnivå låter dig testa Redfin-skrapning och se resultat på några minuter. För Python-metoderna är kodsnuttarna ovan en fungerande startpunkt — lägg bara till proxies och tålamod.

Testa Thunderbit för löpande Redfin-data

Vanliga frågor

Har Redfin ett publikt API?

Nej. Redfin erbjuder inget officiellt publikt API. Det dolda Stingray API:t (/stingray/api/home/details/*) returnerar strukturerad JSON och används av Redfins egen frontend, men det är inofficiellt, odokumenterat, kan ändras utan förvarning och är uttryckligen förbjudet i Redfins robots.txt. Open source-wrappers som reteps/redfin på PyPI ger Python-åtkomst, men använd dem med full förståelse för riskerna.

Kan jag skrapa Redfin utan Python?

Ja. Thunderbit är ett AI-baserat Chrome-tillägg som använder din webbläsarsession för bättre motståndskraft mot anti-bot-skydd — installera det, gå till Redfin, klicka på "AI Suggest Fields" och exportera till Excel, Google Sheets, Airtable eller Notion. Det finns också andra no-code-verktyg för skrapning och färdiga dataleverantörer om du vill utforska alternativ.

Hur ofta ändrar Redfin sin webbplatslayout?

Historiken i GitHub-ärenden visar att CSS-selektorer brukar gå sönder ungefär var 6–12:e månad. Redfin har släppt två generationer av listkort-DOM — äldre (homecardV2Price, homeAddressV2) och nuvarande (bp-Homecard__Price--value, bp-Homecard__Address). Mogna scrapers testar båda i följd.

AI-baserade verktyg som Thunderbit anpassar sig automatiskt eftersom de identifierar fält utifrån innehåll snarare än CSS-selektorer.

Vilken proxytyp är bäst för att skrapa Redfin?

Amerikanska residential proxies för skrapning i större skala — community-benchmarks placerar lyckandefrekvensen runt 80 %. Datacenter-proxies träffar Cloudflare Error 1020 nästan direkt; IP-områden från AWS, GCP, Azure och OVH är svartlistade. Mobile proxies har högst lyckandefrekvens men kostar 5–10 gånger mer.

För små personliga projekt (<100 sidor) kan rätt headers + curl_cffi-impersonering + 2–5 sekunders fördröjningar fungera utan proxies alls.

Kan jag skrapa sålda objekt eller objekt utanför marknaden från Redfin?

Ja. Data för sålda objekt och Redfins off-market Estimate (medianfel 7,52 %) finns på objektsidorna via samma metoder. Fälten skiljer sig från aktiva listningar: off-market-sidor visar försäljningspris, försäljningsdatum, fastighetshistorik och endpointen för owner-estimate, men saknar aktuellt listpris, dagar på marknaden och information om öppet hus. Stingray API-endpointen för off-market-estimat är api/home/details/owner-estimate snarare än api/home/details/avm.

Testa Thunderbit för Redfin-skrapning Get Started Free

Läs mer