Så här skrapar jag Amazon-recensioner med Python (förbi inloggningsväggen)

Min Amazon-recensionsskrapare fungerade perfekt i sex veckor — sedan en morgon fick den tillbaka 200 OK och en sida fylld av ingenting. Inget felmeddelande, ingen CAPTCHA, bara tom HTML där hundratals recensioner brukade ligga.

Om det där låter bekant är du långt ifrån ensam. I slutet av 2025 började Amazon lägga hela sina recensionssidor bakom en inloggningsvägg, och mängder av Python-skript för skrapning slutade fungera över en natt. Jag har spenderat de senaste månaderna på med att lösa problemet från båda håll — både genom att bygga vår AI-skrapare och genom att underhålla min egen Python-pipeline för recensioner — så jag kände att det var dags att skriva den guide jag själv hade velat ha när mitt skript först dog. Det här inlägget går igenom arbetssättet som faktiskt funkar: cookie-baserad autentisering, stabila selektorer som klarar Amazons CSS-förvrängning, lösningar för 10-sidorsgränsen i pagineringen, skydd mot botdetektion och ett extra avsnitt om sentimentanalys som förvandlar rå recensionstext till riktiga affärsinsikter. Och om du halvvägs tänker: "Jag vill helst slippa underhålla all den här koden", så visar jag hur löser samma jobb på ungefär två minuter utan någon Python alls.

Vad är skrapning av Amazon-recensioner egentligen — och varför spelar det roll?

Att skrapa Amazon-recensioner innebär att man programmässigt hämtar kundrecensionsdata — stjärnbetyg, recensionstext, författarnamn, datum, verifierade köp-märken — från Amazons produktsidor. Eftersom Amazon (och aldrig förde tillbaka det), är webbscraping den enda programmässiga vägen till den här datan.

Siffrorna talar sitt tydliga språk. , och . Att visa bara 5 recensioner på en produktsida kan . Företag som systematiskt analyserar recensionssentiment ser . Det här är alltså inte abstrakt datavetenskap — det är konkurrensanalys, signaler för produktförbättring och marknadsföringsspråk, allt i fri text på Amazons servrar.

Varför skrapa Amazon-recensioner med Python?

Python är fortfarande förstahandsvalet för den här typen av arbete. Det är , och ekosystemet — requests, BeautifulSoup, pandas, Scrapy — gör webscraping tillgängligt även för personer som inte jobbar som utvecklare på heltid.

Olika team använder den här datan på olika sätt:

Ett varumärke inom köksutrustning , formulerade om produkten och återtog sin plats som nummer 1 inom 60 dagar. Ett företag för aktivitetsarmband , identifierade ett latexallergiproblem, lanserade en hypoallergen variant och minskade returerna med 40 %. Det är den typen av avkastning som gör utvecklingsinsatsen värd mödan.

Inloggningsväggen: varför din Amazon-recensionsskrapare slutade fungera

Den 14 november 2024 . Förändringen bekräftades både i och av . Om du besöker /product-reviews/{ASIN}/ i ett inkognitofönster skickas du vidare till en inloggningssida i stället för att få recensionsdata.

Symtomen är luriga: ditt skript får ett 200 OK-svar, men HTML-innehållet består av ett inloggningsformulär (name="email", id="ap_password") i stället för recensioner. Ingen felkod. Ingen CAPTCHA. Bara... ingenting användbart.

Amazon gjorde detta av skäl som rör bot-skydd och regional efterlevnad. Tillämpningen är inkonsekvent — ibland laddar ett färskt webbläsarfönster några få recensioner innan väggen slår till, särskilt på första sidan — men för all skrapning i större skala bör du utgå från att väggen alltid finns där.

Olika landsdomäner hos Amazon (.de, .co.uk, .co.jp) tillämpar väggen var för sig. Som en forumanvändare uttryckte det: "man behöver en inloggning för varje land." Dina .com-cookies fungerar alltså inte på .co.uk.

Utdragna recensioner kontra fullständiga recensioner: vad du fortfarande kan se utan inloggning

Amazons produktsidor (/dp/{ASIN}/) visar fortfarande ungefär utan autentisering. De är handplockade av Amazons algoritm och är bra för en snabb känslokoll, men de går varken att sortera, filtrera eller bläddra igenom.

De fullständiga recensionssidorna (/product-reviews/{ASIN}/) — med sortering på nyast, filtrering på stjärnbetyg och paginering över hundratals recensioner — kräver inloggning.

Om du bara behöver några få recensioner för en snabb temperaturmätning kan du skrapa produktsidan. För hundratals eller tusentals behöver du hantera autentisering.

Det du behöver innan du börjar: Python-inställning och bibliotek

Innan vi skriver någon kod, här är grunduppsättningen:

• Svårighetsgrad: Medelnivå (du bör känna dig bekväm med Python och grundläggande HTML)
• Tidsåtgång: ~45 minuter för hela flödet; ~10 minuter för en enkel skrapning
• Du behöver: Python 3.8+, Chrome-webbläsare, ett giltigt Amazon-konto

Installera kärnbiblioteken:

1pip install requests beautifulsoup4 lxml pandas textblob

Valfritt (för mer avancerad sentimentanalys):

1pip install transformers torch

Vad är en ASIN? Det är Amazons produktidentifierare med 10 tecken. Du hittar den i valfri produkt-URL — till exempel i amazon.com/dp/B0BCNKKZ91 är ASIN:et B0BCNKKZ91. Det är nyckeln du använder i recensions-URL:en.

Steg 1: Ta dig förbi inloggningsväggen med cookie-baserad autentisering

Det mest pålitliga sättet är att logga in på Amazon i webbläsaren, kopiera sessionscookies och injicera dem i din Python requests.Session(). Då slipper du de CAPTCHA:er och SMS-baserade tvåfaktorsflöden som ofta sabbar Selenium-baserad inloggningsautomation.

Du behöver dessa sju cookies:

Så hämtar du cookies från Chrome DevTools

1. Logga in på amazon.com i Chrome
2. Öppna DevTools (F12 eller högerklicka → Inspektera)
3. Gå till Application → Storage → Cookies → https://www.amazon.com
4. Leta reda på varje cookienamn i tabellen och kopiera värdet
5. Formatera dem som en semikolonseparerad sträng för Python

Ställ in din session så här:

1import requests
2session = requests.Session()
3# Klistra in dina cookievärden här
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Viktigt: Återanvänd samma session-objekt för alla dina förfrågningar. Det håller cookies konsekventa och efterliknar en riktig webbläsarsession. Cookies brukar hålla i sig från dagar till veckor vid scraping-belastning, men om du börjar få inloggningsomdirigeringar igen behöver du uppdatera dem från webbläsaren.

För marknadsplatser som inte är .com ändras cookie-namnen något — amazon.de använder at-acbde i stället för at-main, amazon.co.uk använder at-acbuk och så vidare. Varje marknadsplats behöver sin egen oberoende session.

Steg 2: Bygg förfrågan och tolka recensions-HTML med BeautifulSoup

Amazons recensions-URL följer det här mönstret:

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

Kärnfunktionen:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Hänsynsfull fördröjning
5    response = session.get(url, timeout=15)
6    # Upptäck inloggningsvägg
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Inloggningsvägg upptäckt — uppdatera dina cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Ett litet knep som hjälper: innan du går till recensionssidan, besök produktsidan först. Det skapar ett mer naturligt surfbeteende i din session.

1# Besök produktsidan först (imiterar normal webbläsning)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Gå sedan till recensionssidan
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)

Steg 3: Använd stabila selektorer för att extrahera recensionsdata (lita inte på CSS-klasser)

Det här är där de flesta guider från 2022–2023 faller isär. Amazon fördunklar CSS-klassnamn — de ändras periodvis, och som en frustrerad utvecklare skrev i en forumtråd: "ingen av dem hade något konsekvent mönster för namnen på span-taggs klasser."

Lösningen: Amazon använder data-hook-attribut på recensionselement, och de är förvånansvärt stabila. De är semantiska identifierare som Amazons egen frontendkod bygger på, så de slumpas inte om.

Extraktionskoden med data-hook-selektorer:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Stjärnbetyg
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        # Titel
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Brödtext
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Författare
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Datum och land
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        # Verifierat köp
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

Jag har kört den här uppsättningen selektorer mot flera ASIN:er i månader nu, och data-hook-attributen har inte ändrats en enda gång. CSS-klasserna däremot har roterat minst två gånger under samma period.

Steg 4: Hantera paginering och Amazons 10-sidorsgräns

Amazon begränsar parametern pageNumber till 10 sidor med 10 recensioner vardera — ett hårt tak på cirka 100 recensioner per filterkombination. Knappen för "Nästa sida" försvinner helt efter sida 10.

Enkel pagineringsloop:

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  # Inga fler recensioner på den här sidan
8    all_reviews.extend(page_reviews)
9    print(f"Sida {page}: {len(page_reviews)} recensioner")

Så får du mer än 10 sidor Amazon-recensioner

Lösningen är filterbucketing. Varje kombination av filterByStar och sortBy får sitt eget oberoende 10-sidorsfönster.

Värden för stjärnfilter: one_star, two_star, three_star, four_star, five_star
Sorteringsvärden: recent, helpful (standard)

Genom att kombinera alla 5 stjärnfilter × 2 sorteringsordningar kan du komma åt upp till 100 sidor, alltså 1 000 recensioner per produkt — och för produkter med ojämn fördelning av stjärnbetyg kommer du ofta ganska nära hela recensionsmängden.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Enkel deduplicering
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                # Deduplicera med kombinationen titel + författare
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}] Sida {page}: {len(page_reviews)} recensioner")
23print(f"Totalt antal unika recensioner: {len(all_reviews)}")

Det kommer att finnas överlapp mellan bucketerna, så deduplicering är viktig. Jag använder en kombination av recensionstitel + författarnamn som en snabb nyckel — inte perfekt, men det fångar majoriteten av dubbletterna.

Steg 5: Undvik Amazons bot-skydd (rotera, stryp, försök igen)

Amazon använder AWS WAF Bot Control, och den har blivit betydligt aggressivare. Enkla motåtgärder i ett lager (bara rotera User-Agents, bara lägga till fördröjningar) räcker inte längre.

En retry-wrapper redo för produktion:

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            # Upptäck blockeringar
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA upptäckt. Väntar {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}). Väntar {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Inloggningsväggen — cookies har gått ut")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Försök {attempt + 1} misslyckades: {e}")
33    return None

En notis om proxies: Amazon (AWS, GCP, Azure, DigitalOcean) på nätverksnivå. Om du skrapar mer än några hundra sidor är residential proxies i praktiken nödvändiga — räkna med 50–200+ USD per månad beroende på volym. För mindre projekt (under 100 förfrågningar per dag) brukar noggrann throttling från din hem-IP ofta fungera bra.

Amazon granskar också TLS-fingeravtryck. Pythons standardbibliotek requests har en . För produktion bör du överväga curl_cffi, som efterliknar riktiga webbläsares TLS-stacks. För mindre tutorial-nivå på skrapning (några hundra sidor) räcker requests med bra headers oftast.

Steg 6: Exportera dina skrapade Amazon-recensioner till CSV eller Excel

När du väl har samlat in recensionerna är det enkelt att få dem i ett användbart format med pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Exporterade {len(df)} recensioner till amazon_reviews.csv")

Exempel på utdata:

För Excel-export: df.to_excel("amazon_reviews.xlsx", index=False) (kräver openpyxl).

För Google Sheets fungerar gspread, men det kräver — skapa ett projekt, aktivera två API:er, generera servicekonto-uppgifter, dela kalkylarket. Om det låter som mer förarbete än själva scrapingen, har du inte fel. (Det här är ett av de där tillfällena när ett verktyg som som exporterar till Google Sheets med ett klick börjar se väldigt lockande ut.)

Bonus: Lägg till sentimentanalys i dina skrapade recensioner på 5 rader Python

De flesta scrapingguider slutar vid CSV-export. Men att score:a sentiment är det som förvandlar rådata till affärsbeslut.

Det snabbaste basalternativet använder TextBlob:

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

Det ger dig ett polarisationsvärde från -1.0 (mycket negativt) till +1.0 (mycket positivt) för varje recension. Exempel på utdata:

De intressanta raderna är avvikelserna — en 3-stjärnig recension med positiv sentimenttext, eller en 5-stjärnig recension med negativt språk. Sådana skillnader avslöjar ofta nyanserade kundåsikter som stjärnbetyg ensamma missar.

För produktionsklassad noggrannhet rekommenderas Hugging Face Transformers. , och jämfört med lexikonbaserade verktyg. Modellen nlptown/bert-base-multilingual-uncased-sentiment kan till och med förutsäga 1–5 stjärnor direkt:

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)

Amazon-recensioner följer en — en stor topp vid 5 stjärnor, en mindre topp vid 1 stjärna och en dal i mitten. Det betyder att medelbetyget ofta är en dålig proxy för faktisk produktkvalitet. Segmentera 1-stjärneklustret och analysera återkommande teman där — det är ofta där den enda åtgärdbara bristen gömmer sig.

Den ärliga avvägningen: egen Python, betalda scraping-API:er eller Thunderbit

Jag har underhållit Python-scrapers för Amazon, och jag ska vara ärlig: de går sönder. Selektorer ändras, cookies går ut, Amazon rullar ut ett nytt lager botdetektion, och plötsligt ägnar du lördagsmorgonen åt att felsöka en scraper i stället för att analysera data. Forumanvändare beskriver samma frustration — DIY-skript som "fungerade förra månaden" behöver nu ständiga patchar.

Så här står sig de tre vanligaste alternativen mot varandra:

Python ger dig full kontroll och är verkligen det bästa sättet att förstå hur webscraping fungerar under huven. Betalda API:er (ScrapingBee, Oxylabs, Bright Data) är logiska för produktionsflöden där driftsäkerhet väger tyngre än kostnad. Och för team som behöver recensionsdata utan utvecklingsbördan — e-handelsdrift som följer konkurrenters produkter varje vecka, marknadsteam som hämtar kundspråk för annonscopy — finns ett tredje spår.

Så skrapar du Amazon-recensioner med Thunderbit (utan kod, utan underhåll)

Vi byggde för just de scenarier där det känns överdrivet att underhålla en Python-scraper. Flödet ser ut så här:

1. Installera
2. Gå till Amazon-sidans recensionsvy i webbläsaren (du är redan inloggad, så inloggningsväggen är inget problem)
3. Klicka på "AI Suggest Fields" — Thunderbit läser sidan och föreslår kolumner som Author, Rating, Title, Review Text, Date, Verified Purchase
4. Klicka på "Scrape" — datan extraheras direkt, med inbyggd paginering
5. Exportera till Excel, Google Sheets, Airtable eller Notion

Den stora fördelen är att Thunderbits AI läser sidstrukturen på nytt varje gång. Inga CSS-selektorer att underhålla, ingen cookiehantering, ingen botkod. När Amazon ändrar sin HTML anpassar sig AI:n. För läsare som vill ha programmatisk åtkomst utan att bygga allt själva erbjuder Thunderbit också ett — strukturerad dataextraktion via API med AI-baserad fältdetektion, utan att behöva underhålla selektorer.

För mer fördjupning om Amazon-data, se våra guider om och .

Tips för att skrapa Amazon-recensioner i stor skala med Python

Om du skrapar recensioner för många ASIN:er kommer några vanor att spara dig mycket huvudvärk:

• Batcha dina ASIN:er med pauser mellan produkterna, inte bara mellan sidorna. Jag använder 10–15 sekunders paus mellan ASIN:er.
• Deduplicera aggressivt. När du kombinerar flera stjärnfilter och sorteringskombinationer får du överlappande recensioner. Använd en mängd av tuplerna (title, author, date) som dedupliceringsnyckel.
• Logga misslyckanden. Spåra vilka kombinationer av ASIN + sida + filter som misslyckades så att du kan köra om dem utan att behöva skrapa om allt.
• Lagra i en databas för större projekt. En enkel SQLite-databas skalar mycket bättre än växande CSV-filer:

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

• Schemalägg återkommande skrapningar. För löpande övervakning kan du sätta upp ett cron-jobb eller använda Thunderbits Scheduled Scraper-funktion — beskriv URL:en och schemat så sköter den resten utan server.

För fler angreppssätt, se våra inlägg om och för fler alternativ.

En snabb notis om juridik och etik

Amazons förbjuder uttryckligen "användning av robot, spindel, scraper eller andra automatiserade metoder för att få åtkomst till Amazon Services." Samtidigt har nylig amerikansk rättspraxis varit gynnsam för skrapning av offentligt data. I slog en federal domstol fast att skrapning av offentligt tillgänglig data inte bryter mot användarvillkor när skraparen inte är en inloggad "användare".

Nyansen är viktig: skrapning bakom inloggning (vilket den här guiden handlar om) hamnar i avtalsrättens territorium, eftersom du gick med på Amazons användarvillkor när du skapade ditt konto. Att skrapa offentligt synliga utvalda recensioner innebär mindre juridisk risk än att skrapa bakom inloggningsväggen.

Praktiska riktlinjer: återdistribuera inte skrapad data kommersiellt, skrapa inte personuppgifter utöver det som redan visas offentligt, respektera robots.txt och rådfråga jurist vid storskalig eller kommersiell användning. Detta är inte juridisk rådgivning. För mer om det juridiska landskapet, se vår översikt över .

Slutsats: skrapa Amazon-recensioner med Python — eller hoppa över koden helt

Snabb sammanfattning av vad guiden gick igenom:

• Inloggningsväggen är verklig, men går att lösa med cookie-baserad autentisering — kopiera 7 cookies från webbläsaren och injicera dem i en requests.Session()
• Använd data-hook-selektorer, inte CSS-klasser, för extraktion som inte går sönder varannan vecka
• Kombinera stjärnfilter och sorteringsordningar för att komma runt 10-sidorsgränsen och få tillgång till 500+ recensioner per produkt
• Lägg till sentimentanalys med TextBlob för en snabb grundnivå eller Hugging Face Transformers för produktionsnoggrannhet
• Underhåll skydd mot botdetektion: throttling, rotation av User-Agent, exponentiell backoff och residential proxies i större skala

Python ger dig full kontroll och är det bästa sättet att förstå vad som händer under huven. Men om ditt användningsfall är "jag behöver konkurrenters recensionsdata i ett kalkylblad före fredag" snarare än "jag vill bygga en produktionspipeline för data", kanske underhållsbördan för en egen scraper helt enkelt inte är värd det.

hanterar autentisering, selektorer, paginering och export med några klick — testa och se om den passar ditt arbetsflöde. I takt med att Amazon fortsätter skärpa sina motåtgärder mot botar kommer AI-drivna verktyg som anpassar sig i realtid att gå från trevligt att ha till nödvändigt.

Du kan också utforska vår för videogenomgångar av scraping-flöden.

Vanliga frågor

1. Går det att skrapa Amazon-recensioner utan att logga in?

Ja, men bara de cirka 8 "utvalda recensioner" som visas på produktsidan (/dp/{ASIN}/). De fullständiga recensionssidorna med sortering, filtrering och paginering kräver autentisering sedan slutet av 2024. För de flesta affärsanvändningsfall behöver du hantera inloggningsväggen.

2. Är det lagligt att skrapa Amazon-recensioner?

Amazons användarvillkor förbjuder automatiserad scraping. Däremot har nylig amerikansk rättspraxis (Meta v. Bright Data, 2024; hiQ v. LinkedIn) stöttar skrapning av offentligt tillgänglig data. Skrapning bakom inloggning innebär högre juridisk risk eftersom du har godkänt Amazons användarvillkor. Rådgör med jurist vid kommersiell användning.

3. Hur många Amazon-recensioner kan jag skrapa per produkt?

Amazon begränsar recensionssidor till 10 per kombination av sorteringsordning och stjärnfilter. Genom att använda alla 5 stjärnfilter × 2 sorteringsordningar kan du komma åt upp till 100 sidor (ungefär 1 000 recensioner) per produkt. Med nyckelordsfilter är det teoretiska taket mycket högre, men med betydande dubletter.

4. Vilket är det bästa Python-biblioteket för att skrapa Amazon-recensioner?

requests + BeautifulSoup för statisk HTML-parsning är den vanligaste och mest pålitliga kombinationen. Selenium är användbart när JavaScript-rendering krävs. För ett no-code-alternativ som hanterar inloggningsväggar och paginering automatiskt, prova .

5. Hur undviker jag att bli blockerad när jag skrapar Amazon?

Rotera User-Agent-strängar från en pool med 10+ riktiga webbläsarsträngar, lägg till slumpmässiga fördröjningar på 2–5 sekunder mellan förfrågningar, implementera exponentiell backoff vid 503/429-fel, använd residential proxies i större skala (datacenter-IP:er blockeras ofta i förväg) och håll sessioncookies konsekventa mellan förfrågningar. För ett helt underhållsfritt arbetssätt hanterar Thunderbit skydd mot botar automatiskt via din webbläsarsession.

Läs mer