Web Scraping Booking.com : Hôtels, prix et avis (Guide 2026)

Il existe plusieurs cas d'utilisation où le scraping de Booking.com s'avère rentable presque immédiatement. Les équipes chargées de l'analyse des tarifs comparent en temps réel les prix par nuit des hôtels concurrents. Les responsables des revenus suivent les disponibilités et les tendances en matière de remises pour synchroniser leurs propres promotions. Les équipes d'études de marché et d'analyse des voyages utilisent le volume d'avis, les notes et la couverture des équipements pour évaluer une destination. Et toute personne développant un métamoteur de recherche ou un agent de voyage basé sur l'IA a besoin de données structurées sur les établissements que le site public ne rend accessibles qu'en JavaScript.

Tout au long de ce guide, nous extrairons cinq types d'entités concrètes : les listes de résultats de recherche (fiches d'hôtels sur une page de résultats), les pages de détails des hôtels (description, adresse, équipements, géolocalisation), les tarifs à la nuit et la disponibilité, les avis des clients, ainsi que l'inventaire des hôtels basé sur le plan du site pour une découverte en masse. Chacune a ses propres particularités, et c'est en les combinant que vous obtenez un véritable ensemble de données plutôt qu'une simple capture d'écran d'une page de résultats de recherche.

Il existe deux méthodes raisonnables pour effectuer le web scraping de Booking.com, quel que soit le volume, et elles sont complémentaires plutôt que concurrentes.

Selenium avec Selenium Wire pilote une instance Chrome réelle, exécute le JavaScript de la page et vous permet de lire le DOM rendu. C'est l'option la plus simple lorsque vous ne connaissez pas encore les requêtes cachées de la page, et elle tolère bien les variations de mise en page car vous interrogez le même DOM que celui vu par l'utilisateur. Le prix à payer est la vitesse et l'utilisation des ressources : chaque page correspond à un onglet de navigateur complet. Pour des listes sélectionnées de quelques milliers d'hôtels, cela convient. Pour une surveillance continue, cela devient coûteux.

Appeler le point de terminaison interne /dml/graphql point de terminaison interne avec httpx contourne complètement le navigateur. Le front-end de Booking.com récupère les résultats de recherche à partir de ce point de terminaison ; ainsi, une fois que vous reproduisez la structure de la requête, vous obtenez le même JSON que le site, dix à cinquante fois plus rapidement qu'avec Selenium et avec une empreinte mémoire minime. Le compromis réside dans la fragilité : les charges utiles et les en-têtes requis changent, et vous devez les maintenir synchronisés.

Une bonne pratique : prototypez avec Selenium, verrouillez la requête GraphQL une fois que vous comprenez les données, et utilisez le chemin API pour la production.

Utilisez Python 3.10 ou une version plus récente dans un nouvel environnement virtualenv afin que les dépendances restent isolées :

mkdir booking_scraper && cd booking_scraper
python -m venv .venv && source .venv/bin/activate
pip install selenium selenium-wire webdriver-manager httpx parsel
touch app.py

selenium-wire est un remplacement direct de selenium qui expose les requêtes réseau sous-jacentes, dont nous aurons besoin pour la synchronisation de la pagination. webdriver-manager télécharge automatiquement le binaire correspondant chromedriver , vous évitant ainsi d'avoir à gérer les versions des pilotes d'une machine à l'autre. httpx nous fournit un client compatible HTTP/2 pour la méthode 2, et parsel fournit des sélecteurs CSS et XPath de type Scrapy pour analyser le code HTML des hôtels. Notre tutoriel Selenium étape par étape est un bon point de départ si vous n'avez jamais utilisé Selenium pour le scraping auparavant.)

C'est le point d'entrée le plus convivial pour le scraping de Booking.com : ouvrez une URL de recherche dans une session Chrome réelle, laissez JavaScript afficher les fiches de propriétés, puis parcourez le DOM. Nous utilisons Selenium Wire plutôt que Selenium standard, car la page de recherche charge les résultats via des appels XHR/fetch en arrière-plan. Selenium Wire nous permet d'inspecter ces requêtes individuelles et d'attendre qu'une réponse spécifique soit effectivement renvoyée, ce qui est important pour la pagination sans conditions de concurrence.

Incluez toujours des dates d'arrivée et de départ explicites dans l'URL. Sans elles, Booking.com revient à la disponibilité par défaut et votre colonne de prix ne correspondra pas à ce qu'un utilisateur verrait dans une fenêtre de réservation réelle.

from seleniumwire import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
url = ('https://www.booking.com/searchresults.html'
       '?ss=London&checkin=2026-05-10&checkout=2026-05-12&group_adults=2')
driver.get(url)

cards = driver.find_elements(By.CSS_SELECTOR, "div[data-testid='property-card']")
print(f'Found {len(cards)} property cards on page 1')

Booking.com est assez cohérent dans l'utilisation des data-testid attributs sur ses fiches de résultats, ce qui les rend plus stables à cibler que les noms de classe générés automatiquement.

Chaque fiche d'établissement comporte les mêmes quelques data-testid hooks, de sorte que l'analyseur par carte est essentiellement un petit dictionnaire de sélecteurs. Les sélecteurs CSS sont généralement le bon choix ici (concis et rapides), mais XPath convient lorsque vous avez besoin d'une traversée des éléments parents ou frères. Consultez notre guide XPath vs CSS selectors si vous hésitez entre les deux.

def parse_card(card):
    def text(sel):
        nodes = card.find_elements(By.CSS_SELECTOR, sel)
        return nodes[0].text.strip() if nodes else None

    def attr(sel, name):
        nodes = card.find_elements(By.CSS_SELECTOR, sel)
        return nodes[0].get_attribute(name) if nodes else None

    score_block = text("div[data-testid='review-score']") or ''
    score_lines = [s.strip() for s in score_block.split('\n') if s.strip()]
    score = score_lines[0] if score_lines else None
    review_count = next((l for l in score_lines if 'review' in l.lower()), None)

    return {
        'name':         text("div[data-testid='title']"),
        'url':          attr("a[data-testid='title-link']", 'href'),
        'address':      text("span[data-testid='address']"),
        'score':        score,
        'review_count': review_count,
        'price':        text("span[data-testid='price-and-discounted-price']"),
        'image':        attr("img[data-testid='image']", 'src'),
    }

listings = [parse_card(c) for c in cards]

Deux points à noter concernant les prix. Premièrement, le review-score bloc sur Booking.com regroupe la note numérique et le texte du nombre d'avis en un seul élément ; nous le divisons donc en lignes et les extrayons séparément. Deuxièmement, le prix que vous récupérez à partir d'une fiche de recherche exclut presque toujours les taxes et les frais ; le montant total tout compris n'apparaît qu'une fois que vous avancez dans le processus de réservation. Considérez-le comme le tarif de base, et non comme le montant final, et indiquez-le clairement par la suite.

Chaque clic sur le bouton de passage à la page suivante déclenche une requête POST vers /dml/graphql et attend la réponse JSON. Si vous cliquez et extrayez immédiatement le DOM, vous lisez la page précédente. Selenium Wire résout ce problème en vous permettant de bloquer sur la réponse réelle.

from selenium.webdriver.common.by import By

def total_pages(driver):
    nums = driver.find_elements(By.CSS_SELECTOR, "div[data-testid='pagination'] li")
    return max((int(n.text) for n in nums if n.text.isdigit()), default=1)

pages = total_pages(driver)
all_listings = [parse_card(c) for c in cards]

for page in range(2, pages + 1):
    del driver.requests  # clear so the next wait does not match an old response
    next_btn = driver.find_element(
        By.CSS_SELECTOR, "button[aria-label='Next page']")
    next_btn.click()
    driver.wait_for_request(r'/dml/graphql', timeout=10)
    cards = driver.find_elements(
        By.CSS_SELECTOR, "div[data-testid='property-card']")
    all_listings.extend(parse_card(c) for c in cards)

del driver.requests est la ligne importante. Sans elle, wait_for_request correspond sans problème à l'appel GraphQL de la page précédente et vous avancez avant que les nouvelles données n'arrivent. Récupérez le nombre total de pages à partir du contrôle de pagination plutôt que de le coder en dur ; les requêtes chargées peuvent paginer jusqu'à vingt pages, les plus calmes jusqu'à deux.

Une fois que Selenium vous a montré que la page de recherche est alimentée par /dml/graphql, la solution la plus rapide consiste à appeler vous-même ce point de terminaison et à contourner le navigateur. C'est là que le web scraping de Booking.com devient véritablement évolutif.

Le processus de découverte est le même que celui que vous utiliseriez pour n'importe quelle [API JavaScript cachée] : ouvrez DevTools (F12), passez à l'onglet Réseau, filtrez par Fetch/XHR, puis lancez une vraie recherche et cliquez sur la deuxième page. Vous verrez une requête POST vers /dml/graphql portant un corps JSON avec un operationName, un variables objet (contenant la destination, les dates, le nombre de personnes et un offset), ainsi qu'un query ou extensions qui fixe le hachage de la requête. Cliquez avec le bouton droit sur la requête et sélectionnez « Copier en tant que cURL » : voilà votre point de départ.

Vérifiez à nouveau les noms exacts des champs par rapport à votre propre capture DevTools avant de lancer la production ; Booking.com renomme périodiquement ses opérations GraphQL, et la référence la plus sûre est ce que le front-end envoie aujourd’hui.

import httpx

ENDPOINT = 'https://www.booking.com/dml/graphql'
HEADERS = {
    'content-type':    'application/json',
    'origin':          'https://www.booking.com',
    'referer':         'https://www.booking.com/searchresults.html',
    'user-agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                       'AppleWebKit/537.36 (KHTML, like Gecko) '
                       'Chrome/124.0 Safari/537.36',
    'accept-language': 'en-US,en;q=0.9',
}

def search_page(client, payload, offset):
    body = {**payload}
    body['variables']['input']['pagination'] = {'offset': offset, 'rowsPerPage': 25}
    r = client.post(ENDPOINT, json=body, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

def search_all(payload, max_results=1000):
    results = []
    with httpx.Client(http2=True) as client:
        for offset in range(0, max_results, 25):
            page = search_page(client, payload, offset)
            hits = (page.get('data', {})
                        .get('searchQueries', {})
                        .get('search', {})
                        .get('results', []))
            if not hits:
                break
            results.extend(hits)
    return results

Deux détails qui posent souvent problème. Le point de terminaison renvoie 25 résultats par appel, contrôlés par une variable offset que vous incrémentez par paliers de 25 résultats. Et la requête doit donner l'impression de provenir du site lui-même : origin et referer être définie sur booking.com, content-type: application/json, et un accept-language qui correspond à votre région IP. Supprimez ces en-têtes et vous obtiendrez un 400 générique ou un blocage partiel après quelques requêtes. Utilisez HTTP/2 (httpx le fait lorsque vous passez http2=True) car le proxy de Booking.com semble identifier les clients qui ne négocient encore que HTTP/1.1.

Les fiches de résultats de recherche ne constituent qu'une partie du scraping de Booking.com ; elles vous donnent un nom et un prix, mais pas les informations détaillées sur les hôtels que les équipes de voyage recherchent réellement. Pour cela, scrapez directement l'URL de l'hôtel. Les pages d'hôtels sont pour la plupart générées par le serveur, donc une simple requête GET avec parsel suffit, aucun navigateur n'est nécessaire.

import httpx
from parsel import Selector

def scrape_hotel(url):
    html = httpx.get(url, headers=HEADERS, http2=True, follow_redirects=True).text
    sel = Selector(text=html)
    map_link = sel.css("a[data-atlas-latlng]::attr(data-atlas-latlng)").get('')
    lat, lng = (map_link.split(',') + [None, None])[:2]
    return {
        'name':        sel.css('h2.pp-header__title::text').get(default='').strip(),
        'description': ' '.join(sel.css("div[data-testid='property-description'] *::text").getall()).strip(),
        'address':     sel.css("span[data-testid='address']::text").get(default='').strip(),
        'lat':         lat,
        'lng':         lng,
        'amenities':   [a.strip() for a in sel.css("div[data-testid='facility-list-most-popular'] li::text").getall() if a.strip()],
    }

La latitude et la longitude sont généralement intégrées dans un data-atlas-latlng attribut du lien de la carte, ce qui est plus fiable que de les extraire de scripts intégrés. Les équipements sont regroupés en blocs de fonctionnalités ; parcourez les groupes si vous souhaitez les classer par catégorie plutôt que de les présenter à plat.

Les tarifs à la nuitée ne figurent pas dans le code HTML de l'hôtel ; ils se trouvent dans une requête GraphQL distincte qui renvoie une réponse sous forme de calendrier. Capturez la requête de la même manière que pour l'appel de recherche : ouvrez la page de l'hôtel dans DevTools, modifiez les dates et surveillez la requête POST de tarification/disponibilité vers /dml/graphql. Le corps de la requête comprend les identifiants de l'hôtel (numériques hotel_id, le code pays et la devise) ainsi qu’une plage de dates.

Les pages d’hôtels intègrent également un jeton de type CSRF dans le code HTML, que la requête de tarification attend dans le corps ou dans un en-tête. Extrayez-le de la page une fois par hôtel, puis réutilisez-le pour chaque appel de tarification.

def scrape_pricing(client, hotel_id, csrf, checkin, checkout, currency='EUR'):
    payload = {
        'operationName': 'AvailabilityCalendar',  # verify in DevTools
        'variables': {
            'input': {
                'hotelId': hotel_id,
                'checkIn': checkin,
                'checkOut': checkout,
                'currency': currency,
            }
        },
        'extensions': {'csrf': csrf},
    }
    r = client.post(ENDPOINT, json=payload, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

Les avis des clients se chargent via une requête XHR distincte lorsque vous cliquez sur l'onglet « Avis » d'une page d'hôtel. Ouvrez DevTools, passez à l'onglet « Fetch/XHR », cliquez sur l'onglet « Avis » et copiez la requête. Elle effectue un paginage via une skip (ou offset) par lots d'environ 25, et renvoie le texte de l'avis, la note, la langue, le pays de l'auteur et la date.

Une fois que vous disposez d'un appel fonctionnel, vous pouvez le répartir en parallèle en exécutant des lots dans un httpx.AsyncClient:

import asyncio, httpx

async def fetch_reviews(client, hotel_id, skip):
    r = await client.post(ENDPOINT, json=review_payload(hotel_id, skip), headers=HEADERS)
    return r.json()

async def all_reviews(hotel_id, total):
    async with httpx.AsyncClient(http2=True) as c:
        tasks = [fetch_reviews(c, hotel_id, s) for s in range(0, total, 25)]
        return await asyncio.gather(*tasks)

Limitez la concurrence à moins de dix requêtes par hôtel ; les avis sont soumis à une limitation de débit stricte.

Pour le web scraping en masse de l'inventaire de Booking.com, plutôt que de procéder par requête unique, commencez par https://www.booking.com/robots.txt. Booking.com publie ses Sitemap: entrées à cet endroit, y compris les index de plans de site pour les hôtels, les attractions et les aéroports. Chaque index de plan de site pointe vers des sous-plans de site limités à 50 000 URL (conformément au protocole de plan de site), ce qui explique pourquoi l'index des hôtels est réparti sur de nombreux fichiers. En parcourant l'index, vous obtenez des dizaines de millions d'URL d'hôtels, avec des doublons, que vous pouvez dédupliquer à partir du slug de l'URL ou d'un identifiant d'hôtel analysé. Notre guide de scraping des sitemaps propose un modèle réutilisable à cet effet.

Pour les recherches ciblées, le point de terminaison de saisie semi-automatique de Booking.com convertit une chaîne de caractères correspondant à une ville ou un quartier en identifiants de destination attendus par l'appel GraphQL de recherche, ce qui est plus efficace que de les coder manuellement.

Pour réussir le scraping de Booking.com, quel que soit le volume, il faut se faire passer pour un navigateur normal et s'effacer lorsque le site vous le demande. En 2026, la pile anti-bot de Booking.com semble identifier à la fois le comportement TLS et HTTP/2, donc les bases sont non négociables : un client compatible HTTP/2 (httpx avec http2=True), un ensemble d'en-têtes réaliste incluant accept-language et sec-ch-ua-*, ainsi qu'un user-agent correspondant à une version actuelle de Chrome. (Vérifiez régulièrement la sensibilité à HTTP/2 ; cela change.)

Utilisez des proxys résidentiels ou d'FAI plutôt que des plages de centres de données ; les adresses IP de centres de données qui accèdent à Booking.com déclenchent des captchas après quelques dizaines de requêtes. Maintenez une concurrence modérée (5 à 10 par IP), ajoutez de la gigue et réduisez de manière exponentielle le nombre de requêtes 429 et 403. Le réseau de proxys résidentiels de WebScrapingAPI et l'API Scraper gèrent tous deux la rotation, les tentatives de reconnexion et les empreintes TLS si vous préférez ne pas réinventer cette infrastructure. Les navigateurs anti-détection constituent un dernier recours pour les pages les plus difficiles.

Booking.com déduit la devise affichée à partir de la géolocalisation de votre adresse IP de sortie ; ainsi, un scraper basé aux États-Unis verra l'USD et un scraper basé dans l'UE verra l'EUR par défaut. Pour une devise cohérente, acheminez le trafic via un proxy ciblé par pays ou transmettez un selected_currency paramètre de requête à chaque demande. (Vérifiez ce comportement régulièrement ; le nom du paramètre et la logique de déduction de l'adresse IP sont susceptibles de changer discrètement.)

La plateforme limite également chaque recherche à environ 1 000 résultats. Pour répertorier l'offre dans une ville très fréquentée, divisez la requête : scrapez Londres par quartier (Shoreditch, Camden, Kensington), puis par nombre d'étoiles, puis par tranche de prix, et regroupez les résultats par identifiant d'hôtel.

Pour les exécutions en production, intégrez ce code dans Scrapy et laissez-le gérer les tentatives de reconnexion, la persistance et les exécutions distribuées. Enregistrez les résultats normalisés dans Postgres ou un magasin de données en colonnes, effectuez des sauvegardes quotidiennes et assurez-vous que vos scrapers respectent robots.txt et les conditions d'utilisation de Booking.com.

• Le web scraping de Booking.com fonctionne mieux en combinant deux méthodes : Selenium Wire pour le prototypage et la stabilité du DOM, et l'endpoint interne /dml/graphql point de terminaison via httpx pour la vitesse en production.
• Extrayez l'ensemble complet des entités (résultats de recherche, pages de détails des hôtels, tarifs à la nuitée et avis des clients), plutôt que de vous limiter aux résultats de recherche (SERP), sinon l'ensemble de données sera trop maigre pour une analyse tarifaire.
• Utilisez data-testid des sélecteurs et wait_for_request on /dml/graphql pour garantir la résilience du scraper de la page de recherche face aux variations de mise en page et aux conditions de concurrence de pagination.
• Prévoyez dès le départ les contraintes de la plateforme : proxys résidentiels, en-têtes HTTP/2, sélection de la devise basée sur l'adresse IP et la limite de pagination d'environ 1 000 résultats qui impose le partitionnement des requêtes.
• Utilisez les sitemaps sous /robots.txt pour la découverte en masse d’URL d’hôtels et l’API de saisie semi-automatique de localisation pour résoudre les identifiants de destination.

Dans la plupart des juridictions, l'extraction de listes d'hôtels, de prix et d'avis agrégés accessibles au public est généralement considérée comme autorisée lorsqu'elle est effectuée à un rythme raisonnable et sans contourner l'authentification. Cela dit, les conditions d'utilisation, la directive européenne sur les bases de données et le RGPD (pour toute information permettant d'identifier un auteur d'avis) sont tous à prendre en compte. Faites examiner votre cas d'utilisation spécifique par un conseiller juridique avant tout déploiement commercial, et évitez de stocker des données à caractère personnel.

Deux moyens fiables : acheminer les requêtes via un proxy situé dans le pays dont vous souhaitez la devise (Booking.com déduit la devise à partir de l'adresse IP de sortie), ou passer un selected_currency=EUR-style à chaque requête pour remplacer la valeur par défaut déduite. Combinez les deux pour plus de cohérence, car la valeur de remplacement est parfois ignorée lorsque l'adresse IP et le paramètre sont en conflit pour les hôtels dont les prix sont affichés dans une devise locale fixe.

Segmentez la requête. Booking.com limite chaque recherche à environ 1 000 résultats ; la solution consiste donc à diviser la ville en sous-ensembles plus petits qui respectent tous cette limite : par quartier, puis par nombre d'étoiles, puis par tranche de prix si nécessaire. Regroupez les identifiants d'hôtels obtenus et éliminez les doublons. Pour un inventaire complet, utilisez plutôt le plan du site de l'hôtel plutôt que l'interface de recherche.

Utilisez Selenium pour la découverte et les petites tâches ; utilisez le point de terminaison GraphQL pour les opérations à grande échelle. Selenium est plus tolérant lorsque le front-end change, car vous interrogez le DOM rendu. GraphQL est bien plus rapide et moins coûteux par requête, mais vous devez synchroniser les charges utiles et les en-têtes des requêtes avec le site en ligne. Une pratique courante consiste à maintenir les deux et à basculer de l'API vers le navigateur lorsque l'API tombe en panne.

Il s'agit presque toujours de l'une des trois raisons suivantes : vos dates d'arrivée et de départ ne sont pas fixées dans l'URL, votre adresse IP de sortie a modifié la devise ou appliqué une réduction régionale, ou le prix affiché dans la fiche de recherche exclut les taxes et les frais que le navigateur n'affiche qu'à l'étape suivante. Fixez les dates, définissez la devise et indiquez clairement que les prix récupérés correspondent à des tarifs par nuit hors taxes.

Le web scraping de Booking.com est un problème gérable dès lors que vous cessez de le traiter comme une simple page et commencez à le considérer comme un écosystème de points de terminaison. Selenium Wire vous offre une approche progressive pour les résultats de recherche et la pagination, le point de terminaison interne /dml/graphql vous offre la vitesse nécessaire à la surveillance continue, et des appels dédiés aux pages de détails des hôtels, aux tarifs par nuit et aux avis complètent l'ensemble de données. Ajoutez à cela la découverte du plan du site, le partitionnement des requêtes et le contrôle explicite de la devise, et vous obtenez un scraper qui va bien au-delà de l'exemple simpliste d'une requête unique.

Les éléments que la plupart des équipes sous-estiment sont ceux liés à l’infrastructure : l’empreinte digitale TLS et HTTP/2, la qualité des proxys résidentiels, la logique de réessai et de recul, ainsi que la patience nécessaire pour maintenir la synchronisation des sélecteurs et des charges utiles GraphQL à mesure que le site évolue.

Si vous préférez ne pas gérer vous-même cette couche anti-blocage, notre équipe chez WebScrapingAPI propose une API de scraper qui renvoie du HTML brut via des adresses IP résidentielles tournantes, avec gestion des CAPTCHA et du TLS prise en charge pour vous, ainsi qu’une API de navigateur pour les interactions en plusieurs étapes que Selenium gère dans ce guide. Intégrez l'une ou l'autre de ces API au code ci-dessus et vous pourrez vous concentrer sur l'analyse et le modèle de données, qui constituent la partie qui différencie réellement votre produit.