Redfin oppdaterer 70 % av nye MLS-annonser i USA innen fem minutter etter at de er lagt ut. Den typen ferskhet er gull verdt for alle som bygger en pipeline for eiendomsdata — og det er nettopp derfor så mange skrappere går etter Redfin og blir blokkert i løpet av få minutter.
Jeg har brukt mange år på å jobbe med datauttrekksverktøy hos Thunderbit, og jeg kan si dette: skillet mellom "hent data fra Redfin" og "hent data fra Redfin uten å bli blokkert" er stedet der de fleste guider faller sammen. De viser BeautifulSoup-koden, hopper over delen der Cloudflare sluker forespørslene dine, og lar deg sitte igjen med en 403-side og lure på hva som gikk galt. Denne guiden er annerledes. Jeg går gjennom tre reelle tilnærminger — HTML-parsing, Redfins skjulte API og en kodefri vei med Thunderbit — og bruker god plass på anti-bot-forsvarene som faktisk betyr noe. Når du er ferdig, vet du nøyaktig hvilken metode som passer ferdighetsnivået ditt, skalaen du trenger, og hvor mye vedlikehold du tåler.
Prøv Thunderbit for Redfin-henting
Hva er Redfin, og hvorfor er dataene deres viktige?
Redfin er en teknologidrevet eiendomsmegler med fastlønnede meglere som henter annonser direkte fra MLS-feeder. Tjenesten dekker over 100 byområder i USA og Canada på tvers av 42 delstater og har nesten 50 millioner månedlige besøkende. I motsetning til rene aggregatportaler er Redfins data verifisert av meglere, og den egenutviklede Redfin Estimate AVM-en dekker over 95 millioner eiendommer med en medianfeil på bare 1,96 % for boliger som ligger ute.
Kombinasjonen av oppdateringer i MLS-hastighet, kvalitetskontroll fra megler og en presis AVM gjør at eiendomsinvestorer, meglere, proptech-startups og dataanalytikere alle ønsker programmatisk tilgang til Redfin-data. Python er et naturlig valg: økosystemet for scraping (requests, BeautifulSoup, Selenium, Playwright) er modent, fellesskapet er stort, og det passer rett inn med pandas og Jupyter for analyse.
Hvorfor hente Redfin med Python?
Bruksområdene er like varierte som folkene som trenger dataene. Slik bruker ulike målgrupper vanligvis hentede Redfin-data:
| Målgruppe | Hovedmål for scraping | Eksempel på bruk |
|---|---|---|
| Eiendomsmeglere | Leadgenerering, markedsinnsikt | Nye og utløpte annonser i eget område; meglerkatalog for konkurranseanalyse |
| Eiendomsinvestorer | Deal flow, cap-rate-analyse | Sjekk av leieavkastning, identifisering av undervurderte eiendommer, daglige varsler om nye annonser |
| Proptech-startups | Produktdata-pipelines | Treningsdata for AVM, markedsdashbord, oppkjøpsmotorer for iBuyer |
| Dataanalytikere | Markedsanalyse, BI | Prisutvikling på ZIP-kodenivå, tidsserier for dager på markedet, forholdet mellom salgspris og listepris |
| Flippere / wholesalere | Sporing av distressed properties | Oppdagelse av prisfall, tvangssalg, comps utenfor markedet |
Den bredere utviklingen støtter dette: over 72 % av eiendomsfirmaer bruker nå prediktiv analyse for å finne muligheter og styre risiko. PropTech-markedet er anslått å nå $47 milliarder i 2025 med en årlig vekst på 16,4 %. Strukturert eiendomsdata er ikke lenger et “kjekt å ha” — det er et grunnkrav.
Alle Redfin-felt du kan hente ut (full referanse)
Før du skriver én eneste kodelinje, må du vite hva som faktisk er tilgjengelig. Jeg har gått gjennom Redfins søkeresultatsider, boligdetaljsider og meglerprofiler — og sammenlignet med åpne Stingray-wrapper-prosjekter som reteps/redfin og RedfinPlus. Totalt kommer vi til 117 ulike felt på tvers av sidetyper.
Denne tabellen er verdt å bokmerke. Når du kjenner datastrukturen før du koder, sparer du timer med prøving, feiling og jakt på selektorer.
Felt på søkeresultatsiden
Dette er de lette feltene som finnes i annonsekortene — ofte mulig å hente uten full JS-rendering:
| Felt | Datatype | Merknader |
|---|---|---|
| Eiendoms-ID | Tall | Intern Redfin-int, parsés fra /home/{id} i href |
| Listepris | Tall | |
| Full adresse | Tekst | |
| Antall soverom / bad / kvadratfot | Tall | Tre verdier etter hverandre |
| Boligtype | Enkeltvalg | SFH, Condo, Townhouse, Multi |
| Status | Tekst | Active, Pending, Contingent |
| Dager på markedet | Tall | |
| Indikator for prisfall | Tall | Avvik fra opprinnelig listepris |
| Hovedbilde | Bilde-URL | Ett bilde per kort |
| Hot Home-merke | Boolsk | |
| Åpen visning dato/tid | Tekst | |
| Meglerattribusjon | Tekst |
Felt på detaljsiden for eiendommen
Det er på detaljsiden du finner dybden. Mange av disse feltene krever JavaScript-rendering eller Stingray API:
| Felt | Datatype | Merknader |
|---|---|---|
| Redfin Estimate (på markedet) | Tall | Via /stingray/api/home/details/avm |
| Redfin Estimate (utenfor markedet) | Tall | Via /stingray/api/home/details/owner-estimate; medianfeil 7,52 % |
| Byggeår / renovert | Tall | |
| Tomtestørrelse | Tall | |
| Borettslagsavgift / HOA | Tall | Månedsvis, hvis aktuelt |
| Eiendomsskatt (årlig) | Tall | |
| Taksert verdi | Tall | |
| Salgshistorikk-tabell | Tabell | Pris, dato, hendelsestype |
| Beskrivelse av eiendommen | Tekst | Markedsføringsavsnitt |
| Bilde-URL-er (karusell) | Bilde-URL-er | 20+ per annonse |
| Navn, telefon og e-post til megler | Tekst / Telefon / E-post | Telefon er ofte skjult |
| Skolevurderinger (barneskole/ungdomsskole/vgs) | Tall | Pluss distriktsnavn |
| Walk / Transit / Bike Score | Tall | |
| Klimarisikoscorer | Tall | Flom, brann, varme, vind |
| Lignende aktive / solgte / nærliggende boliger | URL-er | Karusell-data |
| Parkering, garasje, oppvarming, kjøling | Tekst | Fasilitetsgrupper |
Felt på meglerprofilen
| Felt | Datatype | Merknader |
|---|---|---|
| Meglernavn, bilde, meglerfirma, bio | Tekst / Bilde | |
| Telefon, kontaktskjema | Telefon / Tekst | Klikk-for-å-vise |
| Antall aktive annonser | Tall | |
| Salg siste 12 måneder / totalt volum | Tall | |
| Gjennomsnittlig forhold mellom listepris og salgspris | Tall | |
| Stjernevurdering / antall omtaler | Tall | |
| Erfaring i år / lisensnummer | Tekst / Tall |
Når du bruker Thunderbits funksjon AI Suggest Fields på en Redfin-side, oppdager den automatisk de fleste av disse kolonnene og setter riktig datatype — du slipper manuell mapping av CSS-selektorer. Mer om det senere.
Slik er Redfins anti-bot-forsvar bygget opp (mer enn bare “bruk proxy”)
Her vil jeg sette ned foten, for de fleste guider hopper glatt over blokkering-problemet og går rett til “kjøp proxies fra sponsoren vår.” Det hjelper ikke. Hvis du ikke forstår hva Redfin gjør for å oppdage skrappere, brenner du bare proxykreditter og blir blokkert likevel. ScrapeOps gir Redfins anti-bot-vanskelighetsgrad 7,5 av 10, og Scraperly klassifiserer den som middels (3/5) — “mindre aggressiv enn Zillows enterprise WAF, med tilpasset rate limiting og JavaScript-utfordringer.”
Redfin kjører et lagdelt oppsett: Cloudflare ytterst (JS-utfordring, Turnstile, TLS/JA3-fingerprinting) pluss en Redfin-spesifikk rate limiter på applikasjonsnivå. Det finnes ingen Crawl-delay i robots.txt, fordi håndhevingen skjer i WAF-laget.
Hvorfor enkel requests + BeautifulSoup feiler på Redfin
Hvis du sender en enkel requests.get() til en Redfin-side med standard headere, skjer typisk dette:
- HTTP 403 — Cloudflares JS-utfordring ble ikke løst, så du får utfordringssiden i stedet for annonsen.
- En mellomliggende utfordringsside — HTML-bodyen inneholder Cloudflares Turnstile-widget, ikke boligdata.
- HTTP 200 med delvis HTML — Du får et skall med en stor innebygd JSON-klump under
root.__reactServerState.InitialContext, men ingen forhåndsrendrede annonsekort, ingen pris-historikk og ingen skolevurderinger.
Redfin bruker sitt eget React SSR-rammeverk (ikke Next.js), og hydreringnøkkelen er Redfin-spesifikk — root.__reactServerState.InitialContext med annonse-data nestet under ReactServerAgent.cache.dataCache. Dette er ikke __NEXT_DATA__ eller window.__INITIAL_STATE__.
Den vanligste årsaken til stille 403-svar? Manglende Sec-Fetch-*-headere. Redfin/Cloudflare validerer eksplisitt Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-Dest og Sec-Fetch-User. Hvis de mangler, blir du flagget umiddelbart.
Tiltaksplanen: forsinkelser, headere, proxies og sesjoner
Her er en full gjennomgang av forsvarene, med konkrete tiltak for hvert av dem:
| Redfin-forsvar | Hva det gjør | Signal for oppdagelse | Tiltaksstrategi |
|---|---|---|---|
| Cloudflare JS-utfordring | Mellomside som utsteder cf_clearance-cookie | 403 + Cloudflare-HTML | curl_cffi med impersonate="chrome120"; varm sesjon via hjemmesiden; amerikansk residential proxy |
| Cloudflare Turnstile | Interaktiv CAPTCHA på høyrisikosessioner | 403 + Turnstile-widget | Headless nettleser med stealth + residential proxy |
| Cloudflare Error 1020 (ASN-ban) | Blokkerer flaggede IP-er/ASN-er i WAF | 403-body med “Error 1020 Access Denied” | Bytt til residential/mobile proxy; bruk aldri datacenter-ASN-er |
| TLS/JA3-fingerprinting | Oppdager TLS-stakker som ikke er nettlesere | Stille 403 selv med perfekte headere | curl_cffi-impersonering eller ekte nettleser |
| HTTP/2-fingerprinting | Sjekker HTTP/2 SETTINGS og HPACK-rekkefølge | Stille blokkering | curl_cffi snakker HTTP/2 som Chrome |
| Header-validering (UA, Sec-Fetch-*) | Nettleser-typisk header-sett | 403 på første forespørsel | Full Chrome-headerpakke inkludert Sec-Fetch-Site/Mode/Dest/User, realistisk Referer |
| Cookie-/sesjonskontinuitet | Sporer cf_clearance, RF_BROWSER_ID | Utfordringer ved kalde deep-URL-kall | Vedvarende session; varm opp via hjemmesiden først |
| Rate limit på app-nivå | Per-IP forespørselsgrense | 429 | 2–5 sekunders forsinkelse med jitter; eksponentiell backoff |
| Dårlig rykte på datacenter-IP | Blokkerer kjente DC-ASN-er | Umiddelbar 1020/403 | Kun amerikanske residential- eller mobile proxies |
| Konkurransesporing | Flere parallelle forespørsler fra samme IP | Plutselig eskalering til Turnstile | Maks 2 samtidige per IP |
Praktiske terskler fra testing i fellesskapet:
- Sikker rytme: 1 forespørsel per 2–3 sekunder per IP
- Vedvarende mer enn 20–30 forespørsler per minutt fra én datacenter-IP utløser vanligvis en utfordring i løpet av minutter
- Myke rate limits slipper ofte etter 5–15 minutter hvis trafikken stopper
- Datacenter-forbud (AWS, GCP, Azure, OVH) kan vare fra timer til dager
Vanlige Python requests (urllib3 + OpenSSL) produserer en JA3-fingerprint som ikke matcher noen nettleser — og blir blokkert stille selv med perfekte headere. Bransjefiks er curl_cffi med impersonate="chrome120", som snakker Chrome-korrekt TLS + HTTP/2.
Tre måter å hente Redfin-data med Python på (og hvilken du bør velge)
Jeg har ikke funnet én eneste konkurrerende guide som sammenligner alle tre tilnærmingene side om side. Her er beslutningsmatrisen:
| Kriterium | HTML-parsing (BS4 + Selenium) | Skjult Stingray API | Thunderbit (kodefri) |
|---|---|---|---|
| Oppsett | Middels (Python-miljø + nettleserdriver) | Høyt (reverse engineering av endepunkter) | Lavt (installer Chrome-utvidelse) |
| Risiko for blokkering | Høy (DOM-forespørsler er mest synlige) | Middels (API-lignende forespørsler ser renere ut) | Lavest (bruker din ekte nettlesersesjon) |
| Kvalitet på datastruktur | Middels (ustrukturert HTML → manuell parsing) | Utmerket (forhåndsstrukturert JSON) | Høy (AI oppdager felter og typer automatisk) |
| Vedlikehold | Høyt — én layoutendring bryter selektorer | Middels — endepunkter kan endres uten varsel | Lavest — AI tilpasser seg layoutendringer |
| Skala | Lav–middels (hundrevis med proxies) | Middels–høy (tusenvis, renere forespørsler) | Middels (50 sider per batch via sky-scraping) |
| Best for | Utviklere som vil ha full kontroll | Utviklere som trenger ren JSON | Ikke-utviklere, raske prosjekter, løpende data uten utviklerressurser |
Vedlikeholdsaspektet er verdt å understreke. Redfin har hatt to generasjoner med annonsekort-DOM — eldre (homecardV2Price) og nåværende (span.bp-Homecard__Price--value). Historikken i GitHub-issues viser at CSS-selektorer ryker omtrent hver 6.–12. måned. Når det skjer, går en BeautifulSoup-scraper i stykker over natten. En AI-basert feltgjenkjenner tilpasser seg.
Før du begynner
- Vanskelighetsgrad: Middels (tilnærming 1 og 2), nybegynner (tilnærming 3)
- Tidsbruk: Ca. 30 minutter for tilnærming 1 eller 2; ca. 5 minutter for tilnærming 3
- Dette trenger du:
- Python 3.8+ med pip (tilnærming 1 og 2)
- Chrome-nettleser (alle tilnærminger)
- Thunderbit Chrome-utvidelse (tilnærming 3)
- US residential proxies for scraping i stor skala (tilnærming 1 og 2)
Hent Redfin-data med AI Get Started Free
Tilnærming 1: Hent Redfin med Python ved hjelp av HTML-parsing (BeautifulSoup + Selenium)
Dette er veien for deg som vil ha full kontroll. Du skriver selektorene, du styrer nettleseren, du håndterer feilene.
Det er den mest lærerike tilnærmingen. Den er også den mest skjøre.
Steg 1: Sett opp Python-miljøet
Opprett et virtuelt miljø og installer nødvendige biblioteker:
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 er helt sentral her — det er det som lar HTTP-forespørslene dine late som de kommer fra en ekte Chrome-TLS-fingerprint, i stedet for standardfingeravtrykket til Python requests som Cloudflare stopper på stedet.
Steg 2: Konfigurer nettleser-headere og sesjon
Dette er der de fleste nybegynnere feiler. Du trenger hele Chrome-headersetet, inkludert Sec-Fetch-*-headerne som Redfin/Cloudflare eksplisitt validerer:
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)
# Varm opp sesjonen — hent cf_clearance- og RF_BROWSER_ID-cookies
session.get("https://www.redfin.com/")
Oppvarming av sesjonen er avgjørende — hvis du går rett på en dyp eiendoms-URL uten cookies og uten Referer, scorer Cloudflare deg lavere.
Begynn alltid med hjemmesiden.
Steg 3: Hent søkeresultater fra Redfin
Når sesjonen er varm, kan du hente en bysøkeside og parse annonsekortene. Nåværende 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): # Sider 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"Blokkert på side {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)
# Tilfeldig pause mellom 2 og 5 sekunder
time.sleep(random.uniform(2, 5))
print(f"Hentet {len(listings)} annonser")
Du bør ende opp med en voksende liste av dictionaries, der hver inneholder pris, adresse, soverom/bad/kvadratfot og lenke til detaljsiden for en San Francisco-annonsen. Hvis du får 0 kort, sjekk HTTP-statuskoden — en 403 betyr at Cloudflare har fanget deg, og at du sannsynligvis trenger residential proxies.
Steg 4: Hent detaljer for hver bolig
Søkeresultatene gir deg grunnleggende info. Detaljsidene gir deg Redfin Estimate, byggeår, HOA, salgshistorikk, meglerinformasjon og bilder. Disse sidene krever JavaScript-rendering, så vi bytter til 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]: # Berik de 10 første
driver.get(listing["url"])
time.sleep(random.uniform(3, 6)) # Vent 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()
Etter dette steget bør de første 10 annonsene dine være beriket med Redfin Estimate og data om byggeår. XPath-selektorene er mer robuste enn CSS for slike nestede fasilitetsfelt, men de er fortsatt skjøre — enhver endring i DOM-en kan ødelegge dem.
Steg 5: Håndter blokkering og feil
Implementer retry-logikk med eksponentiell 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"Blokkert ({resp.status_code}). Prøver igjen om {wait:.1f}s...")
time.sleep(wait)
else:
print(f"Uventet status: {resp.status_code}")
break
return None
Tegn på at du er blokkert: HTTP 403 med Cloudflare-HTML i bodyen, HTTP 429 (eksplisitt rate limit), tom responsbody, eller “Error 1020 Access Denied” i sidens innhold. Hvis dette skjer jevnlig, er det på tide å legge til residential proxies eller bytte til API-tilnærmingen.
Tilnærming 2: Hent Redfin med Python ved hjelp av det skjulte Stingray API-et
Dette er min favorittmetode. Frontenden til Redfin snakker med et internt JSON-API på /stingray/api/home/details/*, og svarene kommer tilbake som ren, typet JSON — ingen HTML-parsing nødvendig.
Slik finner du Redfins skjulte API-endepunkter
Åpne Chrome DevTools → Network-fanen → filtrer på Fetch/XHR → gå til en vilkårlig Redfin-boligsiden. Du vil se forespørsler til endepunkter som:
api/home/details/initialInfo— løser URL → propertyId, listingIdapi/home/details/aboveTheFold— pris, soverom, bad, kvadratfot, bilder, status, megler, MLS#api/home/details/belowTheFold— fasiliteter, HOA, skatt, parkering, byggeår, tomt, historikkapi/home/details/avm— Redfin Estimate for boliger som ligger uteapi/home/details/owner-estimate— Redfin Estimate for boliger utenfor markedetapi/home/details/descriptiveParagraph— markedsføringsbeskrivelse
For leiesider hentes rentalId (en 36-tegns UUID) fra URL-en i <meta property="og:image">.
Hente boligdata via Stingray API-et
Det finnes en viktig særhet: Stingray JSON-svar starter med den bokstavelige strengen {}&& som et anti-CSRF-tiltak. Du må fjerne dette før du parser:
import json
from curl_cffi import requests as curl_requests
session = curl_requests.Session(impersonate="chrome120")
session.headers.update(HEADERS)
# Varm opp sesjonen
session.get("https://www.redfin.com/")
# Hent en boligsiden for cookies og property ID
property_url = "https://www.redfin.com/CA/San-Francisco/123-Main-St-94102/home/12345678"
page_resp = session.get(property_url)
# Hent Stingray API-et
api_url = "https://www.redfin.com/stingray/api/home/details/aboveTheFold?propertyId=12345678"
api_resp = session.get(api_url, headers={"Referer": property_url})
# Fjern anti-CSRF-prefikset
payload = json.loads(api_resp.text.replace("{}&&", "", 1))
# Hent strukturert data
listing_data = payload.get("payload", {})
print(json.dumps(listing_data, indent=2))
Svaret inneholder typede felt: pris som heltall, soverom/bad som tall, bilde-URL-er som arrays, meglerinfo som nestede objekter. Ingen BeautifulSoup-parsing, ingen CSS-selektorer, ingen gjetting.
Fordeler og begrensninger ved den skjulte API-tilnærmingen
Fordeler:
- Forhåndsstrukturert JSON — mye renere enn HTML-parsing
- Raskere per forespørsel (mindre payload, ingen rendering)
- Lavere blokkeringsrisiko (API-lignende forespørsler ser mer naturlige ut)
Begrensninger:
- Endepunkter kan endres uten varsel — det finnes ingen offisiell dokumentasjon
robots.txtforbyr eksplisitt/stingray/for wildcard-brukeren- Krever reverse engineering for å oppdage nye endepunkter
- Trenger fortsatt oppvarming av sesjon og riktige headere for å unngå Cloudflare
Det kodefrie alternativet: Hent Redfin med Thunderbit
Hvis du trenger Redfin-data og ikke vil vedlikeholde Python-skript — eller bare vil ha resultater på fem minutter — start her. Vi bygde Thunderbit nettopp for dette: strukturert datauttrekk fra hvilken som helst nettside, uten kode.
Steg 1: Installer Thunderbit og gå til Redfin
Installer Thunderbit Chrome-utvidelsen fra Chrome Web Store. Åpne Redfin og gå til en søkeresultatside — for eksempel boliger til salgs i San Francisco.
Steg 2: Klikk “AI Suggest Fields”
Klikk Thunderbit-ikonet i verktøylinjen i nettleseren, og velg deretter “AI Suggest Fields.” AI-en leser Redfin-siden og foreslår automatisk kolonner som “Address,” “Price,” “Beds,” “Baths,” “SqFt,” “Property Type,” og “Listing Photo” — med riktige datatyper satt automatisk.
Du kan fjerne kolonner du ikke trenger, eller legge til egne ved å klikke “+ Add Column” og beskrive det du vil ha med vanlige ord (for eksempel “listing agent name” eller “days on market”).
Du skal nå se en tabellforhåndsvisning med kolonnene dine, klar til fylling.
Steg 3: Klikk “Scrape” og se dataene komme inn
Klikk “Scrape”-knappen. Thunderbit behandler de synlige annonsene og fyller inn tabellen din. For sider med paginering håndterer den dette automatisk — ingen løkkelogikk nødvendig.
I mine tester fylles en tabell med 50 rader på omtrent 45 sekunder. Strukturert data, klar til eksport.
Slik håndterer Thunderbit Redfins anti-bot-forsvar
Fordi Thunderbit kjører i din egen nettleser, arver den dine eksisterende Redfin-cookies, sesjon og nettleserfingeravtrykk. For Cloudflare ser det ut som en normal bruker som surfer på Redfin — for teknisk sett er det akkurat det det er. Ingen headless browser, ingen datacenter-IP, ingen feilmatchende TLS-fingeravtrykk. For offentlig tilgjengelige sider kan Thunderbits cloud scraping-modus behandle 50 sider av gangen.
Det er en fundamentalt annen tilnærming enn å sende requests fra et Python-skript på en server.
Nettlesersesjonen din er allerede betrodd.
Hent undersider på Redfin med Thunderbit
Etter at du har hentet søkeresultatene, klikker du “Scrape Subpages” for å la AI-en besøke hver detaljside og berike tabellen med flere felt — Redfin Estimate, byggeår, HOA-avgift, meglerinfo, boligbilder og salgshistorikk.
Det er det samme som en 40-linjers Selenium-løkke fra tilnærming 1 — bare at det tar ett klikk og krever null vedlikehold.
Når Redfin endrer DOM-en fra homecardV2Price til span.bp-Homecard__Price--value, tilpasser AI-en seg. Python-selektorene dine gjør ikke det.
Hent Redfin-undersider med AI Get Started Free
Mer enn CSV: Eksporter Redfin-data til Google Sheets, Airtable og Notion
De fleste guider stopper ved df.to_csv(). Det holder for en engangsanalyse. Men hvis du jobber i et eiendomsteam, trenger du delte, levende data — ikke statiske filer som samler støv på noens skrivebord.
Eksport 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)
# Vis eiendomsbilder direkte med 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}")')
Merk: Sheets har en hard grense på 10 millioner celler per regneark, og API-et tillater 300 lese- og 300 skriveforespørsler per minutt per prosjekt. Bruk ws.batch_update() i stedet for å oppdatere celle for celle når du har mer enn noen dusin rader.
Airtable via pyairtable:
Viktig endring i 2024: Airtable faset ut gamle API-nøkler 1. februar 2024. Du må bruke Personal Access Tokens (PAT) nå — alle guider som fortsatt viser api_key=... er utdatert.
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 henter og lagrer på nytt
}
for row in listings
]
created = table.batch_create(records, typecast=True)
Airtables rate limit er 5 forespørsler per sekund per base, med 30 sekunders sperre ved overtredelse. Vedlegg-feltet aksepterer [{"url": ...}]-payloads — Airtables servere henter URL-en, lagrer den på nytt i sitt CDN og lager miniatyrbilder automatisk.
Eksport med Thunderbit (1 klikk til Sheets, Airtable og Notion)
Thunderbit har innebygd eksport med ett klikk til Google Sheets, Airtable og Notion — og her er delen jeg faktisk er stolt av: eiendomsbildene lastes opp og vises som innebygde bilder i Notion og Airtable. Ingen =IMAGE()-triks, ingen ødelagte CDN-lenker. Du klikker “Export to Airtable”, og teamet ditt får en visuell eiendomsdatabase med miniatyrbilder de kan bla gjennom på mobilen.
For eiendomsteam som jobber visuelt med utvalg av annonser, er dette forskjellen mellom et nyttig verktøy og en bunke CSV-rader.
Er det lov å hente data fra Redfin? Hva ToS, robots.txt og rettspraksis sier
Jeg er ikke advokat, og dette er ikke juridisk rådgivning. Men etter mange år i datauttrekksfeltet kan jeg si dette: “er det lov?” er spørsmålet alle stiller, og de fleste guider unngår.
Redfins robots.txt
Redfins robots.txt er detaljert. Viktige punkter:
- Fullt blokkerte boter:
peer39_crawler/1.0,AmazonAdBot,FireCrawlAgent— Redfin navngir spesifikt den populære scraping-tjenesten fra LLM-æraen - For wildcard
User-agent: *er disse blokkert:/stingray/(hele det interne API-navnerommet),/myredfin/,/api/v1/rentals/,/api/v1/properties/,/owner-estimate/ - Ingen
Crawl-delay:-regel for noen brukeragent - Over 50 sitemaps deklarert — sitemaps er den reneste og minst WAF-tunge måten å enumerere URL-er på
Redfins bruksvilkår
Del 2.3.5 sier: "You may not automatedly crawl or query the Services for any purpose or by any means... unless you have received prior express written permission."
Dette er en browsewrap-avtale — aksept ved fortsatt bruk, ikke en klikkavtale. Amerikanske domstoler har historisk vært skeptiske til å håndheve browsewrap mot brukere som ikke hadde faktisk kjennskap (se Nguyen v. Barnes & Noble, 9th Cir. 2014).
Relevant rettspraksis (kort)
- Van Buren v. United States (Høyesterett, 2021): CFAAs "exceeds authorized access"-bestemmelse bruker en test om “porten er opp eller ned”. Å bruke en åpen dør til et formål man ikke likte, er ikke føderal hacking.
- hiQ Labs v. LinkedIn (9th Cir., 2022): Å hente offentlig tilgjengelige data er ikke et CFAA-brudd. Men hiQ betalte til slutt $500,000 i forlik på kontraktsbrudd, fordi de hadde opprettet LinkedIn-kontoer og klikket “I agree.”
- Meta Platforms v. Bright Data (N.D. Cal., jan. 2024): Retten ga summary judgment til Bright Data — utlogging av scraping av offentlige data gjorde ikke Bright Data til en “user” bundet av Metas ToS.
- X Corp. v. Bright Data (N.D. Cal., mai 2024): Dommer Alsup avviste Xs krav og slo fast at delstatskrav som forsøker å kontrollere kopiering av offentlig innhold, var fortrengt av Copyright Act.
Praktisk veiledning
- Hent bare offentlig tilgjengelige data — registrer aldri en konto og scrape deretter (det skaper eksponering mot klikkavtale)
- Respekter rate limits — aggressive volum kan støtte krav om trespass to chattels
- Ikke republiser rådata eller bilder i stor skala — CoStar v. Zillow-søksmålet (anlagt i juli 2025, med mulige erstatninger på over 1 milliard dollar) er en påminnelse om at opphavsrett til bilder er alvorlig
- Thunderbits nettleserbaserte tilnærming — som kjører i din egen autentiserte sesjon — ligger nærmere “manuell surfing i maskinhastighet” enn en headless datacenter-bot, og er dermed en av de mest forsvarlige tilnærmingene du har, kort av et lisensiert API
Tips og vanlige fallgruver
Noen harde erfaringer fra å bygge utvinningsverktøy og se tusenvis av brukere scrape eiendomssider:
- Varm alltid opp sesjonen. Gå til
redfin.com/før du besøker en dyp URL. Kalde kall til dype URL-er er den vanligste årsaken til Cloudflare-utfordringer. - Roter User-Agent på en realistisk måte. Ikke bruk bare én — roter mellom 5–10 aktuelle Chrome-/Firefox-UA-er. Men ikke roter for aggressivt (ulik UA for hver forespørsel ser mistenkelig ut).
- Dedupliser etter eiendoms-ID. Redfins paginering overlapper noen ganger. Pars
/home/{id}fra hver annonse-URL og dedupliser før du beriker dataene. - Unngå scraping i rushtiden hvis du kan. Sent på kvelden / tidlig morgen amerikansk tid ser det i min erfaring ut til å være mindre WAF-sjekk.
- Hvis du får 429, trekk deg tilbake eksponentielt. Ikke prøv igjen med én gang — det er slik du eskalerer fra myk rate limit til hard IP-ban.
- For prosjekter i stor skala (1 000+ sider), sett av budsjett til residential proxies. Datacenter-IP-er (AWS, GCP, Azure, OVH) blir svartelistet av Cloudflares ASN-ryktessystem. Du vil treffe Error 1020 nesten umiddelbart.
Velg riktig måte å hente Redfin-data på
Så hvilken tilnærming bør du velge? Det kommer an på hvem du er og hva du trenger.
HTML-parsing (BeautifulSoup + Selenium): Best for utviklere som vil ha full kontroll, er komfortable med å vedlikeholde CSS-selektorer, og ikke har noe imot å bygge om når Redfin endrer DOM-en. Forvent å måtte se over koden hver 6.–12. måned.
Skjult Stingray API: Best for utviklere som trenger ren, strukturert JSON og tåler reverse engineering av udokumenterte endepunkter. Mindre vedlikehold enn HTML-parsing, men endepunktene kan endres uten varsel. Husk at /stingray/ er eksplisitt forbudt i robots.txt.
Thunderbit (kodefri): Best for ikke-utviklere, raske prosjekter og team som trenger løpende Redfin-data uten utviklerressurser. AI-en tilpasser seg layoutendringer, underside-scraping beriker data med ett klikk, og eksport til Google Sheets, Airtable eller Notion er innebygd. Hvis du er et eiendomsteam som trenger en levende eiendomsdatabase — ikke et engangsdump i CSV — er dette den minst smertefulle veien.
Uansett hvilken vei du velger: forstå Redfins anti-bot-forsvar før du begynner, vit hvilke felter du trenger, velg et eksportformat som passer arbeidsflyten til teamet ditt, og hold deg på riktig side av juridiske retningslinjer.
Klar for å prøve den kodefrie veien? Thunderbits gratisnivå lar deg teste Redfin-scraping og se resultater på minutter. For Python-tilnærmingene er kodestykkene over et fungerende utgangspunkt — du trenger bare å legge til proxies og tålmodighet.
Prøv Thunderbit for løpende Redfin-data
Vanlige spørsmål
Har Redfin et offentlig API?
Nei. Redfin tilbyr ikke et offisielt offentlig API. Det skjulte Stingray API-et (/stingray/api/home/details/*) returnerer strukturert JSON og brukes av Redfins egen frontend, men det er uoffisielt, udokumentert, kan endres uten varsel og er eksplisitt forbudt i Redfins robots.txt. Åpne wrappers som reteps/redfin på PyPI gir Python-tilgang, men bruk dem med forståelse for risikoen.
Kan jeg hente data fra Redfin uten Python?
Ja. Thunderbit er en AI-basert Chrome-utvidelse som arver nettlesersesjonen din for å stå sterkere mot anti-bot-systemer — installer den, gå til Redfin, klikk “AI Suggest Fields”, og eksporter til Excel, Google Sheets, Airtable eller Notion. Det finnes også andre kodefrie scraping-verktøy og ferdige dataleverandører i markedet hvis du vil utforske alternativer.
Hvor ofte endrer Redfin nettsidelayouten sin?
Historikken i GitHub-issues fra fellesskapet viser at CSS-selektorer ryker omtrent hver 6.–12. måned. Redfin har hatt to generasjoner med annonsekort-DOM — eldre (homecardV2Price, homeAddressV2) og nåværende (bp-Homecard__Price--value, bp-Homecard__Address). Modne skrappere prøver begge i rekkefølge.
AI-baserte verktøy som Thunderbit tilpasser seg automatisk fordi de gjenkjenner felter ut fra innhold, ikke CSS-selektorer.
Hva er den beste proxy-typen for å scrape Redfin?
US residential proxies for scraping i stor skala — community-benchmarks legger suksessraten rundt 80 %. Datacenter-proxies treffer Cloudflare Error 1020 nesten umiddelbart; AWS-, GCP-, Azure- og OVH-IP-er er svartelistet. Mobile proxies har høyest suksessrate, men koster 5–10 ganger mer.
For små, personlige prosjekter (<100 sider) kan riktige headere + curl_cffi-impersonering + 2–5 sekunders forsinkelser fungere helt uten proxies.
Kan jeg hente solgte eller off-market eiendomsdata fra Redfin?
Ja. Data for solgte boliger og off-market Redfin Estimate (medianfeil 7,52 %) er tilgjengelig på detaljsider med de samme metodene. Feltene er litt annerledes enn for aktive annonser: off-market-sider viser salgspris, salgsdato, historikk og endpointet for owner-estimate, men mangler dagens listepris, dager på markedet og info om åpen visning. Stingray-endepunktet for off-market-estimater er api/home/details/owner-estimate i stedet for api/home/details/avm.
Prøv Thunderbit for Redfin-henting Get Started Free
Les mer
