En ce qui concerne le secteur de l'immobilier, l'accès à des données précises et à jour peut vous donner un avantage concurrentiel. Zillow est une plateforme qui est devenue une source incontournable de données sur l'immobilier. Avec sa vaste base de données d'annonces immobilières, de tendances du marché et d'informations sur les quartiers, Zillow est devenue une mine d'or de données précieuses pour les acheteurs, les vendeurs et les professionnels de l'immobilier.

Zillow, qui bénéficie de statistiques de site impressionnantes, enregistre des millions de visites par jour et héberge un nombre impressionnant d'annonces immobilières. Avec une interface conviviale et une gamme variée de fonctionnalités, Zillow attire un public important à la recherche d'informations sur les tendances immobilières et les détails des propriétés.

Visiteurs de Zillow

Les professionnels de l'immobilier s'appuient largement sur des données précises et complètes pour prendre des décisions éclairées. Qu'il s'agisse d'étudier les tendances du marché, d'évaluer les prix de l'immobilier ou d'identifier des opportunités d'investissement, il est essentiel d'avoir accès à des données fiables. Mais l'extraction manuelle des données de Zillow peut être une tâche fastidieuse et chronophage. C'est là que le scraping de données entre en jeu. Le scraping de données de Zillow permet aux professionnels de l'immobilier de collecter et d'analyser de grandes quantités de données rapidement et efficacement, économisant ainsi du temps et des efforts.

Venez explorer le monde du scraping de données Zillow à l'aide de PythonNous commencerons par une approche couramment utilisée, comprendrons ses limites, puis nous nous pencherons sur l'efficacité de la Crawlbase Crawling APIRejoignez-nous dans cette aventure à travers les subtilités du web scraping sur Zillow !

Table des Matières

  1. Comprendre la configuration du scraping Zillow
  • Chemins de recherche de Zillow
  • Données clés disponibles sur Zillow
  1. Configuration de votre environnement Python
  • Installer Python
  • Installation des bibliothèques essentielles
  • Choisir un IDE de développement adapté
  1. Créer un grattoir Zillow
  • Utilisation de la bibliothèque de requêtes de Python
  • Inspectez la page Zillow pour les sélecteurs CSS
  • Analyser du HTML avec BeautifulSoup
  • Inconvénients et défis de l’approche commune
  1. Grattez Zillow avec Crawlbase
  • Crawlbase Inscription et jeton API
  • Accéder au Crawling API avec Crawlbase Bibliothèque
  • Extraction de l'URL des pages de propriétés à partir du SERP
  • Gestion de la pagination pour une récupération de données étendue
  • Extraction de données à partir des URL des pages de propriétés de Zillow
  • Sauvegarde des données Zillow récupérées dans une base de données
  • Avantages de l'utilisation Crawlbase's Crawling API pour le grattage de Zillow
  1. Réflexions finales
  2. Foire Aux Questions (FAQ)

Comprendre la configuration du scraping Zillow

Zillow propose une interface conviviale et une vaste base de données d'annonces immobilières. Avec Zillow, vous pouvez facilement rechercher des propriétés en fonction de l'emplacement souhaité, de la fourchette de prix et d'autres critères spécifiques. La plateforme fournit des informations détaillées sur la propriété, notamment le nombre de chambres et de salles de bains, la superficie en pieds carrés et même des visites virtuelles ou des visites guidées en 3D dans certains cas.

De plus, Zillow va au-delà des simples annonces immobilières. Il fournit également des informations précieuses sur les quartiers et les tendances du marché. Vous pouvez explorer les taux de criminalité, les notes scolaires et les équipements d'une zone particulière pour déterminer s'ils correspondent à vos préférences et à votre style de vie. Les outils de cartographie interactifs de Zillow vous permettent de visualiser la proximité de la propriété avec les équipements à proximité tels que les écoles, les parcs et les centres commerciaux.

Chemins de recherche de Zillow

Zillow propose divers autres filtres de recherche, tels que la fourchette de prix, le type de propriété, le nombre de chambres, etc. En utilisant efficacement ces filtres, vous pouvez affiner votre recherche et extraire des données spécifiques qui correspondent à vos besoins. Les URL sont classées en sections distinctes en fonction des requêtes et des préférences des utilisateurs. Voici des exemples de certaines catégories principales au sein des URL SERP :

  • Annonces de vente: https://www.zillow.com/{location}/sale/?searchQueryState={...}
  • Propriétés vendues: https://www.zillow.com/{location}/sold/?searchQueryState={...}
  • Annonces de location: https://www.zillow.com/{location}/rentals/?searchQueryState={....}

Ces URL représentent des sections spécifiques de la base de données de Zillow, permettant aux utilisateurs d'explorer les propriétés disponibles à la vente, les propriétés récemment vendues ou les annonces de location dans un emplacement particulier.

Principaux points de données pouvant être récupérés sur Zillow

Lorsque vous extrayez des données de Zillow, il est essentiel d'identifier les points de données clés qui correspondent à vos objectifs. Zillow fournit une vaste gamme d'informations, allant des détails de la propriété aux tendances du marché. Voici quelques-uns des points de données essentiels que vous pouvez extraire de Zillow :

Grattez Zillow
  • Description:Contient des informations détaillées sur la propriété, telles que la superficie en pieds carrés, le nombre de chambres et de salles de bains et le type de propriété (par exemple, maison unifamiliale, condo, appartement).
  • Historique des prix:Suivez les informations de prix historiques pour une propriété, permettant aux utilisateurs d'analyser les tendances et les fluctuations de prix au fil du temps.
  • Zillow Zestimation: Outil d'évaluation immobilière exclusif de Zillow qui fournit une estimation de la valeur marchande d'une propriété en fonction de divers facteurs. Il offre un aperçu de la valeur potentielle d'une propriété.
  • Information sur le quartier:Fournit des données sur le quartier, y compris les écoles à proximité, les commodités, les taux de criminalité et d'autres détails pertinents qui contribuent à une compréhension globale de la région.
  • Tendances du marché local:Fournit des informations sur le marché immobilier local, présentant des tendances telles que les prix médians des maisons, les niveaux de stocks et le temps moyen que les propriétés passent sur le marché.
  • Ventes de maisons comparables:Permet aux utilisateurs de comparer les détails et le prix d'une propriété avec des maisons similaires dans la région, facilitant ainsi l'analyse du marché et la prise de décision.
  • Informations de location:Pour les propriétés locatives, Zillow inclut des détails tels que le loyer mensuel, les conditions de location et les équipements, aidant ainsi les locataires et les propriétaires à faire des choix éclairés.
  • Informations sur la taxe foncière:Fournit des données sur les taxes foncières, aidant les utilisateurs à comprendre les implications fiscales associées à une propriété particulière.
  • Caractéristiques et commodités de la maison:Répertorie les caractéristiques et équipements spécifiques disponibles dans une propriété, fournissant un aperçu détaillé aux acheteurs ou locataires potentiels.
  • Cartes interactives:Utilise des cartes pour afficher les emplacements des propriétés, les limites des quartiers et les points d'intérêt à proximité, améliorant ainsi la compréhension spatiale.

Comprendre et exploiter ces points de données clés sur Zillow est essentiel pour toute personne impliquée dans la recherche immobilière, que ce soit pour un usage personnel, des décisions d'investissement ou une analyse de marché.

Comment récupérer des données sur Zillow avec Python

La mise en place d'un environnement Python propice est l'étape fondamentale pour un scraping efficace des données immobilières de Zillow. Voici un bref guide pour préparer votre environnement Python :

Installer Python

Commencez par installer Python sur votre machine. Visitez le site officiel de Python (https://www.python.org/) pour télécharger la dernière version compatible avec votre système d'exploitation.

Lors de l’installation, assurez-vous de cocher la case « Ajouter Python au CHEMIN » pour rendre Python accessible depuis n’importe quelle fenêtre d’invite de commande.

Une fois Python installé, ouvrez une invite de commande ou une fenêtre de terminal et vérifiez l'installation en utilisant la commande suivante :

1
python --version

Installation des bibliothèques essentielles

Pour le scraping web, vous devrez installer des bibliothèques essentielles, telles que requests pour les requêtes HTTP et beautifulsoup4 pour l'analyse HTML. Pour exploiter pleinement Crawlbase Crawling API de manière transparente, installez le Crawlbase Bibliothèque Python également. Utilisez les commandes suivantes :

1
2
3
demandes d'installation pip
pip installer beautifulsoup4
pip installe crawlbase

Choisir un IDE de développement adapté :

Choisir le bon environnement de développement intégré (IDE) peut grandement améliorer votre expérience de codage. Il existe plusieurs IDE parmi lesquels choisir ; en voici quelques-uns parmi les plus populaires :

  • PyCharm: Un IDE puissant et riche en fonctionnalités spécialement conçu pour le développement Python. Il offre une assistance de code intelligente, un débogueur visuel et une prise en charge intégrée du développement Web.
  • VSCode (Code de Visual Studio):Un éditeur de code léger mais puissant qui prend en charge le développement Python. Il est fourni avec une variété d'extensions, ce qui le rend personnalisable selon vos préférences.
  • Jupyter Notebook:Idéal pour les tâches d'analyse et de visualisation de données. Jupyter fournit un environnement interactif et est largement utilisé dans les projets de science des données.
  • Spyder:Un IDE de type MATLAB qui est particulièrement adapté au calcul scientifique et à l'analyse de données. Il est fourni avec la distribution Anaconda.

Choisissez un IDE en fonction de vos préférences et des exigences spécifiques de votre projet de scraping de données immobilières. Assurez-vous que l'IDE sélectionné prend en charge Python et fournit les fonctionnalités dont vous avez besoin pour un codage et un débogage efficaces.

Créer un grattoir Zillow

Dans cette section, nous allons parcourir l'approche courante pour créer un scraper Zillow à l'aide de Python. Cette méthode consiste à utiliser le requests bibliothèque pour récupérer des pages Web et BeautifulSoup pour analyser le HTML afin d'extraire les informations souhaitées.

Dans notre exemple, concentrons-nous sur la recherche de propriétés en vente à Columbia Heights, Washington, DC. Décomposons le processus en éléments digestes :

Utilisation de la bibliothèque de requêtes Python pour le scraping Web Zillow

Le requests La bibliothèque nous permet d'envoyer des requêtes HTTP aux serveurs de Zillow et de récupérer le contenu HTML des pages Web. Voici un extrait de code pour effectuer une requête sur le site Web de Zillow :

1
2
3
4
5
6
7
8
9
10
importer demandes

URL = "https://www.zillow.com/columbia-heights-washington-dc/sale/"
réponse = demandes.get(url)

if réponse.status_code == 200:
    html_content = réponse.texte
    impression(contenu_html)
d'autre:
    impression(f"Échec de la récupération de la page. Code d'état : {réponse.status_code}")

Ouvrez votre éditeur de texte ou IDE préféré, copiez le code fourni et enregistrez-le dans un fichier Python. Par exemple, nommez-le zillow_scraper.py.

Exécutez le script :

Ouvrez votre terminal ou votre invite de commande et accédez au répertoire dans lequel vous avez enregistré zillow_scraper.pyExécutez le script à l’aide de la commande suivante :

1
zillow_scraper.py

Lorsque vous appuyez sur Entrée, votre script prend vie, envoyant une requête au site Web Zillow, récupérant le contenu HTML et l'affichant sur votre terminal.

Capture instantanée de sortie HTML

Inspectez la page Zillow pour les sélecteurs CSS

Avec le contenu HTML obtenu à partir de la page, l’étape suivante consiste à analyser la page Web et à identifier l’emplacement des points de données dont nous avons besoin.

Inspection SERP de Zillow
  1. Outils de développement ouverts:Cliquez simplement avec le bouton droit de la souris sur la page Web dans votre navigateur et choisissez « Inspecter » (ou « Inspecter l'élément »). Cela affichera les outils de développement, vous permettant d'explorer la structure HTML.
  2. Parcourir les éléments HTML:Une fois dans les outils de développement, explorez les éléments HTML pour localiser les données spécifiques que vous souhaitez extraire. Recherchez des identifiants, des classes ou des balises uniques associés aux informations souhaitées.
  3. Identifier les sélecteurs CSS:Prenez note des sélecteurs CSS qui correspondent aux éléments qui vous intéressent. Ces sélecteurs servent de marqueurs essentiels pour votre script Python, l'aidant à identifier et à collecter les données souhaitées.

Analyser du HTML avec BeautifulSoup

Une fois que nous avons récupéré le contenu HTML de Zillow à l'aide de la bibliothèque de requêtes et que les sélecteurs CSS sont entre nos mains, l'étape suivante consiste à analyser ce contenu et à extraire les informations dont nous avons besoin. C'est là que BeautifulSoup entre en jeu, nous aidant à naviguer et à rechercher la structure HTML sans effort.

Dans notre exemple, nous allons récupérer le lien Web vers chaque propriété répertoriée sur la page de recherche Zillow choisie. Ensuite, nous utiliserons ces liens pour extraire des informations clés sur chaque propriété. Maintenant, améliorons notre script existant pour collecter ces informations directement à partir du code HTML.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
importer demandes
allant de bs4 importer BeautifulSoup
importer json

def obtenir_les_urls_de_la_propriété(url):
    en-têtes = {« Agent utilisateur »: « Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64 ; rv:109.0) Gecko/20100101 Firefox/122.0 »}

    réponse = requêtes.get(url, headers=en-têtes)

    URL de la page de propriété = []

    if réponse.status_code == 200:
        soupe = BeautifulSoup(réponse.texte, 'html.parser')

        URL_de_la_page_de_propriété = [propriété['href'] pour propriété in soupe.select('div[id="grid-search-results"] > ul > li[class^="ListItem-"] article[data-test="property-card"] a[data-test="property-card-link"]')]

    d'autre:
        impression(f'Erreur : {réponse.status_code}')

    retourner URL de la page de propriété

def principal†
    URL = "https://www.zillow.com/columbia-heights-washington-dc/sale/"
    résultats = get_property_urls(url)

    impression(json.dumps(résultats, indent=2))

if __nom__ == "__principale__":
    principale()

Mais le code HTML que nous recevons à l'aide des requêtes contiendra-t-il les informations requises ? Voyons le résultat du script ci-dessus :

1
2
3
4
5
6
7
8
9
10
11
[
  "https://www.zillow.com/homedetails/1429-Girard-St-NW-101-Washington-DC-20009/2053968963_zpid/",
  "https://www.zillow.com/homedetails/1439-Euclid-St-NW-APT-301-Washington-DC-20009/68081615_zpid/",
  "https://www.zillow.com/homedetails/1362-Newton-St-NW-Washington-DC-20010/472850_zpid/",
  "https://www.zillow.com/homedetails/1362-Parkwood-Pl-NW-Washington-DC-20010/472302_zpid/",
  "https://www.zillow.com/homedetails/1458-Columbia-Rd-NW-APT-300-Washington-DC-20009/82293130_zpid/",
  "https://www.zillow.com/homedetails/1438-Meridian-Pl-NW-APT-106-Washington-DC-20010/467942_zpid/",
  "https://www.zillow.com/homedetails/2909-13th-St-NW-Washington-DC-20009/473495_zpid/",
  "https://www.zillow.com/homedetails/1421-Columbia-Rd-NW-APT-B4-Washington-DC-20009/467706_zpid/",
  "https://www.zillow.com/homedetails/2516-12th-St-NW-Washington-DC-20009/473993_zpid/"
]

Vous remarquerez que la sortie ne capture qu'une partie des résultats attendus. Cette limitation est due au fait que Zillow utilise JavaScript/Ajax pour charger dynamiquement les résultats de recherche sur sa page SERP. Lorsque vous effectuez une requête HTTP vers l'URL Zillow, la réponse HTML manque d'une partie importante des résultats de recherche, ce qui entraîne l'absence d'informations utiles. Le contenu chargé dynamiquement n'est pas présent dans la réponse HTML initiale, ce qui rend difficile la récupération de l'ensemble complet des données via une requête statique.

Bien que l'approche courante consistant à utiliser la bibliothèque de requêtes Python et BeautifulSoup pour le scraping Zillow soit une méthode simple, elle comporte certains inconvénients et défis tels que la limitation du débit, le blocage IP et la mauvaise gestion du chargement de contenu dynamique.

Grattez Zillow avec Crawlbase

Maintenant, explorons une méthode plus avancée et plus efficace pour le scraping Zillow en utilisant le Crawlbase Crawling API. Cette approche offre plusieurs avantages par rapport à la méthode courante et aborde ses limites. paramètres permettez-nous de gérer diverses tâches de grattage sans effort.

Voici un guide étape par étape pour exploiter la puissance de cette API dédiée :

Crawlbase Création de compte et récupération de jetons API

Lancement du processus d'extraction des données cibles via le Crawlbase Crawling API commence par établir votre présence sur le Crawlbase Plateforme. Voici les étapes à suivre pour créer un compte et obtenir votre jeton API indispensable :

  1. Rendez nous visite Crawlbase:Lancez votre navigateur Web et accédez à l' Inscription page sur la Crawlbase site Web pour commencer votre inscription.
  2. Saisissez vos informations d'identification: Fournissez votre adresse e-mail et créez un mot de passe sécurisé pour votre Crawlbase compte. L'exactitude dans le remplissage des informations requises est cruciale.
  3. Étapes de vérification:Après avoir soumis vos informations, consultez votre boîte de réception pour obtenir un e-mail de vérification. Suivez les étapes décrites dans l'e-mail pour vérifier votre compte.
  4. Connectez-vous à votre compte:Une fois votre compte vérifié, revenez à la Crawlbase site Web et connectez-vous en utilisant les informations d'identification que vous avez créées.
  5. Obtenez votre jeton API:Accéder au Crawlbase Crawling API nécessite un jeton API, que vous pouvez localiser dans votre documentation de compte.

Note rapide: Crawlbase Nous proposons deux types de jetons : l'un pour les sites web statiques, l'autre pour les sites web dynamiques ou JavaScript. Comme nous nous concentrons sur le scraping de Zillow, nous utiliserons le jeton JS. Avantage supplémentaire : Crawlbase étend une allocation initiale de 1,000 XNUMX demandes gratuites pour le Crawling API, ce qui en fait un choix optimal pour notre effort de scraping Web.

Accéder au Crawling API avec Crawlbase Bibliothèque

Le Crawlbase La bibliothèque en Python facilite une interaction transparente avec l'API, vous permettant de l'intégrer sans effort dans votre projet de scraping Zillow. L'extrait de code fourni montre comment initialiser et utiliser le Crawling API par l'intermédiaire du Crawlbase Bibliothèque Python.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
allant de base d'exploration importer API d'exploration

API_TOKEN = 'VOTRE_CRAWLBASE_JS_TOKEN'
crawling_api = API d'exploration({'jeton':API_TOKEN})

URL = "https://www.zillow.com/columbia-heights-washington-dc/sale/"

réponse = crawling_api.get(url)

if réponse['en-têtes']['pc_status']== «200 ':
    html_content = réponse['corps'].décoder(« utf-8 »)
    impression(contenu_html)
d'autre:
    impression(f"Échec de la récupération de la page. Crawlbase code d'état : {réponse['en-têtes']['pc_status']}")

Documentation détaillée de la Crawling API est disponible sur Crawlbase plateforme. Vous pouvez le lire ici.. Si vous voulez en savoir plus sur le Crawlbase Bibliothèque Python et voir des exemples supplémentaires de son utilisation, vous pouvez trouver la documentation ici..

Extraction de l'URL des pages de propriétés à partir du SERP

Pour extraire toutes les URL des pages de propriétés du SERP de Zillow, nous allons améliorer notre script commun en intégrant le Crawling API. Zillow, comme de nombreux sites Web modernes, utilise des éléments dynamiques qui se chargent de manière asynchrone via JavaScript. Nous allons intégrer le ajax_wait haut page_wait paramètres pour garantir que notre script capture toutes les URL de propriétés pertinentes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
allant de base d'exploration importer API d'exploration
allant de bs4 importer BeautifulSoup
importer json

def obtenir_les_urls_de_la_propriété(API, URL):
    choix = {
        'utilisateur_agent': « Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64 ; rv:109.0) Gecko/20100101 Firefox/122.0 »,
        'ajax_wait': 'vrai',
        'page_wait': 5000
    }

    réponse = api.get(url, options)

    URL de la page de propriété = []

    if réponse['en-têtes']['pc_status']== «200 ':
        html_content = réponse['corps'].décoder(« utf-8 »)
        soupe = BeautifulSoup(contenu_html, 'html.parser')

        URL_de_la_page_de_propriété = [propriété['href'] pour propriété in soupe.select('div[id="grid-search-results"] > ul > li[class^="ListItem-"] article[data-test="property-card"] a[data-test="property-card-link"]')]

    d'autre:
        impression(f'Erreur : {réponse["en-têtes"]["pc_status"]}')

    retourner URL de la page de propriété

def principal†
    API_TOKEN = 'VOTRE_CRAWLBASE_JS_TOKEN'
    crawling_api = API d'exploration({'jeton':API_TOKEN})
    serp_url = "https://www.zillow.com/columbia-heights-washington-dc/sale/"

    résultats = get_property_urls(crawling_api, serp_url)

    impression(json.dumps(résultats, indent=2))

if __nom__ == "__principale__":
    principale()

Exemple de sortie :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[
  "https://www.zillow.com/homedetails/1429-Girard-St-NW-101-Washington-DC-20009/2053968963_zpid/",
  "https://www.zillow.com/homedetails/1439-Euclid-St-NW-APT-301-Washington-DC-20009/68081615_zpid/",
  "https://www.zillow.com/homedetails/1362-Newton-St-NW-Washington-DC-20010/472850_zpid/",
  "https://www.zillow.com/homedetails/1362-Parkwood-Pl-NW-Washington-DC-20010/472302_zpid/",
  "https://www.zillow.com/homedetails/1458-Columbia-Rd-NW-APT-300-Washington-DC-20009/82293130_zpid/",
  "https://www.zillow.com/homedetails/1438-Meridian-Pl-NW-APT-106-Washington-DC-20010/467942_zpid/",
  "https://www.zillow.com/homedetails/2909-13th-St-NW-Washington-DC-20009/473495_zpid/",
  "https://www.zillow.com/homedetails/1421-Columbia-Rd-NW-APT-B4-Washington-DC-20009/467706_zpid/",
  "https://www.zillow.com/homedetails/2516-12th-St-NW-Washington-DC-20009/473993_zpid/",
  "https://www.zillow.com/homedetails/2617-University-Pl-NW-1-Washington-DC-20009/334524041_zpid/",
  "https://www.zillow.com/homedetails/1344-Kenyon-St-NW-Washington-DC-20010/473267_zpid/",
  "https://www.zillow.com/homedetails/2920-Georgia-Ave-NW-UNIT-304-Washington-DC-20001/126228603_zpid/",
  "https://www.zillow.com/homedetails/2829-13th-St-NW-1-Washington-DC-20009/2055076326_zpid/",
  "https://www.zillow.com/homedetails/1372-Monroe-St-NW-UNIT-A-Washington-DC-20010/71722141_zpid/"
  ..... plus
]

Gestion de la pagination pour une récupération de données étendue

Pour garantir une récupération complète des données à partir de Zillow, nous devons aborder la pagination. Zillow organise les résultats de recherche sur plusieurs pages, chacune identifiée par un numéro de page dans l'URL. Zillow utilise le {pageNo}_p Paramètre de chemin pour la gestion de la pagination. Modifions notre script existant pour gérer la pagination et collecter les URL de propriétés de plusieurs pages.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
allant de base d'exploration importer API d'exploration
allant de bs4 importer BeautifulSoup
importer fois
importer json

def récupérer_html(api, url, options, max_retries=2):
    tentatives = 0
    tout en tentatives <= max_retries :
        Essai:
            réponse = api.get(url, options)

            if réponse['en-têtes']['pc_status']== «200 ':
                retourner réponse['corps'].décoder(« utf-8 »)
            d'autre:
                augmenter Exception(f'Réponse avec pc_status : {réponse["en-têtes"]["pc_status"]}')

        sauf Exception as e:
            impression(f'Exception : {str(e)}')
            tentatives += 1
            if tentatives <= max_retries :
                impression(f'Réessayer ({réessais}/{max_retries})...')
                temps.sommeil(1)

    impression(f'Nombre maximal de tentatives atteint. Impossible de récupérer les données de {URL}')
    retourner Aucun

def obtenir_les_urls_de_la_propriété(api, base_url, options, max_pages):
    # Récupérez la première page pour déterminer le nombre réel de pages
    première_page_url = f"{base_url}1_p/"
    première_page_html = fetch_html(api, première_page_url, options)

    if première_page_html is pas Aucun:
        première_page_soup = BeautifulSoup(première_page_html, 'html.parser')

        # Extraire le nombre total de pages disponibles
        pagination_max_element = first_page_soup.select_one('div.search-pagination > nav > li:nth-last-child(3)')
        nombre_total = int(pagination_max_element.texte) if pagination_max_element d'autre 1
    d'autre:
        retourner []

    # Déterminer le nombre final de pages à extraire
    pages_max_actuelles = m.(nombre_total_de_pages, nombre_max_de_pages)

    all_property_page_urls = []

    pour numéro de page in gamme(1, nombre_max_de_pages_actuels + 1):
        URL = f"{base_url}{numéro_de_page}_p/"
        page_html = fetch_html(api, url, options)

        if page_html is pas Aucun:
            soupe = BeautifulSoup(page_html, 'html.parser')

            URL_de_la_page_de_propriété = [propriété['href'] pour propriété in soupe.select('div[id="grid-search-results"] > ul > li[class^="ListItem-"] article[data-test="property-card"] a[data-test="property-card-link"]')]

            all_property_page_urls.extend(property_page_urls)

    retourner toutes_les_urls_des_pages_de_propriétés

def principal†
    API_TOKEN = 'VOTRE_CRAWLBASE_JS_TOKEN'
    crawling_api = API d'exploration({'jeton':API_TOKEN})
    serp_url = "https://www.zillow.com/columbia-heights-washington-dc/sale/"
    choix = {
        'utilisateur_agent': « Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64 ; rv:109.0) Gecko/20100101 Firefox/122.0 »,
        'ajax_wait': 'vrai',
        'page_wait': 5000
    }
    max_pages = 2  # Ajustez le nombre de pages à extraire selon vos besoins

    property_page_urls = get_property_urls(crawling_api, serp_url, options, max_pages)

    # traiter davantage les property_page_urls

if __nom__ == "__principale__":
    principale()

La première fonction, fetch_html, est conçu pour récupérer le contenu HTML d'une URL donnée à l'aide d'une API, avec la possibilité de spécifier des paramètres. Il intègre un mécanisme de nouvelle tentative, tentant la requête jusqu'à un nombre de fois spécifié (la valeur par défaut est 2) en cas d'erreurs ou de dépassements de délai. La fonction renvoie le contenu HTML décodé si le serveur répond avec un état de réussite (HTTP 200), et dans le cas contraire, elle génère une exception avec des détails sur l'état de la réponse.

La deuxième fonction, get_property_urls, vise à collecter les URL de propriétés de plusieurs pages sur un site Web spécifié. Il récupère d'abord le contenu HTML de la page initiale pour déterminer le nombre total de pages disponibles. Ensuite, il parcourt les pages, récupère et analyse le code HTML pour extraire les URL de propriétés. Le nombre maximal de pages à extraire est déterminé par le minimum du nombre total de pages disponibles et le paramètre de pages maximal spécifié. La fonction renvoie une liste d'URL de propriétés collectées à partir du nombre de pages spécifié.

Extraction de données à partir des URL des pages de propriétés de Zillow

Maintenant que nous disposons d'une liste complète des URL des pages de propriétés, l'étape suivante consiste à extraire les données nécessaires de chaque page de propriété. Améliorons notre script pour parcourir ces URL et recueillir des détails pertinents tels que le type de propriété, l'adresse, le prix, la taille, le nombre de chambres et de salles de bains et d'autres points de données essentiels.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
allant de base d'exploration importer API d'exploration
allant de bs4 importer BeautifulSoup
importer fois
importer json

def récupérer_html(API, URL, options):
    # ... (inchangé)

def obtenir_les_urls_de_la_propriété(api, base_url, options, max_pages):
    # ... (inchangé)

def scrape_properties_data(API, URL, options):
    propriétés_données = []

    pour url in URL:
        page_html = fetch_html(api, url, options)

        if page_html is pas Aucun:
            soupe = BeautifulSoup(page_html, 'html.parser')
            type_element = soupe.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(3) div.dBmBNo:first-child > span')
            builtin_year_element = soupe.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(3) div.dBmBNo:nth-child(2) > span')

            address_element = soup.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(2) div[class^="styles__AddressWrapper-"] > h1')
            price_element = soupe.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(2) span[data-testid="price"] > span')
            size_element = soupe.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(2) div[data-testid="bed-bath-sqft-facts"] > div[data-testid="bed-bath-sqft-fact-container"]:last-child > span:first-child')
            bedroom_element = soup.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(2) div[data-testid="bed-bath-sqft-facts"] > div[data-testid="bed-bath-sqft-fact-container"]:first-child > span:first-child')
            salles de bains_element = soup.select_one('div[data-testid="macro-data-view"] > div[data-renderstrat="inline"]:nth-child(2) div[data-testid="bed-bath-sqft-facts"] > bouton > div[data-testid="bed-bath-sqft-fact-container"] > span:first-child')

            données_propriété = {
                'URL de la propriété': URL,
                'taper': type_element.text.strip() if type_élément d'autre Aucun,
                'adresse': address_element.text.strip() if élément_adresse d'autre Aucun,
                'taille': size_element.text.strip() if élément_taille d'autre Aucun,
                'prix': élément_prix.texte.strip() if élément_prix d'autre Aucun,
                'chambres':bedrooms_element.text.strip() if chambres_element d'autre Aucun,
                'salles de bains':éléments_salles_de_bains.texte.strip() if salle de bain_element d'autre Aucun,
                'année de construction': élément_année_intégré.texte.strip() if élément_année_intégré d'autre Aucun,
            }

            propriétés_données.append(property_data)

    retourner propriétés_données

def principal†
    API_TOKEN = 'VOTRE_CRAWLBASE_JS_TOKEN'
    crawling_api = API d'exploration({'jeton':API_TOKEN})
    serp_url = "https://www.zillow.com/columbia-heights-washington-dc/sale/"
    choix = {
        'utilisateur_agent': « Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64 ; rv:109.0) Gecko/20100101 Firefox/122.0 »,
        'ajax_wait': 'vrai',
        'page_wait': 5000
    }
    max_pages = 2  # Ajustez le nombre de pages à extraire selon vos besoins

    property_page_urls = get_property_urls(crawling_api, serp_url, options, max_pages)

    propriétés_données = scrape_properties_data(crawling_api, property_page_urls, options)

    impression(json.dumps(properties_data, indent=2))

if __nom__ == "__principale__":
    principale()

Ce script présente le scrape_properties_data Fonction qui récupère le contenu HTML de chaque URL de page de propriété et extrait les détails dont nous avons besoin. Ajustez les points de données en fonction de vos besoins et un traitement supplémentaire peut être effectué si nécessaire.

Exemple de sortie :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
[
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/1008-Fairmont-St-NW-Washington-DC-20001/473889_zpid/",
    "type": "Maison de ville",
    "adresse": « 1008 Fairmont St NW, Washington, DC 00 »,
    "Taille": "1,801",
    "prix": «$ 850,000»,
    "chambres": "3",
    "salles de bains": "4",
    "année de construction": "Construit en 1910"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/1429-Girard-St-NW-101-Washington-DC-20009/2053968963_zpid/",
    "type": « Coopérative boursière »,
    "adresse": « 1429 Girard St NW #101, Washington, DC 00 »,
    "Taille": "965",
    "prix": «$ 114,745»,
    "chambres": "2",
    "salles de bains": "1",
    "année de construction": "Construit en 1966"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/1362-Parkwood-Pl-NW-Washington-DC-20010/472302_zpid/",
    "type": "Résidence unifamiliale",
    "adresse": « 1362 Parkwood Pl NW, Washington, DC 00 »,
    "Taille": "1,760",
    "prix": «$ 675,000»,
    "chambres": "3",
    "salles de bains": "2",
    "année de construction": "Construit en 1911"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/3128-Sherman-Ave-NW-APT-1-Washington-DC-20010/2076798673_zpid/",
    "type": « Coopérative boursière »,
    "adresse": « 3128 Sherman Ave NW APT 1,\u00a0Washington, DC 20010 »,
    "Taille": "610",
    "prix": «$ 117,000»,
    "chambres": "1",
    "salles de bains": "1",
    "année de construction": "Construit en 1955"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/1438-Meridian-Pl-NW-APT-106-Washington-DC-20010/467942_zpid/",
    "type": "Condominium",
    "adresse": « 1438 Meridian Pl NW APT 106, Washington, DC 00 »,
    "Taille": "634",
    "prix": «$ 385,000»,
    "chambres": "2",
    "salles de bains": "2",
    "année de construction": "Construit en 1910"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/2909-13th-St-NW-Washington-DC-20009/473495_zpid/",
    "type": "Maison de ville",
    "adresse": « 2909 13th St NW,\u00a0Washington, DC 20009 »,
    "Taille": "3,950",
    "prix": «$ 1,025,000»,
    "chambres": "7",
    "salles de bains": "3",
    "année de construction": "Construit en 1909"
  },
  {
    "URL de la propriété": "https://www.zillow.com/homedetails/1412-Chapin-St-NW-APT-1-Washington-DC-20009/183133784_zpid/",
    "type": "Condominium",
    "adresse": « 1412 Chapin St NW APT 1,\u00a0Washington, DC 20009 »,
    "Taille": "724",
    "prix": «$ 550,000»,
    "chambres": "2",
    "salles de bains": "2",
    "année de construction": "Construit en 2015"
  },
  ..... plus
]

Sauvegarde des données Zillow récupérées dans une base de données

Une fois que vous avez extrait avec succès les données souhaitées des pages de propriétés de Zillow, il est recommandé de stocker ces informations de manière systématique. Une méthode efficace consiste à utiliser une base de données SQLite pour organiser et gérer vos données immobilières récupérées. Vous trouverez ci-dessous une version améliorée du script permettant d'intégrer la fonctionnalité SQLite et de sauvegarder les données récupérées :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
allant de base d'exploration importer API d'exploration
allant de bs4 importer BeautifulSoup
importer sqlite3
importer fois

def récupérer_html(API, URL, options):
    # ... (inchangé)

def obtenir_les_urls_de_la_propriété(api, base_url, options, max_pages):
    # ... (inchangé)

def scrape_properties_data(API, URL, options):
    # ... (inchangé)

def initialiser_base_de_données(chemin_base_de_donnees='zillow_properties_data.db'):
    # Établir une connexion à la base de données SQLite
    connexion = sqlite3.connect(chemin_base_de_données)
    curseur = connexion.curseur()

    # Créer la table « propriétés » si elle n'existe pas
    curseur.execute('' '
        propriétés CREATE TABLE IF NOT EXISTS (
            id CLÉ PRIMAIRE ENTIER,
            url TEXTE,
            tapez TEXTE,
            adresse TEXTE,
            prix TEXTE,
            taille TEXTE,
            chambres TEXTE,
            salles de bains TEXTE,
            année_de_construction TEXTE
        )
    '' ')

    # Validez les modifications et fermez la connexion
    connexion.commit()
    connexion.close()

def insérer_dans_la_base_de_données(données_propriété, chemin_base_de_données='zillow_properties_data.db'):
    # Établir une connexion à la base de données SQLite
    connexion = sqlite3.connect(chemin_base_de_données)
    curseur = connexion.curseur()

    # Insérer les données de propriété dans la table « propriétés »
    curseur.execute('' '
        INSÉRER DANS les propriétés (url, type, adresse, prix, taille, chambres, salles de bains, année de construction)
        VALEURS (?, ?, ?, ?, ?, ?, ?, ?, ?)
    '' ', (
        propriété_données.get('URL de la propriété'),
        propriété_données.get('taper'),
        propriété_données.get('adresse'),
        propriété_données.get('prix'),
        propriété_données.get('taille'),
        propriété_données.get('chambres'),
        propriété_données.get('salles de bains'),
        propriété_données.get('année de construction')
    ))

    # Validez les modifications et fermez la connexion
    connexion.commit()
    connexion.close()

def principal†
    API_TOKEN = 'VOTRE_CRAWLBASE_JS_TOKEN'
    crawling_api = API d'exploration({'jeton':API_TOKEN})
    serp_url = "https://www.zillow.com/columbia-heights-washington-dc/sale/"
    choix = {
        'utilisateur_agent': « Mozilla/5.0 (Windows NT 10.0 ; Win64 ; x64 ; rv:109.0) Gecko/20100101 Firefox/122.0 »,
        'ajax_wait': 'vrai',
        'page_wait': 5000
    }
    max_pages = 2  # Ajustez le nombre de pages à extraire selon vos besoins

    # Initialiser la base de données
    initialiser_base_de_données()

    property_page_urls = get_property_urls(crawling_api, serp_url, options, max_pages)

    propriétés_données = scrape_properties_data(crawling_api, property_page_urls, options)

    # Insérer des données dans la base de données
    pour données_de_propriété in propriétés_données :
        insert_into_database(données_de_propriété)


if __nom__ == "__principale__":
    principale()

Ce script introduit deux fonctions : initialize_database pour configurer la table de base de données SQLite, et insert_into_database pour insérer les données de chaque propriété dans la base de données. Le fichier de base de données SQLite (zillow_properties_data.db) sera créé dans le répertoire du script. Ajustez la structure du tableau et la logique d'insertion en fonction de vos points de données spécifiques.

properties Aperçu du tableau :

Aperçu du tableau des propriétés

Avantages de l'utilisation Crawlbase's Crawling API pour le grattage de Zillow

L'extraction de données immobilières de Zillow devient plus efficace avec Crawlbase's Crawling API. Voici pourquoi il se démarque :

  • Gestion efficace du contenu dynamique: CrawlbaseL'API de gère habilement le contenu dynamique sur Zillow, garantissant que votre scraper capture toutes les données pertinentes, même avec des retards ou des changements dynamiques.
  • Risque de blocage IP minimisé: Crawlbase réduit le risque de blocage IP en vous permettant de changer d'adresse IP, améliorant ainsi le taux de réussite de votre projet de scraping Zillow.
  • Paramètres de scraping personnalisés:Personnalisez les requêtes API avec des paramètres tels que user_agent, format et country pour un grattage adaptable et efficace en fonction des besoins spécifiques.
  • La pagination simplifiée: Crawlbase simplifie la gestion de la pagination avec des paramètres tels que ajax_wait haut page_wait, garantissant une navigation fluide dans les pages de Zillow pour une récupération de données étendue.
  • Prise en charge du réseau Tor:Pour plus d'intimité, Crawlbase prend en charge le réseau Tor via le tor_network paramètre, permettant le scraping sécurisé des sites Web onion.
  • Exploration asynchrone:L'API prend en charge l'exploration asynchrone avec le paramètre async, améliorant ainsi l'efficacité des tâches de scraping Zillow à grande échelle.
  • Analyse automatique pour l'extraction de données: Utilisez le autoparse paramètre pour une extraction simplifiée des données au format JSON, réduisant les efforts de post-traitement.

En résumé, les Crawlbase's Crawling API rationalise le scraping Zillow avec efficacité et adaptabilité, ce qui en fait un choix robuste pour les projets d'extraction de données immobilières.

Cas d'utilisation potentiels des données immobilières de Zillow

Cas d'utilisation des données immobilières de Zillow

Identifier les tendances du marché:Les données de Zillow permettent aux professionnels de l'immobilier d'identifier les tendances du marché, telles que les fluctuations de prix, les modèles de demande et les quartiers populaires. Ces informations aident à prendre des décisions éclairées concernant les investissements immobiliers et les stratégies de vente.

Évaluation et comparaison de propriétés:L'analyse des données de Zillow permet aux professionnels d'évaluer la valeur des biens immobiliers et de faire des comparaisons précises. Ces informations sont essentielles pour déterminer des prix compétitifs, comprendre la compétitivité du marché et conseiller les clients sur des évaluations immobilières réalistes.

Stratégies de marketing ciblées:En explorant les données de Zillow, les professionnels de l'immobilier peuvent adapter leurs stratégies marketing. Ils peuvent cibler des groupes démographiques spécifiques, créer des campagnes publicitaires efficaces et atteindre des clients potentiels qui recherchent activement des propriétés correspondant à certains critères.

Opportunités d'investissement:Les données de Zillow fournissent des informations sur les opportunités d'investissement potentielles. Les professionnels de l'immobilier peuvent identifier les zones à fort potentiel de croissance, les tendances émergentes et les opportunités lucratives de développement ou d'investissement immobilier.

Consultations et recommandations des clients:Armés de données Zillow complètes, les professionnels peuvent fournir aux clients des informations précises et à jour lors des consultations. Cela renforce la crédibilité des recommandations et permet aux clients de prendre des décisions éclairées.

Réflexions finales

Dans le monde de l'extraction de données immobilières sur Zillow, la simplicité et l'efficacité jouent un rôle essentiel. Si l'approche courante peut être utile, Crawlbase Crawling API apparaît comme un choix plus judicieux. Dites adieu aux défis et adoptez une solution simplifiée, fiable et évolutive grâce à Crawlbase Crawling API pour le grattage Zillow.

Pour ceux qui souhaitent découvrir le scraping de données à partir de diverses plateformes, n'hésitez pas à consulter nos guides complets :

(I.e. Comment récupérer des données sur Amazon
(I.e. Comment réduire les prix d'Airbnb
(I.e. Comment récupérer des données sur Booking.com
(I.e. Comment récupérer des données Expedia

Bon scraping ! Si vous rencontrez des obstacles ou avez besoin de conseils, notre équipe dédiée est là pour vous accompagner dans votre voyage dans le monde des données immobilières.

Foire Aux Questions (FAQ)

Q1 : Pouvez-vous gratter Zillow ?

Le scraping Web est un domaine juridique complexe. Bien que les conditions de service de Zillow autorisent généralement la navigation, l'extraction systématique de données peut être soumise à des restrictions. Il est conseillé de consulter les conditions générales de Zillow, y compris les robots.txt fichier. Respectez toujours les politiques du site Web et tenez compte des implications éthiques du scraping Web.

Q2 : Puis-je utiliser les données de l’API Zillow à des fins commerciales ?

L'utilisation des données récupérées, notamment à des fins commerciales, dépend des politiques de Zillow. Il est important d'examiner attentivement et de respecter les conditions de service de Zillow, y compris toutes les directives relatives à l'utilisation des données et aux droits d'auteur. Il est recommandé de demander un avis juridique si vous envisagez d'utiliser les données récupérées à des fins commerciales.

Q3 : Existe-t-il des limitations à l'utilisation du Crawlbase Crawling API pour le scraping Zillow ?

Tandis que le Crawlbase Crawling API Bien que cet outil soit robuste, les utilisateurs doivent être conscients de certaines limitations. Celles-ci peuvent inclure les limites de débit imposées par l'API, les politiques d'utilisation de l'API et les ajustements potentiels nécessaires en raison de modifications de la structure du site web cible. Il est conseillé de se référer à la section Crawlbase documentation pour des informations complètes sur les limitations de l'API.

Q4 : Comment puis-je gérer le contenu dynamique sur Zillow en utilisant le Crawlbase Crawling API?

Le Crawlbase Crawling API fournit des mécanismes pour gérer le contenu dynamique. Des paramètres tels que ajax_wait haut page_wait sont des outils essentiels pour garantir que l'API capture tout le contenu pertinent, même si les pages Web subissent des modifications dynamiques pendant le processus de scraping. L'ajustement de ces paramètres en fonction du comportement du site Web contribue à une récupération efficace du contenu.