Cómo raspar Realtor.com: Guía práctica 2026

Saber cómo extraer datos de Realtor.com abre la puerta a una larga lista de casos de uso prácticos. Los equipos de inversión recopilan anuncios para realizar análisis de propiedades comparables y entrenar modelos de valoración automatizada (AVM). Las agencias inmobiliarias buscan generar clientes potenciales, detectando propiedades caducadas o que vuelven a salir al mercado antes que la competencia. Los investigadores de mercado realizan un seguimiento de las tendencias de inventario y precios código postal por código postal. Los ingenieros de proptech incorporan los anuncios a los flujos de trabajo de LLM para su enriquecimiento. El denominador común: los anuncios de Realtor.com se actualizan constantemente, por lo que la recopilación manual se vuelve inviable más allá de unas pocas propiedades, y el scraping estructurado es la única forma sensata de mantenerse al día.

La mayoría de los tutoriales se detienen en seis campos. Se pueden extraer muchos más recorriendo tanto los resultados de búsqueda como las páginas de detalles. En una ficha de resultados de búsqueda, los campos fiables son el precio de venta, la dirección completa, el número de dormitorios, el de baños, la superficie, el tamaño del terreno, el estado del anuncio y la URL canónica de la página de detalles.

Sigue cada URL de detalles y podrás extraer:

• Datos de la propiedad: año de construcción, tipo de propiedad, cuotas de la comunidad de propietarios, aparcamiento, dimensiones del terreno
• Equipamientos: calefacción, aire acondicionado, suelos, electrodomésticos, características exteriores
• Geografía: latitud y longitud (útil para la cartografía y las uniones a nivel de código postal)
• Multimedia: URL de las imágenes de la galería de fotos del anuncio
• Agente: nombre del agente, número de teléfono y agencia inmobiliaria
• Metadatos del anuncio: ID de MLS, días en el mercado, historial de precios

Ese es el conjunto de datos que alimenta las comparativas, las listas de clientes potenciales y los AVM, no solo un volcado de precios y direcciones.

Antes de escribir código de scraping, debes comprender a qué te enfrentas. Realtor.com utiliza una pila de protección antibots basada en el comportamiento que va mucho más allá del bloqueo de IP. Los análisis de ingeniería inversa atribuyen la protección a una pila de huellas digitales de tipo Kasada; independientemente de si Kasada es o no el proveedor actual, las señales de detección están bien documentadas en el ámbito de la protección contra bots.

Hay tres capas importantes a la hora de aprender a extraer datos de Realtor.com en un volumen significativo:

1. huellas digitales TLS y JS. Python sin formato requests envía un protocolo de enlace TLS y un orden de encabezados que no coinciden con los navegadores reales, lo que el sistema de Realtor.com puede detectar desde el primer acceso.
2. Correlación de comportamiento. Los proxies de entropía del ratón, los patrones de desplazamiento y las señales de interacción con el DOM se comparan con las distribuciones humanas. Un rastreador que bombardea páginas desde una sola IP no se parece en nada a un humano.
3. Páginas CAPTCHA. Cuando tu puntuación supera el umbral, el cuerpo se convierte en una página de desafío en lugar de listados, a menudo con un código de estado 200, por lo que un rastreador ingenuo ni siquiera se da cuenta de que ha fallado.

Planifica las tres medidas desde el primer día en lugar de añadirlas a toda prisa tras el primer lote de filas vacías.

No hay una única respuesta correcta sobre cómo extraer datos de Realtor.com, pero vale la pena conocer tres vías, y cada una se adapta a un caso de uso diferente.

Recomendación rápida: si eres un equipo de Python que está creando un feed de datos recurrente, utiliza requests además de una API de scraping y analiza el HTML con BeautifulSoup, que es lo que hace esta guía. Recurre a un navegador sin interfaz solo cuando realmente necesites interactuar con una vista que requiera iniciar sesión o que esté muy basada en JS, y trata los scrapers visuales sin código como herramientas puntuales en lugar de como infraestructura de producción.

Antes de entrar en cómo extraer datos de Realtor.com de principio a fin, configura un entorno limpio. Necesitarás Python 3.9 o una versión más reciente, un virtualenv nuevo y cuatro paquetes:

python -m venv .venv && source .venv/bin/activate
pip install requests beautifulsoup4 lxml pandas

También necesitarás una clave API de scraping. En esta guía utilizaremos WebScrapingAPI como capa de solicitud; regístrate, copia tu clave del panel de control y guárdala como variable de entorno para que nunca termine en git:

export WSA_KEY="your_key_here"

Eso es todo lo que hay que configurar. Sin controladores de navegador, sin listas de proxies de las que ocuparse.

Ahora crearemos el scraper propiamente dicho en cinco pasos específicos: inspeccionar el DOM e identificar selectores estables, recuperar páginas de búsqueda a través de la API de scraping, analizar las fichas de anuncios con BeautifulSoup, recorrer los resultados paginados y exportar a JSON, CSV o un DataFrame de pandas. Los bloques de código que aparecen a continuación dan por hecho la configuración de la sección anterior.

Abre los resultados de búsqueda de Realtor.com en Chrome, haz clic con el botón derecho en una ficha de anuncio y selecciona «Inspeccionar». Cada ficha está envuelta en un <li> con data-testid="result-card". Los campos de precio, dirección y metadatos se encuentran dentro de <div>s y <li>que llevan sus propios data-label atributos (pc-price, pc-address, pc-meta-beds, y así sucesivamente).

Realtor.com también vincula cada tarjeta a una clase con hash como BasePropertyCard_propertyCardWrap__abc123. No selecciones por el hash. Esos sufijos se regeneran en cada compilación del front-end y romperán tu rastreador sin previo aviso. Ancla en data-testid los data-label siempre que sea posible. Están ahí explícitamente para las propias pruebas del front-end, lo que los convierte en los puntos de anclaje más estables de los que dispones.

Una vez mapeados los selectores, dirige la solicitud real a través de la API de scraping. La API se encarga de la rotación de proxies residenciales, la renderización de JS y el manejo de CAPTCHA, por lo que tu código se centra en el análisis.

import os, requests

WSA_KEY = os.environ["WSA_KEY"]
SEARCH_URL = "https://www.realtor.com/realestateandhomes-search/Cincinnati_OH"

def fetch(url: str) -> str:
    r = requests.get(
        "https://api.webscrapingapi.com/v2",
        params={
            "api_key": WSA_KEY,
            "url": url,
            "render_js": "1",
            "country": "us",
        },
        timeout=60,
    )
    r.raise_for_status()
    return r.text

html = fetch(SEARCH_URL)

¿Por qué enrutar a través de una API en Realtor.com específicamente? Un requests.get se topará con una página de CAPTCHA en unas pocas llamadas porque la huella digital TLS y el orden de los encabezados no coinciden con los de un navegador real. La API normaliza ambos aspectos por ti y rota la IP residencial en cada solicitud.

Con el HTML en mano, BeautifulSoup lo convierte en algo que puedes consultar. Sé prudente: no todas las fichas contienen todos los campos, así que protege cada búsqueda para que la falta de un solo dato sobre el tamaño del terreno no eche a perder toda la fila.

from bs4 import BeautifulSoup

def parse_cards(html: str) -> list[dict]:
    soup = BeautifulSoup(html, "lxml")
    cards = soup.select('li[data-testid="result-card"]')
    listings = []
    for card in cards:
        def text(sel):
            el = card.select_one(sel)
            return el.get_text(strip=True) if el else None
        link = card.select_one("a[data-testid='card-link']")
        listings.append({
            "price":    text('[data-label="pc-price"]'),
            "address":  text('[data-label="pc-address"]'),
            "beds":     text('[data-label="pc-meta-beds"] span'),
            "baths":    text('[data-label="pc-meta-baths"] span'),
            "sqft":     text('[data-label="pc-meta-sqft"] span'),
            "lot_size": text('[data-label="pc-meta-sqftlot"] span'),
            "url": link["href"] if link and link.has_attr("href") else None,
        })
    return listings

Utilizaremos el url campo en breve para seguir cada anuncio hasta su página de detalles. Si prefieres profundizar en el uso de BeautifulSoup, nuestra guía de análisis de BeautifulSoup en Python es una lectura muy recomendable.

Realtor.com utiliza la paginación con un /pg-N patrón de URL, y cada página de resultados devuelve aproximadamente 42 tarjetas (el número exacto varía, así que no lo trates como una condición de parada). La estrategia más sólida combina un contador de páginas con una comprobación de resultados vacíos:

def scrape_search(base_url: str, max_pages: int = 10) -> list[dict]:
    all_listings = []
    for page in range(1, max_pages + 1):
        page_url = base_url if page == 1 else f"{base_url}/pg-{page}"
        cards = parse_cards(fetch(page_url))
        if not cards:
            break
        all_listings.extend(cards)
    return all_listings

Detener el proceso cuando una página devuelve cero tarjetas es mucho más seguro que confiar en cualquier recuento fijo por página.

Una vez que hayas recopilado los anuncios, pásalos por pandas para eliminar duplicados y exportarlos en cualquier formato que necesites. La URL de la página de detalles es la clave más estable por anuncio.

import pandas as pd

df = pd.DataFrame(scrape_search(SEARCH_URL))
df = df.drop_duplicates(subset="url").reset_index(drop=True)

df.to_json("realtor_listings.json", orient="records", indent=2)
df.to_csv("realtor_listings.csv", index=False)

CSV es la vía más sencilla para Excel y las herramientas de BI. JSON funciona mejor si el código posterior espera objetos anidados, especialmente después de añadir campos de la página de detalles. En cualquier caso, elimina los duplicados antes de exportar, ya que Realtor.com a veces muestra el mismo anuncio en páginas de búsqueda adyacentes.

Las páginas de detalles contienen el conjunto de datos más completo: año de construcción, servicios, contacto del agente, latitud/longitud, fotos. Realtor.com incorpora dos cargas útiles estructuradas:

1. Un <script type="application/ld+json"> según el vocabulario RealEstateListing de schema.org.
2. Una <script id="__NEXT_DATA__"> carga útil (el blob de hidratación de Next.js) con el registro completo de la propiedad.

Ambos están en formato JSON:

import json
from bs4 import BeautifulSoup

def parse_detail(html: str) -> dict:
    soup = BeautifulSoup(html, "lxml")
    raw  = soup.find("script", id="__NEXT_DATA__").string
    prop = json.loads(raw)["props"]["pageProps"]["initialReduxState"]["propertyDetails"]
    coord = (prop.get("location", {}).get("address", {}).get("coordinate") or {})
    adv   = (prop.get("advertisers") or [{}])[0]
    return {
        "year_built": prop.get("description", {}).get("year_built"),
        "lat": coord.get("lat"), "lon": coord.get("lon"),
        "amenities": prop.get("description", {}).get("features", []),
        "agent_name":  adv.get("name"),
        "agent_phone": (adv.get("phones") or [{}])[0].get("number"),
        "brokered_by": adv.get("office", {}).get("name"),
        "photos": [p["href"] for p in (prop.get("photos") or [])],
    }

Esa ruta de clave varía; registra la carga útil sin procesar durante el desarrollo y vuelve a fijarla cuando veas una KeyError. JSON-LD es más estable, pero expone menos campos.

Una vez que tengas un JSON de anuncios limpio, un LLM es la forma más rápida de enriquecerlo. Omite el patrón de «resumir esta página»; divide por anuncio y utiliza indicaciones estructuradas.

Dos procesos que dan resultados:

• Análisis comparativo. Introduce entre cinco y diez anuncios del mismo código postal en una sola solicitud con un esquema JSON que solicite el precio ajustado por metro cuadrado, coincidencias de tipo de vivienda e indicadores de valores atípicos. Obtendrás un informe comparativo en una sola ronda.
• Enriquecimiento de clientes potenciales. Pasa el nombre del agente, la agencia inmobiliaria y la URL del anuncio a un modelo que devuelve una ficha de contacto normalizada con una puntuación de confianza.

Extraer páginas como Markdown en lugar de HTML a través de tu API de scraping reduce el coste de los tokens aproximadamente a la mitad.

Si extraes datos de Realtor.com desde una IP de centro de datos con encabezados predeterminados, te bloquearán. Más allá de lo que una API de scraping gestiona por ti, las medidas de mitigación que marcan la diferencia son:

• Proxies residenciales. Las IP de centros de datos se marcan en masa; la rotación residencial hace que el tráfico parezca de visitantes reales.
• Rotación de encabezados. Aleatoriza User-Agent, Accept-Languagey Sec-Ch-Ua por solicitud, y mantén la coherencia (un UA de iPhone con un encabezado de plataforma Windows delata al instante).
• Limitación de velocidad. Un intervalo de entre tres y seis segundos entre solicitudes te mantiene por debajo de la mayoría de los umbrales de comportamiento.
• Retroceso exponencial. En 403 o 429, espera 2 ** attempt + random.random() y rota la sesión; nunca vuelvas a intentarlo en la misma conexión.

Construir todo eso por tu cuenta es todo un proyecto; la mayoría de los equipos lo delegan.

Las páginas de anuncios de Realtor.com son públicas, por lo que recopilar campos de precio, dirección y estructura para investigación interna suele ser justificable, pero no es un pase libre. Lee los Términos de uso de Realtor.com y el archivo robots.txt antes de crear un proceso de trabajo recurrente. Trata los nombres de los agentes, los números de teléfono y los correos electrónicos como datos personales según la CCPA de California y normativas análogas; recopilarlos para su reventa o para contacto no solicitado te lleva a un terreno regulado.

La mayoría de los errores de los scrapers de Realtor se deben a cinco modos de fallo:

• Lista de anuncios vacía. Estás viendo una página CAPTCHA que ha devuelto un código de estado 200; comprueba el título de la página y, a continuación, activa la renderización de JS en la API.
• Desviación de clase hash. Sustituya cualquier BasePropertyCard_propertyCardWrap__* selector por un data-testid o data-label lookup.
• Picos de 403 / 429. Aumenta el tiempo de espera, rota la sesión y solo aumenta la concurrencia una vez que se estabilice tu tasa de error.
• Campos de detalle faltantes. Se ha __NEXT_DATA__ ruta de la clave se ha movido; registra la carga útil sin procesar y vuelve a fijar las claves.
• Filas duplicadas. Desduplique siempre en la URL del listado antes de exportar.

• Primero los selectores, luego las solicitudes. Ancla en data-testid y data-label , nunca en nombres de clase con hash como BasePropertyCard_propertyCardWrap__*, que se regeneran en cada compilación del front-end.
• En producción, utiliza una API de scraping. El requests accederá a páginas con CAPTCHA en Realtor.com en unas pocas llamadas; una capa de API gestiona los proxies, la renderización de JS y la identificación de TLS en un solo paso.
• Las páginas de detalles multiplican por 10 tu conjunto de datos. El año de construcción, las comodidades, los contactos de los agentes y la latitud/longitud se encuentran en el __NEXT_DATA__ blob y JSON-LD de cada página de propiedad, no en la ficha de resultados de búsqueda.
• Limita el tráfico y retrocede, incluso con una buena API. Aproximadamente de tres a seis segundos de fluctuación, rotación residencial y retroceso exponencial en 403/429 mantienen estables los flujos de trabajo de larga duración.
• Respeta el marco legal. Los datos de los anuncios son públicos; los datos de contacto de los agentes son datos personales. Lee los términos antes de escalar y evita la reventa de campos regulados.

No existe ninguna API pública de uso general para explorar los listados. La empresa matriz de Realtor.com ha ofrecido históricamente acceso a las API web RETS y RESO a través de fuentes de datos MLS, pero estas están restringidas a acuerdos con agentes inmobiliarios o socios, en lugar de estar abiertas a registros de desarrolladores. Para la mayoría de los desarrolladores y analistas independientes, el scraping estructurado de páginas de listados públicos sigue siendo la única vía práctica para obtener datos a gran escala.

Sí, casi de inmediato. La pila antibots de Realtor.com mantiene listas de los principales ASN en la nube y los limita o los bloquea de forma agresiva. Un rastreador que se ejecute en una instancia EC2 o Cloud Run estándar se encontrará con páginas CAPTCHA tras unas pocas llamadas. Necesitarás proxies residenciales o móviles, o una API de rastreo que gestione la rotación de IP de forma transparente.

Los tres están renderizados con React, paginados y protegidos por sistemas anti-bot basados en el comportamiento, pero los detalles de implementación difieren. Zillow se basa en gran medida en su __NEXT_DATA__ carga útil y es agresivo en las comprobaciones de huellas digitales móviles. Redfin expone una API JSON interna más rica utilizada por su frontend. Realtor.com se sitúa entre ambos: data-testid ganchos en las tarjetas más un __NEXT_DATA__ blob en las páginas de detalles.

Para empezar, no dependas de clases con hash. Ancla cada selector en data-testid y data-label , que forman parte del propio contrato de pruebas del front-end y rara vez cambian. Añade una prueba de humo que recupere un anuncio conocido cada mañana y compruebe que el precio no está vacío; luego, avisa cuando falle para que puedas volver a fijar los selectores antes de que el proceso se vacíe silenciosamente.

Un rango inicial útil es de aproximadamente entre tres y seis segundos de retraso aleatorio entre solicitudes por sesión, con entre una y tres sesiones simultáneas, cada una en una IP residencial diferente. Vigila tu tasa de 403/429; si supera el uno o dos por ciento en una hora, reduce aún más la velocidad o rota los proxies de forma más agresiva. El tráfico en ráfagas se marca más rápido que el volumen constante.

Saber cómo extraer datos de Realtor.com de principio a fin consiste principalmente en encajar las piezas correctas en el orden adecuado: fijar selectores estables, enrutar las solicitudes a través de algo que gestione la pila anti-bot por ti, seguir las URL de los anuncios hasta las páginas de detalle para el resto del conjunto de datos y deduplicar antes de exportar. Si lo haces bien, tendrás un proceso que sobrevivirá a la próxima refactorización del front-end en lugar de romperse con ella.

Las partes difíciles —la rotación residencial, el renderizado de JS y el manejo de CAPTCHA— son precisamente lo que atasca a los equipos durante semanas si se desarrollan internamente. También son las partes que más se benefician de delegarse a una capa de solicitudes gestionada, para que tus ingenieros puedan centrarse en el análisis, el modelado y la analítica posterior.

Si prefieres no gestionar tú mismo una flota de proxies, un generador de encabezados y un solucionador de CAPTCHA, nuestra API de scraper en WebScrapingAPI está diseñada precisamente para este tipo de trabajo: devuelve HTML renderizado para cualquier URL que le indiques, gestiona los reintentos en casos de 403/429 y rota IP residenciales en 195 países, de modo que tu scraper parezca 200 personas diferentes navegando por los anuncios de Cincinnati. Incorpóralo a la estructura anterior y el único código que tendrás que mantener será la capa de análisis.