Redfin מעדכנת 70% מרשימות ה-MLS החדשות בארה"ב בתוך חמש דקות מהרגע שהן עולות לרשת. טריות כזו היא דלק לכל מי שבונה צינור נתונים לנדל"ן — ולכן כל כך הרבה סקרייפרים מכוונים ל-Redfin ונחסמים תוך דקות.
שנים אני עובד על כלי חילוץ נתונים ב-Thunderbit, ואני יכול לומר לכם: הפער בין "לגרד את Redfin" לבין "לגרד את Redfin בלי להיחסם" הוא בדיוק המקום שבו רוב המדריכים נופלים. הם מראים קוד BeautifulSoup, מדלגים על השלב שבו Cloudflare בולעת את הבקשות שלכם, ומשאירים אתכם מול דף 403 ותהייה מה השתבש. המדריך הזה שונה. אעבור אתכם דרך שלוש גישות אמיתיות — ניתוח HTML, ה-API הנסתר של Redfin, ונתיב ללא קוד עם Thunderbit — ואקדיש זמן רציני להגנות האנטי-בוט שבאמת חשוב להכיר. בסוף תדעו בדיוק איזו שיטה מתאימה לרמת היכולת שלכם, להיקף העבודה, ולסף הסבל שלכם לתחזוקה.
נסו את Thunderbit לגרידת Redfin
מה זה Redfin, ולמה הנתונים שלה כל כך חשובים?
Redfin היא חברת תיווך נדל"ן מבוססת טכנולוגיה, עם סוכנים שכירים שמושכים רישומים ישירות מפידי MLS. היא מכסה יותר מ-100 מטרופולינים בארה"ב ובקנדה ב-42 מדינות ומשרתת כמעט 50 מיליון מבקרים בחודש. בניגוד לפורטלים שמאגדים נתונים בלבד, הנתונים של Redfin מאומתים על ידי סוכנים, ו-Redfin Estimate AVM הקנייני שלה מכסה מעל 95 מיליון נכסים עם שגיאה חציונית של רק 1.96% עבור בתים שמפורסמים בשוק.
השילוב הזה — עדכניות ברמת MLS, איכות מאומתת-תיווך, ו-AVM מדויק — הוא הסיבה שמשקיעי נדל"ן, סוכנים, סטארטאפים בתחום proptech ואנליסטים כולם רוצים גישה תכנותית לנתוני Redfin. Python היא הבחירה הטבעית למשימה: סביבת הסקרייפינג שלה (requests, BeautifulSoup, Selenium, Playwright) בשלה, התמיכה הקהילתית עצומה, והיא מתחברת ישירות ל-pandas ול-Jupyter לצורכי ניתוח.
למה לגרד את Redfin עם Python?
המקרי שימוש מגוונים בדיוק כמו האנשים שזקוקים לנתונים. כך בדרך כלל משתמשים שונים בנתוני Redfin שנגרדו:
| קהל יעד | מטרה עיקרית של הגרידה | מקרה שימוש לדוגמה |
|---|---|---|
| סוכני נדל"ן | יצירת לידים, מודיעין שוק | רישומים חדשים ורישומים שפג תוקפם באזור השירות; ספריית סוכנים להשוואה תחרותית |
| משקיעי נדל"ן | איתור עסקאות, ניתוח cap rate | סינון תשואת שכירות, זיהוי נכסים מתומחרים בחסר, התראות יומיות על רישומים חדשים |
| סטארטאפים בתחום PropTech | צינורות נתונים למוצר | נתוני אימון ל-AVM, דשבורדים לשוק, מנועי רכישה ל-iBuyer |
| אנליסטים של נתונים | מחקר שוק, BI | מגמות מחיר חציוני לפי ZIP, סדרות זמן של ימי שוק, יחס מחיר-מכירה |
| סיטונאים / משקמי נכסים | מעקב אחר נכסים במצוקה | זיהוי הורדות מחיר, עיקולים, השוואות לנכסים שלא נרשמו בשוק |
המגמה הרחבה יותר מחזקת את זה: יותר מ-72% מחברות הנדל"ן כבר משתמשות באנליטיקה חזויה כדי לזהות הזדמנויות ולנהל סיכונים. שוק ה-PropTech צפוי להגיע ל-47 מיליארד דולר ב-2025 בקצב צמיחה שנתי של 16.4%. נתוני נדל"ן מובנים כבר מזמן אינם "nice to have" — הם תנאי בסיס.
כל שדה נתונים ב-Redfin שאפשר לגרד (מדריך מלא)
לפני שמתחילים לכתוב שורת קוד אחת, צריך להבין מה באמת זמין. בדקתי את דפי תוצאות החיפוש של Redfin, דפי פרטי נכס, ופרופילי סוכנים — והשוויתי מול עוטפים בקוד פתוח ל-Stingray API כמו הפרויקטים reteps/redfin ו-RedfinPlus. בסך הכול יש 117 שדות ייחודיים על פני סוגי הדפים השונים.
כדאי לשמור את הטבלה הזו במועדפים. ידיעה של הסכימה לפני הכתיבה חוסכת שעות של ניסוי וטעייה בחיפוש סלקטורים.
שדות בדף תוצאות החיפוש
אלה שדות קלים יחסית, שמופיעים בכרטיסי הרישום — ולעיתים אפשר לחלץ אותם בלי רינדור מלא של JS:
| שדה | סוג נתונים | הערות |
|---|---|---|
| מזהה נכס | מספר | int פנימי של Redfin, נשלף מ-/home/{id} ב-href |
| מחיר מבוקש | מספר | |
| כתובת מלאה | טקסט | |
| חדרים / אמבטיות / שטח | מספר | שלושה ערכים ברצף |
| סוג נכס | בחירה יחידה | SFH, Condo, Townhouse, Multi |
| סטטוס | טקסט | Active, Pending, Contingent |
| ימים בשוק | מספר | |
| אינדיקטור להורדת מחיר | מספר | הפרש מהמחיר ההתחלתי |
| תמונה ראשית | כתובת URL של תמונה | תמונה אחת לכל כרטיס |
| תג Hot Home | בוליאני | |
| תאריך/שעת בית פתוח | טקסט | |
| ייחוס תיווך | טקסט |
שדות בדף פרטי נכס
בדף הפרטים נמצא העומק האמיתי. רבים מהשדות האלה דורשים רינדור JavaScript או את Stingray API:
| שדה | סוג נתונים | הערות |
|---|---|---|
| Redfin Estimate (בשוק) | מספר | דרך /stingray/api/home/details/avm |
| Redfin Estimate (מחוץ לשוק) | מספר | דרך /stingray/api/home/details/owner-estimate; שגיאה חציונית 7.52% |
| שנת בנייה / שיפוץ | מספר | |
| גודל המגרש | מספר | |
| דמי HOA | מספר | חודשיים, אם רלוונטי |
| מס נכס (שנתי) | מספר | |
| שווי מוערך לצורכי מס | מספר | |
| טבלת היסטוריית מכירה | טבלה | מחיר, תאריך, סוג אירוע |
| תיאור הנכס | טקסט | פסקת שיווק |
| כתובות URL של תמונות (קרוסלה) | כתובות URL של תמונות | 20+ לכל רישום |
| שם הסוכן, טלפון, אימייל | טקסט / טלפון / אימייל | הטלפון לעיתים מוסתר |
| דירוגי בתי ספר (יסודי/חטיבה/תיכון) | מספר | כולל שם המחוז |
| ציון הליכה / תחבורה / אופניים | מספר | |
| ציוני סיכון אקלימי | מספר | הצפה, שריפה, חום, רוח |
| נכסים דומים פעילים / שנמכרו / בקרבת מקום | כתובות URL | נתוני קרוסלה |
| חניה, מוסך, חימום, קירור | טקסט | קבוצות מתקנים |
שדות בפרופיל סוכן
| שדה | סוג נתונים | הערות |
|---|---|---|
| שם הסוכן, תמונה, תיווך, ביוגרפיה | טקסט / תמונה | |
| טלפון, טופס יצירת קשר | טלפון / טקסט | נחשף בלחיצה |
| מספר נכסים פעילים | מספר | |
| מכירות ב-12 החודשים האחרונים / נפח כולל | מספר | |
| יחס ממוצע מחיר רשום למחיר מכירה | מספר | |
| דירוג כוכבים / מספר ביקורות | מספר | |
| שנות ניסיון / מספר רישיון | טקסט / מספר |
כשמשתמשים ב-AI Suggest Fields של Thunderbit על דף Redfin, המערכת מזהה אוטומטית את רוב העמודות האלה ומקצה להן סוגי נתונים נכונים — בלי למפות CSS selectors ידנית. עוד מעט נרחיב על זה.
פירוק מנגנוני ההגנה של Redfin נגד בוטים (לא רק "תשתמשו בפרוקסי")
כאן אני רוצה לשים דגל, כי רוב המדריכים מדלגים על בעיית החסימה וקופצים ישר ל"תקנו פרוקסי מהספונסר שלנו". זה לא מועיל. אם לא מבינים מה Redfin עושה כדי לזהות סקרייפרים, תשרפו קרדיטים על פרוקסי ועדיין תיחסמו. ScrapeOps מדרגת את קושי ההגנה של Redfin ב-7.5 מתוך 10, ו-Scraperly מגדירה אותו כבינוני (3/5) — "פחות אגרסיבי מה-WAF הארגוני של Zillow, ומתבסס על הגבלת קצב מותאמת אישית ואתגרי JavaScript."
Redfin מפעילה שכבות הגנה: Cloudflare בקצה (אתגר JS, Turnstile, Fingerprinting של TLS/JA3) יחד עם מגביל קצב ברמת היישום של Redfin. אין הנחיית Crawl-delay ב-robots.txt שלהם, כי האכיפה מתבצעת ברמת ה-WAF.
למה requests + BeautifulSoup פשוט נכשלים ב-Redfin
אם שולחים requests.get() בסיסי לדף נכס של Redfin עם כותרות ברירת מחדל, בדרך כלל קורה אחד מהדברים הבאים:
- HTTP 403 — אתגר ה-JS של Cloudflare לא נפתר, ולכן מקבלים את דף האתגר במקום את הרישום.
- דף אתגר ביניים — גוף ה-HTML מכיל את ווידג'ט Turnstile של Cloudflare, לא את נתוני הנכס.
- HTTP 200 עם HTML חלקי — מתקבל שלד עם blob JSON גדול תחת
root.__reactServerState.InitialContext, אבל בלי כרטיסי חיפוש מוכנים מראש, בלי היסטוריית מחירים ובלי דירוגי בתי ספר.
Redfin משתמשת במסגרת React SSR משלה (לא Next.js), ומפתח ה-hydration הוא ייחודי ל-Redfin — root.__reactServerState.InitialContext עם נתוני הרישום מקוננים תחת ReactServerAgent.cache.dataCache. זה לא __NEXT_DATA__ ולא window.__INITIAL_STATE__.
הסיבה הנפוצה ביותר ל-403 שקט? חסרים headers מסוג Sec-Fetch-*. Redfin/Cloudflare מאמתים במפורש את Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-Dest ו-Sec-Fetch-User. אם הם לא קיימים, תסומנו מיד.
ספר החוקים למיטיגציה: השהיות, כותרות, פרוקסי וסשנים
הנה פירוק מלא של כל שכבת הגנה, יחד עם דרכי התמודדות ספציפיות:
| הגנת Redfin | מה היא עושה | סימן לזיהוי | אסטרטגיית מיטיגציה |
|---|---|---|---|
| אתגר JS של Cloudflare | דף ביניים שמנפיק עוגיית cf_clearance | 403 + גוף HTML של Cloudflare | curl_cffi עם impersonate="chrome120"; חימום סשן דרך דף הבית; פרוקסי מגורים אמריקאי |
| Cloudflare Turnstile | CAPTCHA אינטראקטיבי בסשנים בסיכון גבוה | 403 + ווידג'ט Turnstile | דפדפן headless עם stealth + פרוקסי מגורים |
| Cloudflare Error 1020 (חסימת ASN) | חוסם כתובות IP / ASNs שסומנו ב-WAF | גוף 403 עם "Error 1020 Access Denied" | מעבר לפרוקסי מגורים / מובייל; לא להשתמש אף פעם ב-ASNs של דאטה-סנטר |
| TLS/JA3 fingerprinting | מזהה מחסניות TLS שאינן דפדפן | 403 שקט גם עם כותרות מושלמות | התחזות עם curl_cffi או דפדפן אמיתי |
| Fingerprinting של HTTP/2 | בודק SETTINGS של HTTP/2 וסדר HPACK | חסימה שקטה | curl_cffi מדבר HTTP/2 כמו Chrome |
| אימות כותרות (UA, Sec-Fetch-*) | סט כותרות תואם-דפדפן | 403 בבקשה הראשונה | סט מלא של כותרות Chrome כולל Sec-Fetch-Site/Mode/Dest/User, ו-Referer ריאלי |
| רציפות עוגיות / סשן | עוקב אחרי cf_clearance, RF_BROWSER_ID | אתגרים בכניסות קרות ל-URL עמוק | Persistent Session; חימום דרך דף הבית קודם |
| מגבלת קצב ברמת האפליקציה | מגביל בקשות לפי IP | 429 | השהיה של 2–5 שניות עם jitter; backoff אקספוננציאלי |
| מוניטין IP של דאטה-סנטר | חוסם ASNs מוכרים של DC | 1020/403 מיידי | רק פרוקסי מגורים או מובייל בארה"ב |
| זיהוי מקביליות | כמה בקשות מקבילות מאותו IP | הסלמה פתאומית ל-Turnstile | עד 2 בקשות מקבילות לכל IP |
ספי עבודה פרקטיים מניסויי קהילה:
- קצב בטוח: בקשה אחת כל 2–3 שניות לכל IP
- מעל 20–30 בקשות בדקה מ-IP אחד של דאטה-סנטר מפעיל אתגר בתוך דקות
- מגבלות רכות משתחררות אחרי 5–15 דקות אם מפסיקים את התעבורה
- חסימות IP של דאטה-סנטר (AWS, GCP, Azure, OVH) עשויות להימשך שעות עד ימים
requests הסטנדרטי של Python (urllib3 + OpenSSL) מייצר טביעת JA3 שלא תואמת לאף דפדפן — ולכן נחסם בשקט גם כשכל הכותרות נראות מושלמות. הפתרון המקובל בתעשייה הוא curl_cffi עם impersonate="chrome120", שמדבר TLS + HTTP/2 מדויקים ל-Chrome.
שלוש דרכים לגרד את Redfin עם Python (ואיזו לבחור)
לא מצאתי מדריך מתחרה אחד שמשווה את שלוש הגישות זו לצד זו. הנה מטריצת ההחלטה:
| קריטריון | ניתוח HTML (BS4 + Selenium) | ה-API הנסתר Stingray | Thunderbit (ללא קוד) |
|---|---|---|---|
| קושי בהקמה | בינוני (סביבת Python + דרייבר דפדפן) | גבוה (הנדסה לאחור של נקודות קצה) | נמוך (התקנת תוסף Chrome) |
| סיכון לחסימה | גבוה (בקשות DOM הן הכי נראות) | בינוני (בקשות בסגנון API נראות נקיות יותר) | הנמוך ביותר (משתמש בסשן הדפדפן האמיתי שלך) |
| איכות מבנה הנתונים | בינונית (HTML לא מובנה → פריסה ידנית) | מצוינת (JSON מובנה מראש) | גבוהה (AI מזהה שדות וסוגים אוטומטית) |
| עומס תחזוקה | גבוה — כל שינוי בפריסה שובר את הסלקטורים | בינוני — נקודות קצה עשויות להשתנות בלי הודעה | הנמוך ביותר — ה-AI מסתגל לשינויים בפריסה |
| קנה מידה | נמוך–בינוני (מאות עם פרוקסי) | בינוני–גבוה (אלפים, בקשות נקיות יותר) | בינוני (50 דפים/אצווה דרך גרירת ענן) |
| הכי מתאים ל | מפתחים שרוצים שליטה מלאה | מפתחים שצריכים JSON נקי | לא-מפתחים, פרויקטים מהירים, נתונים שוטפים בלי משאבי פיתוח |
הזווית של תחזוקה חשובה במיוחד. Redfin שחררה שתי דורות DOM לכרטיסים — הישן (homecardV2Price) והנוכחי (span.bp-Homecard__Price--value). היסטוריית הבעיות ב-GitHub בקהילה מראה שבירת CSS selectors בערך כל 6–12 חודשים. כשזה קורה, סקרייפר מבוסס BeautifulSoup נשבר בן לילה. זיהוי שדות מבוסס AI מסתגל.
לפני שמתחילים
- רמת קושי: בינונית (גישות 1 ו-2), מתחילים (גישה 3)
- זמן נדרש: כ-30 דקות לגישה 1 או 2; כ-5 דקות לגישה 3
- מה צריך:
- Python 3.8+ עם pip (גישות 1 ו-2)
- דפדפן Chrome (כל הגישות)
- תוסף Thunderbit ל-Chrome (גישה 3)
- פרוקסי מגורים אמריקאיים לגרידה בהיקף גדול (גישות 1 ו-2)
גרדו נתוני Redfin בעזרת AI Get Started Free
גישה 1: לגרד את Redfin עם Python באמצעות ניתוח HTML (BeautifulSoup + Selenium)
זו דרך ה"שליטה המלאה". אתם כותבים את הסלקטורים, אתם מנהלים את הדפדפן, אתם מטפלים בשגיאות.
זו הגישה הכי מלמדת. וגם הכי שבירה.
שלב 1: הקמת סביבת Python
צרו סביבה וירטואלית והתקינו את הספריות הנדרשות:
python -m venv redfin-scraper
source redfin-scraper/bin/activate # ב-Windows: redfin-scraper\Scripts\activate
pip install requests beautifulsoup4 selenium webdriver-manager pandas curl_cffi
curl_cffi הוא מרכיב קריטי כאן — הוא מאפשר לבקשות HTTP שלכם להתחזות לטביעת TLS אמיתית של Chrome במקום לטביעת ברירת המחדל של requests, ש-Cloudflare חוסמת מיד.
שלב 2: קונפיגורציה של כותרות הדפדפן והסשן
כאן רוב המתחילים נופלים. צריך את סט הכותרות המלא של Chrome, כולל כותרות Sec-Fetch-* ש-Redfin/Cloudflare מאמתות במפורש:
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)
# חמום הסשן — איסוף cookies של cf_clearance ו-RF_BROWSER_ID
session.get("https://www.redfin.com/")
שלב חימום הסשן קריטי — כניסה קרה ל-URL עמוק של נכס (בלי cookies קודמות ובלי Referer) מקבלת ניקוד שלילי מצד Cloudflare.
תמיד מתחילים מדף הבית.
שלב 3: גרידת תוצאות חיפוש ב-Redfin
אחרי שחיממתם את הסשן, אפשר להביא דף חיפוש עירוני ולנתח את כרטיסי הרישום. סלקטורים עדכניים (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): # דפים 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"נחסמתם בדף {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)
# השהיה אקראית בין 2 ל-5 שניות
time.sleep(random.uniform(2, 5))
print(f"נגרדו {len(listings)} רישומים")
אמור להיווצר לכם אוסף הולך וגדל של dictionaries, שכל אחד מהם מכיל מחיר, כתובת, חדרים/אמבטיות/שטח, ו-URL לדף הפרטים של רישום בסן פרנסיסקו. אם קיבלתם 0 כרטיסים, בדקו את קוד הסטטוס HTTP — 403 אומר ש-Cloudflare זיהתה אתכם, וסביר שתצטרכו פרוקסי מגורים.
שלב 4: גרידת דפי פרטי נכס בודדים
תוצאות החיפוש נותנות את הבסיס. דפי הפרטים נותנים את Redfin Estimate, שנת הבנייה, HOA, היסטוריית מכירה, פרטי הסוכן והתמונות. הדפים האלה דורשים רינדור JavaScript, לכן עוברים ל-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]: # מעשירים את 10 הראשונים
driver.get(listing["url"])
time.sleep(random.uniform(3, 6)) # המתנה לרינדור JS
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()
אחרי שלב זה, עשרת הרישומים הראשונים שלכם אמורים להיות מועשרים בערכי Redfin Estimate ונתוני שנת בנייה. ה-XPath selectors עמידים יותר מ-CSS עבור שדות מתקנים מקוננים כאלה, אבל הם עדיין שבירים — כל שינוי ב-DOM עלול לשבור אותם.
שלב 5: טיפול בחסימות ושגיאות
יש ליישם מנגנון retry עם 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"נחסמתם ({resp.status_code}). מנסים שוב בעוד {wait:.1f} שניות...")
time.sleep(wait)
else:
print(f"סטטוס לא צפוי: {resp.status_code}")
break
return None
סימנים לכך שנחסמתם: HTTP 403 עם HTML של Cloudflare בגוף, HTTP 429 (הגבלת קצב מפורשת), גוף תשובה ריק, או "Error 1020 Access Denied" בתוכן הדף. אם זה קורה שוב ושוב, זה הזמן להוסיף פרוקסי מגורים או לעבור לגישת ה-API.
גישה 2: לגרד את Redfin עם Python באמצעות ה-Stingray API הנסתר
זו הגישה המועדפת עליי. ה-frontend של Redfin מדבר עם API פנימי בפורמט JSON ב-/stingray/api/home/details/*, והתגובות חוזרות כ-JSON נקי וממוסד — בלי צורך בניתוח HTML.
איך מגלים את נקודות הקצה הנסתרות של Redfin
פותחים Chrome DevTools → לשונית Network → מסננים לפי Fetch/XHR → נכנסים לכל דף נכס ב-Redfin. תראו בקשות לנקודות קצה כמו:
api/home/details/initialInfo— ממפה URL → propertyId, listingIdapi/home/details/aboveTheFold— מחיר, חדרים, אמבטיות, שטח, תמונות, סטטוס, סוכן, MLS#api/home/details/belowTheFold— מתקנים, HOA, מסים, חניה, שנת בנייה, מגרש, היסטוריהapi/home/details/avm— Redfin Estimate עבור נכס בשוקapi/home/details/owner-estimate— Redfin Estimate עבור נכס מחוץ לשוקapi/home/details/descriptiveParagraph— תיאור שיווקי
בדפי שכירות, ה-rentalId (UUID באורך 36 תווים) נשלף מתוך ה-URL של תגית <meta property="og:image">.
חילוץ נתוני נכס דרך Stingray API
יש כאן קווץ' חשוב: תגובות JSON של Stingray מתחילות במחרוזת המילולית {}&& כאמצעי נגד CSRF. צריך להסיר אותה לפני הפענוח:
import json
from curl_cffi import requests as curl_requests
session = curl_requests.Session(impersonate="chrome120")
session.headers.update(HEADERS)
# חימום סשן
session.get("https://www.redfin.com/")
# בקשה לדף נכס כדי לקבל cookies ו-property ID
property_url = "https://www.redfin.com/CA/San-Francisco/123-Main-St-94102/home/12345678"
page_resp = session.get(property_url)
# עכשיו פונים ל-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})
# מסירים את הקידומת נגד CSRF
payload = json.loads(api_resp.text.replace("{}&&", "", 1))
# מחלצים נתונים מובנים
listing_data = payload.get("payload", {})
print(json.dumps(listing_data, indent=2))
התגובה כוללת שדות טיפוסיים: מחיר כמספר שלם, חדרים/אמבטיות כמספרים, כתובות URL של תמונות כמערכים, ופרטי סוכן כאובייקטים מקוננים. בלי BeautifulSoup, בלי CSS selectors, בלי ניחושים.
יתרונות ומגבלות של גישת ה-API הנסתר
יתרונות:
- JSON מובנה מראש — הרבה יותר נקי מניתוח HTML
- מהיר יותר לכל בקשה (payload קטן יותר, בלי עלות רינדור)
- סיכון חסימה נמוך יותר (בקשות בסגנון API עם כותרות נכונות נראות טבעיות יותר)
מגבלות:
- נקודות קצה יכולות להשתנות בלי הודעה מראש — אין תיעוד רשמי
robots.txtאוסר במפורש על/stingray/עבור user-agent כללי- דורש הנדסה לאחור כדי לגלות נקודות קצה חדשות
- עדיין צריך חימום סשן וכותרות נכונות כדי להימנע מ-Cloudflare
האלטרנטיבה ללא קוד: לגרד את Redfin עם Thunderbit
אם אתם צריכים נתוני Redfin ולא רוצים לתחזק סקריפטים ב-Python — או פשוט רוצים תוצאות בתוך חמש דקות — התחילו כאן. בנינו את Thunderbit בדיוק לזה: חילוץ נתונים מובנים מכל אתר, בלי קוד.
שלב 1: מתקינים את Thunderbit ונכנסים ל-Redfin
התקינו את תוסף Thunderbit ל-Chrome מחנות התוספים של Chrome. פתחו את Redfin וגשו לדף תוצאות חיפוש — למשל בתים למכירה בסן פרנסיסקו.
שלב 2: לוחצים על "AI Suggest Fields"
לחצו על אייקון Thunderbit בסרגל הדפדפן, ואז על "AI Suggest Fields." ה-AI קורא את דף Redfin ומציע אוטומטית עמודות כמו "Address", "Price", "Beds", "Baths", "SqFt", "Property Type" ו-"Listing Photo" — עם סוגי נתונים נכונים שנקבעים אוטומטית.
אפשר להסיר עמודות לא נחוצות או להוסיף עמודות מותאמות אישית בלחיצה על "+ Add Column" ותיאור פשוט באנגלית של מה שאתם רוצים (למשל, "listing agent name" או "days on market").
אמורה להופיע לכם תצוגה מקדימה של טבלה עם העמודות שהוגדרו, מוכנה למילוי.
שלב 3: לוחצים "Scrape" וצופים בנתונים נכנסים
לחצו על "Scrape". Thunderbit מעבד את הרישומים הגלויים וממלא את הטבלה. עבור תוצאות מחולקות לדפים, הוא מטפל ב-pagination אוטומטית — בלי צורך בלולאה.
בבדיקות שלי, טבלה של 50 שורות התמלאה בכ-45 שניות. נתונים מובנים, מוכנים לייצוא.
איך Thunderbit מתמודד עם ההגנות האנטי-בוט של Redfin
מכיוון ש-Thunderbit רץ בדפדפן שלכם, הוא יורש את ה-cookies, הסשן וטביעת הדפדפן הקיימים של Redfin. מבחינת Cloudflare, זה נראה כמו משתמש רגיל שמבקר ב-Redfin — כי טכנית, זה בדיוק מה שזה. אין דפדפן headless, אין IP של דאטה-סנטר, ואין טביעת TLS לא תואמת. עבור דפים ציבוריים, מצב ה-cloud scraping של Thunderbit יכול לעבד 50 דפים בבת אחת.
זו גישה שונה מהותית משליחת requests מסקריפט Python על שרת.
הסשן של הדפדפן שלכם כבר נחשב אמין.
גרידת תתי-דפים של Redfin עם Thunderbit
אחרי שגרדתם את תוצאות החיפוש, לחצו על "Scrape Subpages" כדי שה-AI יבקר בכל URL של דף נכס ויעשיר את הטבלה בשדות נוספים — Redfin Estimate, שנת בנייה, דמי HOA, פרטי סוכן, תמונות הנכס והיסטוריית מכירות.
זה המקבילה של לולאת Selenium בת 40 שורות מגישה 1 — רק שבפועל זה קליק אחד וללא תחזוקה.
כש-Redfin משנה את ה-DOM מ-homecardV2Price ל-span.bp-Homecard__Price--value, ה-AI מסתגל. הסלקטורים שלכם ב-Python לא.
גרדו תתי-דפים של Redfin בעזרת AI Get Started Free
מעבר ל-CSV: ייצוא נתוני Redfin ל-Google Sheets, Airtable ו-Notion
רוב המדריכים עוצרים ב-df.to_csv(). זה בסדר לניתוח חד-פעמי. אבל אם אתם חלק מצוות נדל"ן, אתם צריכים נתונים חיים ושיתופיים — לא קבצים סטטיים שיושבים על שולחן עבודה של מישהו.
ייצוא עם Python (gspread + Airtable API)
Google Sheets דרך 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)
# הצגת תמונות נכסים ישירות דרך נוסחת IMAGE()
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}")')
שימו לב: ל-Sheets יש מגבלת קשיחה של 10 מיליון תאים לגיליון, וה-API מאפשר 300 בקשות קריאה + 300 בקשות כתיבה בדקה לכל פרויקט. השתמשו ב-ws.batch_update() במקום לולאה תא-אחר-תא כשמדובר ביותר מכמה עשרות שורות.
Airtable דרך pyairtable:
שינוי קריטי ב-2024: Airtable הפסיקה לתמוך במפתחות API ישנים ב-1 בפברואר 2024. כעת חייבים להשתמש ב-Personal Access Tokens (PATs) — כל מדריך שעדיין מראה api_key=... כבר לא תקף.
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 מושכת ומאחסנת מחדש
}
for row in listings
]
created = table.batch_create(records, typecast=True)
מגבלת הקצב של Airtable היא 5 בקשות לשנייה לכל base, עם נעילה של 30 שניות במקרה של חריגה. שדה ה-attachment מקבל payload מסוג [{"url": ...}] — השרתים של Airtable מושכים את ה-URL, מאחסנים אותו מחדש ב-CDN שלהם, ומייצרים thumbnails אוטומטית.
ייצוא עם Thunderbit (קליק אחד ל-Sheets, Airtable, Notion)
ל-Thunderbit יש ייצוא מובנה בלחיצה אחת ל-Google Sheets, Airtable ו-Notion — והחלק שאני באמת גאה בו: תמונות נכסים מועלות ומוצגות כ-images מוטבעים ב-Notion וב-Airtable. בלי טריקים של נוסחת =IMAGE(), בלי קישורי CDN שבורים. לוחצים "Export to Airtable", והצוות שלכם מקבל מסד נתונים חזותי של נכסים עם thumbnails שאפשר לדפדף בהם מהטלפון.
עבור צוותי נדל"ן שעושים מיון חזותי של רישומים, זה ההבדל בין כלי שימושי לבין ערימת שורות CSV.
האם זה חוקי לגרד את Redfin? מה אומרות ה-ToS, robots.txt והפסיקה
אני לא עורך דין, וזו לא ייעוץ משפטי. אבל אחרי שנים בתחום חילוץ הנתונים, אני יכול לומר: "האם זה חוקי?" היא השאלה שכולם שואלים ורוב המדריכים מתחמקים ממנה.
robots.txt של Redfin
ה-robots.txt של Redfin מפורט מאוד. נקודות מפתח:
- בוטים שנחסמים לחלוטין:
peer39_crawler/1.0,AmazonAdBot,FireCrawlAgent— Redfin אפילו מציינת בשמות את שירות הסקרייפינג הפופולרי של עידן ה-LLM - הדגשות תחת
User-agent: * Disallow:/stingray/(כל מרחב ה-API הפנימי),/myredfin/,/api/v1/rentals/,/api/v1/properties/,/owner-estimate/ - אין הנחיית
Crawl-delay:עבור אף user agent - מוגדרים 50+ sitemaps — sitemaps הם הדרך הנקייה והקלה ל-WAF לרשום URLs
תנאי השימוש של Redfin
סעיף 2.3.5 קובע: "You may not automatedly crawl or query the Services for any purpose or by any means... unless you have received prior express written permission."
זהו הסכם מסוג browsewrap — קבלה דרך שימוש מתמשך, לא דרך לחיצה מפורשת. בתי המשפט בארה"ב היו לאורך השנים סקפטיים ביחס לאכיפת browsewrap מול משתמשים שלא קיבלו הודעה בפועל (ראו Nguyen v. Barnes & Noble, 9th Cir. 2014).
פסיקה רלוונטית בקצרה
- Van Buren v. United States (בית המשפט העליון, 2021): סעיף ה-"exceeds authorized access" בחוק CFAA נבחן לפי מודל של "השער פתוח או סגור". שימוש בדלת פתוחה למטרה לא רצויה אינו פריצה פדרלית.
- hiQ Labs v. LinkedIn (9th Cir., 2022): גרידת מידע ציבורי אינה הפרה של CFAA. אבל hiQ שילמה בסוף 500,000 דולר בהסדר על בסיס הפרת חוזה — כי היא פתחה חשבונות LinkedIn ולחצה "I agree."
- Meta Platforms v. Bright Data (N.D. Cal., ינואר 2024): בית המשפט נתן פסק דין מקוצר לטובת Bright Data — גרידה של מידע ציבורי כשהמשתמש מנותק לא הפכה את Bright Data ל"user" הכפוף ל-ToS של Meta.
- X Corp. v. Bright Data (N.D. Cal., מאי 2024): השופט Alsup דחה את טענות X, וקבע שטענות לפי דיני מדינה שניסו לשלוט בהעתקת תוכן ציבורי נדחו מפני חוק זכויות היוצרים.
הנחיות מעשיות
- גרדו רק נתונים ציבוריים — אל תירשמו לחשבון ואז תגרדו (זה יוצר חשיפה חוזית מסוג clickwrap)
- כבדו מגבלות קצב — נפחים אגרסיביים מחזקים טענות של trespass-to-chattels
- אל תפרסמו מחדש בקנה מידה גדול נתונים גולמיים או תמונות — התביעה CoStar v. Zillow (שהוגשה ביולי 2025, עם נזקים פוטנציאליים מעל מיליארד דולר) מזכירה שזכויות יוצרים על תמונות הן עניין רציני
- הגישה של Thunderbit מבוססת הדפדפן — ריצה בסשן המאומת שלכם — קרובה יותר ל"גלישה ידנית במהירות מכונה" מאשר לבוט headless בדאטה-סנטר, וזה מצב הגנתי חזק יותר מכל עוד לא מדובר ב-API מורשה
טיפים ומלכודות נפוצות
כמה שיעורים שנלמדו קשה בפיתוח כלי חילוץ ובצפייה באלפי משתמשים גורדים אתרי נדל"ן:
- תמיד תחממו את הסשן. היכנסו ל-
redfin.com/לפני כל URL עמוק. כניסות קרות ל-URL עמוק הן הטריגר מספר 1 לאתגרי Cloudflare. - סובבו User-Agent בצורה ריאליסטית. אל תשתמשו רק באחד — עברו בין 5–10 User-Agents עדכניים של Chrome/Firefox. אבל אל תסובבו יותר מדי באגרסיביות (User-Agent שונה בכל בקשה נראה חשוד).
- דדו-פליקציה לפי מזהה נכס. ה-pagination של Redfin לפעמים חופף. חלצו את
/home/{id}מכל URL של רישום ובצעו dedupe לפני העשרה. - אם אפשר, אל תגרדו בשעות עומס. מאוחר בלילה / מוקדם בבוקר לפי זמן ארה"ב יש, מניסיוני, פחות בדיקה מצד ה-WAF.
- אם קיבלתם 429, תתרחקו עם backoff אקספוננציאלי. אל תנסו מיד שוב — כך עוברים מהגבלת קצב רכה לחסימת IP קשיחה.
- לפרויקטים גדולים (1,000+ דפים), תכננו תקציב לפרוקסי מגורים. IPs של דאטה-סנטר (AWS, GCP, Azure, OVH) נמצאים ברשימה שחורה של מערכת המוניטין לפי ASN של Cloudflare. כמעט מיד תיתקלו ב-Error 1020.
איך לבחור את הדרך הנכונה לגרידת Redfin
אז איזו גישה לבחור? זה תלוי מי אתם ומה אתם צריכים.
ניתוח HTML (BeautifulSoup + Selenium): הכי טוב למפתחים שרוצים שליטה מלאה, נוח להם לתחזק CSS selectors, ולא אכפת להם לבנות מחדש כשה-DOM של Redfin משתנה. צפו לחזור לקוד כל 6–12 חודשים.
ה-API הנסתר Stingray: הכי טוב למפתחים שצריכים JSON נקי ומובנה ויודעים להתמודד עם הנדסה לאחור של נקודות קצה לא מתועדות. פחות תחזוקה מניתוח HTML, אבל נקודות קצה יכולות להשתנות בלי הודעה. זכרו ש-/stingray/ אסור במפורש ב-robots.txt.
Thunderbit (ללא קוד): הכי טוב ללא-מפתחים, לפרויקטים מהירים, ולצוותים שצריכים נתוני Redfin שוטפים בלי משאבי פיתוח. ה-AI מסתגל לשינויי פריסה, גרידת תתי-דפים מעשירה נתונים בלחיצה אחת, וייצוא ל-Google Sheets, Airtable או Notion מובנה כבר מהקופסה. אם אתם צוות נדל"ן שצריך מסד נתונים חי של נכסים — לא dump חד-פעמי של CSV — זו הדרך עם הכי מעט חיכוך.
לא משנה באיזו דרך תבחרו: הבינו את ההגנות האנטי-בוט של Redfin לפני שמתחילים, ידעו אילו שדות אתם צריכים, בחרו פורמט ייצוא שמתאים לזרימת העבודה של הצוות, ושמרו על הצד הנכון של ההנחיות המשפטיות.
מוכנים לנסות את המסלול ללא קוד? החבילה החינמית של Thunderbit מאפשרת לכם להתנסות בגרידת Redfin ולראות תוצאות בתוך דקות. עבור גישות Python, קטעי הקוד שלמעלה הם נקודת פתיחה שעובדת — רק הוסיפו פרוקסי וסבלנות.
נסו את Thunderbit לנתוני Redfin שוטפים
שאלות נפוצות
האם ל-Redfin יש API ציבורי?
לא. ל-Redfin אין API ציבורי רשמי. ה-Stingray API הנסתר (/stingray/api/home/details/*) מחזיר JSON מובנה ומשמש את ה-frontend של Redfin עצמה, אבל הוא לא רשמי, לא מתועד, עשוי להשתנות בלי הודעה, ומפורש כאסור ב-robots.txt של Redfin. עטיפות קוד פתוח כמו reteps/redfin ב-PyPI מספקות גישה ב-Python, אבל כדאי להשתמש בהן תוך הבנת הסיכונים.
אפשר לגרד את Redfin בלי Python?
כן. Thunderbit הוא תוסף AI ל-Chrome שיורש את סשן הדפדפן שלכם לצורך עמידות מול בוטים — מתקינים אותו, נכנסים ל-Redfin, לוחצים "AI Suggest Fields", ומייצאים ל-Excel, Google Sheets, Airtable או Notion. יש גם כלי גרידה נוספים ללא קוד וספקי דאטה מוכנים מראש בשוק אם תרצו לחקור חלופות.
באיזו תדירות Redfin משנה את מבנה האתר שלה?
היסטוריית הבעיות ב-GitHub בקהילה מראה שבירה של CSS selectors בערך כל 6–12 חודשים. Redfin שחררה שני דורות DOM לכרטיסים — הישן (homecardV2Price, homeAddressV2) והנוכחי (bp-Homecard__Price--value, bp-Homecard__Address). סקרייפרים בשלים מנסים את שניהם ברצף.
כלים מבוססי AI כמו Thunderbit מסתגלים אוטומטית כי הם מזהים שדות לפי תוכן ולא לפי CSS selectors.
איזה סוג פרוקסי הכי טוב לגרידת Redfin?
פרוקסי מגורים אמריקאיים לגרידה בהיקף גדול — מדדי קהילה מציבים את שיעור ההצלחה סביב 80%. פרוקסי דאטה-סנטר נתקלים ב-Cloudflare Error 1020 כמעט מיד; טווחי IP של AWS, GCP, Azure ו-OVH ברשימה שחורה. פרוקסי מובייל הם בעלי שיעור ההצלחה הגבוה ביותר, אבל עולים פי 5–10 יותר.
לגרידה אישית קטנה (<100 דפים), כותרות נכונות + התחזות דרך curl_cffi + השהיות של 2–5 שניות עשויים לעבוד גם בלי פרוקסי בכלל.
אפשר לגרד נתוני נכסים שנמכרו או לא נמצאים כרגע בשוק מ-Redfin?
כן. נתוני נכסים שנמכרו ו-Redfin Estimate מחוץ לשוק (שגיאה חציונית 7.52%) זמינים בדפי הפרטים באמצעות אותן גישות לגרידה. השfields שונים מרישומים פעילים: דפי מחוץ לשוק חושפים מחיר מכירה, תאריך מכירה, היסטוריית נכס ו-endpoint של owner-estimate, אבל חסרים מחיר רשום נוכחי, ימים בשוק ומידע על בית פתוח. נקודת הקצה של Stingray עבור הערכות מחוץ לשוק היא api/home/details/owner-estimate ולא api/home/details/avm.
נסו את Thunderbit לגרידת Redfin Get Started Free
למידע נוסף
