In this Article
El scraping de datos inmobiliarios es la forma en que las plataformas de propiedades, los inversionistas y los equipos de proptech convierten listados en línea dispersos en un conjunto de datos estructurado: precios, direcciones, habitaciones, baños, superficie en pies cuadrados y tendencias en todo un mercado. Esta guía muestra cómo hacer scraping de listados de propiedades con Python de la forma robusta (analizando los datos estructurados que los sitios ya incorporan), además de la configuración anti-bot y de proxies que mantiene la recopilación en funcionamiento en distintas regiones.
Soy Andrii Byzov, un AI-Native Fractional CMO que crea pipelines de datos web. A continuación: qué datos inmobiliarios puedes recopilar, una línea legal clara y código funcional para resultados de búsqueda y listados individuales, con proxies residenciales para obtener datos geográficamente precisos y sin bloqueos.
Datos clave
- La mayoría de los datos de los listados son públicos y de menor riesgo — precio, habitaciones/baños, sqft, tipo — pero las direcciones, fotos, descripciones y nombres de agentes pueden ser datos personales o estar protegidos por derechos de autor, así que evalúa antes de reutilizarlos.
- Analiza el JSON incrustado cuando esté presente, no CSS frágil. Muchos sitios inmobiliarios exponen los datos de los listados como JSON-LD (schema.org); analízalo cuando esté disponible y recurre a las tarjetas HTML cuando no lo esté.
- Algunos sitios personalizan por ubicación — resultados, disponibilidad, idioma o moneda — por lo que los proxies con segmentación geográfica ayudan a coincidir con un mercado específico.
- Los grandes portales se defienden con fuerza. Zillow, Realtor.com, Rightmove y sitios similares limitan la tasa y marcan rápidamente las IPs de centros de datos; los proxies residenciales rotativos ayudan, pero ninguna herramienta garantiza el acceso ni el cumplimiento.
- Los datos de contacto de agentes y propietarios son datos personales. Mantenlos fuera del pipeline; recopila datos de propiedades, no de personas.
¿Qué datos inmobiliarios puedes extraer?
Un anuncio de propiedad contiene datos enriquecidos y estructurados. Los campos que generalmente vale la pena recopilar, y los que deben manejarse con cuidado:
- Datos de propiedad de menor riesgo: precio, habitaciones, baños, superficie en pies cuadrados, tamaño del lote, tipo de propiedad, año de construcción, estado del anuncio, días en el mercado e historial de precios.
- Manejar con cuidado o evitar: direcciones exactas, fotos y descripciones completas (a menudo protegidas por derechos de autor), y datos de contacto de agentes/propietarios (datos personales). La disponibilidad pública no hace que estos datos sean automáticamente reutilizables.
¿Es legal extraer datos inmobiliarios?
Recopilar datos públicos de propiedades es ampliamente defendible, y así es como funcionan la inteligencia de precios y el proptech, pero la disponibilidad pública no hace automáticamente que los datos no sean personales o reutilizables: evalúa la privacidad, los derechos de autor, los derechos sobre bases de datos, los contratos y la legislación local. La línea práctica: no extraigas datos detrás de un inicio de sesión, excluye los datos personales (detalles de agentes/propietarios), no republices fotos o descripciones protegidas por derechos de autor, respeta los términos y robots.txt de cada sitio, y no eludas controles de acceso ni CAPTCHAs. Los grandes portales restringen el acceso automatizado, así que para ellos es preferible usar una API oficial, un feed de datos con licencia o permiso por escrito. Para ver el marco completo, consulta nuestra guía sobre si el web scraping es legal. Esta es información general, no asesoramiento legal.
Paso 1 — Configura tu entorno
Instala las bibliotecas que necesita el scraper inmobiliario. Los sitios estáticos compatibles con JSON-LD funcionan con requests; los portales con mucho JavaScript como Zillow necesitan un navegador headless.
# Core libraries for real estate data scraping
# requests -> fetch pages | beautifulsoup4 + lxml -> parse HTML/JSON
pip install requests beautifulsoup4 lxml
# Many listing sites are JavaScript-heavy and well defended (e.g. Zillow).
# For those, add a headless browser:
pip install playwright && playwright install chromium
Paso 2 — Obtener una página de listados
Extrae una página de resultados de búsqueda (la URL de viviendas en venta de una ciudad) con encabezados adecuados, enrutada a través de un proxy residencial para que los listados coincidan con el mercado objetivo.
import requests
HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
"Accept-Language": "en-US,en;q=0.9"}
# Route through residential proxies for geo-accurate listings (see Step 5)
proxies = {"http": "http://LOGIN:[email protected]:823",
"https": "http://LOGIN:[email protected]:823"}
def get_html(url):
r = requests.get(url, headers=HEADERS, proxies=proxies, timeout=30)
r.raise_for_status()
return r.text
html = get_html("https://example-realestate.com/homes/for_sale/CityName/")
Paso 3 — Extraer listados desde JSON incrustado
Cuando está disponible, la forma más confiable de extraer listados de propiedades es leer los datos estructurados que el sitio ya incrusta. Muchas plataformas inmobiliarias incluyen application/ld+json (schema.org) con el precio, la dirección y la URL de un listado — estables ante rediseños, a diferencia de los nombres de clases CSS. No todos los sitios lo exponen (algunos mantienen los datos en el estado de la app JS), así que revisa cada uno y recurre al análisis de las tarjetas en el Paso 4.
import json
from bs4 import BeautifulSoup
LISTING_TYPES = ("Residence", "Product", "RealEstateListing", "Offer",
"SingleFamilyResidence", "Apartment", "House")
def listings_from_jsonld(html):
"""Where available, sites embed listing data as JSON-LD (schema.org).
Parsing it is more stable than CSS classes — but not every site has it,
so fall back to the cards in Step 4 when this returns nothing."""
soup = BeautifulSoup(html, "lxml")
nodes, out = [], []
for tag in soup.find_all("script", type="application/ld+json"):
try:
data = json.loads(tag.string or "{}")
except json.JSONDecodeError:
continue
stack = data if isinstance(data, list) else [data]
while stack: # flatten @graph / ItemList / nested
n = stack.pop()
if not isinstance(n, dict):
continue
if "@graph" in n:
stack.extend(n["@graph"])
if n.get("@type") == "ItemList":
stack.extend(x.get("item", x) for x in n.get("itemListElement", []))
nodes.append(n)
for n in nodes:
types = n.get("@type", "")
types = types if isinstance(types, list) else [types]
if any(t in LISTING_TYPES for t in types):
offers = n.get("offers") or {}
if isinstance(offers, list):
offers = offers[0] if offers else {}
out.append({"name": n.get("name"),
"price": offers.get("price") or n.get("price"),
"address": n.get("address"),
"url": n.get("url")})
return out
print(listings_from_jsonld(html)[:3])
Paso 4 — Analizar las tarjetas de anuncios (fallback)
Cuando un sitio no expone JSON-LD limpio, analiza directamente las tarjetas de resultados de búsqueda: precio, dirección, habitaciones, baños, pies cuadrados y el enlace del anuncio. Los selectores varían según el sitio y cambian con frecuencia, así que confírmalos en DevTools.
def parse_listing_cards(html):
"""Fallback: parse the search-results cards directly. Selectors differ by
site and change often — confirm the current ones in DevTools."""
soup = BeautifulSoup(html, "lxml")
cards = []
for card in soup.select("[data-test='property-card']"):
def t(sel):
el = card.select_one(sel)
return el.get_text(strip=True) if el else None
cards.append({
"price": t("[data-test='property-price']"),
"address": t("[data-test='property-address']"),
"beds": t("[data-test='property-beds']"),
"baths": t("[data-test='property-baths']"),
"sqft": t("[data-test='property-sqft']"),
"url": (card.select_one("a[href]") or {}).get("href"),
})
return cards
Paso 5 — Gestionar la paginación
Una página de resultados no es un conjunto de datos. Recorre las páginas en bucle hasta que se agoten los resultados o alcances un límite, espaciando las solicitudes para no activar los límites de tasa.
import time, random
def scrape_all_pages(base_url, max_pages=10):
"""Page through search results until empty or max_pages."""
all_listings = []
for page in range(1, max_pages + 1):
html = get_html(f"{base_url}?page={page}")
cards = parse_listing_cards(html)
if not cards: # no more results -> stop
break
all_listings.extend(cards)
time.sleep(random.uniform(1, 3)) # pace requests
return all_listings
Paso 6 — Usa proxies para obtener datos geográficamente precisos y desbloqueados
Dos cosas hacen que el web scraping inmobiliario sea más difícil sin proxies. Primero, la ubicación: algunos sitios personalizan los resultados, la disponibilidad, el idioma o la moneda según la región, por lo que, para coincidir con un mercado específico, haces la consulta desde una IP de allí. Segundo, el bloqueo: los grandes portales detectan rápidamente las IPs de centros de datos y aplican límites de tasa de forma agresiva. Los proxies residenciales de DataImpulse ($1/GB, rotativos, 195 países con segmentación por ciudad/estado) ayudan con ambas cosas: IPs de usuarios reales en el mercado correcto que reducen los bloqueos basados en IP, aunque el acceso no está garantizado y aun así debes seguir las reglas de cada sitio. Enruta las solicitudes a través de ellos y exporta los datos que recopilaste.
import time, random, json, csv
# Listings differ by region: route through a proxy in the target market so
# prices, availability, and currency match what a local user sees.
proxies = {
"http": "http://LOGIN__cr.us;sid.re1:[email protected]:823",
"https": "http://LOGIN__cr.us;sid.re1:[email protected]:823",
}
listings = scrape_all_pages("https://example-realestate.com/homes/for_sale/CityName/")
with open("listings.json", "w", encoding="utf-8") as f:
json.dump(listings, f, indent=2, ensure_ascii=False)
if listings:
with open("listings.csv", "w", newline="", encoding="utf-8") as f:
w = csv.DictWriter(f, fieldnames=listings[0].keys())
w.writeheader(); w.writerows(listings)
Preguntas frecuentes
¿Es legal extraer datos inmobiliarios?
Recopilar datos públicos y no personales de propiedades (precio, dirección, habitaciones, pies cuadrados) es ampliamente defendible y estándar en proptech. Evita los datos personales (contactos de agentes/propietarios), no extraigas datos detrás de inicios de sesión, no republices fotos ni descripciones protegidas por derechos de autor, y respeta los términos del sitio y robots.txt. Los grandes portales restringen el acceso automatizado, así que obtén permiso o asesoría legal para uso comercial. Esta es información general, no asesoría legal — consulta nuestra guía sobre la legalidad del web scraping.
¿Cuál es la mejor forma de extraer listados de propiedades?
Analiza los datos estructurados que los sitios ya incorporan — la mayoría de las plataformas inmobiliarias incluyen listados como JSON-LD (schema.org) en el HTML de la página, lo que es mucho más estable que perseguir nombres de clases CSS que cambian con cada rediseño. Recurre al análisis de las tarjetas de listado solo cuando no haya JSON limpio disponible.
¿Necesito proxies para extraer datos de sitios inmobiliarios?
Para volumen, generalmente sí. Los grandes portales (Zillow, Realtor.com, Rightmove) limitan la frecuencia y marcan IPs de centros de datos rápidamente, y algunos listados dependen de la ubicación. Los proxies residenciales rotativos en el mercado objetivo ayudan a devolver datos precisos según la ubicación y a reducir los bloqueos basados en IP — aunque no garantizan el acceso ni hacen que el scraping cumpla con las normas.
¿Puedo extraer datos directamente de Zillow o Realtor.com?
Son públicos, pero están muy protegidos, renderizados con JavaScript, y sus términos restringen el acceso automatizado. Para esos portales, prefiere una API oficial, un feed de datos con licencia o un permiso por escrito en lugar de evadir sus defensas. Si recopilas datos públicos, toma solo datos públicos de propiedades, permanece sin iniciar sesión, no eludas controles de acceso y espacia las solicitudes. Consulta nuestra guía de mejores proxies para Zillow.
¿Qué datos inmobiliarios puedo recopilar?
Principalmente datos públicos de propiedades — precio, habitaciones, baños, superficie en pies cuadrados, tamaño del lote, tipo, estado, días en el mercado, historial de precios. Pero la disponibilidad pública no convierte automáticamente los datos en no personales o reutilizables: las direcciones exactas, fotos, descripciones y detalles de agentes/propietarios pueden tener implicaciones de privacidad o derechos de autor, así que evalúalos antes de almacenarlos o republicarlos.
Conclusión
El scraping de datos inmobiliarios convierte listados dispersos en un conjunto de datos utilizable, y la fórmula confiable es: leer el JSON-LD incrustado cuando sea posible, recurrir al análisis de tarjetas cuando no lo sea, recorrer los resultados página por página y enrutar todo a través de proxies residenciales con segmentación geográfica para que los datos sean precisos según la ubicación y no estén bloqueados. Limítate a datos públicos y no personales sobre propiedades, y te mantendrás en un terreno defendible. Para la infraestructura, consulta best proxies for real estate data y la guía más amplia best proxies for web scraping.
Última actualización: June 25, 2026.