Můj skript na stahování recenzí z Amazonu běžel šest týdnů bez jediné chyby — a pak jednoho rána vrátil 200 OK a stránku plnou prázdna. Žádná chyba, žádná CAPTCHA, jen prázdné HTML tam, kde dřív byly stovky recenzí.
Jestli vám to zní povědomě, nejste v tom sami. Koncem roku 2025 začal Amazon schovávat celé stránky s recenzemi za přihlašovací bránu a spousta Python scrapingových skriptů přestala ze dne na den fungovat. Posledních pár měsíců jsem v Thunderbit řešil tenhle problém ze dvou stran — vyvíjel jsem náš AI scraper a zároveň si udržoval vlastní Python pipeline na recenze — takže jsem si řekl, že je čas sepsat průvodce, který bych tehdy sám potřeboval. Tenhle článek popisuje funkční postup: autentizaci přes cookies, stabilní selektory odolné vůči Amazonovu maskování CSS, obejití desetistránkového limitu stránkování, obranu proti botům a navrch i sekci o analýze sentimentu, která surové texty recenzí promění v reálné obchodní poznatky. A pokud si v půlce řeknete „tohle se mi fakt nechce celé udržovat v kódu“, ukážu vám, jak to Thunderbit zvládne asi za dvě minuty a bez jediného řádku Pythonu.
Co je sběr recenzí z Amazonu a proč na něm záleží?
Sběr recenzí z Amazonu znamená programové získávání zákaznických dat z recenzí — hvězdičkového hodnocení, textu recenze, jména autora, data, štítku ověřeného nákupu — z produktových stránek Amazonu. Protože Amazon odstranil obsah recenzí ze svého Product Advertising API už v roce 2010 (a nikdy ho nevrátil), je web scraping jediná programová cesta, jak se k těmto datům dostat.
Čísla to potvrzují. 95 % nakupujících si před koupí čte recenze a 94 % uvádí Amazon jako svůj hlavní zdroj recenzí produktů. Zobrazení pouhých 5 recenzí na produktové stránce může zvýšit konverzi o 270 %. Firmy, které systematicky analyzují sentiment v recenzích, zaznamenávají až o 15 % vyšší retenci zákazníků. Tohle není abstraktní datová věda — je to konkurenční zpravodajství, signály pro vylepšení produktu a marketingový jazyk, to vše napsané černé na bílém na serverech Amazonu.
Proč sbírat recenze z Amazonu v Pythonu
Python je pro tenhle typ práce pořád jasná volba. Je to nejžádanější jazyk v průzkumu Stack Overflow Developer Survey 2024 a jeho ekosystém — requests, BeautifulSoup, pandas, Scrapy — dělá web scraping dostupný i lidem, kteří nejsou full-time vývojáři.
Různé týmy ta data využívají různě:
| Tým | Případ použití | Co extrahují |
|---|---|---|
| Produkt / R&D | Odhalení opakujících se stížností, určování priorit oprav | Text 1–2hvězdičkových recenzí, četnost klíčových slov |
| Obchod | Sledování sentimentu u konkurenčních produktů | Hodnocení, trendy objemu recenzí |
| Marketing | Vyhledání zákaznického jazyka pro reklamní texty | Pozitivní fráze z recenzí, zmínky o funkcích |
| Ecommerce Operations | Sledování sentimentu vlastních produktů v čase | Rozložení hvězdiček, podíl ověřených nákupů |
| Průzkum trhu | Porovnání lídrů v kategorii napříč funkcemi | Datové sady recenzí pro více ASINů |
Jedna značka kuchyňského náčiní prošla negativní recenze, zjistila, že 22 % z nich zmiňuje „opotřebení nepřilnavé vrstvy“, produkt přepracovala a do 60 dnů získala zpět pozici #1 Best Seller. Firma vyrábějící fitness náramky z recenzí vytáhla zmínky o „podráždění pásku“, odhalila problém s alergií na latex, uvedla hypoalergenní variantu a snížila vracení zboží o 40 %. Přesně taková návratnost dělá z té technické práce smysluplnou investici.
Přihlašovací brána: proč váš scraper na Amazon recenze přestal fungovat
- listopadu 2024 Amazon začal vyžadovat přihlášení pro zobrazení celé stránky s recenzemi produktu. Změnu potvrdily jak komunitní fóra, tak blogy poskytovatelů scrapingových nástrojů. Když si v anonymním okně otevřete
/product-reviews/{ASIN}/, přesměruje vás to na přihlašovací stránku místo dat s recenzemi.
Příznaky jsou zrádné: skript dostane odpověď 200 OK, ale HTML tělo obsahuje přihlašovací formulář (name="email", id="ap_password") místo recenzí. Žádný chybový kód. Žádná CAPTCHA. Jen… nic užitečného.
Amazon to udělal kvůli ochraně proti botům a kvůli regionální shodě s pravidly. Prosazování je navíc nekonzistentní — někdy se v čerstvě otevřeném okně pár recenzí načte, než se brána aktivuje, hlavně na první stránce — ale u jakéhokoli scraperu ve větším měřítku je potřeba počítat s tím, že brána je aktivní pořád.
Jednotlivé domény Amazonu podle zemí (.de, .co.uk, .co.jp) vynucují přihlašování samostatně. Jak napsal jeden uživatel na fóru: „pro každou zemi je potřeba samostatné přihlášení“. Cookies z .com vám na .co.uk fungovat nebudou.
Featured Reviews vs. plné recenze: co je ještě dostupné bez přihlášení
Produktové stránky Amazonu (/dp/{ASIN}/) stále zobrazují přibližně 8 „featured reviews“ i bez autentizace. Amazon je vybírá algoritmem ručně nebo poloručně a hodí se pro rychlou kontrolu sentimentu, ale nejdou řadit, filtrovat ani stránkovat.
Plné stránky recenzí (/product-reviews/{ASIN}/) — seřazení od nejnovějších, filtrování podle hvězdiček a stránkování přes stovky recenzí — už vyžadují přihlášení.
Když potřebujete jen pár recenzí na rychlý orientační odhad, stačí produktová stránka. Pro stovky nebo tisíce recenzí je ale potřeba řešit autentizaci.
Co potřebujete, než začnete: Python a knihovny
Než napíšeme jediný řádek kódu, tady je příprava:
- Obtížnost: středně pokročilá (orientace v Pythonu, základní znalost HTML)
- Časová náročnost: cca 45 minut pro celý pipeline; cca 10 minut pro základní scrape
- Co budete potřebovat: Python 3.8+, prohlížeč Chrome, platný účet Amazonu
Nainstalujte základní knihovny:
pip install requests beautifulsoup4 lxml pandas textblob
Volitelně (pro pokročilou analýzu sentimentu):
pip install transformers torch
Co je ASIN? Je to desetiznakový identifikátor produktu na Amazonu. Najdete ho v každé produktové URL — například v amazon.com/dp/B0BCNKKZ91 je ASIN B0BCNKKZ91. To je klíč, který vložíte do URL pro recenze.
Krok 1: Projděte přihlašovací bránou pomocí autentizace přes cookies
Nejspolehlivější postup je přihlásit se do Amazonu v prohlížeči, zkopírovat session cookies a vložit je do requests.Session() v Pythonu. Tím se vyhnete CAPTCHA a SMS 2FA, které často komplikují automatizované přihlašování přes Selenium.
Potřebujete těchto sedm cookies:
| Název cookie | Účel |
|---|---|
session-id | Průběžně se měnící identifikátor relace |
session-id-time | Časové razítko relace |
session-token | Průběžně rotující token relace |
ubid-main | Identifikátor prohlížení uživatele |
at-main | Hlavní autentizační token |
sess-at-main | Autentizace v rámci relace |
x-main | Identifikátor navázaný na e-mail uživatele |
Jak vytáhnout cookies z Chrome DevTools
- Přihlaste se do amazon.com v Chrome
- Otevřete DevTools (F12 nebo klik pravým tlačítkem → Inspect)
- Jděte na Application → Storage → Cookies →
https://www.amazon.com - Najděte v tabulce každé uvedené cookie a zkopírujte její hodnotu
- Naformátujte je jako řetězec oddělený středníky pro Python
Session nastavte takto:
import requests
session = requests.Session()
# Sem vložte hodnoty vašich cookies
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Důležité: Používejte stejný objekt session pro všechny požadavky. Cookies tak zůstanou konzistentní a chování bude připomínat skutečnou relaci v prohlížeči. Cookies obvykle vydrží dny až týdny při scrapingové zátěži, ale jakmile se znovu začnete přesměrovávat na přihlášení, obnovte je z prohlížeče.
U tržišť mimo .com se názvy cookies mírně liší — amazon.de používá at-acbde místo at-main, amazon.co.uk používá at-acbuk a podobně. Každé tržiště potřebuje vlastní samostatnou relaci.
Krok 2: Sestavte požadavek a parsujte HTML recenzí pomocí BeautifulSoup
URL pro recenze Amazonu vypadá takto:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
Jádro funkce:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # slušná prodleva
response = session.get(url, timeout=15)
# Detekce přihlašovací brány
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Detekována přihlašovací brána — obnovte cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Pomáhá i malý trik: než otevřete stránku s recenzemi, navštivte nejdřív produktovou stránku. V relaci to vytvoří přirozenější vzorec chování.
# Nejprve navštivte produktovou stránku (napodobí běžné prohlížení)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Potom otevřete stránku s recenzemi
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Krok 3: Použijte stabilní selektory pro získání dat z recenzí (spoléhejte na data-hook, ne na CSS třídy)
Tady většina návodů z let 2022–2023 selhává. Amazon maskuje názvy CSS tříd — pravidelně se mění a jak si jeden frustrovaný vývojář stěžoval ve fóru: „neměli ani jediný vzor v názvech tříd u span tagů.“
Řešení: Amazon používá u prvků recenzí atributy data-hook a ty jsou překvapivě stabilní. Jsou to sémantické identifikátory, na kterých závisí frontend Amazonu, takže se nenechávají náhodně měnit.
| Pole recenze | Stabilní selektor (data-hook) | Křehký selektor (class) |
|---|---|---|
| Text recenze | [data-hook="review-body"] | .review-text-content (mění se) |
| Hvězdičkové hodnocení | [data-hook="review-star-rating"] | .a-icon-alt (nejasné) |
| Titulek recenze | [data-hook="review-title"] | .review-title (někdy) |
| Jméno autora | span.a-profile-name | Relativně stabilní |
| Datum recenze | [data-hook="review-date"] | .review-date (závislé na regionu) |
| Ověřený nákup | [data-hook="avp-badge"] | span.a-size-mini |
Kód pro extrakci pomocí selektorů data-hook:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Hvězdičkové hodnocení
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Titulek
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Tělo recenze
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Autor
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Datum a země
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Formát: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Ověřený nákup
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Tenhle výběr selektorů používám proti několika ASINům už měsíce a atributy data-hook se ani jednou nezměnily. Zato CSS třídy se za stejnou dobu otočily už nejméně dvakrát.
Krok 4: Ošetřete stránkování a desetistránkový limit Amazonu
Amazon omezuje parametr pageNumber na 10 stránek po 10 recenzích — tvrdý strop zhruba 100 recenzí pro jednu kombinaci filtrů. Tlačítko „Next page“ po desáté stránce prostě zmizí.
Základní smyčka pro stránkování:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Na této stránce už nejsou žádné další recenze
all_reviews.extend(page_reviews)
print(f"Stránka {page}: {len(page_reviews)} recenzí")
Jak získat víc než 10 stránek recenzí z Amazonu
Řešení je rozdělení do filtrů. Každá kombinace filterByStar a sortBy má vlastní nezávislé 10stránkové okno.
Hodnoty hvězdičkového filtru: one_star, two_star, three_star, four_star, five_star
Hodnoty řazení: recent, helpful (výchozí)
Když zkombinujete všech 5 hvězdičkových filtrů × 2 způsoby řazení, dostanete až 100 stran, tedy 1 000 recenzí na produkt — a u produktů s nerovnoměrným rozložením hodnocení se často dostanete velmi blízko kompletní sadě recenzí.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # jednoduchá deduplikace
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Deduplikace podle kombinace titulu a autora
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Stránka {page}: {len(page_reviews)} recenzí")
print(f"Celkem unikátních recenzí: {len(all_reviews)}")
Mezi jednotlivými bloky budou překryvy, takže deduplikace je zásadní. Jako rychlý klíč používám kombinaci titulu recenze + jména autora — není to dokonalé, ale zachytí naprostou většinu duplicit.
Krok 5: Vyhněte se ochraně proti botům (rotace, zpomalení, retry)
Amazon používá AWS WAF Bot Control a ten je dnes mnohem agresivnější. Jednovrstvá ochrana typu „jen rotovat User-Agent“ nebo „jen přidat prodlevu“ už nestačí.
| Technika | Implementace |
|---|---|
| Rotace User-Agentů | Náhodný výběr z 10+ reálných browser stringů |
| Exponenciální backoff | Zpoždění opakování 2 s → 4 s → 8 s při 503 |
| Omezování požadavků | random.uniform(2, 5) sekund mezi stránkami |
| Rotace proxy | Střídání rezidenčních proxy |
| Otisk relace | Konzistentní cookies + hlavičky pro jednu relaci |
| TLS impersonace | V produkci použít curl_cffi místo standardního requests |
Retry wrapper připravený pro produkci:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Detekce blokace
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"Detekována CAPTCHA. Čekám {wait} s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Rate limit ({response.status_code}). Čekám {wait} s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Přihlašovací brána — cookies vypršely")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Pokus {attempt + 1} selhal: {e}")
return None
Poznámka k proxy: Amazon blokuje známé datacentrové IP rozsahy (AWS, GCP, Azure, DigitalOcean) už na úrovni sítě. Pokud scrapujete víc než pár stovek stránek, jsou rezidenční proxy v podstatě nutnost — počítejte s cenou 50–200+ USD měsíčně podle objemu. U menších projektů (pod 100 požadavků denně) často stačí opatrné zpomalení z domácí IP adresy.
Amazon navíc kontroluje TLS fingerprint. Standardní knihovna Python requests má známý JA3 hash, který WAFy předem blokují. Pro produkční scrapers zvažte curl_cffi, který se tváří jako reálný browser TLS stack. Pro tutorialové objemy (pár stovek stránek) obvykle stačí requests s dobrými hlavičkami.
Krok 6: Exportujte stažené recenze z Amazonu do CSV nebo Excelu
Jakmile máte recenze stažené, je jejich uložení do použitelného formátu s pandas jednoduché:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"Exportováno {len(df)} recenzí do amazon_reviews.csv")
Ukázkový výstup:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Nejlepší nákup roku | Baterie vydrží celý den, displej je nádherný... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Zklamání po 2 týdnech | Nabíjecí port přestal fungovat... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Skvělá hodnota za tu cenu | Dělá vše, co potřebuji, jen drobné zpoždění u náročných aplikací... | March 10, 2025 | the United States | False |
Pro export do Excelu použijte: df.to_excel("amazon_reviews.xlsx", index=False) (vyžaduje openpyxl).
Pro Google Sheets funguje knihovna gspread, ale vyžaduje 8+ kroků konfigurace Google Cloud — vytvořit projekt, povolit dvě API, vygenerovat service account credentials, sdílet tabulku. Pokud vám to připadá jako víc nastavování než samotný scraping, nemýlíte se. (To je přesně ten moment, kdy začíná být nástroj jako Thunderbit, který exportuje do Google Sheets jedním kliknutím, hodně lákavý.)
Bonus: Přidejte do stažených recenzí analýzu sentimentu v 5 řádcích Pythonu
Většina návodů na scraping končí exportem do CSV. Jenže teprve skórování sentimentu promění syrová data v obchodní rozhodnutí.
Nejrychlejší základ je TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Dostanete tím skóre polarity od -1.0 (velmi negativní) do +1.0 (velmi pozitivní) pro každou recenzi. Ukázkový výstup:
| content (zkráceno) | rating | sentiment |
|---|---|---|
| "Baterie vydrží celý den, displej je nádherný..." | 5.0 | 0.65 |
| "Nabíjecí port přestal fungovat po..." | 2.0 | -0.40 |
| "Dělá vše, co potřebuji, jen drobné zpoždění..." | 4.0 | 0.25 |
| "Naprostý odpad. Hned vráceno." | 1.0 | -0.75 |
| "Je to v pohodě. Nic extra, ale funguje." | 3.0 | 0.10 |
Nejzajímavější jsou nesoulady — třeba tříhvězdičková recenze s pozitivním textem nebo pětihvězdičková recenze s negativním jazykem. Tyhle rozdíly často odhalí jemnější názor zákazníka, který samotné hvězdičky neukážou.
Pro přesnost na produkční úrovni se doporučují Hugging Face Transformers. VADER byl trénovaný na tweetech, ne na produktových recenzích a transformer modely dosahují přes 98% přesnosti při klasifikaci recenzí oproti lexikálním nástrojům. Model nlptown/bert-base-multilingual-uncased-sentiment dokonce umí přímo předpovědět hodnocení 1–5 hvězdiček:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Recenze na Amazonu mají J-tvarované rozložení — velký vrchol u 5 hvězdiček, menší vrchol u 1 hvězdičky a propad uprostřed. To znamená, že průměrné hodnocení je často špatný ukazatel skutečné kvality produktu. Zaměřte se na shluk 1hvězdičkových recenzí a hledejte opakující se témata — právě tam obvykle leží jedna opravitelná závada.
Upřímné srovnání: DIY Python vs. placené scraping API vs. Thunderbit
Spravoval jsem Python scrapers pro Amazon a řeknu to na rovinu: rozbíjejí se. Selektory se mění, cookies expirují, Amazon nasadí novou vrstvu detekce botů a najednou vaše sobotní dopoledne místo analýzy dat zabere ladění scraperu. Uživatelé na fórech popisují stejnou frustraci — vlastní skripty, které „fungovaly minulý měsíc“, je teď potřeba neustále opravovat.
Takhle vypadají hlavní tři přístupy vedle sebe:
| Kritérium | DIY Python (BS4/Selenium) | Placené scraping API | Thunderbit (bez kódu) |
|---|---|---|---|
| Čas na nastavení | 1–3 hodiny | 30 min (API klíč) | 2 minuty |
| Náklady | Zdarma (+ proxy) | 50–200+ USD/měsíc | K dispozici zdarma v rámci free tieru |
| Řešení přihlašovací brány | Ruční správa cookies | Obvykle řešeno | Automaticky řešeno |
| Údržba | Vysoká (selektory se lámou) | Nízká (spravuje poskytovatel) | Žádná (AI se přizpůsobuje) |
| Stránkování | Nutný vlastní kód | Vestavěné | Vestavěné |
| Podpora více zemí | Samostatné relace pro každou doménu | Obvykle podporováno | Přes prohlížeč = vaše lokalita |
| Analýza sentimentu | Dopíšete si vlastní kód | Někdy v ceně | Export do Sheets, analýza kdekoli |
| Nejlepší pro | Učení, plná kontrola | Škálování, produkční pipeline | Rychlý sběr dat, netechnické týmy |
Python vám dá plnou kontrolu a je skvělý způsob, jak pochopit, co se děje pod kapotou. Placená API (ScrapingBee, Oxylabs, Bright Data) dávají smysl pro produkční pipeline, kde je důležitější dostupnost než cena. A pro týmy, které potřebují recenze bez režie vývoje — například ecommerce tým sledující konkurenty jednou týdně nebo marketingový tým sbírající zákaznický jazyk pro reklamy — existuje třetí cesta.
Jak scrapovat recenze Amazonu s Thunderbit (bez kódu, bez údržby)
Thunderbit jsme postavili přesně pro situace, kdy je údržba Python scraperu zbytečně složitá. Postup vypadá takto:
- Nainstalujte rozšíření Thunderbit Chrome Extension
- Otevřete v prohlížeči stránku s recenzemi produktu Amazonu (už jste přihlášení, takže přihlašovací brána nevadí)
- Klikněte na „AI Suggest Fields“ — Thunderbit přečte stránku a navrhne sloupce jako Author, Rating, Title, Review Text, Date, Verified Purchase
- Klikněte na „Scrape“ — data se vytáhnou okamžitě, včetně vestavěného stránkování
- Exportujte do Excelu, Google Sheets, Airtable nebo Notion
Hlavní výhoda je v tom, že Thunderbitova AI čte strukturu stránky pokaždé znovu. Žádné CSS selektory na údržbu, žádná správa cookies, žádný anti-bot kód. Když Amazon změní HTML, AI se přizpůsobí. Pro čtenáře, kteří chtějí programový přístup bez kompletní vlastní implementace, Thunderbit nabízí i Extract API — strukturovanou extrakci dat přes API s AI detekcí polí, bez údržby selektorů.
Pro hlubší pohled na data z Amazonu se podívejte i na naše průvodce jak scrapovat produkty a recenze z Amazonu a jak extrahovat a analyzovat prodejní data z Amazonu.
Tipy pro sběr recenzí z Amazonu ve velkém pomocí Pythonu
Pokud scrapujete recenze napříč mnoha ASINy, pár návyků vám ušetří spoustu starostí:
- Dávkujte ASINy a dělejte prodlevy mezi produkty, nejen mezi stránkami. Já používám pauzy 10–15 sekund mezi jednotlivými ASINy.
- Deduplikujte agresivně. Při kombinování více hvězdičkových filtrů a režimů řazení se recenze překrývají. Jako dedup klíč používejte tuple
(title, author, date). - Logujte chyby. Sledujte, které kombinace ASIN + stránka + filtr selhaly, abyste je mohli zopakovat bez nutnosti znovu stahovat všechno.
- Ukládejte data do databáze u větších projektů. Jednoduchá SQLite databáze škáluje mnohem lépe než narůstající CSV soubory:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Plánujte opakované scrapingy. Pro průběžné monitorování si nastavte cron job nebo použijte funkci Scheduled Scraper v Thunderbit — popíšete URL a rozvrh a vše ostatní vyřeší bez serveru.
Další postupy najdete v našich článcích nejlepší automatizované nástroje pro web scraping a jak dostat data z webu do Excelu, které pokrývají další možnosti.
Krátká poznámka k právu a etice
Podmínky používání Amazonu Conditions of Use výslovně zakazují „používání robotů, spiderů, scraperů nebo jiných automatizovaných prostředků pro přístup ke službám Amazonu“. Na druhou stranu je poslední americká judikatura vůči scraperům veřejných dat spíše příznivá. V kauze Meta Platforms v. Bright Data (leden 2024) federální soud rozhodl, že scraping veřejně přístupných dat neporušuje podmínky služby, pokud scraper není přihlášený „uživatel“.
Je tu ale důležitý rozdíl: scraping za přihlášením, což je i případ tohoto návodu, vás posouvá do roviny smluvního práva, protože jste souhlasili s podmínkami Amazonu při vytvoření účtu. Sběr veřejně viditelných featured reviews je z hlediska práva méně rizikový než scraping za přihlašovací bránou.
Praktická doporučení: nešířte stažená data komerčně, nesbírejte osobní údaje uživatelů nad rámec toho, co je veřejně zobrazené, respektujte robots.txt a při velkém nebo komerčním využití se poraďte s právníkem. Nejde o právní radu. Více k této problematice najdete v našem přehledu právních dopadů web scrapingu.
Závěr: scrapujte recenze Amazonu v Pythonu, nebo kód úplně přeskočte
Rychlé shrnutí toho, co jsme si prošli:
- Přihlašovací brána je reálná, ale dá se obejít pomocí autentizace přes cookies — zkopírujte 7 cookies z prohlížeče a vložte je do
requests.Session() - Pro extrakci používejte selektory
data-hook, ne CSS třídy, které se lámou každých pár týdnů - Kombinujte hvězdičkové filtry a způsoby řazení, abyste obešli desetistránkový limit stránkování a dostali se na 500+ recenzí na produkt
- Přidejte analýzu sentimentu přes TextBlob jako rychlý základ nebo Hugging Face Transformers pro přesnost na produkční úrovni
- Držte se obrany proti botům: throttling, rotace User-Agentů, exponenciální backoff a pro škálování rezidenční proxy
Python vám dá plnou kontrolu a je nejlepší cestou, jak pochopit, co se děje pod kapotou. Ale pokud je váš use case spíš „potřebuji do pátku mít recenze konkurence v tabulce“ než „chci postavit produkční datovou pipeline“, možná za to udržování vlastního scraperu nestojí.
Thunderbit řeší autentizaci, selektory, stránkování i export na pár kliknutí — vyzkoušejte free tier a zjistěte, jestli vám sedí do workflow. Jak Amazon dál zpřísňuje ochranu proti botům, AI nástroje, které se přizpůsobují v reálném čase, se z příjemného bonusu mění v nutnost.
Můžete se také podívat na náš YouTube kanál Thunderbit, kde najdete video návody ke scrapingovým workflow.
Často kladené otázky
1. Dá se sbírat Amazon recenze bez přihlášení?
Ano, ale jen zhruba těch 8 „featured reviews“, které jsou zobrazené na produktové stránce (/dp/{ASIN}/). Plné stránky recenzí se řazením, filtrováním a stránkováním vyžadují od konce roku 2024 autentizaci. Pro většinu firemních použití budete muset přihlašovací bránu řešit.
2. Je sběr recenzí z Amazonu legální?
Podmínky Amazonu automatizovaný scraping zakazují. Nicméně nedávná judikatura v USA (Meta v. Bright Data, 2024; hiQ v. LinkedIn) podporuje sběr veřejně dostupných dat. Scraping za přihlášením s sebou nese vyšší právní riziko, protože jste souhlasili s podmínkami Amazonu. Pro komerční použití se poraďte s právníkem.
3. Kolik recenzí z Amazonu můžu na jeden produkt získat?
Amazon omezuje recenzní stránky na 10 stránek pro každou kombinaci řazení a hvězdičkového filtru. Když použijete všech 5 hvězdičkových filtrů × 2 způsoby řazení, dostanete až 100 stránek (zhruba 1 000 recenzí) na produkt. S filtrem podle klíčových slov je teoretický strop vyšší, ale s výraznou duplicitou.
4. Jaká je nejlepší Python knihovna pro sběr recenzí z Amazonu?
requests + BeautifulSoup pro parsování statického HTML je nejběžnější a nejspolehlivější kombinace. Selenium se hodí, když je potřeba renderování přes JavaScript. Jako no-code alternativu, která zvládá přihlašovací brány i stránkování automaticky, zkuste Thunderbit.
5. Jak se při sběru dat z Amazonu vyhnout blokaci?
Rotujte User-Agenty z poolu 10+ reálných browser stringů, přidejte náhodné prodlevy 2–5 sekund mezi požadavky, implementujte exponenciální backoff pro chyby 503/429, při větším objemu používejte rezidenční proxy (datacentrové IP jsou předblokované) a udržujte konzistentní session cookies napříč požadavky. Pro přístup bez údržby řeší Thunderbit obranu proti botům automaticky přes vaši browser session.
Více informací
