Cum extrag recenziile Amazon cu Python (dincolo de login wall)

Scraperul meu pentru recenziile Amazon a mers perfect timp de șase săptămâni — apoi, într-o dimineață, a returnat 200 OK și o pagină complet goală. Fără eroare, fără CAPTCHA, doar HTML gol acolo unde înainte erau sute de recenzii.

Dacă ți se pare cunoscut, nu ești singur. La final de 2025, Amazon a început să pună paginile complete de recenzii în spatele unui login wall, iar o mulțime de scripturi Python de scraping au picat peste noapte. În ultimele luni, la am lucrat la problemă din ambele direcții — construind propriul nostru AI scraper, dar și menținând pipeline-ul meu de recenzii în Python — așa că am simțit că a venit momentul să scriu ghidul pe care mi-aș fi dorit să-l am când scriptul meu a murit prima dată. Articolul de față acoperă metoda care chiar funcționează: autentificare bazată pe cookie-uri, selectori stabili care rezistă la obfuscare CSS din Amazon, soluții pentru limita de 10 pagini, mecanisme anti-bot și, ca bonus, o secțiune de analiză a sentimentului care transformă textul brut al recenziilor în insight-uri reale de business. Iar dacă ajungi pe la jumătate și te gândești „mai bine n-aș întreține tot codul ăsta”, îți arăt cum face același lucru în aproximativ două minute, fără Python.

Ce înseamnă scraping-ul recenziilor Amazon și de ce contează?

Scraping-ul recenziilor Amazon înseamnă extragerea programatică a datelor din recenziile clienților — ratingul în stele, textul recenziei, numele autorului, data, badge-ul de achiziție verificată — din paginile produselor Amazon. Pentru că Amazon a (și nu l-a mai readus niciodată), scraping-ul web este singura cale programatică de a ajunge la aceste date.

Și cifrele confirmă asta. , iar . Afișarea a doar 5 recenzii pe pagina unui produs poate . Companiile care analizează sistematic sentimentul recenziilor văd . Nu vorbim despre știință de date abstractă — e inteligență competitivă, semnale pentru îmbunătățirea produsului și limbaj de marketing, toate în text simplu pe serverele Amazon.

De ce să extragi recenzii Amazon cu Python

Python rămâne limbajul preferat pentru acest tip de lucru. Este , iar ecosistemul său — requests, BeautifulSoup, pandas, Scrapy — face web scraping-ul accesibil chiar și pentru cei care nu sunt dezvoltatori full-time.

Echipe diferite folosesc aceste date în moduri diferite:

Un brand de vase de bucătărie a , a reformulat produsul și și-a recâștigat poziția de #1 Best Seller în 60 de zile. O companie de brățări fitness a , a descoperit o problemă legată de alergia la latex, a lansat o variantă hipoalergenică și a redus retururile cu 40%. Acesta este genul de ROI care face efortul tehnic să merite.

Login wall: de ce scraperul tău pentru recenziile Amazon a încetat să mai funcționeze

Pe 14 noiembrie 2024, . Schimbarea a fost confirmată atât pe , cât și pe . Dacă vizitezi /product-reviews/{ASIN}/ într-o fereastră incognito, vei fi redirecționat către o pagină de sign-in în loc să vezi datele din recenzii.

Simptomele sunt subtile: scriptul primește răspuns 200 OK, dar corpul HTML conține un formular de autentificare (name="email", id="ap_password") în loc de recenzii. Fără cod de eroare. Fără CAPTCHA. Doar... nimic util.

Amazon a făcut asta din motive de anti-bot și conformitate regională. Aplicarea este inconsistentă — uneori o fereastră nouă de browser afișează câteva recenzii înainte să se activeze zidul, mai ales pe prima pagină — dar pentru orice scraper care rulează la scară, trebuie să presupui că login wall-ul este mereu activ.

Domeniile Amazon din diferite țări (.de, .co.uk, .co.jp) aplică acest zid separat. După cum spunea un utilizator de forum: „este necesar un login pentru fiecare țară.” Cookie-urile tale de pe .com nu vor funcționa pe .co.uk.

Featured reviews vs. recenziile complete: ce mai poți accesa fără login

Paginile produselor Amazon (URL-ul /dp/{ASIN}/) afișează încă aproximativ fără autentificare. Acestea sunt alese de algoritmul Amazon și sunt utile pentru un check rapid de sentiment, dar nu pot fi sortate, filtrate sau paginate.

Paginile complete de recenzii (/product-reviews/{ASIN}/) — cu sortare după cele mai noi, filtrare după rating în stele și paginare prin sute de recenzii — necesită login.

Dacă ai nevoie doar de câteva recenzii pentru o verificare rapidă, extrage datele din pagina produsului. Pentru sute sau mii, va trebui să gestionezi autentificarea.

Ce îți trebuie înainte să începi: configurarea Python și bibliotecile necesare

Înainte să scriem cod, iată setup-ul:

• Nivel: intermediar (te simți confortabil cu Python și ai cunoștințe de bază HTML)
• Timp necesar: ~45 de minute pentru tot pipeline-ul; ~10 minute pentru un scraping simplu
• Ce îți trebuie: Python 3.8+, browser Chrome, un cont Amazon valid

Instalează bibliotecile de bază:

1pip install requests beautifulsoup4 lxml pandas textblob

Opțional (pentru analiză avansată de sentiment):

1pip install transformers torch

Ce este un ASIN? Este identificatorul de produs Amazon format din 10 caractere. Îl găsești în orice URL de produs — de exemplu, în amazon.com/dp/B0BCNKKZ91, ASIN-ul este B0BCNKKZ91. Acesta este cheia pe care o vei pune în URL-ul recenziilor.

Pasul 1: Treci de login wall cu autentificare bazată pe cookie-uri

Cea mai sigură metodă este să te autentifici în Amazon în browser, să copiezi cookie-urile sesiunii și să le introduci în requests.Session() din Python. Așa eviți CAPTCHA-urile și SMS 2FA care dau bătăi de cap la automatizarea loginului cu Selenium.

Ai nevoie de aceste șapte cookie-uri:

Cum extragi cookie-urile din Chrome DevTools

1. Autentifică-te pe amazon.com în Chrome
2. Deschide DevTools (F12 sau click dreapta → Inspect)
3. Mergi la Application → Storage → Cookies → https://www.amazon.com
4. Găsește fiecare cookie din tabel și copiază valoarea lui
5. Formatează-le ca șir separat prin punct și virgulă pentru Python

Configurează sesiunea așa:

1import requests
2session = requests.Session()
3> This paragraph contains content that cannot be parsed and has been skipped.
4> This paragraph contains content that cannot be parsed and has been skipped.
5session.cookies.update(cookies)
6session.headers.update(headers)

Important: Refolosește același obiect session pentru toate cererile. Asta păstrează cookie-urile consistente și imită o sesiune reală de browser. Cookie-urile rezistă de obicei zile sau săptămâni sub încărcare de scraping, dar dacă începi să primești din nou redirecționări către login, reîmprospătează-le din browser.

Pentru marketplace-urile care nu sunt .com, numele cookie-urilor se schimbă ușor — amazon.de folosește at-acbde în loc de at-main, amazon.co.uk folosește at-acbuk și așa mai departe. Fiecare marketplace are nevoie de propria sesiune independentă.

Pasul 2: Construiește cererea și parsează HTML-ul recenziilor cu BeautifulSoup

URL-ul pentru recenziile Amazon are această structură:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

Funcția de bază:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Pauză politicoasă
5    response = session.get(url, timeout=15)
6    # Detectează login wall
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Login wall detectat — reîmprospătează cookie-urile")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Un mic truc util: înainte să accesezi pagina de recenzii, vizitează mai întâi pagina produsului. Asta creează un pattern de browsing natural în sesiunea ta.

1# Vizitează mai întâi pagina produsului (mimează browsing-ul real)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Apoi accesează pagina recenziilor
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Pasul 3: Folosește selectori stabili pentru a extrage datele din recenzii (nu te mai baza pe clase CSS)

Aici se rup cele mai multe tutoriale din 2022–2023. Amazon obfuschează numele claselor CSS — se schimbă periodic, iar după cum spunea un dezvoltator frustrat într-un thread de forum: „niciunul nu avea vreun model clar pentru numele claselor tagurilor span.”

Soluția: Amazon folosește atribute data-hook pe elementele de recenzie, iar acestea sunt remarcabil de stabile. Sunt identificatori semantici de care depinde chiar codul frontend al Amazon, așa că nu sunt randomizați.

Codul de extragere folosind selectori data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Rating în stele
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Titlu
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Conținut
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autor
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Data și țara
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Format: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Achiziție verificată
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34> This paragraph contains content that cannot be parsed and has been skipped.
35    return reviews

Am rulat acest set de selectori pe mai multe ASIN-uri timp de luni întregi, iar atributele data-hook nu s-au schimbat nici măcar o dată. În schimb, clasele CSS s-au schimbat de cel puțin două ori în aceeași perioadă.

Pasul 4: Gestionează paginarea și limita Amazon de 10 pagini

Amazon limitează parametrul pageNumber la 10 pagini a câte 10 recenzii fiecare — un plafon dur de aproximativ 100 de recenzii per combinație de filtre. Butonul „Next page” dispare pur și simplu după pagina 10.

Buclă de paginare de bază:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Nu mai sunt recenzii pe această pagină
8    all_reviews.extend(page_reviews)
9    print(f"Pagina {page}: {len(page_reviews)} recenzii")

Cum obții mai mult de 10 pagini de recenzii Amazon

Soluția este împărțirea pe filtre. Fiecare combinație de filterByStar și sortBy primește propria fereastră independentă de 10 pagini.

Valorile pentru filtrul de stele: one_star, two_star, three_star, four_star, five_star
Valorile de sortare: recent, helpful (implicit)

Combinând toate cele 5 filtre de stele × 2 ordini de sortare, poți accesa până la 100 de pagini, adică 1.000 de recenzii per produs — iar pentru produsele cu distribuții inegale ale stelelor, de multe ori vei ajunge foarte aproape de setul complet de recenzii.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Deduplicare simplă
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Deduplicare după combinația titlu + autor
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Pagina {page}: {len(page_reviews)} recenzii")
23print(f"Total recenzii unice: {len(all_reviews)}")

Vor exista suprapuneri între bucket-uri, așa că deduplicarea este esențială. Eu folosesc o combinație de titlu al recenziei + numele autorului ca cheie rapidă — nu e perfectă, dar prinde marea majoritate a duplicatelor.

Pasul 5: Ocolește apărările anti-bot (rotație, throttling, retry)

Amazon folosește AWS WAF Bot Control, iar acesta a devenit mult mai agresiv. Contramăsurile pe un singur strat (doar rotirea User-Agent-urilor, doar adăugarea de întârzieri) nu mai sunt suficiente.

This paragraph contains content that cannot be parsed and has been skipped.

Un wrapper de retry gata de producție:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Detectează blocările
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA detectat. Aștept {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Rate limit ({response.status_code}). Aștept {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Login wall — cookie-urile au expirat")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Încercarea {attempt + 1} a eșuat: {e}")
33    return None

O notă despre proxy-uri: Amazon (AWS, GCP, Azure, DigitalOcean) la nivel de rețea. Dacă scrapi mai mult de câteva sute de pagini, proxy-urile rezidențiale sunt practic obligatorii — așteaptă-te la 50–200+ USD/lună, în funcție de volum. Pentru proiecte mici (sub 100 de cereri/zi), throttling-ul atent din IP-ul de acasă funcționează de obicei bine.

Amazon inspectează și amprenta TLS. Biblioteca standard Python requests are un . Pentru scraper-e de producție, ia în calcul curl_cffi, care imită stack-urile TLS ale browserelor reale. Pentru scraping la scară tutorial (câteva sute de pagini), requests cu headere bune face de obicei treaba.

Pasul 6: Exportă recenziile Amazon extrase în CSV sau Excel

După ce ai colectat recenziile, transformarea lor într-un format utilizabil este simplă cu pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Am exportat {len(df)} recenzii în amazon_reviews.csv")

Exemplu de rezultat:

Pentru export în Excel: df.to_excel("amazon_reviews.xlsx", index=False) (necesită openpyxl).

Pentru Google Sheets, biblioteca gspread funcționează, dar necesită — crearea unui proiect, activarea a două API-uri, generarea de credențiale pentru service account, partajarea foii. Dacă ți se pare mai mult setup decât scraping-ul propriu-zis, nu greșești. (Acesta este unul dintre momentele în care un instrument precum , care exportă în Google Sheets cu un singur click, începe să pară foarte atractiv.)

Bonus: adaugă analiză de sentiment recenziilor tale în doar 5 linii de Python

Cele mai multe tutoriale de scraping se opresc la exportul CSV. Dar scorarea sentimentului este ceea ce transformă datele brute în decizii de business.

Cel mai rapid baseline folosește TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Asta îți dă un scor de polaritate de la -1.0 (foarte negativ) la +1.0 (foarte pozitiv) pentru fiecare recenzie. Exemplu de rezultat:

Rândurile interesante sunt cele care nu se potrivesc: o recenzie de 3 stele cu text pozitiv sau o recenzie de 5 stele cu limbaj negativ. Aceste discrepanțe scot la iveală adesea opinii nuanțate ale clienților, pe care ratingul în stele singur le ratează.

Pentru acuratețe de nivel producție, recomandarea este Hugging Face Transformers. , iar față de instrumentele lexicale. Modelul nlptown/bert-base-multilingual-uncased-sentiment poate chiar prezice direct ratinguri de la 1 la 5 stele:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Recenziile Amazon urmează o — un vârf mare la 5 stele, un vârf mai mic la 1 stea și o vale în mijloc. Asta înseamnă că media ratingului este adesea un proxy slab pentru calitatea reală a produsului. Segmentează clusterul de 1 stea și caută temele recurente — acolo se ascunde de obicei un defect fixabil.

Compromisul onest: Python făcut de tine vs. API-uri de scraping plătite vs. Thunderbit

Am întreținut scrapers Python pentru Amazon și, sincer, se strică. Se schimbă selectori, expiră cookie-urile, Amazon lansează un nou strat de detecție bot și, dintr-odată, sâmbăta ta dimineață se transformă în depanarea unui scraper în loc să analizezi datele. Utilizatorii din forumuri raportează aceeași frustrare — scripturi DIY care „mergeau luna trecută” și acum cer patch-uri constante.

Așa arată comparația dintre cele trei abordări principale:

Python îți oferă control total și este, sincer, cea mai bună metodă de a înțelege cum funcționează web scraping-ul „pe dedesubt”. Dar dacă cazul tău de utilizare este „am nevoie de date despre recenziile concurenței într-un spreadsheet până vineri”, nu „vreau să construiesc un pipeline de producție”, costul de întreținere al unui scraper custom s-ar putea să nu merite.

Cum să extragi recenziile Amazon cu Thunderbit (fără cod, fără mentenanță)

Am construit pentru exact acele scenarii în care întreținerea unui scraper Python pare exagerată. Fluxul arată așa:

1. Instalezi extensia
2. Navighezi la pagina de recenzii a produsului Amazon în browser (ești deja autentificat, deci login wall-ul nu mai contează)
3. Dai click pe „AI Suggest Fields” — Thunderbit citește pagina și propune coloane precum Author, Rating, Title, Review Text, Date, Verified Purchase
4. Dai click pe „Scrape” — datele sunt extrase instant, cu paginare inclusă
5. Exporți în Excel, Google Sheets, Airtable sau Notion

Avantajul principal este că AI-ul din Thunderbit citește structura paginii de fiecare dată, proaspăt. Fără selectori CSS de întreținut, fără management de cookie-uri, fără cod anti-bot. Când Amazon schimbă HTML-ul, AI-ul se adaptează. Pentru cititorii care vor acces programatic fără muncă manuală completă, Thunderbit oferă și un — extragere structurată de date prin API, cu detecție a câmpurilor asistată de AI, fără întreținerea selectoarelor.

Pentru aprofundare pe date Amazon, vezi ghidurile noastre despre și .

Sfaturi pentru scraping-ul recenziilor Amazon la scară, cu Python

Dacă extragi recenzii pentru multe ASIN-uri, câteva practici îți vor salva multă bătaie de cap:

• Procesează ASIN-urile în loturi și lasă pauze între produse, nu doar între pagini. Eu folosesc pauze de 10–15 secunde între ASIN-uri.
• Deduplică agresiv. Când combini mai multe filtre de stele și ordine de sortare, vei obține recenzii suprapuse. Folosește un set de tuple (title, author, date) ca cheie de deduplicare.
• Loghează eșecurile. Ține evidența combinațiilor ASIN + pagină + filtru care au eșuat, ca să le poți reîncerca fără să rescrapi totul.
• Stochează într-o bază de date pentru proiecte mari. O bază de date SQLite simplă scalează mult mai bine decât fișiere CSV tot mai mari:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.to_sql("reviews", conn, if_exists="append", index=False)

• Programează scraping-uri recurente. Pentru monitorizare continuă, setează un cron job sau folosește funcția Scheduled Scraper din Thunderbit — descrii URL-ul și programul, iar restul este gestionat fără server.

Pentru metode suplimentare, articolele noastre despre și prezintă și alte opțiuni.

O scurtă notă despre aspectele legale și etice

ale Amazon interzic explicit „utilizarea oricărui robot, spider, scraper sau a altor mijloace automate pentru a accesa Amazon Services.” Totuși, jurisprudența recentă din SUA a fost favorabilă scraper-elor de date publice. În , o instanță federală a decis că scraping-ul datelor accesibile public nu încalcă termenii de utilizare atunci când scraper-ul nu este un „utilizator” autentificat.

Nuanta importantă: scraping-ul din spatele unui login (care este exact ce acoperă acest tutorial) intră în zona dreptului contractual, pentru că ai acceptat ToS-ul Amazon când ți-ai creat contul. Extragerile doar din recenziile vizibile public implică un risc legal mai mic decât scraping-ul din spatele login wall-ului.

Ghid practic: nu redistribui comercial datele extrase, nu colecta date personale ale utilizatorilor dincolo de ceea ce este afișat public, respectă robots.txt și consultă un avocat pentru utilizare la scară mare sau comercială. Acesta nu este sfat juridic. Pentru mai multe detalii despre contextul legal, vezi prezentarea noastră despre .

Concluzie: extrage recenziile Amazon cu Python sau sari complet peste cod

Recapitulare rapidă a ceea ce am parcurs în acest ghid:

• Login wall-ul există, dar poate fi depășit cu autentificare bazată pe cookie-uri — copiază 7 cookie-uri din browser și injectează-le într-un requests.Session()
• Folosește selectori data-hook, nu clase CSS, pentru o extragere care nu se rupe la fiecare câteva săptămâni
• Combină filtrele de stele și ordinea de sortare pentru a depăși limita de 10 pagini și pentru a accesa peste 500 de recenzii per produs
• Adaugă analiză de sentiment cu TextBlob pentru un baseline rapid sau Hugging Face Transformers pentru acuratețe de producție
• Menține apărarea anti-bot: throttling, rotația User-Agent-urilor, exponential backoff și proxy-uri rezidențiale pentru scară

Python îți oferă control total și este cea mai bună cale să înțelegi ce se întâmplă „sub capotă”. Dar dacă scenariul tău este „am nevoie de date despre recenziile concurenței într-un spreadsheet până vineri”, nu „vreau să construiesc un pipeline de date pentru producție”, e posibil ca efortul de întreținere al unui scraper custom să nu merite.

gestionează autentificarea, selectoarele, paginarea și exportul prin câteva click-uri — încearcă și vezi dacă se potrivește fluxului tău de lucru. Pe măsură ce Amazon continuă să întărească măsurile anti-bot, instrumentele bazate pe AI care se adaptează în timp real vor deveni tot mai puțin un „nice to have” și tot mai mult o necesitate.

Poți explora și pentru tutoriale video despre fluxurile de scraping.

Întrebări frecvente

1. Poți extrage recenziile Amazon fără să te autentifici?

Da, dar doar cele aproximativ 8 „featured reviews” afișate pe pagina produsului (/dp/{ASIN}/). Paginile complete de recenzii, cu sortare, filtrare și paginare, necesită autentificare începând de la finalul lui 2024. Pentru majoritatea cazurilor de business, va trebui să gestionezi login wall-ul.

2. Este legal să extragi recenzii Amazon?

Termenii de utilizare Amazon interzic scraping-ul automat. Totuși, jurisprudența recentă din SUA (Meta v. Bright Data, 2024; hiQ v. LinkedIn) susține scraping-ul datelor accesibile public. Scraping-ul din spatele unui login implică un risc legal mai mare, deoarece ai fost de acord cu ToS-ul Amazon. Consultă un avocat pentru utilizare comercială.

3. Câte recenzii Amazon pot extrage per produs?

Amazon limitează paginile de recenzii la 10 per combinație de sortare și filtru de stele. Folosind toate cele 5 filtre de stele × 2 ordini de sortare, poți accesa până la 100 de pagini (aproximativ 1.000 de recenzii) per produs. Cu filtre de cuvinte cheie, plafonul teoretic este mult mai mare, deși cu o duplicare semnificativă.

4. Care este cea mai bună bibliotecă Python pentru extragerea recenziilor Amazon?

requests + BeautifulSoup pentru parsarea HTML static este cea mai comună și mai fiabilă combinație. Selenium este util când ai nevoie de randare JavaScript. Pentru o alternativă fără cod care gestionează automat login wall-ul și paginarea, încearcă .

5. Cum evit să fiu blocat când extrag date din Amazon?

Rotește stringurile User-Agent dintr-un pool de 10+ stringuri reale de browser, adaugă întârzieri aleatoare de 2–5 secunde între cereri, implementează exponential backoff la erorile 503/429, folosește proxy-uri rezidențiale pentru volum mare (IP-urile de datacenter sunt blocate preventiv) și păstrează cookie-urile sesiunii consistente între cereri. Pentru o abordare fără mentenanță, Thunderbit gestionează automat apărarea anti-bot prin sesiunea ta de browser.

Află mai mult