Cum să extragi date de pe Zillow cu Python (fără să fii blocat)

Zillow găzduiește peste 160 de milioane de înregistrări imobiliare din SUA, iar extragerea acestor date la scară este una dintre cele mai cerute — și cele mai frustrante — sarcini din analiza datelor imobiliare. Dacă ai încercat vreodată să faci scraping pe Zillow și te-ai trezit în fața unei pagini CAPTCHA în locul datelor despre anunțuri, nu ești singur.

Am petrecut mult timp cercetând și testând diferite metode de extragere a datelor de pe Zillow — atât cu Python, cât și cu instrumente no-code construite la Thunderbit. Acest ghid le acoperă pe ambele. Indiferent dacă vrei un tutorial complet în Python, cu strategii anti-bot, sau ai nevoie doar de 200 de anunțuri într-un spreadsheet până la prânz, vei găsi aici o secțiune utilă. Vom explica de ce contează datele Zillow, cum este construit site-ul în spate, un tutorial Python pas cu pas, motivele exacte pentru care se defectează scrapers și cum poți automatiza extragerile recurente pentru monitorizarea prețurilor.

De ce merită să extragi date de pe Zillow?

Zillow este cea mai mare sursă de date imobiliare rezidențiale din SUA. Atrage 210 milioane de vizite lunare și găzduiește în jur de 750.000+ anunțuri active de vânzare, plus 1,9 milioane de anunțuri de închiriere. Platforma acoperă peste 50% din tot traficul portalurilor imobiliare din SUA — mai mult decât dublul următorului competitor.

Înainte să intrăm în cod Python, e important de știut că scraping-ul de pe Zillow cu Python nu este singura opțiune, iar alegerea metodei greșite îți poate consuma ore întregi. Instrumentele Python precum httpx și BeautifulSoup cer un nivel intermediar de cunoștințe, gestionarea manuală a headerelor și proxy-urilor, rulează la viteze moderate (1–3 secunde pe pagină) și au nevoie de întreținere frecventă, deși sunt gratuite; Selenium sau Playwright îmbunătățesc gestionarea anti-bot prin randarea JavaScript, dar sunt mai lente (5–15 secunde pe pagină) și tot necesită multă întreținere; API-urile de scraping precum ScraperAPI sau ScrapFly sunt mai rapide, includ protecție anti-bot și necesită întreținere moderată, dar costă 30–599 $ pe lună; API-ul oficial Zillow prin Bridge Interactive este rapid și ușor de întreținut, dar limitat și costă în jur de 500 $ pe lună; iar instrumentele no-code precum Thunderbit sunt prietenoase pentru începători, rapide, nu necesită întreținere datorită adaptării AI și oferă de obicei un model freemium.

Economia de timp este uriașă. Cercetarea manuală în peste 50 de coduri poștale poate consuma 15–20 de ore pe săptămână. Extracția automată face aceeași muncă în câteva minute — o reducere de 99,7% a timpului.

Toate metodele de a extrage date de pe Zillow: Python vs. API vs. no-code (comparativ)

Înainte să intri în cod Python, trebuie să știi că „scrape Zillow cu Python” nu este singura variantă. Alegerea greșită îți poate irosi ore. Iată o comparație clară, ca să poți alege metoda potrivită:

Metodă	Nivel de experiență	Gestionare anti-bot	Viteză	Întreținere	Cost
Python + httpx/BeautifulSoup	Intermediar	Manuală (headere, proxy-uri)	Moderată (1–3s/pagină)	Ridicată (se rup selectorii)	Gratuit
Python + Selenium/Playwright	Intermediar	Mai bună (randare JS)	Lentă (5–15s/pagină)	Ridicată	Gratuit
API de scraping (ScraperAPI, ScrapFly)	Intermediar	Integrată	Rapidă	Medie	30–599 $/lună
API oficial Zillow (Bridge Interactive)	Începător–Intermediar	N/A	Rapidă	Scăzută	~500 $/lună, acces limitat
Instrument no-code (Thunderbit)	Începător	Integrată (AI se adaptează)	Rapidă	Niciuna (AI recitește pagina)	Freemium

Dacă ai nevoie de date chiar acum, fără să scrii cod, începe cu Thunderbit. Dacă vrei să înțelegi mecanismul sau ai nevoie de personalizare completă, continuă cu tutorialul în Python.

Varianta de 2 minute: extrage date de pe Zillow cu Thunderbit (fără cod)

Înainte de analiza aprofundată în Python, iată varianta pentru oricine are nevoie rapid de date Zillow — fără configurare Python, fără proxy-uri și fără întreținerea selectorilor. Am construit acest flux în Thunderbit special pentru a obține date imobiliare structurate fără efort tehnic.

Dificultate: Începător Timp necesar: ~2 minute Ai nevoie de: browser Chrome, Thunderbit Chrome Extension (merge și varianta gratuită)

Pasul 1: Instalează Thunderbit și deschide Zillow

Instalează extensia Thunderbit din Chrome Web Store. Apoi deschide o pagină de rezultate Zillow — de exemplu, caută locuințe în Houston, TX.

Pasul 2: Apasă „AI Suggest Fields”

Deschide bara laterală Thunderbit și apasă „AI Suggest Fields”. AI-ul citește pagina și propune automat coloane precum: preț, adresă, dormitoare, băi, suprafață, Zestimate, URL-ul anunțului și multe altele. Din testele mele, detectează de obicei peste 20 de câmpuri fără nicio configurare manuală.

Pasul 3: Apasă „Scrape”

Apasă butonul Scrape. Datele apar într-un tabel structurat în extensie. Thunderbit gestionează automat paginarea Zillow — atât cea pe bază de click, cât și scroll-ul infinit.

Pasul 4: Completează cu extragerea subpaginilor

Vrei date din pagina de detalii, cum ar fi istoricul taxelor, ratingurile școlilor sau istoricul prețurilor? Folosește „Scrape Subpages” pentru a îmbogăți tabelul. Thunderbit urmează fiecare URL al anunțului și extrage câmpurile suplimentare — fără cod extra.

Pasul 5: Exportă

Exportă în Google Sheets, Excel, Airtable sau Notion. Exportul este gratuit.

De ce funcționează bine Thunderbit pentru Zillow

Avantajul real aici este reziliența. AI-ul Thunderbit citește structura paginii de fiecare dată când faci scraping. Când Zillow își schimbă layout-ul (ceea ce se întâmplă des), nu ai de reparat selectori CSS fragili. AI-ul se adaptează automat. Asta rezolvă cu adevărat problema naturii „inherent fragile” a scrapers-urilor codată, care îi frustrează pe mulți utilizatori.

Ce date poți extrage de pe Zillow? (peste 20 de câmpuri)

Cele mai multe ghiduri iau doar prețul și adresa, apoi se opresc. În realitate, anunțurile Zillow conțin mult mai multe date care pot fi extrase decât cred oamenii — iată un tabel de referință:

Câmp	Unde se găsește	Dificultate de extragere
Prețul listării	Căutare + Detalii	Ușoară
Adresă / Cod poștal	Căutare + Detalii	Ușoară
Zestimate	Căutare + Detalii	Ușoară
Istoricul prețurilor (fiecare eveniment)	Detalii	Grea (JSON imbricat)
Istoricul taxelor	Detalii	Grea (JSON imbricat)
Dormitoare / Băi / Suprafață	Căutare + Detalii	Ușoară
Anul construcției	Detalii	Ușoară
Taxa HOA	Detalii	Medie
Walk Score / Transit Score	Detalii (iframe)	Grea (necesită randare JS)
Ratingurile școlilor	Detalii	Medie
Dimensiunea terenului	Detalii	Ușoară
Zile pe Zillow	Căutare	Ușoară
Agent / Agenție imobiliară	Căutare + Detalii	Medie
MLS #	Detalii	Ușoară
Tipul proprietății	Căutare + Detalii	Ușoară
Latitudine / Longitudine	JSON `__NEXT_DATA__`	Medie
Descrierea text	Detalii	Ușoară
URL-uri foto	Căutare + Detalii	Medie
Rent Zestimate	Detalii	Medie
Vânzări comparabile din apropiere	Detalii	Grea

Câmpurile „grele” — istoricul prețurilor, istoricul taxelor, vânzările comparabile — se află în JSON imbricat pe paginile de detalii. Secțiunea Python de mai jos arată exact cum le extragi. Iar dacă preferi să sari peste cod, AI Suggest Fields de la Thunderbit detectează automat majoritatea acestor coloane, iar Subpage Scraping extrage câmpurile din pagina de detalii fără intervenție manuală.

Configurarea mediului Python pentru a extrage date de pe Zillow

Dificultate: Intermediar Timp necesar: ~5 minute pentru configurare, ~30 minute pentru tutorialul complet Ai nevoie de: Python 3.8+, browser Chrome (pentru inspectarea paginilor), un editor de text sau IDE

Instalează bibliotecile necesare:

pip install httpx beautifulsoup4 pandas lxml

Ce face fiecare:

httpx — client HTTP cu performanțe mai bune decât requests și suport async
beautifulsoup4 + lxml — parsarea HTML
pandas — export de date în CSV/Excel
Opțional: selenium sau playwright dacă trebuie să randăi pagini cu mult JavaScript

Înainte să faci scraping: înțelege structura paginii Zillow

Acesta este cel mai important lucru de înțeles înainte să scrii cod. Zillow este o aplicație Next.js — confirmat de postări tehnice ale angajaților Zillow. Asta înseamnă că majoritatea datelor dorite nu se află în elementele HTML vizibile. Ele sunt încorporate într-un blob JSON în <script id="__NEXT_DATA__">.

Deschide orice pagină de proprietate Zillow, apasă F12, mergi la Elements și caută __NEXT_DATA__. Vei găsi un obiect JSON uriaș care conține toate datele anunțului — prețuri, coordonate, detalii despre proprietate, istoricul prețurilor, înregistrări fiscale, ratinguri școlare și multe altele.

De ce contează asta? Clasele CSS de pe Zillow sunt hash-uite (generate de styled-components) și se schimbă la fiecare deploy. O clasă precum StyledPropertyCardHomeDetailsList-c11n-8-109-3__sc-1j0som5-0 va avea un hash complet diferit săptămâna viitoare. Orice scraper bazat pe selectori CSS se va rupe periodic.

Abordarea cu JSON-ul __NEXT_DATA__ este mult mai stabilă, deoarece nu depinde deloc de structura HTML.

Căi JSON importante pentru rezultatele căutării:

Cale	Conținut
`props.pageProps.searchPageState.cat1.searchResults.listResults`	Lista rezultatelor căutării
`props.pageProps.searchPageState.cat1.searchResults.mapResults`	Rezultate din vizualizarea pe hartă
`props.pageProps.searchPageState.cat1.searchList.totalPages`	Numărul total de pagini disponibile

Pentru paginile de detalii, unele folosesc __NEXT_DATA__, iar altele folosesc un script alternativ numit hdpApolloPreloadedData. Codul de mai jos le acoperă pe ambele.

Pas cu pas: cum extragi date de pe Zillow cu Python

Pasul 1: Configurează headerele HTTP ca să eviți blocarea imediată

Dacă trimiți un simplu httpx.get() către Zillow, vei primi o pagină CAPTCHA, nu datele anunțurilor. Zillow folosește PerimeterX (HUMAN Security) împreună cu Cloudflare — ambele evaluate la 8/10 dificultate în benchmark-urile de scraping. Sistemul verifică fingerprint-ul TLS, headerele HTTP și reputația IP-ului.

Acestea sunt headerele minime care funcționează în 2025:

import httpx

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                   "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,"
              "image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Sec-Ch-Ua": '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
    "Sec-Ch-Ua-Platform": '"Windows"',
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Site": "none",
    "Sec-Fetch-User": "?1",
    "Upgrade-Insecure-Requests": "1",
}

Headerele Sec-Ch-Ua sunt critice. Multe tutoriale le omit — exact de aceea codul din acele tutoriale nu funcționează împotriva PerimeterX.

Pasul 2: Extrage rezultatele căutării de pe Zillow

URL-urile de căutare Zillow urmează un model previzibil. Pentru Houston, TX:

Pagina 1: https://www.zillow.com/houston-tx/
Pagina 2: https://www.zillow.com/houston-tx/2_p/
Pagina 3: https://www.zillow.com/houston-tx/3_p/

Fiecare pagină conține aproximativ 41 de anunțuri. Zillow limitează rezultatele la 20 de pagini (~820 de anunțuri). Pentru seturi de date mai mari, va trebui să împarți căutarea pe zone geografice (revenim la asta mai jos).

Iată codul pentru a extrage rezultatele căutării din JSON-ul __NEXT_DATA__:

from bs4 import BeautifulSoup
import json
import time
import random

def scrape_zillow_search(url):
    """Extrage date despre anunțuri dintr-o pagină de rezultate Zillow."""
    response = httpx.get(url, headers=headers, timeout=15)

    if response.status_code != 200:
        print(f"Am primit statusul {response.status_code} pentru {url}")
        return []

    soup = BeautifulSoup(response.text, "lxml")
    script_tag = soup.find("script", {"id": "__NEXT_DATA__"})

    if not script_tag:
        print("Nu s-a găsit __NEXT_DATA__ — probabil blocat de CAPTCHA")
        return []

    next_data = json.loads(script_tag.string)

    try:
        results = (
            next_data["props"]["pageProps"]["searchPageState"]
            ["cat1"]["searchResults"]["listResults"]
        )
    except KeyError:
        print("Structură JSON neașteptată — Zillow poate și-a schimbat formatul")
        return []

    listings = []
    for item in results:
        listing = {
            "zpid": item.get("zpid"),
            "address": item.get("addressStreet"),
            "city": item.get("addressCity"),
            "state": item.get("addressState"),
            "zipcode": item.get("addressZipcode"),
            "price": item.get("unformattedPrice") or item.get("price"),
            "beds": item.get("beds"),
            "baths": item.get("baths"),
            "sqft": item.get("area"),
            "zestimate": item.get("zestimate"),
            "days_on_zillow": item.get("daysOnZillow"),
            "listing_url": item.get("detailUrl"),
            "img_src": item.get("imgSrc"),
            "property_type": item.get("hdpData", {}).get("homeInfo", {}).get("homeType"),
            "latitude": item.get("latLong", {}).get("latitude"),
            "longitude": item.get("latLong", {}).get("longitude"),
        }
        listings.append(listing)

    return listings

Ca să extragi mai multe pagini, rulează un loop cu pauze:

all_listings = []
base_url = "https://www.zillow.com/houston-tx/"

for page in range(1, 6):  # Primele 5 pagini
    url = base_url if page == 1 else f"{base_url}{page}_p/"
    print(f"Extrag pagina {page}...")

    page_listings = scrape_zillow_search(url)
    all_listings.extend(page_listings)

    # Pauză aleatorie între 3 și 7 secunde
    delay = random.uniform(3, 7)
    time.sleep(delay)

print(f"Număr total de anunțuri extrase: {len(all_listings)}")

Ar trebui să vezi cum datele structurate se adună în all_listings. Dacă obții rezultate goale, verifică secțiunea „De ce se rup scrapers” de mai jos.

Pasul 3: Extrage paginile de detalii ale proprietăților Zillow

Rezultatele căutării îți dau informațiile de bază. Paginile de detalii conțin date mai profunde: istoricul prețurilor, istoricul taxelor, ratingurile școlilor, informații despre agent și descrierea proprietății. Fiecare URL de anunț din Pasul 2 duce la o pagină de detalii.

Paginile de detalii Zillow folosesc două formate de date posibile. Iată codul care le gestionează pe ambele:

def scrape_zillow_detail(url):
    """Extrage date detaliate despre o proprietate dintr-o pagină Zillow."""
    response = httpx.get(url, headers=headers, timeout=15)

    if response.status_code != 200:
        return None

    soup = BeautifulSoup(response.text, "lxml")

    # Încearcă mai întâi __NEXT_DATA__ (cea mai comună variantă)
    script_tag = soup.find("script", {"id": "__NEXT_DATA__"})
    if script_tag:
        next_data = json.loads(script_tag.string)
        try:
            cache_str = next_data["props"]["pageProps"]["componentProps"]["gdpClientCache"]
            cache = json.loads(cache_str)
            first_key = next(iter(cache))
            prop = cache[first_key]["property"]
            return extract_property_fields(prop)
        except (KeyError, StopIteration):
            pass

    # Variantă de rezervă: hdpApolloPreloadedData
    apollo_tag = soup.find("script", {"id": "hdpApolloPreloadedData"})
    if apollo_tag:
        raw = json.loads(apollo_tag.string)
        api_cache = json.loads(raw["apiCache"])
        for key, value in api_cache.items():
            if "ForSale" in key or "property" in str(value)[:100]:
                prop = value.get("property", value)
                return extract_property_fields(prop)

    return None


def extract_property_fields(prop):
    """Extrage câmpuri structurate dintr-un obiect JSON Zillow despre proprietate."""
    return {
        "zpid": prop.get("zpid"),
        "zestimate": prop.get("zestimate"),
        "rent_zestimate": prop.get("rentZestimate"),
        "description": prop.get("description"),
        "year_built": prop.get("yearBuilt"),
        "lot_size": prop.get("lotSize"),
        "hoa_fee": prop.get("monthlyHoaFee"),
        "mls_id": prop.get("mlsid"),
        "broker_name": prop.get("brokerName") or prop.get("attributionInfo", {}).get("brokerName"),
        "price_history": [
            {
                "date": event.get("date"),
                "event": event.get("event"),
                "price": event.get("price"),
            }
            for event in prop.get("priceHistory", [])
        ],
        "tax_history": [
            {
                "year": record.get("time"),
                "tax_paid": record.get("taxPaid"),
                "value": record.get("value"),
            }
            for record in prop.get("taxHistory", [])
        ],
        "schools": [
            {
                "name": school.get("name"),
                "rating": school.get("rating"),
                "distance": school.get("distance"),
            }
            for school in prop.get("schools", [])
        ],
    }

Parcurge URL-urile anunțurilor cu pauze:

detail_data = []
for listing in all_listings[:10]:  # Începe cu 10 pentru test
    detail_url = listing.get("listing_url")
    if not detail_url:
        continue

    if not detail_url.startswith("http"):
        detail_url = f"https://www.zillow.com{detail_url}"

    print(f"Extrag detalii: {detail_url}")
    detail = scrape_zillow_detail(detail_url)

    if detail:
        detail_data.append({**listing, **detail})

    time.sleep(random.uniform(3, 8))

După acest pas, ar trebui să ai o listă de dicționare care conține atât datele de nivel căutare, cât și datele din pagina de detalii pentru fiecare proprietate.

Pasul 4: Gestionează paginarea pentru a extrage mai multe pagini

Pentru zone cu mai mult de 820 de anunțuri (limita de 20 de pagini), trebuie să împarți zona geografic. API-ul intern Zillow acceptă parametri mapBounds. Strategia: împarte harta în cadrane și extrage fiecare zonă separat.

def split_bounds(bounds):
    """Împarte limitele hărții în 4 cadrane."""
    mid_lat = (bounds["north"] + bounds["south"]) / 2
    mid_lng = (bounds["east"] + bounds["west"]) / 2

    return [
        {"north": bounds["north"], "south": mid_lat, "east": bounds["east"], "west": mid_lng},
        {"north": bounds["north"], "south": mid_lat, "east": mid_lng, "west": bounds["west"]},
        {"north": mid_lat, "south": bounds["south"], "east": bounds["east"], "west": mid_lng},
        {"north": mid_lat, "south": bounds["south"], "east": mid_lng, "west": bounds["west"]},
    ]

Pentru majoritatea cazurilor — monitorizarea a 50–200 de anunțuri într-o anumită zonă — paginarea standard prin URL este suficientă. Abordarea pe cadrane este utilă pentru extrageri la nivel de oraș sau stat.

Pasul 5: Exportă datele Zillow extrase

Salvează totul în CSV cu pandas:

import pandas as pd

df = pd.DataFrame(detail_data)
df.to_csv("zillow_houston_listings.csv", index=False)
print(f"Am exportat {len(df)} anunțuri în zillow_houston_listings.csv")

Pentru export în JSON:

with open("zillow_houston_listings.json", "w") as f:
    json.dump(detail_data, f, indent=2)

Dacă vrei să sari complet peste pasul de export, Thunderbit exportă gratuit în Google Sheets, Airtable și Notion — util dacă vrei datele imediat într-un format colaborativ.

De ce se rup scrapers-urile Zillow (și cum construiești unele rezistente)

Acesta este ghidul de supraviețuire.

Din experiența mea, scrapers-urile se rup pe Zillow din trei motive specifice — iar fiecare are o soluție concretă.

PerimeterX și CAPTCHA: de ce cererile tale returnează date goale

Integrarea PerimeterX de la Zillow verifică simultan mai multe semnale: fingerprint-ul TLS, headerele HTTP, reputația IP-ului și tiparul cererilor. Când detectează automatizare, returnează o pagină CAPTCHA „Press & Hold” în locul datelor despre anunț.

Scenariul exact de eșec: trimiți o cerere cu headerele implicite din Python. HTML-ul răspunsului conține scripturi de challenge PerimeterX în locul datelor despre proprietate — iar parsarea cu BeautifulSoup nu găsește niciun tag __NEXT_DATA__.

Soluția: folosește headerele complete, similare unui browser, din Pasul 1. Dacă faci mai mult de câteva zeci de cereri, ai nevoie și de rotație de proxy-uri (acoperită mai jos). Pentru scraping intens, ia în considerare o bibliotecă precum curl_cffi cu impersonate="chrome" — este singurul client HTTP Python care poate emula un fingerprint TLS real de Chrome.

Selectori CSS dinamici: de ce BeautifulSoup returnează None

Dacă folosești selectori CSS precum .list-card-price sau nume de clase cu hash, scraperul tău se va rupe de fiecare dată când Zillow publică o versiune nouă.

Zillow folosește styled-components, care generează clase precum StyledPropertyCardHomeDetailsList-c11n-8-109-3__sc-1j0som5-0. Partea de hash se schimbă la fiecare build.

Soluția: nu folosi deloc selectori CSS. Extrage datele din blob-ul JSON __NEXT_DATA__, așa cum se arată în codul de mai sus. Această abordare este stabilă de ani de zile, pentru că structura JSON se schimbă mult mai rar decât markup-ul HTML.

Dacă trebuie neapărat să folosești parsarea HTML, caută atribute data-test (de exemplu, data-test="property-card") sau folosește potrivire de clasă pe substring, de tipul [class*="PropertyCard"]. Totuși, extragerea din JSON rămâne cea mai sigură metodă.

Rotația proxy-urilor și exponential backoff: cod care rezistă la interdicții IP

IP-urile din datacentere sunt blocate imediat de Zillow. Ai nevoie de proxy-uri rezidențiale pentru acces fiabil. Rata sigură: 1 cerere la 3–8 secunde per IP, sub aproximativ 500 de cereri/oră.

Iată un decorator de retry cu exponential backoff și jitter:

import random
import time

def backoff_with_jitter(attempt, base_delay=2, max_delay=60):
    """Exponential backoff cu jitter complet, în stil AWS."""
    delay = min(max_delay, base_delay * (2 ** attempt))
    return random.uniform(0, delay)

def fetch_with_retry(url, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = httpx.get(url, headers=headers, timeout=15)
            if response.status_code == 200:
                return response
            if response.status_code in (403, 429):
                delay = backoff_with_jitter(attempt, base_delay=5)
                print(f"Blocat ({response.status_code}). Reîncerc în {delay:.1f}s...")
                time.sleep(delay)
                continue
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(backoff_with_jitter(attempt))
    return None

Și un pool simplu de rotație a proxy-urilor:

class ProxyPool:
    def __init__(self, proxies):
        self.proxies = proxies
        self.index = 0
        self.failures = {}

    def get_next(self):
        proxy = self.proxies[self.index % len(self.proxies)]
        self.index += 1
        return {"http://": proxy, "https://": proxy}

    def report_failure(self, proxy):
        self.failures[proxy] = self.failures.get(proxy, 0) + 1
        if self.failures[proxy] > 3:
            self.proxies.remove(proxy)

# Utilizare:
pool = ProxyPool(proxies=[
    "http://user:pass@residential1.example.com:8080",
    "http://user:pass@residential2.example.com:8080",
])

Ca furnizori de proxy, DataImpulse oferă proxy-uri rezidențiale la aproximativ 1 $/GB (cea mai ieftină opțiune), iar IPRoyal și Smartproxy sunt opțiuni bune de nivel mediu, la 4–7 $/GB.

Alternativa fără întreținere

Dacă extragi date de pe Zillow în mod regulat și te-ai săturat să repari selectori rupți sau să gestionezi pool-uri de proxy, AI-ul Thunderbit citește structura paginii de la zero la fiecare extragere. Fără selectori de întreținut, fără configurare de proxy. Rezolvă cu adevărat problema fragilității care transformă scrapers-urile codate într-o bătaie de cap recurentă.

Automatizează scraping-ul Zillow: programare și monitorizarea prețurilor

Fiecare investitor imobiliar cu care am vorbit își dorește asta, iar niciun alt ghid de scraping Zillow nu o acoperă bine: extrageri automate recurente pentru urmărirea prețurilor.

Pentru utilizatorii Python: cron jobs și detectarea modificărilor de preț

Setează un cron job care rulează scraperul săptămânal și marchează schimbările de preț:

import pandas as pd
from datetime import datetime

def detect_price_changes(new_data, historical_file, threshold=0.05):
    """Compară extragerea nouă cu datele istorice și marchează schimbările > prag."""
    try:
        old = pd.read_csv(historical_file)
    except FileNotFoundError:
        new_data.to_csv(historical_file, index=False)
        print("Prima rulare — datele de bază au fost salvate.")
        return pd.DataFrame()

    merged = new_data.merge(old, on="zpid", suffixes=("_new", "_old"))
    merged["price_change_pct"] = (
        (merged["price_new"] - merged["price_old"]) / merged["price_old"]
    )
    alerts = merged[merged["price_change_pct"].abs() > threshold]

    # Adaugă noile date cu timestamp
    new_data["scraped_at"] = datetime.now().isoformat()
    new_data.to_csv(historical_file, mode="a", header=False, index=False)

    return alerts

Adaugă asta în crontab pentru rulare săptămânală, lunea la 6:00 AM:

0 6 * * 1 cd /path/to/scraper && python zillow_monitor.py

Un exemplu practic: monitorizezi 50 de anunțuri din Austin, TX, săptămânal. În fiecare luni, scriptul extrage prețurile curente, le compară cu săptămâna precedentă și generează un CSV care evidențiază orice scădere de preț mai mare de 5%.

Pentru non-programatori: Scheduled Scraper de la Thunderbit

Scheduled Scraper de la Thunderbit îți permite să descrii intervalul în limbaj natural („în fiecare luni la 9 dimineața”), să introduci URL-urile de căutare Zillow și să apeși Schedule. Datele se exportă automat în Google Sheets la fiecare rulare. Fără Python, fără cron, fără server de întreținut. Este deosebit de util pentru agenți imobiliari sau echipe operaționale care au nevoie de monitorizare constantă a prețurilor fără suport de inginerie.

Sfaturi pentru a extrage date de pe Zillow în mod responsabil

Câteva recomandări pentru a rămâne în limitele corecte:

Extrage doar date public disponibile. Nu accesa pagini aflate în spatele unui login sau al unor mecanisme de autentificare.
Folosește rate rezonabile de cereri. 3–8 secunde între cereri. Nu supraîncărca serverul.
Nu extrage date personale/private ale utilizatorilor. Numele agenților și informațiile agențiilor din anunțuri sunt publice; datele conturilor de utilizator nu sunt.
Stochează și folosește datele etic. Cercetarea de piață, analiza investițiilor și generarea de lead-uri sunt utilizări legitime. Spam-ul nu este.
Context legal: hotărârea hiQ v. LinkedIn a stabilit că extragerea datelor public accesibile nu încalcă CFAA. Decizia Meta v. Bright Data (2024) a menținut principii similare. Totuși, termenii de utilizare Zillow restricționează accesul automatizat, iar ei aplică aceste restricții prin blocări IP și CAPTCHA-uri, nu prin acțiuni legale. Verifică întotdeauna ghidurile actuale și respectă robots.txt.

Alege abordarea potrivită pentru a extrage date de pe Zillow cu Python

Cea mai bună variantă depinde de situația ta:

Ai nevoie rapid de date, fără cod? Thunderbit te duce de la o pagină de căutare Zillow la un spreadsheet structurat în aproximativ 2 minute. AI-ul se adaptează schimbărilor de layout, gestionează paginarea și exportă gratuit. Instalează Chrome Extension și testează-l pe o pagină Zillow.

Vrei control total? Folosește codul Python din acest ghid. Extrage din JSON-ul __NEXT_DATA__ (nu din selectorii CSS) pentru stabilitate. Setează headere de browser corecte. Folosește proxy-uri rezidențiale și exponential backoff pentru fiabilitate.

Vrei să scalezi? API-urile de scraping precum ScrapFly (rata de succes de 99% pe Zillow) sau ScraperAPI gestionează pentru tine infrastructura de proxy și CAPTCHA, la 30–599 $/lună, în funcție de volum.

Urmărești prețurile în timp? Setează un cron job cu scriptul de detectare a schimbărilor de preț sau folosește Scheduled Scraper de la Thunderbit pentru o abordare fără întreținere.

Datele există. Singura întrebare este cât timp de inginerie vrei să consumi ca să le extragi. Pentru mai multe informații despre aducerea datelor web în spreadsheet-uri, vezi ghidul nostru despre cum să extragi date de pe un website în Excel sau recapitularea statisticilor Zillow pentru cele mai recente date ale platformei. Poți urmări și tutoriale pe canalul Thunderbit de YouTube.

Încearcă Thunderbit pentru scraping Zillow Get Started Free

Întrebări frecvente

Poți face scraping pe Zillow cu Python gratuit?

Da — httpx, BeautifulSoup și pandas sunt toate gratuite și open-source. Compromisul este timpul: va trebui să gestionezi singur headerele, rotația proxy-urilor și întreținerea selectorilor. Așteaptă-te să investești 4–8 ore pentru configurarea inițială și 4–10 ore pe lună pentru întreținere atunci când Zillow își schimbă site-ul. Thunderbit oferă și el un plan gratuit dacă vrei să eviți complet efortul de codare.

Are Zillow un API oficial?

Zillow și-a retras API-ul public gratuit în septembrie 2021. Accesul se face acum prin Bridge Interactive, care necesită aprobare, costă aproximativ 500 $/lună și este destinat profesioniștilor licențiați din imobiliare. Pentru majoritatea utilizatorilor — investitori, cercetători, agenți care fac analiză de piață — scraping-ul este alternativa practică. Zillow publică totuși gratuit date de cercetare sub formă de CSV descărcabile la zillow.com/research/data/, inclusiv Zillow Home Value Index și Zillow Observed Rent Index.

Cum evit să fiu blocat când fac scraping pe Zillow?

Trei lucruri: (1) folosește headere reale de browser, inclusiv Sec-Ch-Ua — este headerul pe care îl omit cele mai multe tutoriale și primul pe care îl verifică PerimeterX; (2) rotește proxy-uri rezidențiale — IP-urile din datacentere sunt blocate imediat; (3) extrage datele din JSON-ul __NEXT_DATA__ în loc de selectori HTML, ca să eviți defectarea din cauza schimbărilor de layout. Păstrează ritmul la 1 cerere la 3–8 secunde per IP. Sau folosește un instrument precum Thunderbit, care gestionează automat protecția anti-bot.

Care este cea mai bună metodă de a extrage date de pe Zillow fără programare?

Thunderbit AI Web Scraper este cea mai rapidă soluție. Instalează Chrome Extension, deschide o pagină de căutare Zillow, apasă „AI Suggest Fields” pentru detectarea automată a coloanelor, apoi apasă „Scrape”. Exportă în Google Sheets, Excel, Airtable sau Notion fără să scrii cod. AI-ul recitește pagina la fiecare rulare, așa că nu se rupe când Zillow își actualizează layout-ul.

Cât de des își schimbă Zillow structura site-ului și cum afectează asta scrapers-urile?

Zillow lansează actualizări frecvent — uneori săptămânal. Pentru că folosește styled-components, numele claselor CSS se schimbă la fiecare deploy, iar scrapers-urile construite pe selectori CSS se rup în mod regulat. Cea mai rezistentă abordare în Python este extragerea din blob-ul JSON __NEXT_DATA__, care își schimbă structura mult mai rar. Pentru o variantă fără întreținere, AI-ul Thunderbit recitește structura paginii la fiecare extragere și se adaptează automat la modificările de layout.

Află mai mult