Scrape TripAdvisor v Pythonu (Aniž byste byli zablokováni)

Minulý týden jsem z TripAdvisoru zkoušel vytáhnout hodnocení hotelů a počet recenzí pro zhruba 200 ubytování ve třech evropských městech. Můj první skript — obyčejný requests.get() s výchozími hlavičkami — mi na každém jediném požadavku vrátil parádní chybu 403 Forbidden. Ani jeden byte užitečných dat.

TripAdvisor je jeden z nejbohatších veřejných zdrojů dat v cestovním ruchu: přes , více než 8 milionů firemních profilů a přibližně 460 milionů unikátních návštěvníků měsíčně. Ovlivňuje víc než ročních výdajů za cestování. Ale dostat se k těmto datům programově? Tam začíná problém. TripAdvisor používá detekci botů DataDome, Cloudflare WAF, TLS fingerprinting a JavaScriptové challenge — vrstvenou obranu, která většinu naivních pokusů o scraping zastaví ještě dřív, než vůbec začnou. Tahle příručka je přesně ten zdroj, který jsem si přál mít: přímé srovnání tří Python přístupů ke scrapingu (plus jedna no-code varianta), kompletní kód ke každému z nich, strukturovanou sekci pro řešení blokací a znovupoužitelné vzory, které fungují pro hotely, restaurace i atrakce. Ať už jste v Pythonu začátečník, nebo zkušený vývojář, tohle vám ušetří spoustu zbytečných 403ek.

Nechcete psát kód? TripAdvisor můžete scrapovat snadno

Rád bych byl hned od začátku upřímný: hodně lidí, kteří hledají „scrape TripAdvisor with Python“, vlastně netouží po programování. Chtějí hlavně data — názvy hotelů, hodnocení, počet recenzí, ceny — a chtějí je rychle v tabulce. Pokud jste to vy, existuje mnohem kratší cesta.

je naše AI-powered Chrome rozšíření, které umí přečíst libovolnou stránku TripAdvisoru a automaticky navrhnout správné sloupce k extrakci. Workflow jsou opravdu jen dva kliky:

1. Otevřete stránku se seznamem na TripAdvisoru (např. výsledky vyhledávání „Hotely v Paříži“).
2. Klikněte na „AI Suggest Fields“ v postranním panelu Thunderbitu. AI projde stránku a navrhne sloupce jako Název hotelu, Hodnocení, Počet recenzí, Cena a Lokalita.
3. Klikněte na „Scrape.“ Thunderbit vytáhne data ze všech záznamů na stránce — a pokud je potřeba víc výsledků, zvládne i stránkování automaticky.
4. Exportujte do Excelu, Google Sheets, Airtable nebo Notion. Export je zdarma v každém plánu.

Thunderbit funguje napříč hotely, restauracemi i atrakcemi bez jakýchkoli změn konfigurace — AI se přizpůsobí tomu, co je na stránce. U stránkovaných výsledků automaticky rozpozná tlačítko „Další“ i nekonečné scrollování. A protože běží ve vašem skutečném Chrome prohlížeči, používá vaše session cookies a fingerprint prohlížeče, což mu dává přirozenou výhodu proti detekci botů.

Vyzkoušet to můžete přes — bezplatná verze nabízí 6 stránek měsíčně, což stačí na otestování workflow.

Pokud potřebujete programové řízení, vlastní logiku parsování nebo plánujete scrapovat 10 000+ stránek, Python je správná volba. Pokračujte ve čtení.

Proč scrapovat TripAdvisor v Pythonu?

Data z TripAdvisoru mají přímý a měřitelný dopad na byznys. Studie ukázala, že zvýšení Global Review Indexu hotelu o 1 bod ze 100 vede k nárůstu průměrné denní sazby o 0,89 % a k růstu Revenue Per Available Room o 1,42 %. Jiná studie na zjistila, že exogenní zvýšení hodnocení na TripAdvisoru o 1 hvězdičku znamená pro průměrný hotel dodatečný roční příjem ve výši 55 000–75 000 dolarů. Recenze nejsou jen ego-metrika — jsou motorem tržeb.

Takhle různá týmy používají data z TripAdvisoru:

Proč právě Python? Tři důvody. Zaprvé ekosystém: BeautifulSoup, Selenium, Playwright, Scrapy, httpx, pandas — Python má zralější scrapingové i analytické knihovny než kterýkoli jiný jazyk. Zadruhé používá Python, takže máte víc podpory komunity, víc odpovědí na StackOverflow a víc aktuálních návodů. Zatřetí výhoda pipeline: můžete scrapovat s BeautifulSoup, čistit data v pandas, dělat sentiment analysis přes Hugging Face Transformers a stavět dashboardy — všechno v jednom jazyce. Žádné přepínání kontextu.

Tři způsoby, jak scrapovat TripAdvisor v Pythonu (vedle sebe)

Každý konkurenční návod si vybere jeden přístup a ten rozvíjí. To ale moc nepomůže, když se rozhodujete ještě předtím, než začnete psát kód. Tady je srovnávací tabulka, kterou bych si býval přál dostat:

Je tu pár důležitých poznámek. Ty syrové rychlosti jsou teoretické — rate limiting TripAdvisoru (~10–15 požadavků za minutu na IP) ve skutečnosti omezuje průchodnost zhruba na 10 stránek za minutu na IP bez ohledu na přístup. Skrytý JSON vám dává nejvíc dat na jeden request, takže potřebujete méně celkových požadavků a jste méně vystaveni rate limitu. Selenium je v reálných testech asi 5× pomalejší než přístupy přes requests, ale je to jediná možnost, když potřebujete klikat na tlačítka nebo renderovat JavaScript.

Zbytek průvodce prochází všemi třemi Python metodami i s kompletním kódem. Vyberte si tu, která odpovídá vaší situaci, nebo je kombinujte (já často používám requests+BS4 pro seznamy a skrytý JSON pro detailní stránky).

Nastavení Python prostředí

Než začneme, připravme si prostředí. Budete potřebovat Python 3.10+ (doporučuji 3.12 nebo 3.13 — všechny hlavní balíčky je podporují bez známých problémů).

Nainstalujte vše najednou:

1pip install requests beautifulsoup4 selenium httpx parsel pandas curl-cffi

Poznámky k balíčkům:

• requests (2.33.1) — HTTP požadavky, vyžaduje Python 3.10+
• beautifulsoup4 (4.14.3) — parsování HTML
• selenium (4.43.0) — automatizace prohlížeče, vyžaduje Python 3.10+
• httpx (0.28.1) — asynchronní HTTP klient
• parsel (1.11.0) — CSS/XPath selektory (lehčí než BS4)
• pandas (3.0.2) — export dat, vyžaduje Python 3.11+
• curl-cffi (0.15.0) — imitace TLS fingerprintu (kritické pro obcházení Cloudflare)

ChromeDriver: Pokud používáte Selenium, dobrá zpráva — od Selenium 4.6 dál Selenium Manager automaticky stáhne a uloží správný binární soubor ChromeDriveru. Ruční instalace není potřeba. Verze se párují dynamicky, takže nemusíte řešit nesoulad verzí Chromu.

Virtuální prostředí (doporučeno):

1python -m venv tripadvisor-scraper
2source tripadvisor-scraper/bin/activate  # macOS/Linux
3tripadvisor-scraper\Scripts\activate     # Windows

Přístup 1: Scrape TripAdvisor pomocí Requests a BeautifulSoup

Tohle je nejjednodušší přístup. Funguje dobře pro scraping výpisů (výsledky vyhledávání hotelů, seznamy restaurací), kde jsou potřebná data přímo v HTML. Žádný prohlížeč, žádné renderování JavaScriptu, minimální nároky na zdroje.

Pochopení vzorů URL na TripAdvisoru

URL TripAdvisoru sledují podle kategorie poměrně předvídatelné vzory:

• Hotely: https://www.tripadvisor.com/Hotels-g{locationId}-{Location_Name}-Hotels.html
• Restaurace: https://www.tripadvisor.com/Restaurants-g{locationId}-{Location_Name}.html
• Atrakce: https://www.tripadvisor.com/Attractions-g{locationId}-Activities-{Location_Name}.html

Stránkování používá parametr oa (offset anchors) vložený do URL. Každá stránka ukazuje 30 výsledků:

• Stránka 1: základní URL (bez parametru oa)
• Stránka 2: Hotels-g187768-oa30-Italy-Hotels.html
• Stránka 3: Hotels-g187768-oa60-Italy-Hotels.html

U stránek s recenzemi je offset parametr or a zvyšuje se po 10:

• Stránka 1: Reviews-or0-Hotel_Name.html
• Stránka 2: Reviews-or10-Hotel_Name.html

Pro zobrazení recenzí ve všech jazycích přidejte do URL ?filterLang=ALL.

Odesílání požadavků s realistickými hlavičkami

TripAdvisor hlavičky kontroluje velmi přísně. Požadavek s defaultními Python hlavičkami je okamžitě zablokován. Musíte napodobit skutečný prohlížeč Chrome:

1import requests
2import time
3import random
4session = requests.Session()
5headers = {
6    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
7    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
8    "Accept-Language": "en-US,en;q=0.9",
9    "Accept-Encoding": "gzip, deflate, br",
10    "Referer": "https://www.tripadvisor.com/",
11    "Sec-Fetch-Dest": "document",
12    "Sec-Fetch-Mode": "navigate",
13    "Sec-Fetch-Site": "none",
14    "Sec-CH-UA": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
15    "Sec-CH-UA-Mobile": "?0",
16    "Sec-CH-UA-Platform": '"Windows"',
17}
18session.headers.update(headers)
19url = "https://www.tripadvisor.com/Hotels-g187147-Paris_Ile_de_France-Hotels.html"
20response = session.get(url)
21print(f"Status: {response.status_code}")
22print(f"Délka obsahu: {len(response.text)} znaků")

Důležitý detail: TripAdvisor ověřuje, že User-Agent a hlavičky Sec-CH-UA Client Hints spolu odpovídají. Když tvrdíte, že jste Chrome 135 v User-Agentu, ale Sec-CH-UA říká Chrome 120, budete označeni jako podezřelí. Vždy rotujte celé sady hlaviček dohromady, ne jednotlivé hlavičky zvlášť.

Parsování výpisů pomocí BeautifulSoup

Jakmile dostanete úspěšnou odpověď, data vytáhněte pomocí BeautifulSoup. TripAdvisor používá atributy data-automation a data-test-attribute, které jsou stabilnější než CSS třídy (ty se mění často):

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "html.parser")
3# Najít všechny karty hotelů
4cards = soup.select('div[data-test-attribute="location-results-card"]')
5hotels = []
6for card in cards:
7    # Název hotelu
8    title_el = card.select_one('div[data-automation="hotel-card-title"]')
9    name = title_el.get_text(strip=True) if title_el else None
10    # Odkaz na detail
11    link_el = card.select_one('div[data-automation="hotel-card-title"] a')
12    link = "https://www.tripadvisor.com" + link_el["href"] if link_el else None
13    # Hodnocení
14    rating_el = card.select_one('[data-automation="bubbleRatingValue"]')
15    rating = rating_el.get_text(strip=True) if rating_el else None
16    # Počet recenzí
17    review_el = card.select_one('[data-automation="bubbleReviewCount"]')
18    review_count = review_el.get_text(strip=True).replace(",", "").split()[0] if review_el else None
19    hotels.append({
20        "name": name,
21        "rating": rating,
22        "review_count": review_count,
23        "url": link,
24    })
25print(f"Na této stránce jsem našel {len(hotels)} hotelů")
26for h in hotels[:3]:
27    print(h)

Poznámka k selektorům: TripAdvisor používá obfuskované názvy tříd CSS (např. FGwzt, yyzcQ), které se mění s každou úpravou webu. Atributy data-automation a data-test-target jsou mnohem stabilnější. Vždy dávejte přednost datovým atributům před třídami.

Zpracování stránkování

Pokud chcete scrapovat víc stránek, projděte offset parametr s rozumnou prodlevou mezi požadavky:

1import pandas as pd
2all_hotels = []
3base_url = "https://www.tripadvisor.com/Hotels-g187147-oa{offset}-Paris_Ile_de_France-Hotels.html"
4for page in range(5):  # Prvních 5 stránek
5    offset = page * 30
6    url = base_url.format(offset=offset) if page > 0 else "https://www.tripadvisor.com/Hotels-g187147-Paris_Ile_de_France-Hotels.html"
7    response = session.get(url)
8    if response.status_code != 200:
9        print(f"Stránka {page + 1}: stav {response.status_code}, končím.")
10        break
11    soup = BeautifulSoup(response.text, "html.parser")
12    cards = soup.select('div[data-test-attribute="location-results-card"]')
13    for card in cards:
14        title_el = card.select_one('div[data-automation="hotel-card-title"]')
15        name = title_el.get_text(strip=True) if title_el else None
16        rating_el = card.select_one('[data-automation="bubbleRatingValue"]')
17        rating = rating_el.get_text(strip=True) if rating_el else None
18        review_el = card.select_one('[data-automation="bubbleReviewCount"]')
19        review_count = review_el.get_text(strip=True).replace(",", "").split()[0] if review_el else None
20        all_hotels.append({"name": name, "rating": rating, "review_count": review_count})
21    print(f"Stránka {page + 1}: nalezeno {len(cards)} hotelů")
22    time.sleep(random.uniform(3, 7))  # Náhodná prodleva proti rate limitu
23df = pd.DataFrame(all_hotels)
24print(f"\nCelkem vyextrahováno hotelů: {len(df)}")

time.sleep(random.uniform(3, 7)) je důležitý. Prahová hodnota rate limitu TripAdvisoru je zhruba 10–15 požadavků za minutu na IP. Při rychlejším tempu riskujete CAPTCHA nebo chyby 429.

Omezení tohoto přístupu

Kde tento přístup selhává? Requests+BS4 selže, když:

• TripAdvisor vrací obsah vykreslený JavaScriptem (některé výsledkové stránky JS vyžadují)
• Text recenze je zkrácený za tlačítkem „Read more“
• Ochrana proti botům přejde na JavaScript challenge nebo CAPTCHA
• Potřebujete data, která se načítají až po klientském renderingu (ceny, dostupnost)

Pro tyto scénáře potřebujete buď Selenium (Přístup 2), nebo skrytý JSON (Přístup 3).

Přístup 2: Scrape TripAdvisor pomocí Selenium (headless prohlížeč)

Selenium spouští skutečný prohlížeč, takže umí renderovat JavaScript, klikat na tlačítka, řešit cookie consent bannery a pracovat s dynamickým obsahem. Cena za to: je asi a na jednu instanci prohlížeče spotřebuje 300–500 MB RAM.

Nastavení Selenium s anti-detection parametry

Ve výchozím stavu je Selenium snadno detekovatelné. Fingerprinting TripAdvisoru ho okamžitě odhalí. Musíte vypnout automatizační příznaky:

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.support.ui import WebDriverWait
5from selenium.webdriver.support import expected_conditions as EC
6options = Options()
7options.add_argument("--headless=new")  # Nový headless režim (Chrome 112+)
8options.add_argument("--disable-blink-features=AutomationControlled")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36")
11options.add_experimental_option("excludeSwitches", ["enable-automation"])
12options.add_experimental_option("useAutomationExtension", False)
13driver = webdriver.Chrome(options=options)
14# Odstranit webdriver property z navigatoru
15driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
16    "source": "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
17})

Stačí to pro TripAdvisor? Pro menší scraping (pod 50 stránek) tohle nastavení s rezidenčními proxy obvykle funguje. Při větších objemech budete možná potřebovat undetected-chromedriver nebo nodriver — ochrana DataDome na TripAdvisoru vyhodnocuje přes 1 000 signálů na jeden request včetně TLS fingerprintů, které čisté Selenium neumí napodobit.

Scrapování výsledků hotelů pomocí Selenium

1import time
2import random
3url = "https://www.tripadvisor.com/Hotels-g187147-Paris_Ile_de_France-Hotels.html"
4driver.get(url)
5# Počkat, až se načtou karty hotelů
6wait = WebDriverWait(driver, 15)
7wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'div[data-test-attribute="location-results-card"]')))
8# Zpracování cookie consent popupu (pokud se objeví)
9try:
10    cookie_btn = driver.find_element(By.ID, "onetrust-accept-btn-handler")
11    cookie_btn.click()
12    time.sleep(1)
13except:
14    pass  # Žádný cookie popup
15# Extrakce dat o hotelech
16cards = driver.find_elements(By.CSS_SELECTOR, 'div[data-test-attribute="location-results-card"]')
17hotels = []
18for card in cards:
19    try:
20        name = card.find_element(By.CSS_SELECTOR, 'div[data-automation="hotel-card-title"]').text
21    except:
22        name = None
23    try:
24        rating = card.find_element(By.CSS_SELECTOR, '[data-automation="bubbleRatingValue"]').text
25    except:
26        rating = None
27    try:
28        reviews = card.find_element(By.CSS_SELECTOR, '[data-automation="bubbleReviewCount"]').text
29    except:
30        reviews = None
31    hotels.append({"name": name, "rating": rating, "review_count": reviews})
32print(f"Vyextrahováno {len(hotels)} hotelů")
33for h in hotels[:3]:
34    print(h)

Na mém stroji to trvalo asi 8 sekund na jednu stránku — oproti méně než 1 sekundě u requests+BS4. Ten rozdíl se při scrapování stovek stránek rychle nasčítá.

Rozkliknutí „Read more“ a scrapování celých recenzí

Stránky recenzí zkracují dlouhé texty za tlačítkem „Read more“. Selenium na to umí kliknout:

1review_url = "https://www.tripadvisor.com/Hotel_Review-g187147-d188726-Reviews-Le_Marais_Hotel-Paris_Ile_de_France.html"
2driver.get(review_url)
3wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'div[data-reviewid]')))
4time.sleep(2)
5# Kliknout na všechna tlačítka „Read more“
6read_more_buttons = driver.find_elements(By.XPATH, '//button//*[contains(text(), "Read more")]/..')
7for btn in read_more_buttons:
8    try:
9        driver.execute_script("arguments[0].click();", btn)
10        time.sleep(0.3)
11    except:
12        pass
13# Extrakce recenzí
14review_elements = driver.find_elements(By.CSS_SELECTOR, 'div[data-reviewid]')
15reviews = []
16for rev in review_elements:
17    try:
18        title = rev.find_element(By.CSS_SELECTOR, 'div[data-test-target="review-title"]').text
19    except:
20        title = None
21    try:
22        body = rev.find_element(By.CSS_SELECTOR, 'q.IRsGHoPm span').text
23    except:
24        try:
25            body = rev.find_element(By.CSS_SELECTOR, 'p.partial_entry').text
26        except:
27            body = None
28    try:
29        rating_class = rev.find_element(By.CSS_SELECTOR, 'div[data-test-target="review-rating"] span').get_attribute("class")
30        # Hodnocení je zakódované v class jako "ui_bubble_rating bubble_50" = 5.0
31        rating_num = [c for c in rating_class.split() if "bubble_" in c][0].replace("bubble_", "")
32        rating = int(rating_num) / 10
33    except:
34        rating = None
35    reviews.append({"title": title, "body": body, "rating": rating})
36print(f"Vyextrahováno {len(reviews)} recenzí")

Přidání rotace proxy do Selenium

Pro dlouhodobý scraping budete potřebovat rotaci proxy. Protože selenium-wire je od ledna 2024 zastaralý, použijte vestavěnou podporu proxy v Chromu:

1# S proxy bez autentizace
2proxy = "http://your-proxy-address:port"
3options.add_argument(f"--proxy-server={proxy}")
4# U proxy s autentizací použijte Chrome extension nebo BiDi protokol v Selenium 4

Pro programovou rotaci proxy vytvářejte novou instanci driveru s jinou proxy pro každou dávku požadavků. Není to elegantní, ale funguje to spolehlivě.

Přístup 3: Skrytý JSON (bez parsování HTML)

Většina návodů tento přístup úplně přeskakuje, což je škoda — je to nejrychlejší a nejčistší ze všech tří. TripAdvisor vkládá strukturovaná data přímo do HTML stránky ve formě JSONu — uvnitř <script> tagů jako JavaScriptové proměnné typu pageManifest a urqlCache. Extrakce tohoto JSONu vám dá čistší data (hodnocení jako čísla, data ve formátu ISO), méně requestů a žádnou potřebu renderovat JavaScript.

Hledání vloženého JSONu ve zdrojovém kódu stránky

Klíčová myšlenka: můžete použít jednoduchý requests.get() pro stažení stránky a potom vytáhnout JSON ze surového HTML, aniž byste vůbec renderovali JavaScript.

1import requests
2import re
3import json
4headers = {
5    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
6    "Accept-Language": "en-US,en;q=0.9",
7    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
8    "Referer": "https://www.tripadvisor.com/",
9    "Sec-CH-UA": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
10    "Sec-CH-UA-Mobile": "?0",
11    "Sec-CH-UA-Platform": '"macOS"',
12}
13url = "https://www.tripadvisor.com/Hotel_Review-g188590-d194317-Reviews-NH_City_Centre_Amsterdam.html"
14response = requests.get(url, headers=headers)
15# Vytáhnout JSON blob pageManifest
16match = re.search(r"pageManifest:({.+?})};", response.text)
17if match:
18    page_data = json.loads(match.group(1))
19    print("Našel jsem data pageManifest")
20    print(f"Klíče: {list(page_data.keys())[:10]}")

Jak zjistit název proměnné sami: Otevřete libovolnou hotelovou stránku TripAdvisoru v Chromu, klikněte pravým tlačítkem → Zobrazit zdroj stránky a pak Ctrl+F na pageManifest, urqlCache nebo aggregateRating. Ta data tam jsou, jen čekají na parsování.

Parsování JSONu a extrakce strukturovaných dat

TripAdvisor také vkládá data schema.org v application/ld+json, která se ještě snadněji extrahují:

1from parsel import Selector
2sel = Selector(text=response.text)
3# Extrakce JSON-LD strukturovaných dat
4json_ld_scripts = sel.xpath("//script[@type='application/ld+json']/text()").getall()
5for script in json_ld_scripts:
6    data = json.loads(script)
7    if isinstance(data, dict) and data.get("@type") in ["Hotel", "Restaurant", "TouristAttraction"]:
8        print(f"Název: {data.get('name')}")
9        print(f"Hodnocení: {data.get('aggregateRating', {}).get('ratingValue')}")
10        print(f"Počet recenzí: {data.get('aggregateRating', {}).get('reviewCount')}")
11        print(f"Cenové rozmezí: {data.get('priceRange')}")
12        print(f"Adresa: {data.get('address', {}).get('streetAddress')}")
13        print(f"Souřadnice: {data.get('geo', {}).get('latitude')}, {data.get('geo', {}).get('longitude')}")
14        break

Data JSON-LD jsou vložená do statického HTML a NEvyžadují renderování JavaScriptu. Získáte název objektu, agregované hodnocení, počet recenzí, adresu, souřadnice, cenové rozmezí i URL fotek — bez parsování jediného HTML tagu.

Pro bohatší data (jednotlivé recenze, rozpad hodnocení, seznam vybavení) potřebujete objekt urqlCache:

1# Extrakce urqlCache pro detailní data recenzí
2cache_match = re.search(r'"urqlCache"\s*:\s*({.+?})\s*,\s*"redux"', response.text)
3if cache_match:
4    cache_data = json.loads(cache_match.group(1))
5    # Projděte cache a najděte data o recenzích
6    for key, value in cache_data.items():
7        if "reviews" in str(value).lower()[:100]:
8            reviews_data = json.loads(value.get("data", "{}")) if isinstance(value, dict) else None
9            if reviews_data:
10                print(f"Našel jsem položku cache s recenzemi: {key[:50]}...")
11                break

Přesné JSON cesty se občas mění, když TripAdvisor aktualizuje frontend, ale obecná struktura — JSON-LD pro souhrnná data a urqlCache pro detailní data — je stabilní už roky.

Reverzní analýza GraphQL API TripAdvisoru (pokročilé)

Pro velký objem dat vrací GraphQL endpointy TripAdvisoru strukturovaná data přímo. Je to nejrychlejší metoda, ale vyžaduje nejvíc údržby.

1import httpx
2import random
3import string
4def generate_request_id():
5    """Vygeneruje hodnotu hlavičky X-Requested-By"""
6    random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=180))
7    return f"TNI1625!{random_chars}"
8# Vyhledání hotelů v Paříži
9search_payload = [{
10    "variables": {
11        "request": {
12            "query": "hotels in Paris",
13            "limit": 10,
14            "scope": "WORLDWIDE",
15            "locale": "en-US",
16            "scopeGeoId": 1,
17            "searchCenter": None,
18            "types": ["LOCATION", "QUERY_SUGGESTION", "RESCUE_RESULT"],
19            "locationTypes": ["GEO", "AIRPORT", "ACCOMMODATION", "ATTRACTION", "EATERY", "NEIGHBORHOOD"]
20        }
21    },
22    "extensions": {
23        "preRegisteredQueryId": "84b17ed122fbdbd4"
24    }
25}]
26graphql_headers = {
27    "Content-Type": "application/json",
28    "Accept": "*/*",
29    "Accept-Language": "en-US,en;q=0.9",
30    "Origin": "https://www.tripadvisor.com",
31    "Referer": "https://www.tripadvisor.com/Hotels",
32    "X-Requested-By": generate_request_id(),
33    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
34}
35with httpx.Client() as client:
36    response = client.post(
37        "https://www.tripadvisor.com/data/graphql/ids",
38        json=search_payload,
39        headers=graphql_headers
40    )
41    if response.status_code == 200:
42        results = response.json()
43        print(json.dumps(results, indent=2)[:1000])
44    else:
45        print(f"GraphQL request failed: {response.status_code}")

Pro získání recenzí přes GraphQL:

1review_payload = [{
2    "variables": {
3        "locationId": 194317,  # NH City Centre Amsterdam
4        "offset": 0,
5        "limit": 20,
6        "filters": {},
7        "sortType": None,
8        "sortBy": "date",
9        "language": "en",
10        "doMachineTranslation": False,
11        "photosPerReviewLimit": 3
12    },
13    "extensions": {
14        "preRegisteredQueryId": "ef1a9f94012220d3"
15    }
16}]
17with httpx.Client() as client:
18    response = client.post(
19        "https://www.tripadvisor.com/data/graphql/ids",
20        json=review_payload,
21        headers=graphql_headers
22    )
23    if response.status_code == 200:
24        data = response.json()
25        reviews = data[0]["data"]["locations"][0]["reviewListPage"]["reviews"]
26        total = data[0]["data"]["locations"][0]["reviewListPage"]["totalCount"]
27        print(f"Celkem recenzí: {total}")
28        for r in reviews[:3]:
29            print(f"  [{r['rating']}/5] {r['title']} - {r['createdDate']}")

Důležité upozornění: Hodnoty preRegisteredQueryId (např. 84b17ed122fbdbd4 pro vyhledávání a ef1a9f94012220d3 pro recenze) se mohou rozbít, když TripAdvisor nasadí novou verzi. V takovém případě požadavky selžou potichu. Budete muset znovu zjistit query ID sledováním síťových požadavků v DevTools prohlížeče.

Proč tato metoda snižuje potřebu proxy

Matematika je jednoduchá. S requests+BS4 potřebujete na 100 detailních stránek hotelů 100 requestů. S metodou skrytého JSONu dostanete z jedné načtené stránky všechna data, která potřebujete — bez dalších požadavků na rozbalení recenzí nebo načítání dynamického obsahu. S GraphQL může jeden API call vrátit 20 recenzí najednou. Méně requestů = menší vystavení rate limitům = menší potřeba rotace proxy. U malých a středních projektů (pod 1 000 stránek) možná nebudete potřebovat proxy vůbec, pokud přidáte rozumné prodlevy.

Scrape hotely, restaurace i atrakce jedním znovupoužitelným skriptem

Čtyři z pěti konkurenčních návodů pokrývají jen hotely. TripAdvisor ale má tři hlavní typy obsahu a URL vzory i datová pole se mezi nimi liší. Tady je způsob, jak postavit jednu funkci, která zvládne všechny tři.

Dostupná datová pole podle kategorie

Vytvoření znovupoužitelné funkce scrape_tripadvisor()

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import time
5import random
6import re
7import json
8def scrape_tripadvisor(category, location_id, location_name, num_pages=3):
9    """
10    Scrape TripAdvisor listings across hotels, restaurants, or attractions.
11    Args:
12        category: "hotels", "restaurants", or "attractions"
13        location_id: TripAdvisor geo ID (e.g., "187147" for Paris)
14        location_name: URL-friendly name (e.g., "Paris_Ile_de_France")
15        num_pages: Number of pages to scrape
16    """
17    url_patterns = {
18        "hotels": "https://www.tripadvisor.com/Hotels-g{geo}-oa{offset}-{name}-Hotels.html",
19        "restaurants": "https://www.tripadvisor.com/Restaurants-g{geo}-oa{offset}-{name}.html",
20        "attractions": "https://www.tripadvisor.com/Attractions-g{geo}-oa{offset}-Activities-{name}.html",
21    }
22    first_page_patterns = {
23        "hotels": "https://www.tripadvisor.com/Hotels-g{geo}-{name}-Hotels.html",
24        "restaurants": "https://www.tripadvisor.com/Restaurants-g{geo}-{name}.html",
25        "attractions": "https://www.tripadvisor.com/Attractions-g{geo}-Activities-{name}.html",
26    }
27    headers = {
28        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
29        "Accept-Language": "en-US,en;q=0.9",
30        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
31        "Referer": "https://www.tripadvisor.com/",
32        "Sec-CH-UA": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
33        "Sec-CH-UA-Mobile": "?0",
34        "Sec-CH-UA-Platform": '"Windows"',
35    }
36    session = requests.Session()
37    session.headers.update(headers)
38    all_items = []
39    for page in range(num_pages):
40        offset = page * 30
41        if page == 0:
42            url = first_page_patterns[category].format(geo=location_id, name=location_name)
43        else:
44            url = url_patterns[category].format(geo=location_id, offset=offset, name=location_name)
45        response = session.get(url)
46        if response.status_code != 200:
47            print(f"  Stránka {page + 1}: stav {response.status_code}, končím.")
48            break
49        soup = BeautifulSoup(response.text, "html.parser")
50        cards = soup.select('div[data-test-attribute="location-results-card"]')
51        for card in cards:
52            item = {"category": category}
53            title_el = card.select_one('div[data-automation="hotel-card-title"]') or card.select_one('a[data-automation]')
54            item["name"] = title_el.get_text(strip=True) if title_el else None
55            rating_el = card.select_one('[data-automation="bubbleRatingValue"]')
56            item["rating"] = rating_el.get_text(strip=True) if rating_el else None
57            review_el = card.select_one('[data-automation="bubbleReviewCount"]')
58            item["review_count"] = review_el.get_text(strip=True) if review_el else None
59            all_items.append(item)
60        print(f"  Stránka {page + 1}: nalezeno {len(cards)} položek")
61        time.sleep(random.uniform(3, 7))
62    return pd.DataFrame(all_items)
63# Ukázky použití
64print("=== Hotely v Paříži ===")
65hotels_df = scrape_tripadvisor("hotels", "187147", "Paris_Ile_de_France", num_pages=2)
66print(hotels_df.head())
67print("\n=== Restaurace v Římě ===")
68restaurants_df = scrape_tripadvisor("restaurants", "187791", "Rome_Lazio", num_pages=2)
69print(restaurants_df.head())
70print("\n=== Atrakce v Barceloně ===")
71attractions_df = scrape_tripadvisor("attractions", "187497", "Barcelona_Catalonia", num_pages=2)
72print(attractions_df.head())

Jedna funkce, tři kategorie, žádná duplikace kódu. Když TripAdvisor změní selektor, opravíte to na jednom místě.

Co dělat, když vás TripAdvisor blokuje (řešení anti-bot problémů)

Tohle je část, kterou jsem potřeboval nejvíc, když jsem začínal s TripAdvisor scrapingem — a také část, kterou žádný konkurenční návod nepodává strukturovaně. TripAdvisor používá DataDome (analyzuje denně) spolu s Cloudflare WAF. Tady je diagnostická tabulka pro nejběžnější selhání:

Retry logika s exponenciálním backoffem

Žádný konkurenční článek tenhle kód ve skutečnosti neukazuje. Tady je znovupoužitelná retry funkce:

1import time
2import random
3import requests
4def fetch_with_retry(session, url, max_retries=4, base_delay=2, max_delay=60):
5    """
6    Fetch a URL with exponential backoff and jitter.
7    Rotates User-Agent on each retry.
8    """
9    user_agents = [
10        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
11        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
12        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
13        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
14    ]
15    for attempt in range(max_retries):
16        # Při opakování rotovat User-Agent
17        if attempt > 0:
18            session.headers["User-Agent"] = random.choice(user_agents)
19        try:
20            response = session.get(url, timeout=30)
21            if response.status_code == 200:
22                return response
23            if response.status_code == 429:
24                # Respektujte Retry-After, pokud existuje
25                retry_after = int(response.headers.get("Retry-After", base_delay * (2 ** attempt)))
26                print(f"  Rate limit (429). Čekám {retry_after}s...")
27                time.sleep(retry_after)
28                continue
29            if response.status_code in (403, 503):
30                wait = min(base_delay * (2 ** attempt) + random.uniform(0, 1), max_delay)
31                print(f"  Dostali jsme {response.status_code}. Pokus {attempt + 1}/{max_retries} za {wait:.1f}s...")
32                time.sleep(wait)
33                continue
34            # Ostatní chyby — neopakovat
35            print(f"  Neočekávaný stav {response.status_code} pro {url}")
36            return response
37        except requests.exceptions.Timeout:
38            wait = min(base_delay * (2 ** attempt) + random.uniform(0, 1), max_delay)
39            print(f"  Timeout. Pokus {attempt + 1}/{max_retries} za {wait:.1f}s...")
40            time.sleep(wait)
41    print(f"  Všechny {max_retries} pokusy vyčerpány pro {url}")
42    return None

Rotace hlaviček, proxy a sessions

Pro dlouhodobý scraping udržujte pool sad hlaviček a rotujte je dohromady:

1import random
2HEADER_SETS = [
3    {
4        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
5        "Sec-CH-UA": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
6        "Sec-CH-UA-Platform": '"Windows"',
7    },
8    {
9        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36",
10        "Sec-CH-UA": '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
11        "Sec-CH-UA-Platform": '"macOS"',
12    },
13    {
14        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
15        "Sec-CH-UA": '"Google Chrome";v="134", "Not-A.Brand";v="8", "Chromium";v="134"',
16        "Sec-CH-UA-Platform": '"Windows"',
17    },
18]
19PROXY_LIST = [
20    "http://user:pass@residential-proxy-1:port",
21    "http://user:pass@residential-proxy-2:port",
22    # Přidejte další rezidenční proxy
23]
24def get_rotated_session():
25    """Vytvoří novou session s rotovanými hlavičkami a proxy."""
26    session = requests.Session()
27    # Vybereme náhodnou sadu hlaviček
28    header_set = random.choice(HEADER_SETS)
29    base_headers = {
30        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
31        "Accept-Language": "en-US,en;q=0.9",
32        "Accept-Encoding": "gzip, deflate, br",
33        "Referer": "https://www.tripadvisor.com/",
34        "Sec-Fetch-Dest": "document",
35        "Sec-Fetch-Mode": "navigate",
36        "Sec-CH-UA-Mobile": "?0",
37    }
38    base_headers.update(header_set)
39    session.headers.update(base_headers)
40    # Vybereme náhodnou proxy
41    if PROXY_LIST:
42        proxy = random.choice(PROXY_LIST)
43        session.proxies = {"http": proxy, "https": proxy}
44    return session

Typ proxy je zásadní. Datacentrové proxy TripAdvisor blokuje téměř okamžitě (HTTP 1020 Access Denied). Pro dlouhodobý scraping jsou nutné rezidenční proxy — běží přes běžné ISP a jsou téměř nerozeznatelné od skutečných uživatelů. Počítejte s cenou 2,50–8,40 USD/GB podle poskytovatele.

Export a ukládání nasbíraných dat z TripAdvisoru

Jakmile data máte, dostat je do použitelného formátu je jednoduché.

Export do CSV (nejběžnější)

1import pandas as pd
2df = pd.DataFrame(all_hotels)
3df.to_csv("tripadvisor_hotels_paris.csv", index=False, encoding="utf-8-sig")
4print(f"Exportováno {len(df)} řádků do CSV")

encoding='utf-8-sig' je důležité — zajistí, že Excel při otevření CSV správně zobrazí ne-latinkové znaky (francouzské akcenty, čínské znaky atd.).

Export do JSON (pro vnořená data)

Když máte recenze vnořené pod hotely, JSON zachová hierarchii:

1# Hierarchická struktura
2hotel_data = {
3    "property_id": "d194317",
4    "name": "NH City Centre Amsterdam",
5    "rating": 4.0,
6    "reviews": [
7        {"title": "Skvělá lokalita", "rating": 5, "date": "2025-03-15", "text": "..."},
8        {"title": "Průměrný pobyt", "rating": 3, "date": "2025-03-10", "text": "..."},
9    ]
10}
11# Pro plochou analýzu použijte json_normalize
12flat_reviews = pd.json_normalize(
13    hotel_data,
14    record_path="reviews",
15    meta=["property_id", "name"]
16)
17flat_reviews.to_csv("reviews_flat.csv", index=False)

Dvou-souborový přístup pro relační data

U velkých datasetů používám dva CSV soubory:

• hotels.csv — jeden řádek na jednu nemovitost (ploché)
• reviews.csv — jeden řádek na jednu recenzi, s property_id jako cizím klíčem

Snadno to pak spojíte v pandas, nahrajete do databáze nebo importujete do BI nástrojů.

Pokud se nechcete zabývat exportní logikou, Thunderbit umožňuje do Excelu, Google Sheets, Airtable nebo Notion — zdarma a bez kódu. Hodí se, když potřebujete výsledky sdílet s netechnickými kolegy.

Tipy pro zodpovědný a efektivní scraping TripAdvisoru

Zodpovědný scraping v šesti bodech:

• Zkontrolujte robots.txt: TripAdvisor v robots.txt úplně blokuje AI trénovací boty (GPTBot, ClaudeBot atd.). Standardní crawlery mají jen částečně omezené cesty. Podívejte se na tripadvisor.com/robots.txt.
• Přidávejte prodlevy: 3–7 sekund mezi requesty je bezpečné rozmezí. Při rychlejším tempu než 10–15 požadavků za minutu na IP riskujete rate limiting.
• Scrapujte jen veřejná data. Nepřihlašujte se kvůli obsahu, který je jinak nepřístupný.
• Ukládejte data bezpečně a dodržujte GDPR/CCPA, pokud pracujete s osobními údaji (jména recenzentů apod.).
• Zvažte oficiální API TripAdvisoru, pokud potřebujete data v komerčním měřítku. nabízí přístup k firemním údajům a až 5 recenzím a 5 fotografiím na lokaci — omezené, ale legální a stabilní.
• Buďte si vědomi právního rámce: posílilo zákazy scrapingu založené na podmínkách použití napříč EU. Podmínky TripAdvisoru scraping výslovně zakazují. Scrapeujte zodpovědně a na vlastní riziko.

Shrnutí

To je celý obrázek.

• Requests + BeautifulSoup je nejjednodušší cesta. Funguje pro statické výpisové stránky, vyžaduje minimum nastavení a je rychlá. Začněte tady, pokud scrapujete méně než 100 stránek a nepotřebujete obsah renderovaný JavaScriptem.
• Selenium zvládne vše, co requests neumí: dynamický obsah, tlačítka „Read more“, cookie bannery. Je asi 5× pomalejší a náročnější na zdroje, ale je to jediná možnost, když potřebujete s webem interagovat.
• Skrytý JSON / GraphQL je nejčistší a nejrychlejší přístup. Dá vám strukturovaná data bez parsování HTML, sníží počet requestů (a tím i potřebu proxy) a vrací data ve formátech připravených pro analýzu. Vyžaduje víc reverzního inženýrství na začátku a občasnou údržbu, když TripAdvisor změní datovou strukturu.

Znovupoužitelná funkce scrape_tripadvisor() pokrývá hotely, restaurace i atrakce. Neměli byste potřebovat druhý návod.

A pokud během čtení zjistíte, že programování není nic pro vás — nebo prostě potřebujete do konce dne 50 hotelů v tabulce — to zvládne na dva kliky s AI rozpoznáním polí, automatickým stránkováním a exportem zdarma do Excelu nebo Google Sheets. Python není nutný.

Pokud chcete jít víc do hloubky, máme další návody na scrapování na a na našem .

Často kladené otázky

1. Je legální scrapovat TripAdvisor?

Podmínky použití TripAdvisoru scraping výslovně zakazují. Soudy ale obecně došly k závěru, že scrapování veřejně dostupných dat (ne za přihlášením) neporušuje v USA zákon Computer Fraud and Abuse Act. Na druhou stranu rozhodnutí Soudního dvora EU ve věci Ryanair z roku 2025 posílilo omezení založená na ToS v Evropě. Scrapujte jen veřejná data, respektujte robots.txt, znovu nepublikujte chráněný obsah a pokud data používáte komerčně, poraďte se s právníkem.

2. Můžu scrapovat TripAdvisor bez Pythonu?

Ano. No-code nástroje jako umí TripAdvisor scrapovat přímo z prohlížeče pomocí AI detekce polí a automatického stránkování. Můžete také použít browser extension, doplňky do Google Sheets nebo komerční scraping API. Python vám dá nejvíc kontroly a flexibility, ale není to jediná možnost.

3. Jak se vyhnout zablokování při scrapování TripAdvisoru?

Klíčové taktiky: používejte realistické a konzistentní hlavičky (hlavně User-Agent a Sec-CH-UA), rotujte rezidenční proxy (datacentrové IP se blokují okamžitě), přidávejte náhodné prodlevy 3–7 sekund mezi requesty, používejte metodu skrytého JSONu, abyste minimalizovali počet requestů, implementujte retry logiku s exponenciálním backoffem a před scrapováním hlubších stránek „zahřejte“ session návštěvou homepage.

4. Jaká data můžu z TripAdvisoru scrapovat?

Hotely, restaurace a atrakce — včetně názvů, hodnocení, počtu recenzí, cenových rozmezí, adres, souřadnic, vybavení (hotely), typů kuchyně (restaurace), délky zájezdů (atrakce) a plných textů recenzí s individuálním hodnocením a datem. Přístupy přes skrytý JSON a GraphQL vrací na jeden request nejbohatší data.

5. Kolik stránek mohu z TripAdvisoru scrapovat za den?

S jednou IP a rozumnými prodlevami zhruba 600–1 000 stránek denně. S 20 rotujícími rezidenčními proxy přibližně 200 000–300 000 stránek denně při použití request-based přístupů. Selenium je pomalejší — počítejte s 8 000–12 000 stránkami denně na proxy. Skrytý JSON / GraphQL dává nejvíc dat na jeden request, takže pro stejné množství informací často potřebujete výrazně méně stránek.

Další informace