Dans ce tutoriel, nous allons aborder :
- La définition d’un scraper Google Maps
- Quelles sont les données que vous pouvez extraire ?
- Comment construire un script de scraping Google Maps avec Python
C’est parti !
Qu’est-ce qu’un scraper Google Maps ?
Un scraper Google Maps est un outil spécialisé permettant d’extraire des données de Google Maps. Il automatise le processus de collecte des données de Google Maps, par exemple à l’aide d’un script de scraping en python. Les données récupérées à l’aide d’un tel scraper sont couramment utilisées pour les études de marché, l’analyse de la concurrence, etc.
Quelles sont les données que vous pouvez récupérer sur Google Maps ?
Les informations que vous pouvez extraire de Google Maps sont les suivantes :
- Nom de l’entreprise: Le nom de l’entreprise ou de l’emplacement indiqué sur Google Maps.
- Adresse : adresse physique de l’entreprise ou de l’emplacement.
- Numéro de téléphone: Numéro de téléphone de contact pour l’entreprise.
- Site web: URL du site web de l’entreprise.
- Heures d’ouverture: Heures d’ouverture et de fermeture de l’entreprise.
- Avis : les avis des clients, y compris les évaluations et les commentaires détaillés.
- Notations: Notation moyenne par étoiles basée sur les commentaires des utilisateurs.
- Photos: Images téléchargées par l’entreprise ou les clients.
Instructions pas à pas pour récupérer les cartes de Google Maps avec Python
Dans cette section guidée, vous allez apprendre à créer un script python pour récupérer les données de Google Maps.
L’objectif final est de récupérer les données contenues dans les éléments de Google Maps sur la page « Restaurants italiens » :
Suivez les étapes ci-dessous !
Étape 1 : Configuration du projet
Avant de commencer, vous devez vérifier que Python 3 est installé sur votre ordinateur. Si ce n’est pas le cas, téléchargez-le, installez-le et suivez l’assistant d’installation.
Ensuite, utilisez les commandes suivantes pour créer un dossier pour le projet, entrez-y et créez un environnement virtuel à l’intérieur de celui-ci :
mkdir google-maps-scraper
cd google-maps-scraper
python -m venv env
Le répertoire google-maps-scraper est le dossier du projet python Google Maps scraper.
Chargez le dossier du projet dans votre IDE Python préféré. PyCharm Community Edition ou Visual Studio Code avec l’extension Python feront l’affaire.
Dans le dossier du projet, créez un fichier scraper.py. Voici la structure de fichier que votre projet devrait avoir à l’heure actuelle :
scraper.py est maintenant un script Python vierge, mais il contiendra bientôt la logique de scraping.
Sur le terminal de l’IDE, activez l’environnement virtuel. Pour ce faire, sous Linux ou macOS, lancez la commande suivante :
./env/bin/activate
Alternativement, sous Windows, exécutez :
env/Scripts/activate
Super, vous avez maintenant un environnement python pour votre scraper !
Étape 2 : Choisir la bibliothèque de scraping
Google Maps est une plateforme hautement interactive, et il est inutile de perdre du temps à déterminer s’il s’agit d’un site statique ou dynamique. Dans ce cas, la meilleure approche pour le scraping est d’utiliser un outil d’automatisation du navigateur.
Si vous ne connaissez pas cette technologie, sachez que les outils d’automatisation de navigateur vous permettent d’assurer le rendu et d’interagir avec des pages web dans un environnement de navigateur contrôlable. En outre, il n’est pas facile de créer une URL de recherche Google Maps valide. La façon la plus simple de procéder est d’effectuer la recherche directement dans un navigateur.
L’un des meilleurs outils d’automatisation de navigateur pour Python est Seleniumce qui en fait un choix idéal pour l’analyse de Google Maps. Préparez-vous à l’installer, car elle sera la principale bibliothèque utilisée pour cette tâche !
Etape #3 : Installer et configurer la bibliothèque de scraping
Installez Selenium via le paquetage selenium pip avec cette commande dans un environnement virtuel Python activé :
pip install selenium
Pour plus de détails sur l’utilisation de cet outil, suivez notre tutoriel sur le web scraping avec Selenium.
Importez Selenium dans scraper.py et créez un objet WebDriver pour contrôler une instance Chrome en mode headless :
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing
# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
service=Service(),
options=options
)
L’extrait ci-dessus initialise une instance Chrome WebDriver pour contrôler une fenêtre de navigateur Chrome en programmant. Le flag « --headless » permet de démarrer Chrome en mode headless, ce qui le lance en arrière-plan, sans charger sa fenêtre. Pour le débogage, vous pouvez commenter cette ligne pour observer les actions du script en temps réel.
A la dernière ligne de votre script de scraping Google Maps, n’oubliez pas de fermer le pilote web :
driver.quit()
Incroyable ! Vous êtes maintenant entièrement configuré pour commencer à récupérer les pages de Google Maps.
Étape 4 : Connexion à la page cible
Utilisez la méthode get() pour vous connecter à la page d’accueil de Google Maps :
driver.get("https://www.google.com/maps")
Pour l’instant, scraper.py contiendra ces lignes :
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing
# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
service=Service(),
options=options
)
# connect to the Google Maps home page
driver.get("https://www.google.com/maps")
# scraping logic...
# close the web browser
driver.quit()
Génial, il est temps de commencer à scraper un site web dynamique comme Google Maps !
Étape 5 : S’occuper de la boîte de dialogue de gestion des cookies du RGPD
Remarque : si vous ne vous trouvez pas dans l’UE (Union européenne), vous pouvez sauter cette étape.
Exécutez le script scraper.py en mode « headed », en ajoutant un point d’arrêt avant la dernière ligne, si possible. La fenêtre du navigateur reste ainsi ouverte, ce qui vous permet de l’observer sans qu’elle se ferme immédiatement. Si vous êtes dans l’UE, vous devriez voir quelque chose comme ceci :
Remarque : le message « Chrome est contrôlé par un logiciel de test automatisé » confirme que Selenium contrôle Chrome.
Google doit afficher certaines options de la politique concernant les cookies pour les utilisateurs de l’UE en raison des exigences du RGPD. Si c’est votre cas, vous devrez gérer ce choix si vous souhaitez interagir avec la page. Si ce n’est pas le cas, vous pouvez passer à l’étape 6.
Regardez l’URL dans la barre d’adresse du navigateur, et vous remarquerez qu’elle ne correspond pas à la page spécifiée dans get(). La raison en est que Google vous a redirigé. Après avoir cliqué sur le bouton « Tout accepter », vous serez redirigé sur la page cible, qui est la page d’accueil de Google Maps.
Pour gérer les options GDPR, ouvrez la page d’accueil de Google Maps en mode incognito sur votre navigateur et attendez la redirection. Cliquez avec le bouton droit sur le bouton « Tout accepter », puis sélectionnez l’option « Inspecter » :
Comme vous l’avez peut-être remarqué, les classes CSS des éléments HTML de la page semblent être générées de manière aléatoire. Cela signifie qu’ils ne sont pas fiables pour le web scraping, car ils sont probablement mis à jour à chaque déploiement. Vous devez donc vous concentrer sur des attributs plus stables, comme aria-label:
accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")
find_element() est une méthode Selenium utilisée pour localiser des éléments HTML sur une page à l’aide de différentes stratégies. Dans ce cas, nous avons utilisé un sélecteur CSS. Si vous souhaitez en savoir plus sur les différents types de sélecteurs, lisez notre Sélecteur XPath vs CSS.
N’oubliez pas d’importer Par en ajoutant cet import à scraper.py:
from selenium.webdriver.common.by import By
L’instruction suivante consiste à cliquer sur le bouton :
accept_button.click()
Voici comment tout s’imbrique pour gérer la page optionnelle du cookie de Google :
try:
# select the "Accept all" button from the GDPR cookie option page
accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")
# click it
accept_button.click()
except NoSuchElementException:
print("No GDPR requirenments")
La commande click() appuie sur le bouton « Tout accepter », ce qui permet à Google de vous rediriger vers la page d’accueil de Google Maps. Si vous n’êtes pas situé dans l’UE, ce bouton ne figurera pas sur la page, ce qui provoquera une NoSuchElementException. Le script détectera l’exception et poursuivra, car il ne s’agit pas d’une erreur critique, mais simplement d’un scénario potentiel.
Assurez-vous d’importer NoSuchElementException:
from selenium.common import NoSuchElementException
Bravo ! Vous êtes maintenant prêt à vous concentrer sur le scraping de Google Maps.
Étape 6 : Soumettre le formulaire de recherche
En ce moment, votre scraper Google Maps devrait atteindre une page comme celle ci-dessous :
Notez que l’emplacement sur les cartes dépend de l’emplacement de votre IP. Dans cet exemple, nous sommes situés à New York.
Ensuite, vous devez remplir le champ « Rechercher sur Google Maps » et soumettre le formulaire de recherche. Pour localiser cet élément, ouvrez la page d’accueil de Google Maps en mode incognito sur votre navigateur. Cliquez avec le bouton droit de la souris sur le champ de saisie de la recherche et choisissez l’option « Inspecter » :
search_input = WebDriverWait(driver, 5).until(
EC.presence_of_element_located((By.CSS_SELECTOR, "#searchboxinput"))
)
WebDriverWait est une classe Selenium spécialisée qui met le script en pause jusqu’à ce qu’une condition spécifiée sur la page soit remplie. Dans l’exemple ci-dessus, elle attend jusqu’à 5 secondes que l’élément HTML saisi apparaisse. Cette attente permet de s’assurer que la page est entièrement chargée, ce qui est nécessaire si vous avez suivi l’étape 5 (en raison de la redirection).
Pour que les lignes ci-dessus fonctionnent, ajoutez ces importations à scraper.py:
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
Next, fill out the input with the `[send_keys()](https://www.selenium.dev/documentation/webdriver/actions_api/keyboard/#send-keys)` method:
search_query = "italian restaurants"
search_input.send_keys(search_query)
Dans ce cas, la requête de recherche est « restaurants italiens », mais vous pouvez rechercher n’importe quel autre terme.
Il ne reste plus qu’à soumettre le formulaire. Inspectez le bouton de soumission, qui est une loupe :
Sélectionnez-le en ciblant son attribut aria-label et cliquez dessus :
search_button = driver.find_element(By.CSS_SELECTOR, "button[aria-label=\"Search\"]")
search_button.click()
Incroyable ! Le navigateur contrôlé va maintenant charger les données à extraire.
Étape 7 : Sélectionner les éléments de Google Maps
C’est l’endroit où votre script devrait se trouver actuellement :
Les données à extraire sont contenues dans les éléments de Google Maps sur la gauche. Comme il s’agit d’une liste, la meilleure structure de données pour contenir les données extraites est un tableau. Initialisez-en un :
items = []
L’objectif est maintenant de sélectionner l’élément Google Maps sur la gauche. Inspectez l’un d’entre eux :
Une fois encore, les classes CSS semblent être générées de manière aléatoire, et ne sont donc pas fiables pour le scraping. Au lieu de cela, vous pouvez cibler l’attribut jsaction . Étant donné que certaines parties du contenu de cet attribut semblent également générées de manière aléatoire, concentrez-vous sur la chaîne cohérente qu’il contient : « mouseover:pane ».
Le sélecteur XPath ci-dessous vous aidera à sélectionner tous les éléments <div> à l’intérieur du parent <div> où role="feed", dont l’attribut jsaction contient la chaîne « mouseover:pane » :
maps_items = WebDriverWait(driver, 10).until(
EC.presence_of_all_elements_located((By.XPATH, '//div[@role="feed"]//div[contains(@jsaction, "mouseover:pane")]'))
)
Encore une fois, WebDriverWait est nécessaire car le contenu à gauche est chargé dynamiquement dans la page.
Itérer sur chaque élément et préparer votre scraper Google Maps pour extraire des données :
for maps_item in maps_items:
# scraping logic...
Génial ! L’étape suivante consiste à extraire les données de ces éléments.
Étape 8 : Récupérer les éléments de Google Maps
Inspecter un seul élément de Google Maps et se concentrer sur les éléments qu’il contient :
Vous voyez ici que vous pouvez scraper :
- Le lien de l’élément Maps de l’élément
a[jsaction][jslog] - Le titre de l’élément
div.fontHeadlineSmall - Les étoiles et le nombre d’avis dans
span[role="img"]
Vous pouvez y parvenir avec la logique ci-dessous :
link_element = maps_item.find_element(By.CSS_SELECTOR, "a[jsaction][jslog]")
url = link_element.get_attribute("href")
title_element = maps_item.find_element(By.CSS_SELECTOR, "div.fontHeadlineSmall")
title = title_element.text
reviews_element = maps_item.find_element(By.CSS_SELECTOR, "span[role=\"img\"]")
reviews_string = reviews_element.get_attribute("aria-label")
# define a regular expression pattern to extract the stars and reviews count
reviews_string_pattern = r"(\d+\.\d+) stars (\d+[,]*\d+) Reviews"
# use re.match to find the matching groups
reviews_string_match = re.match(reviews_string_pattern, reviews_string)
reviews_stars = None
reviews_count = None
# if a match is found, extract the data
if reviews_string_match:
# convert stars to float
reviews_stars = float(reviews_string_match.group(1))
# convert reviews count to integer
reviews_count = int(reviews_string_match.group(2).replace(",", ""))
La fonction get_attribute() renvoie le contenu de l’attribut HTML spécifié, tandis que .text renvoie le contenu de la chaîne dans le noeud.
Notez l’utilisation d’une expression régulière pour extraire les champs de données spécifiques de la chaîne « X.Y étoiles dans Z avis ». Pour en savoir plus, consultez notre article sur l’utilisation des expressions régulières pour le web scraping.
N’oubliez pas d’importer le package « re » de la bibliothèque standard python :
import re
Poursuivre l’inspection de l’élément Google Maps :
À l’intérieur du <div> avec la classe « fondBodyMedium », vous pouvez récupérer la plupart des informations à partir des nœuds <span> sans attributs ou avec seulement l’attribut style . Quant à l’élément de prix facultatif, vous pouvez le sélectionner en ciblant le nœud qui contient « Price » dans l’attribut aria-label :
info_div = maps_item.find_element(By.CSS_SELECTOR, ".fontBodyMedium")
# scrape the price, if present
try:
price_element = info_div.find_element(By.XPATH, ".//*[@aria-label[contains(., 'Price')]]")
price = price_element.text
except NoSuchElementException:
price = None
info = []
# select all <span> elements with no attributes or the @style attribute
# and descendant of a <span>
span_elements = info_div.find_elements(By.XPATH, ".//span[not(@*) or @style][not(descendant::span)]")
for span_element in span_elements:
info.append(span_element.text.replace("⋅", "").strip())
# to remove any duplicate info and empty strings
info = list(filter(None, list(set(info))))
Puisque l’élément de prix est optionnel, vous devez envelopper cette logique avec un bloc « try ... except ». De cette manière, si le nœud de prix n’est pas sur la page, le script continuera sans échouer. Si vous sautez l’étape 5, ajoutez l’importation pour NoSuchElementException:
from selenium.common import NoSuchElementException
Pour éviter les chaînes vides et les éléments d’information en double, notez l’utilisation de filter() et set(). .
Maintenant, concentrez-vous sur l’image :
Vous pouvez la scraper avec :
img_element = WebDriverWait(driver, 5).until(
EC.presence_of_element_located((By.CSS_SELECTOR, "img[decoding=\"async\"][aria-hidden=\"true\"]"))
)
image = img_element.get_attribute("src")
Gardez à l’esprit que WebDriverWait est nécessaire, car les images sont chargées de manière asynchrone et peuvent mettre un certain temps à apparaître.
La dernière étape consiste à récupérer les balises de l’élément du bas :
Vous pouvez les récupérer tous à partir des nœuds <span> ; avec l’attribut style dans le dernier élément .fontBodyMedium :
tags_div = maps_item.find_elements(By.CSS_SELECTOR, ".fontBodyMedium")[-1]
tags = []
tag_elements = tags_div.find_elements(By.CSS_SELECTOR, "span[style]")
for tag_element in tag_elements:
tags.append(tag_element.text)
Excellent ! La logique python de scraping de Google Maps est terminée.
Étape 9 : Collecte des données extraites
Vous disposez à présent des données extraites dans plusieurs variables. Créer un nouvel objet item et le remplir avec ces données :
item = {
"url": url,
"image": image,
"title": title,
"reviews": {
"stars": reviews_stars,
"count": reviews_count
},
"price": price,
"info": info,
"tags": tags
}
Nous l’ajoutons ensuite au tableau des éléments :
items.append(item)
À la fin de la boucle « for » sur les nœuds d’éléments de Google Maps, « items » contiendra toutes vos données de scraping. Il vous suffit d’exporter ces informations dans un fichier lisible par l’homme, tel que CSV.
Etape #10 : Exporter vers CSV
Importez le package csv de la bibliothèque standard python :
import csv
Ensuite, utilisez-le pour remplir un fichier CSV plat contenant vos données Google Maps :
# output CSV file path
output_file = "items.csv"
# flatten and export to CSV
with open(output_file, mode="w", newline="", encoding="utf-8") as csv_file:
# define the CSV field names
fieldnames = ["url", "image", "title", "reviews_stars", "reviews_count", "price", "info", "tags"]
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
# write the header
writer.writeheader()
# write each item, flattening info and tags
for item in items:
writer.writerow({
"url": item["url"],
"image": item["image"],
"title": item["title"],
"reviews_stars": item["reviews"]["stars"],
"reviews_count": item["reviews"]["count"],
"price": item["price"],
"info": "; ".join(item["info"]),
"tags": "; ".join(item["tags"])
})
L’extrait ci-dessus exporte éléments vers un fichier CSV nommé éléments.csv. Les fonctions clés utilisées sont les suivantes :
open(): Ouvre le fichier spécifié en mode écriture avec le codage UTF-8 pour gérer la sortie texte.csv.DictWriter(): Créer un objet CSV writer en utilisant les noms de champs spécifiés, permettant aux lignes d’être écrites sous forme de dictionnaires.writeheader(): écrire la ligne d’en-tête dans le fichier CSV en fonction des noms de champs.writer.writerow(): Ecrire chaque élément comme une ligne dans le CSV.
Notez l’utilisation de la fonction de chaîne join() pour transformer les tableaux en chaînes plates. Cela permet de s’assurer que le fichier CSV de sortie sera un fichier propre, à un seul niveau.
Étape 11 : Assembler le tout
Voici le code final du scraper Google Maps en Python :
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import re
import csv
# to launch Chrome in headless mode
options = Options()
options.add_argument("--headless") # comment it while developing
# create a Chrome web driver instance with the
# specified options
driver = webdriver.Chrome(
service=Service(),
options=options
)
# connect to the Google Maps home page
driver.get("https://www.google.com/maps")
# to deal with the option GDPR options
try:
# select the "Accept all" button from the GDPR cookie option page
accept_button = driver.find_element(By.CSS_SELECTOR, "[aria-label=\"Accept all\"]")
# click it
accept_button.click()
except NoSuchElementException:
print("No GDPR requirenments")
# select the search input and fill it in
search_input = WebDriverWait(driver, 5).until(
EC.presence_of_element_located((By.CSS_SELECTOR, "#searchboxinput"))
)
search_query = "italian restaurants"
search_input.send_keys(search_query)
# submit the search form
search_button = driver.find_element(By.CSS_SELECTOR, "button[aria-label=\"Search\"]")
search_button.click()
# where to store the scraped data
items = []
# select the Google Maps items
maps_items = WebDriverWait(driver, 10).until(
EC.presence_of_all_elements_located((By.XPATH, '//div[@role="feed"]//div[contains(@jsaction, "mouseover:pane")]'))
)
# iterate over the Google Maps items and
# perform the scraping logic
for maps_item in maps_items:
link_element = maps_item.find_element(By.CSS_SELECTOR, "a[jsaction][jslog]")
url = link_element.get_attribute("href")
title_element = maps_item.find_element(By.CSS_SELECTOR, "div.fontHeadlineSmall")
title = title_element.text
reviews_element = maps_item.find_element(By.CSS_SELECTOR, "span[role=\"img\"]")
reviews_string = reviews_element.get_attribute("aria-label")
# define a regular expression pattern to extract the stars and reviews count
reviews_string_pattern = r"(\d+\.\d+) stars (\d+[,]*\d+) Reviews"
# use re.match to find the matching groups
reviews_string_match = re.match(reviews_string_pattern, reviews_string)
reviews_stars = None
reviews_count = None
# if a match is found, extract the data
if reviews_string_match:
# convert stars to float
reviews_stars = float(reviews_string_match.group(1))
# convert reviews count to integer
reviews_count = int(reviews_string_match.group(2).replace(",", ""))
# select the Google Maps item <div> with most info
# and extract data from it
info_div = maps_item.find_element(By.CSS_SELECTOR, ".fontBodyMedium")
# scrape the price, if present
try:
price_element = info_div.find_element(By.XPATH, ".//*[@aria-label[contains(., 'Price')]]")
price = price_element.text
except NoSuchElementException:
price = None
info = []
# select all <span> elements with no attributes or the @style attribute
# and descendant of a <span>
span_elements = info_div.find_elements(By.XPATH, ".//span[not(@*) or @style][not(descendant::span)]")
for span_element in span_elements:
info.append(span_element.text.replace("⋅", "").strip())
# to remove any duplicate info and empty strings
info = list(filter(None, list(set(info))))
img_element = WebDriverWait(driver, 5).until(
EC.presence_of_element_located((By.CSS_SELECTOR, "img[decoding=\"async\"][aria-hidden=\"true\"]"))
)
image = img_element.get_attribute("src")
# select the tag <div> element and extract data from it
tags_div = maps_item.find_elements(By.CSS_SELECTOR, ".fontBodyMedium")[-1]
tags = []
tag_elements = tags_div.find_elements(By.CSS_SELECTOR, "span[style]")
for tag_element in tag_elements:
tags.append(tag_element.text)
# populate a new item with the scraped data
item = {
"url": url,
"image": image,
"title": title,
"reviews": {
"stars": reviews_stars,
"count": reviews_count
},
"price": price,
"info": info,
"tags": tags
}
# add it to the list of scraped data
items.append(item)
# output CSV file path
output_file = "items.csv"
# flatten and export to CSV
with open(output_file, mode="w", newline="", encoding="utf-8") as csv_file:
# define the CSV field names
fieldnames = ["url", "image", "title", "reviews_stars", "reviews_count", "price", "info", "tags"]
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
# write the header
writer.writeheader()
# write each item, flattening info and tags
for item in items:
writer.writerow({
"url": item["url"],
"image": item["image"],
"title": item["title"],
"reviews_stars": item["reviews"]["stars"],
"reviews_count": item["reviews"]["count"],
"price": item["price"],
"info": "; ".join(item["info"]),
"tags": "; ".join(item["tags"])
})
# close the web browser
driver.quit()
En environ 150 lignes de code, vous venez de construire un script de scraping de Google Maps !
Vérifiez qu’il fonctionne en lançant le fichier scraper.py . Sous Windows, lancez le scraper avec :
python scraper.py
De manière équivalente, sous Linux ou macOS, exécutez :
python3 scraper.py
Attendez que le scraper termine son exécution et un fichier items.csv apparaîtra dans le répertoire racine de votre projet. Ouvrez le fichier pour afficher les données extraites, qui devraient contenir des données comme celles-ci :
Félicitations, votre mission est terminée !
Conclusion
Dans ce tutoriel, vous avez appris ce qu’est un scraper Google Maps et comment en construire un en Python. Comme nous l’avons vu, la construction d’un script simple pour récupérer automatiquement les données de Google Maps ne nécessite que quelques lignes de code en python.
Bien que cette solution fonctionne pour les petits projets, sa praticité est limitée pour le scraping à grande échelle. Google a mis en place des mesures anti-bots avancées, telles que les CAPTCHA et les interdictions d’IP, qui peuvent vous bloquer. L’extension du processus à plusieurs pages augmenterait également les coûts d’infrastructure. De plus, cet exemple simple ne tient pas compte de toutes les interactions complexes nécessaires sur les pages de Google Maps.
Cela signifie-t-il qu’il est impossible de scraper les données de Google Maps de manière efficace et fiable ? Pas du tout ! Vous avez simplement besoin d’une solution avancée comme Goolge Maps Scraper API de Bright Data.
L’API Google Maps Scraper offre des points d’extrémité pour récupérer des données de Google Maps, en oubliant tous les principaux défis. Grâce à de simples appels d’API, vous pouvez récupérer les données dont vous avez besoin au format JSON ou HTML. Si les appels à l’API ne vous conviennent pas, vous pouvez également explorer nos jeux de données Google Maps prêts à l’emploi.
Créez un compte Bright Data gratuit dès aujourd’hui pour essayer nos API de scraper ou explorer nos ensembles de données !
Aucune carte de crédit requise
