Como coletar dados do Zillow com o Massive - um guia para iniciantes

O Zillow é um dos maiores sites imobiliários dos EUA, oferecendo um tesouro de listagens de imóveis, preços de propriedades e análises de mercado. Mas eliminar o Zillow não é fácil: suas defesas anti-bots podem rapidamente interromper seus esforços de extração de dados.

Este guia explica como coletar dados de propriedades do Zillow de forma eficaz usando Proxies residenciais da Massive e Python com Playwright. Você aprenderá a contornar a detecção, extrair dados imobiliários de forma confiável e escalar seu fluxo de trabalho de coleta como um profissional.‍

Por que coletar dados imobiliários da Zillow?

Os dados imobiliários da Zillow são uma mina de ouro para:

• Pesquisa de mercado: Analise anúncios de propriedades, tendências de preços e estatísticas de bairros para obter informações sobre a dinâmica do mercado imobiliário.
• Análise de investimento: Examine os padrões históricos de preços e os indicadores de mercado para avaliar possíveis oportunidades de investimento.
• Análise de localização: Investigue a demografia, as comodidades e as características da propriedade do bairro para apoiar o planejamento do desenvolvimento.
• Pesquisa econômica: Monitore as tendências do mercado imobiliário, índices de preços e indicadores econômicos regionais para estudos acadêmicos ou pesquisas políticas.

Seja você analista de dados, investidor imobiliário ou desenvolvedor de ferramentas de automação de edifícios, coletar dados da Zillow pode fornecer informações valiosas sobre o mercado imobiliário.

O problema: as medidas anti-raspagem da Zillow

A coleta de dados do Zillow apresenta desafios significativos devido aos seus robustos sistemas anti-bot:

• Sistemas de verificação humana: A Zillow emprega a verificação “Pressione e segure” e outros métodos para confirmar que as solicitações são originadas de usuários reais em vez de sistemas automatizados.
• Limitação de taxa: O Zillow monitora cuidadosamente a frequência das solicitações de página e pode restringir temporariamente o acesso se muitas solicitações forem feitas em um curto período.
• Bloqueio de IP: O Zillow pode bloquear o acesso de endereços IP que revelam padrões de atividade incomuns.
• Atualizações dinâmicas do site: A Zillow atualiza regularmente a estrutura e o layout do site, exigindo que seu raspador seja adaptável.

Aqui está um exemplo do que acontece quando um raspador é bloqueado pela verificação humana:

É aí que entram os procuradores, especificamente os residenciais.

Por que usar proxies para raspar o Zillow?

Os proxies atuam como intermediários entre seu raspador e a web. Eles são essenciais para o web scraping Zillow porque ajudam a:

• Evitando proibições de IP: Os proxies permitem que você rotacionar endereços IP, reduzindo significativamente o risco de detecção e bloqueio.
• Acessando conteúdo com restrição geográfica: Alguns anúncios e dados de propriedades estão disponíveis somente em determinadas regiões. Os proxies permitem que você apareça como se estivesse navegando em locais diferentes.
• Ignorando limites de taxa: O Zillow impõe limites ao número de solicitações de um único endereço IP. Os proxies ajudam a distribuir suas solicitações em vários IPs, permitindo que você evite essas restrições.

No entanto, nem todos os proxies são criados da mesma forma.

Proxies residenciais versus de data center: o que funciona melhor?

Por experiência própria, os proxies residenciais superam os de datacenter na eliminação do Zillow. Veja o porquê:

• Os proxies residenciais usam IPs reais vinculados a ISPs e dispositivos reais, fazendo com que apareçam como usuários normais.
• Os proxies de data center, embora mais rápidos e baratos, são facilmente detectados pelos sistemas da Zillow.

Se sua meta for uma raspagem consistente e escalável sem bloqueios, residencial é o caminho a percorrer.

Começando com o Massive

Crie sua conta em partners.joinmassive.com e escolha um plano para suas necessidades. Depois disso, vá para o Painel enorme para recuperar suas credenciais de proxy (nome de usuário e senha).

Etapas de configuração:

Visite o Início rápido seção para personalizar suas configurações de proxy:

1. Escolha seu protocolo preferido (HTTP, HTTPS ou SOCKS5).
2. Selecione entre proxies rotativos ou fixos.‍
3. Defina preferências de segmentação geográfica (país, estado, cidade, CEP ou ASN).

Depois de configurado, você receberá um comando cURL pronto para uso para seu caso de uso específico.

Para recursos avançados, como segmentação com base em localização e sessões fixas, consulte o Documentação Massive. Os documentos fornecem instruções passo a passo para tirar o máximo proveito dos Massive Residential Proxies.

Com essa configuração, você pode usar Massive Proxies para coletar dados de produtos Zillow de uma região específica.

Construindo o Zillow Scraper usando proxies Massive

Vamos construir um raspador Zillow usando Dramaturgo e Massive Proxies. O Playwright automatiza as interações do navegador e lida com conteúdo dinâmico de forma eficaz, enquanto os proxies ajudam a evitar a detecção e contornar as restrições.

Vamos coletar anúncios de imóveis para Chicago (Illinois), extraindo as seguintes informações para cada propriedade:

• Endereço
• Status (por exemplo, Ativo, Pendente)
• Preço
• Número de quartos
• Número de banheiros
• Pés quadrados
• Empresa de listagem
• URL da propriedade

‍1. Configure seu ambiente

Comece criando um ambiente virtual e instalando os pacotes necessários. Você também pode usar Conda ou Poetry, se preferir.

python -m venv zillow_envsource 
zillow_env/bin/activate  # Windows: zillow_env\\Scripts\\activate
pip install playwright python-dotenv
playwright install

‍

Crie um .env arquivo para armazenar suas credenciais do Massive Proxy com segurança.

PROXY_SERVER="your_proxy_server"
PROXY_USERNAME="your_username"
PROXY_PASSWORD="your_password"

‍‍

2. Definir configurações de proxy e navegador

Configure credenciais de proxy e bloqueie ativos desnecessários para otimizar o desempenho e evitar a detecção.

class Config:
    PROXY_SERVER = os.getenv("PROXY_SERVER")
    PROXY_USERNAME = os.getenv("PROXY_USERNAME")
    PROXY_PASSWORD = os.getenv("PROXY_PASSWORD")
    BLOCKED_RESOURCES = ["stylesheet", "image", "media", "font", "imageset"]

‍

O bloqueio de recursos desnecessários, como fontes e imagens, acelera o processo de coleta.

‍

Veja um exemplo da aparência da página quando os recursos são bloqueados:

‍

3. Inicie o navegador com suporte a proxy

Aqui, definimos um contexto de navegador que encaminha solicitações por meio de Massive e filtra conteúdo indesejado.

class AsyncZillowSearchScraper:
    def __init__(self, headless: bool = True):
        self.headless = headless
        self.playwright = None
        self.browser = None
        self.context = None

    async def __aenter__(self):
        self.playwright = await async_playwright().start()

        browser_config = {"headless": self.headless}
        if Config.PROXY_SERVER:
            browser_config["proxy"] = {
                "server": Config.PROXY_SERVER,
                "username": Config.PROXY_USERNAME,
                "password": Config.PROXY_PASSWORD,
            }
        self.browser = await self.playwright.chromium.launch(**browser_config)
        self.context = await self.browser.new_context()
        await self.context.route("**/*", self._route_handler)
        return self

    async def _route_handler(self, route):
        if route.request.resource_type in Config.BLOCKED_RESOURCES:
            await route.abort()
        else:
            await route.continue_()

‍

4. Extrair dados de listagem do Zillow

Cada propriedade no Zillow está contida em um <li> etiqueta. Esses <li> as tags têm uma classe que começa com ListItem, e cada tag representa uma única listagem de propriedades. Dentro desses <li> etiquetas, você encontrará todos os principais detalhes sobre a propriedade, como endereço, preço e características da propriedade

.

Veja como esses <li> as tags são estruturadas:

• O abordar está localizado dentro de um <address> tag com o atributo data-test="endereço do cartão de propriedade”.
• O preço está dentro de um <span> tag com o atributo data-test="preço do cartão de propriedade”.

Detalhes adicionais, como o número de quartos, banheiros e metragem quadrada, estão aninhados em <ul> listas.

Veja como analisamos anúncios de propriedades individuais:

class ListingParser:
    @staticmethod
    async def extract_listing_details(listing) -> Optional[Dict]:
        try:
            data_container = await listing.query_selector(
                'div[class*="property-card-data"]'
            )
            if not data_container:
                return None
            # Extract basic details

            details = {
                "address": None,
                "status": None,
                "price": None,
                "bedrooms": None,
                "bathrooms": None,
                "square_feet": None,
                "listing_company": None,
                "url": None,
            }

            # Get address

            if address_elem := await data_container.query_selector(
                'address[data-test="property-card-addr"]'
            ):
                details["address"] = ListingParser.clean_text(
                    await address_elem.text_content()
                )
            # Get price

            if price_elem := await data_container.query_selector(
                'span[data-test="property-card-price"]'
            ):
                details["price"] = ListingParser.clean_text(
                    await price_elem.text_content()
                )
            # Get property URL

            if url_elem := await data_container.query_selector(
                'a[data-test="property-card-link"]'
            ):
                if url := await url_elem.get_attribute("href"):
                    details["url"] = (
                        f"<https://www.zillow.com>{url}"
                        if not url.startswith("http")
                        else url
                    )
            # ...

            return details
        except Exception as e:
            logger.error(f"Error extracting listing details: {e}")
            return None

‍

5. Percorra e pagine pelos resultados

Simule a rolagem para carregar mais anúncios dinamicamente:

async def _scroll_and_get_listings(self, page):
    last_count = 0
    attempts = 0
    MAX_ATTEMPTS = 20

    while attempts < MAX_ATTEMPTS:
        listings = await page.query_selector_all('article[data-test="property-card"]')
        current_count = len(listings)

        if current_count == last_count:
            break
        last_count = current_count
        await page.evaluate("window.scrollBy(0, 500)")
        await asyncio.sleep(1)
        attempts += 1
    return listings

‍

Clique na próxima página (>) botão para navegar por outras páginas.

Para ir para a próxima página:

next_button = await page.query_selector('a[title="Next page"]:not([disabled])')
if next_button:
    await next_button.click()
    await asyncio.sleep(3)

‍

6. Salvar dados extraídos

Salve seus dados copiados do Zillow em um arquivo JSON. Você também pode convertê-lo em CSV posteriormente.

class ResultsSaver:
    @staticmethod
    def save_results(data, filename="zillow_listings.json"):
        with open(filename, "w", encoding="utf-8") as file:
            json.dump(data, file, indent=4, ensure_ascii=False)
        logger.info(f"Saved {len(data)} listings")

    @staticmethod
    def load_existing_results(filename="zillow_listings.json"):
        try:
            if os.path.exists(filename):
                with open(filename, "r", encoding="utf-8") as file:
                    return json.load(file)
        except Exception as e:
            logger.error(f"Error loading data: {e}")
        return []

‍

7. Execute o raspador

Junte tudo em uma função principal para iniciar o raspador, extrair dados e salvar os resultados.

async def main():
    search_url = "https://www.zillow.com/chicago-il/"
    max_pages = None  # Set to a number to limit pages

    async with AsyncZillowSearchScraper(headless=False) as scraper:
        results = await scraper.scrape_search_results(search_url, max_pages=max_pages)
    print(f"\\nTotal listings scraped: {len(results)}")
    if results:
        print("\\nSample listing:")
        print(json.dumps(results[0], indent=2, ensure_ascii=False))


if __name__ == "__main__":
    asyncio.run(main())

‍

Saída de amostra

Depois de configurar e executar com sucesso seu raspador Zillow usando proxies Massive, sua saída ficará mais ou menos assim:

[
    {
        "address": "722 N Trumbull Ave, Chicago, IL 60624",
        "status": "Active",
        "price": "$399,000",
        "bedrooms": "5",
        "bathrooms": "3",
        "square_feet": "2250",
        "listing_company": "REMAX LEGENDS",
        "url": "https://www.zillow.com/homedetails/722-N-Trumbull-Ave-Chicago-IL-60624/3810331_zpid/",
    }
]

Os dados agora estão estruturados e utilizáveis, perfeitos para análises imobiliárias, painéis ou ferramentas de investimento.

‍

Você pode acessar o código completo para coletar dados do Zillow usando proxies Massive em GitHub Gist.

Conclusão

A coleta de dados imobiliários da Zillow oferece uma vantagem na compreensão do mercado, no rastreamento de propriedades e nas ferramentas de automação predial. Com os proxies residenciais da Massive, você pode:

• Extraia dados sem ficar bloqueado
• Segmente CEPs ou cidades específicas
• Automatize seu fluxo de trabalho de resultados de pesquisa do Zillow
• Extraia dados de propriedades Zillow limpos e estruturados

Pronto para criar seu próprio raspador de dados Zillow? Inscreva-se no Massive Proxies hoje.