Web Scraping Booking.com: Hoteles, precios y reseñas (Guía 2026)

Hay varios casos de uso en los que el scraping de Booking.com se amortiza casi de inmediato. Los equipos de inteligencia de tarifas comparan los precios por noche de los hoteles de la competencia en tiempo real. Los gestores de ingresos hacen un seguimiento de la disponibilidad y los patrones de descuento para programar sus propias promociones. Los equipos de investigación de mercado y análisis de viajes utilizan el volumen de reseñas, las puntuaciones y la cobertura de servicios para evaluar un destino. Y cualquiera que esté creando un metabuscador o una agencia de viajes con IA necesita datos estructurados de los establecimientos que el sitio público solo muestra en JavaScript.

A lo largo de esta guía extraeremos cinco tipos de entidades concretas: listados de resultados de búsqueda (fichas de hoteles en una página de resultados), páginas de detalles de hoteles (descripción, dirección, servicios, geolocalización), precios por noche y disponibilidad, opiniones de huéspedes e inventario de hoteles basado en el mapa del sitio para la búsqueda masiva. Cada una tiene sus propias peculiaridades, y mezclarlas es lo que te proporciona un conjunto de datos real en lugar de una simple captura de pantalla de una SERP.

Hay dos formas razonables de realizar el scraping web de Booking.com a cualquier volumen, y son complementarias en lugar de competitivas.

Selenium con Selenium Wire ejecuta una instancia real de Chrome, ejecuta el JavaScript de la página y te permite leer el DOM renderizado. Es la opción que ofrece menos fricción cuando aún no conoces las solicitudes ocultas de la página, y tolera bien las variaciones de diseño porque consultas el mismo DOM que ve el usuario. El precio es la velocidad y el uso de recursos: cada página ocupa una pestaña completa del navegador. Para listas seleccionadas de unos pocos miles de hoteles, eso está bien. Para la monitorización continua, resulta caro.

Llamar al /dml/graphql punto final con httpx omite por completo el navegador. El propio front-end de Booking.com obtiene los resultados de búsqueda de este punto final, por lo que, una vez que imitas la forma de la solicitud, obtienes el mismo JSON que el sitio, entre diez y cincuenta veces más rápido que Selenium y con un consumo de memoria mínimo. La contrapartida es la fragilidad: las cargas útiles y los encabezados requeridos cambian, y debes mantenerlos sincronizados.

Una opción sólida por defecto: haz un prototipo con Selenium, fija la solicitud GraphQL una vez que comprendas los datos y utiliza la ruta de la API para la producción.

Utiliza Python 3.10 o una versión más reciente en un virtualenv nuevo para que las dependencias permanezcan aisladas:

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 es un sustituto directo de selenium que expone las solicitudes de red subyacentes, que necesitaremos para la sincronización de la paginación. webdriver-manager descarga automáticamente el chromedriver , para que no tengas que estar pendiente de las versiones de los controladores en las distintas máquinas. httpx nos proporciona un cliente compatible con HTTP/2 para el Método 2, y parsel proporciona selectores CSS y XPath al estilo de Scrapy para analizar el HTML de los hoteles. Nuestro tutorial paso a paso de Selenium es un buen punto de partida si nunca has utilizado Selenium para el scraping.)

Este es el punto de partida más sencillo para el scraping web de Booking.com: abre una URL de búsqueda en una sesión real de Chrome, deja que JavaScript renderice las fichas de los alojamientos y recorre el DOM. Utilizamos Selenium Wire en lugar de Selenium básico porque la página de búsqueda carga los resultados a través de llamadas XHR/fetch en segundo plano. Selenium Wire nos permite inspeccionar esas solicitudes individuales y esperar hasta que se devuelva realmente una respuesta específica, lo cual es importante para paginar sin condiciones de carrera.

Incluye siempre fechas explícitas de entrada y salida en la URL. Sin ellas, Booking.com recurre a la disponibilidad predeterminada y tu columna de precios no coincidirá con lo que vería un usuario en una ventana de reserva real.

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 es bastante coherente en el uso de data-testid en sus tarjetas de resultados, lo que las hace más estables a la hora de seleccionarlas que los nombres de clase que se generan automáticamente.

Cada ficha de propiedad contiene el mismo conjunto de data-testid ganchos, por lo que el analizador por tarjeta es básicamente un pequeño diccionario de selectores. Los selectores CSS suelen ser la mejor opción aquí (concisos y rápidos), pero XPath está bien cuando necesitas recorrer elementos padres o hermanos. Consulta nuestra guía de selectores XPath vs CSS si estás dudando.

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]

Hay dos cosas que destacar sobre los precios. En primer lugar, el review-score bloque de Booking.com agrupa la puntuación numérica y el texto del recuento de reseñas en un solo elemento, por lo que lo dividimos en líneas y los extraemos por separado. En segundo lugar, el precio que se extrae de una ficha de búsqueda casi siempre excluye impuestos y tasas; el total con todo incluido solo aparece una vez que se avanza más en el proceso de reserva. Trátalo como la tarifa principal, no como el cargo final, y documéntalo más adelante.

Cada clic en el control de página siguiente envía un POST a /dml/graphql y espera a que vuelva el JSON. Si haces clic y extraes inmediatamente el DOM, lees la página anterior. Selenium Wire soluciona esto permitiéndote bloquear la respuesta real.

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 es la línea importante. Sin ella, wait_for_request coincide sin problemas con la llamada GraphQL de la página anterior y avanzas antes de que lleguen los nuevos datos. Obtén el recuento total de páginas del control de paginación en lugar de codificarlo de forma rígida; las consultas con mucho tráfico pueden paginar hasta veinte páginas, las tranquilas, dos.

Una vez que Selenium te ha mostrado que la página de búsqueda se alimenta de /dml/graphql, la opción más rápida es llamar tú mismo a ese punto final y saltarte el navegador. Aquí es donde el web scraping de Booking.com se vuelve realmente escalable.

El proceso de descubrimiento es el mismo que usarías para cualquier [API JavaScript oculta]: abre DevTools (F12), cambia a la pestaña Red, filtra por Fetch/XHR, luego inicia una búsqueda real y haz clic en la página dos. Verás un POST a /dml/graphql que lleva un cuerpo JSON con un operationName, un variables objeto (con el destino, las fechas, el número de huéspedes y un offset), y un query o extensions que fija el hash de la consulta. Haz clic con el botón derecho en la solicitud y selecciona «Copiar como cURL», y ese será tu punto de partida.

Vuelve a verificar los nombres exactos de los campos comparándolos con tu propia captura de DevTools antes de enviar la solicitud; Booking.com renombra las operaciones de GraphQL periódicamente, y la referencia más segura es la que envía el front-end en este momento.

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

Dos detalles que suelen confundir a la gente. El punto final devuelve 25 resultados por llamada, controlados por una variable de desplazamiento que se incrementa en pasos de 25 resultados. Y la solicitud debe parecer que proviene del propio sitio: origin y referer establecida en booking.com, content-type: application/json, y un accept-language que coincida con la región de tu IP. Si eliminas esos encabezados, obtendrás un 400 genérico o un bloqueo suave en unas pocas solicitudes. Usa HTTP/2 (httpx lo hace cuando pasas http2=True) porque el proxy de Booking.com parece identificar a los clientes que siguen negociando solo HTTP/1.1.

Las fichas de resultados de búsqueda son solo una parte del scraping web de Booking.com; te dan un nombre y un precio, pero no te proporcionan los detalles completos del hotel que los equipos de viajes realmente quieren. Para eso, extrae la URL del hotel directamente. Las páginas de los hoteles se renderizan principalmente en el servidor, por lo que basta con un simple GET más parsel es suficiente, sin necesidad de navegador.

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 latitud y la longitud suelen estar incrustadas en un data-atlas-latlng en el enlace del mapa, lo cual es más fiable que extraerlas de scripts en línea. Las comodidades se agrupan en bloques de características; recorre los grupos si quieres que estén categorizados en lugar de agrupados.

El precio por noche no se encuentra en el HTML del hotel; se encuentra detrás de una consulta GraphQL independiente que devuelve una respuesta en forma de calendario. Captura la solicitud de la misma manera que la llamada de búsqueda: abre la página del hotel en DevTools, cambia las fechas y espera a que se envíe el POST de precios/disponibilidad a /dml/graphql. El cuerpo incluye los identificadores del hotel (código numérico hotel_id, código de país y moneda) y un intervalo de fechas.

Las páginas de los hoteles también incorporan un token de tipo CSRF en el HTML que la consulta de precios espera encontrar en el cuerpo o en un encabezado. Extráelo de la página una vez por hotel y luego reutilízalo para cada llamada de precios.

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()

Las opiniones de los huéspedes se cargan a través de una solicitud XHR independiente al hacer clic en la pestaña «Opiniones» de la página de un hotel. Abre DevTools, ve a «Fetch/XHR», haz clic en la pestaña y copia la solicitud. Se pagina a través de un skip (o offset) en lotes de aproximadamente 25, y devuelve el texto de la reseña, la puntuación, el idioma, el país del autor y la fecha.

Una vez que tengas una llamada que funcione, puedes distribuirla de forma simultánea ejecutando lotes en 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)

Mantén la concurrencia en cifras de un solo dígito por hotel; las reseñas tienen una limitación de velocidad muy estricta.

Para el rastreo web masivo del inventario de Booking.com, en lugar de rastrear con una consulta a la vez, empieza en https://www.booking.com/robots.txt. Booking.com publica allí sus Sitemap: entradas allí, incluyendo índices de mapas del sitio de hoteles, atracciones y aeropuertos. Cada índice de mapa del sitio apunta a submapas del sitio con un límite de 50 000 URL (según el protocolo de mapas del sitio), por lo que el índice de hoteles se divide en muchos archivos. Recorrer el índice te proporciona decenas de millones de URL de hoteles, con duplicados, que puedes deduplicar por el slug de la URL o por un ID de hotel analizado. Nuestra guía de rastreo de mapas de sitio tiene un patrón reutilizable para esto.

Para búsquedas específicas, el propio punto final de autocompletado de ubicación de Booking.com resuelve una cadena de ciudad o barrio en los identificadores de destino que espera la llamada GraphQL de búsqueda, lo que es mejor que codificarlos manualmente.

El éxito del scraping de Booking.com, sea cual sea el volumen, se reduce a parecer un navegador normal y retirarse cuando el sitio te lo pide. A partir de 2026, la pila antibots de Booking.com parece identificar tanto el comportamiento TLS como el HTTP/2, por lo que los fundamentos son innegociables: un cliente compatible con HTTP/2 (httpx con http2=True), un conjunto de encabezados realista que incluya accept-language y sec-ch-ua-*, y un user-agent que coincida con una versión actual de Chrome. (Vuelve a verificar la sensibilidad de HTTP/2 periódicamente; esto cambia).

Utilice proxies residenciales o de ISP en lugar de rangos de centros de datos; las IP de centros de datos que acceden a Booking.com empiezan a activar los captchas tras unas pocas docenas de solicitudes. Mantenga una concurrencia conservadora (de 5 a 10 por IP), añada fluctuación y reduzca exponencialmente 429 y 403. Tanto la red de proxies residenciales de WebScrapingAPI como la API Scraper se encargan de la rotación, los reintentos y las huellas TLS si prefieres no reinventar esa infraestructura. Los navegadores antidetección son el último recurso para las páginas más difíciles.

Booking.com deduce la moneda mostrada a partir de la geolocalización de tu IP de salida, por lo que un rastreador con sede en EE. UU. verá USD y uno con sede en la UE verá EUR por defecto. Para mantener una moneda constante, dirígete a través de un proxy específico para cada país o pasa un selected_currency parámetro de consulta en cada solicitud. (Vuelve a comprobar este comportamiento periódicamente; el nombre del parámetro y la lógica de inferencia de la IP son el tipo de cosas que cambian silenciosamente).

La plataforma también limita cualquier búsqueda individual a aproximadamente 1.000 resultados. Para enumerar el inventario en una ciudad concurrida, divide la consulta: rastrea Londres por barrio (Shoreditch, Camden, Kensington), luego por categoría de estrellas, luego por rango de precios, y une los resultados por ID de hotel.

Para las ejecuciones en producción, integra este código en Scrapy y deja que se encargue de los reintentos, la persistencia y las ejecuciones distribuidas. Almacena la salida normalizada en Postgres o en un almacén columnar, realiza instantáneas diarias y mantén la integridad de tus rastreadores con robots.txt los términos de servicio de Booking.com.

• El scraping web de Booking.com funciona mejor combinando dos métodos: Selenium Wire para la creación de prototipos y la estabilidad del DOM, y el /dml/graphql punto final a través de httpx para la velocidad de producción.
• Extrae el conjunto completo de entidades (listados de búsqueda, páginas de detalles de hoteles, precios por noche y opiniones de huéspedes), en lugar de limitarte a la SERP de búsqueda; de lo contrario, el conjunto de datos será demasiado escaso para el análisis de tarifas.
• Utiliza data-testid selectores y wait_for_request on /dml/graphql para que el rastreador de la página de búsqueda sea resistente a los cambios de diseño y a las condiciones de carrera de paginación.
• Planifica de antemano teniendo en cuenta las limitaciones de la plataforma: proxies residenciales, encabezados HTTP/2, selección de moneda basada en la IP y el límite de paginación de aproximadamente 1000 resultados que obliga a dividir las consultas.
• Utilice mapas de sitio en /robots.txt para la detección masiva de URL de hoteles y la API de autocompletado de ubicaciones para resolver los identificadores de destino.

En la mayoría de las jurisdicciones, el scraping de listados de hoteles, precios y reseñas agregadas visibles públicamente se considera generalmente permisible cuando se realiza a un ritmo razonable y sin eludir la autenticación. Dicho esto, los términos de servicio, la Directiva de la UE sobre bases de datos y el RGPD (para cualquier información que permita identificar a los reseñadores) son importantes. Haz que un asesor legal revise tu caso de uso específico antes de la implementación comercial y evita almacenar datos personales.

Hay dos métodos fiables: redirigir las solicitudes a través de un proxy ubicado en el país cuya moneda desees (Booking.com deduce la moneda a partir de la IP de salida), o pasar un selected_currency=EURparámetro de consulta de tipo en cada solicitud para anular el valor predeterminado deducido. Combina ambas opciones para garantizar la coherencia, ya que la anulación se ignora ocasionalmente cuando la IP y el parámetro entran en conflicto para hoteles con precios en una moneda local fija.

Divide la consulta. Booking.com limita cualquier búsqueda individual a unos 1.000 resultados, por lo que la solución es dividir la ciudad en subconjuntos más pequeños que quepan cada uno dentro del límite: por barrio, luego por categoría de estrellas y, si es necesario, por rango de precios. Une los ID de los hoteles resultantes y elimina los duplicados. Para obtener una enumeración completa del inventario, recurre a recorrer el índice del mapa del sitio del hotel en lugar de la interfaz de búsqueda.

Utiliza Selenium para la exploración y los trabajos pequeños; utiliza el punto final de GraphQL para tareas a gran escala. Selenium es más tolerante cuando cambia la interfaz de usuario, ya que consultas el DOM renderizado. GraphQL es mucho más rápido y económico por solicitud, pero debes mantener las cargas útiles y los encabezados de las solicitudes sincronizados con el sitio en vivo. Un patrón común es mantener ambos y realizar una conmutación por error de la API al navegador cuando la API falla.

Casi siempre se debe a una de estas tres cosas: tus fechas de entrada/salida no están fijadas en la URL, tu IP de salida cambió la moneda o aplicó un descuento regional, o el precio de la ficha de búsqueda excluye los impuestos y las tasas que el navegador muestra solo en el siguiente paso. Fija las fechas, corrige la moneda y etiqueta claramente los precios extraídos como tarifas por noche sin impuestos.

El scraping web de Booking.com es un problema manejable una vez que dejas de tratarlo como una sola página y empiezas a tratarlo como un ecosistema de puntos finales. Selenium Wire te ofrece una vía de acceso sencilla para los resultados de búsqueda y la paginación, el punto final interno /dml/graphql te proporciona la velocidad necesaria para la monitorización continua, y las llamadas específicas a las páginas de detalles de los hoteles, los precios por noche y las reseñas completan el conjunto de datos. Añade el descubrimiento del mapa del sitio, la partición de consultas y el control explícito de la moneda, y tendrás un rastreador que va más allá del ejemplo de una sola consulta.

Los aspectos que la mayoría de los equipos subestiman son los relacionados con la infraestructura: huellas de TLS y HTTP/2, calidad de los proxies residenciales, lógica de reintentos y retroceso, y la paciencia para mantener sincronizados los selectores y las cargas útiles de GraphQL a medida que el sitio evoluciona.

Si prefieres no mantener tú mismo esa capa anti-bloqueo, nuestro equipo de WebScrapingAPI ofrece una API de scraper que devuelve HTML sin procesar a través de IP residenciales rotativas, con CAPTCHAs y gestión de TLS gestionados por nosotros, además de una API de navegador para las interacciones de varios pasos que Selenium gestiona en esta guía. Incorpora cualquiera de las dos delante del código anterior y podrás centrarte en el análisis y el modelo de datos, que es la parte que realmente diferencia a tu producto.